brighterscript 1.0.0-alpha.25 → 1.0.0-alpha.26

package/dist/parser/Statement.js

@@ -20,15 +20,13 @@ const NamespaceType_1 = require("../types/NamespaceType");
 const InterfaceType_1 = require("../types/InterfaceType");
 const VoidType_1 = require("../types/VoidType");
 const TypedFunctionType_1 = require("../types/TypedFunctionType");
+const types_1 = require("../types");
 class EmptyStatement extends AstNode_2.Statement {
-    constructor(
-    /**
-     * Create a negative range to indicate this is an interpolated location
-     */
-    range = creators_1.interpolatedRange) {
+    constructor(options) {
+        var _a;
         super();
-        this.range = range;
         this.kind = AstNode_1.AstNodeKind.EmptyStatement;
+        this.range = (_a = options === null || options === void 0 ? void 0 : options.range) !== null && _a !== void 0 ? _a : creators_1.interpolatedRange;
     }
     transpile(state) {
         return [];
@@ -42,11 +40,13 @@ exports.EmptyStatement = EmptyStatement;
  * This is a top-level statement. Consider this the root of the AST
  */
 class Body extends AstNode_2.Statement {
-    constructor(statements = []) {
+    constructor(options) {
+        var _a;
         super();
-        this.statements = statements;
+        this.statements = [];
         this.kind = AstNode_1.AstNodeKind.Body;
         this.symbolTable = new SymbolTable_2.SymbolTable('Body', () => { var _a; return (_a = this.parent) === null || _a === void 0 ? void 0 : _a.getSymbolTable(); });
+        this.statements = (_a = options === null || options === void 0 ? void 0 : options.statements) !== null && _a !== void 0 ? _a : [];
     }
     get range() {
         var _a;
@@ -100,27 +100,29 @@ class Body extends AstNode_2.Statement {
 }
 exports.Body = Body;
 class AssignmentStatement extends AstNode_2.Statement {
-    constructor(equals, name, value, asToken, typeExpression) {
+    constructor(options) {
         super();
-        this.equals = equals;
-        this.name = name;
-        this.value = value;
-        this.asToken = asToken;
-        this.typeExpression = typeExpression;
         this.kind = AstNode_1.AstNodeKind.AssignmentStatement;
-        this.range = util_1.util.createBoundingRange(name, equals, value);
+        this.value = options.value;
+        this.tokens = {
+            equals: options.equals,
+            name: options.name,
+            as: options.as
+        };
+        this.typeExpression = options.typeExpression;
+        this.range = util_1.util.createBoundingRange(util_1.util.createBoundingRangeFromTokens(this.tokens), this.value);
     }
     transpile(state) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         //if the value is a compound assignment, just transpile the expression itself
-        if (TokenKind_1.CompoundAssignmentOperators.includes((_b = (_a = this.value) === null || _a === void 0 ? void 0 : _a.operator) === null || _b === void 0 ? void 0 : _b.kind)) {
+        if (TokenKind_1.CompoundAssignmentOperators.includes((_c = (_b = (_a = this.value) === null || _a === void 0 ? void 0 : _a.tokens) === null || _b === void 0 ? void 0 : _b.operator) === null || _c === void 0 ? void 0 : _c.kind)) {
             return this.value.transpile(state);
         }
         else {
             return [
-                state.transpileToken(this.name),
+                state.transpileToken(this.tokens.name),
                 ' ',
-                state.transpileToken(this.equals),
+                state.transpileToken((_d = this.tokens.equals) !== null && _d !== void 0 ? _d : (0, creators_1.createToken)(TokenKind_1.TokenKind.Equal)),
                 ' ',
                 ...this.value.transpile(state)
             ];
@@ -133,23 +135,23 @@ class AssignmentStatement extends AstNode_2.Statement {
         }
     }
     getType(options) {
-        // TODO: Do we still need this.typeExpression?
-        var _a;
+        var _a, _b, _c;
+        const variableType = (_b = (_a = this.typeExpression) === null || _a === void 0 ? void 0 : _a.getType(Object.assign(Object.assign({}, options), { typeChain: undefined }))) !== null && _b !== void 0 ? _b : this.value.getType(Object.assign(Object.assign({}, options), { typeChain: undefined }));
         // Note: compound assignments (eg. +=) are internally dealt with via the RHS being a BinaryExpression
         // so this.value will be a BinaryExpression, and BinaryExpressions can figure out their own types
-        const rhs = this.value.getType(Object.assign(Object.assign({}, options), { typeChain: undefined }));
-        (_a = options.typeChain) === null || _a === void 0 ? void 0 : _a.push(new interfaces_1.TypeChainEntry(this.name.text, rhs, options.data, this.name.range));
-        return rhs;
+        (_c = options.typeChain) === null || _c === void 0 ? void 0 : _c.push(new interfaces_1.TypeChainEntry(this.tokens.name.text, variableType, options.data, this.tokens.name.range));
+        return variableType;
     }
 }
 exports.AssignmentStatement = AssignmentStatement;
 class Block extends AstNode_2.Statement {
-    constructor(statements, startingRange) {
+    constructor(options) {
+        var _a;
         super();
-        this.statements = statements;
-        this.startingRange = startingRange;
         this.kind = AstNode_1.AstNodeKind.Block;
-        this.range = util_1.util.createBoundingRange({ range: this.startingRange }, ...(statements !== null && statements !== void 0 ? statements : []));
+        this.statements = options.statements;
+        this.startingRange = options.startingRange;
+        this.range = util_1.util.createBoundingRange({ range: this.startingRange }, ...((_a = this.statements) !== null && _a !== void 0 ? _a : []));
     }
     transpile(state) {
         state.blockDepth++;
@@ -183,10 +185,10 @@ class Block extends AstNode_2.Statement {
 }
 exports.Block = Block;
 class ExpressionStatement extends AstNode_2.Statement {
-    constructor(expression) {
+    constructor(options) {
         super();
-        this.expression = expression;
         this.kind = AstNode_1.AstNodeKind.ExpressionStatement;
+        this.expression = options.expression;
         this.range = this.expression.range;
     }
     transpile(state) {
@@ -200,29 +202,31 @@ class ExpressionStatement extends AstNode_2.Statement {
 }
 exports.ExpressionStatement = ExpressionStatement;
 class CommentStatement extends AstNode_2.Statement {
-    constructor(comments) {
+    constructor(options) {
         var _a;
         super();
-        this.comments = comments;
         this.kind = AstNode_1.AstNodeKind.CommentStatement;
         this.visitMode = visitors_1.InternalWalkMode.visitStatements | visitors_1.InternalWalkMode.visitExpressions;
-        if (((_a = this.comments) === null || _a === void 0 ? void 0 : _a.length) > 0) {
-            this.range = util_1.util.createBoundingRange(...this.comments);
+        this.tokens = {
+            comments: options.comments
+        };
+        if (((_a = this.tokens.comments) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            this.range = util_1.util.createBoundingRange(...this.tokens.comments);
         }
     }
     get text() {
-        return this.comments.map(x => x.text).join('\n');
+        return this.tokens.comments.map(x => x.text).join('\n');
     }
     transpile(state) {
         let result = [];
-        for (let i = 0; i < this.comments.length; i++) {
-            let comment = this.comments[i];
+        for (let i = 0; i < this.tokens.comments.length; i++) {
+            let comment = this.tokens.comments[i];
             if (i > 0) {
                 result.push(state.indent());
             }
             result.push(state.transpileToken(comment));
             //add newline for all except final comment
-            if (i < this.comments.length - 1) {
+            if (i < this.tokens.comments.length - 1) {
                 result.push('\n');
             }
         }
@@ -237,15 +241,18 @@ class CommentStatement extends AstNode_2.Statement {
 }
 exports.CommentStatement = CommentStatement;
 class ExitForStatement extends AstNode_2.Statement {
-    constructor(tokens) {
+    constructor(options) {
+        var _a;
         super();
-        this.tokens = tokens;
         this.kind = AstNode_1.AstNodeKind.ExitForStatement;
-        this.range = this.tokens.exitFor.range;
+        this.tokens = {
+            exitFor: options === null || options === void 0 ? void 0 : options.exitFor
+        };
+        this.range = (_a = this.tokens.exitFor) === null || _a === void 0 ? void 0 : _a.range;
     }
     transpile(state) {
         return [
-            state.transpileToken(this.tokens.exitFor)
+            this.tokens.exitFor ? state.transpileToken(this.tokens.exitFor) : 'exit for'
         ];
     }
     walk(visitor, options) {
@@ -254,15 +261,18 @@ class ExitForStatement extends AstNode_2.Statement {
 }
 exports.ExitForStatement = ExitForStatement;
 class ExitWhileStatement extends AstNode_2.Statement {
-    constructor(tokens) {
+    constructor(options) {
+        var _a;
         super();
-        this.tokens = tokens;
         this.kind = AstNode_1.AstNodeKind.ExitWhileStatement;
-        this.range = this.tokens.exitWhile.range;
+        this.tokens = {
+            exitWhile: options === null || options === void 0 ? void 0 : options.exitWhile
+        };
+        this.range = (_a = this.tokens.exitWhile) === null || _a === void 0 ? void 0 : _a.range;
     }
     transpile(state) {
         return [
-            state.transpileToken(this.tokens.exitWhile)
+            this.tokens.exitWhile ? state.transpileToken(this.tokens.exitWhile) : 'exit while'
         ];
     }
     walk(visitor, options) {
@@ -271,11 +281,13 @@ class ExitWhileStatement extends AstNode_2.Statement {
 }
 exports.ExitWhileStatement = ExitWhileStatement;
 class FunctionStatement extends AstNode_2.Statement {
-    constructor(name, func) {
+    constructor(options) {
         super();
-        this.name = name;
-        this.func = func;
         this.kind = AstNode_1.AstNodeKind.FunctionStatement;
+        this.tokens = {
+            name: options.name
+        };
+        this.func = options.func;
         this.range = this.func.range;
     }
     /**
@@ -287,10 +299,10 @@ class FunctionStatement extends AstNode_2.Statement {
         if (namespace) {
             let delimiter = parseMode === Parser_1.ParseMode.BrighterScript ? '.' : '_';
             let namespaceName = namespace.getName(parseMode);
-            return namespaceName + delimiter + ((_a = this.name) === null || _a === void 0 ? void 0 : _a.text);
+            return namespaceName + delimiter + ((_a = this.tokens.name) === null || _a === void 0 ? void 0 : _a.text);
         }
         else {
-            return this.name.text;
+            return this.tokens.name.text;
         }
     }
     getLeadingTrivia() {
@@ -298,7 +310,7 @@ class FunctionStatement extends AstNode_2.Statement {
     }
     transpile(state) {
         //create a fake token using the full transpiled name
-        let nameToken = Object.assign(Object.assign({}, this.name), { text: this.getName(Parser_1.ParseMode.BrightScript) });
+        let nameToken = Object.assign(Object.assign({}, this.tokens.name), { text: this.getName(Parser_1.ParseMode.BrightScript) });
         return this.func.transpile(state, nameToken);
     }
     getTypedef(state) {
@@ -318,26 +330,32 @@ class FunctionStatement extends AstNode_2.Statement {
     getType(options) {
         var _a;
         const funcExprType = this.func.getType(options);
-        funcExprType.setName((_a = this.name) === null || _a === void 0 ? void 0 : _a.text);
+        funcExprType.setName((_a = this.tokens.name) === null || _a === void 0 ? void 0 : _a.text);
         return funcExprType;
     }
 }
 exports.FunctionStatement = FunctionStatement;
 class IfStatement extends AstNode_2.Statement {
-    constructor(tokens, condition, thenBranch, elseBranch, isInline) {
+    constructor(options) {
         super();
-        this.tokens = tokens;
-        this.condition = condition;
-        this.thenBranch = thenBranch;
-        this.elseBranch = elseBranch;
-        this.isInline = isInline;
         this.kind = AstNode_1.AstNodeKind.IfStatement;
-        this.range = util_1.util.createBoundingRange(tokens.if, condition, tokens.then, thenBranch, tokens.else, elseBranch, tokens.endIf);
+        this.condition = options.condition;
+        this.thenBranch = options.thenBranch;
+        this.elseBranch = options.elseBranch;
+        this.isInline = options.isInline;
+        this.tokens = {
+            if: options.if,
+            then: options.then,
+            else: options.else,
+            endIf: options.endIf
+        };
+        this.range = util_1.util.createBoundingRange(util_1.util.createBoundingRangeFromTokens(this.tokens), this.condition, this.thenBranch, this.elseBranch);
     }
     transpile(state) {
+        var _a;
         let results = [];
         //if   (already indented by block)
-        results.push(state.transpileToken(this.tokens.if));
+        results.push(state.transpileToken((_a = this.tokens.if) !== null && _a !== void 0 ? _a : (0, creators_1.createToken)(TokenKind_1.TokenKind.If)));
         results.push(' ');
         //conditions
         results.push(...this.condition.transpile(state));
@@ -411,17 +429,19 @@ class IfStatement extends AstNode_2.Statement {
 }
 exports.IfStatement = IfStatement;
 class IncrementStatement extends AstNode_2.Statement {
-    constructor(value, operator) {
+    constructor(options) {
         super();
-        this.value = value;
-        this.operator = operator;
         this.kind = AstNode_1.AstNodeKind.IncrementStatement;
-        this.range = util_1.util.createBoundingRange(value, operator);
+        this.value = options.value;
+        this.tokens = {
+            operator: options.operator
+        };
+        this.range = util_1.util.createBoundingRange(this.value, this.tokens.operator);
     }
     transpile(state) {
         return [
             ...this.value.transpile(state),
-            state.transpileToken(this.operator)
+            state.transpileToken(this.tokens.operator)
         ];
     }
     walk(visitor, options) {
@@ -437,16 +457,19 @@ exports.IncrementStatement = IncrementStatement;
 class PrintStatement extends AstNode_2.Statement {
     /**
      * Creates a new internal representation of a BrightScript `print` statement.
-     * @param tokens the tokens for this statement
-     * @param tokens.print a print token
-     * @param expressions an array of expressions or `PrintSeparator`s to be evaluated and printed.
+     * @param options the options for this statement
+     * @param options.print a print token
+     * @param options.expressions an array of expressions or `PrintSeparator`s to be evaluated and printed.
      */
-    constructor(tokens, expressions) {
+    constructor(options) {
+        var _a;
         super();
-        this.tokens = tokens;
-        this.expressions = expressions;
         this.kind = AstNode_1.AstNodeKind.PrintStatement;
-        this.range = util_1.util.createBoundingRange(tokens.print, ...(expressions !== null && expressions !== void 0 ? expressions : []));
+        this.tokens = {
+            print: options.print
+        };
+        this.expressions = options.expressions;
+        this.range = util_1.util.createBoundingRange(this.tokens.print, ...((_a = this.expressions) !== null && _a !== void 0 ? _a : []));
     }
     transpile(state) {
         var _a;
@@ -478,22 +501,25 @@ class PrintStatement extends AstNode_2.Statement {
 }
 exports.PrintStatement = PrintStatement;
 class DimStatement extends AstNode_2.Statement {
-    constructor(dimToken, identifier, openingSquare, dimensions, closingSquare) {
+    constructor(options) {
+        var _a;
         super();
-        this.dimToken = dimToken;
-        this.identifier = identifier;
-        this.openingSquare = openingSquare;
-        this.dimensions = dimensions;
-        this.closingSquare = closingSquare;
         this.kind = AstNode_1.AstNodeKind.DimStatement;
-        this.range = util_1.util.createBoundingRange(dimToken, identifier, openingSquare, ...(dimensions !== null && dimensions !== void 0 ? dimensions : []), closingSquare);
+        this.tokens = {
+            dim: options === null || options === void 0 ? void 0 : options.dim,
+            name: options.name,
+            openingSquare: options.openingSquare,
+            closingSquare: options.closingSquare
+        };
+        this.dimensions = options.dimensions;
+        this.range = util_1.util.createBoundingRange(options.dim, options.name, options.openingSquare, ...((_a = this.dimensions) !== null && _a !== void 0 ? _a : []), options.closingSquare);
     }
     transpile(state) {
         let result = [
-            state.transpileToken(this.dimToken),
+            state.transpileToken(this.tokens.dim, 'dim'),
             ' ',
-            state.transpileToken(this.identifier),
-            state.transpileToken(this.openingSquare)
+            state.transpileToken(this.tokens.name),
+            state.transpileToken(this.tokens.openingSquare, '[')
         ];
         for (let i = 0; i < this.dimensions.length; i++) {
             if (i > 0) {
@@ -501,7 +527,7 @@ class DimStatement extends AstNode_2.Statement {
             }
             result.push(...this.dimensions[i].transpile(state));
         }
-        result.push(state.transpileToken(this.closingSquare));
+        result.push(state.transpileToken(this.tokens.closingSquare, ']'));
         return result;
     }
     walk(visitor, options) {
@@ -510,18 +536,30 @@ class DimStatement extends AstNode_2.Statement {
             (0, visitors_1.walkArray)(this.dimensions, visitor, options, this);
         }
     }
+    getType(options) {
+        var _a, _b;
+        const numDimensions = (_b = (_a = this.dimensions) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 1;
+        let type = new types_1.ArrayType();
+        for (let i = 0; i < numDimensions - 1; i++) {
+            type = new types_1.ArrayType(type);
+        }
+        return type;
+    }
 }
 exports.DimStatement = DimStatement;
 class GotoStatement extends AstNode_2.Statement {
-    constructor(tokens) {
+    constructor(options) {
         super();
-        this.tokens = tokens;
         this.kind = AstNode_1.AstNodeKind.GotoStatement;
-        this.range = util_1.util.createBoundingRange(tokens.goto, tokens.label);
+        this.tokens = {
+            goto: options.goto,
+            label: options.label
+        };
+        this.range = util_1.util.createBoundingRange(this.tokens.goto, this.tokens.label);
     }
     transpile(state) {
         return [
-            state.transpileToken(this.tokens.goto),
+            state.transpileToken(this.tokens.goto, 'goto'),
             ' ',
             state.transpileToken(this.tokens.label)
         ];
@@ -532,19 +570,22 @@ class GotoStatement extends AstNode_2.Statement {
 }
 exports.GotoStatement = GotoStatement;
 class LabelStatement extends AstNode_2.Statement {
-    constructor(tokens) {
+    constructor(options) {
         super();
-        this.tokens = tokens;
         this.kind = AstNode_1.AstNodeKind.LabelStatement;
-        this.range = util_1.util.createBoundingRange(tokens.identifier, tokens.colon);
+        this.tokens = {
+            name: options.name,
+            colon: options.colon
+        };
+        this.range = util_1.util.createBoundingRange(this.tokens.name, this.tokens.colon);
     }
     getLeadingTrivia() {
-        return util_1.util.concatAnnotationLeadingTrivia(this, this.tokens.identifier.leadingTrivia);
+        return util_1.util.concatAnnotationLeadingTrivia(this, this.tokens.name.leadingTrivia);
     }
     transpile(state) {
         return [
-            state.transpileToken(this.tokens.identifier),
-            state.transpileToken(this.tokens.colon)
+            state.transpileToken(this.tokens.name),
+            state.transpileToken(this.tokens.colon, ':')
         ];
     }
     walk(visitor, options) {
@@ -553,16 +594,18 @@ class LabelStatement extends AstNode_2.Statement {
 }
 exports.LabelStatement = LabelStatement;
 class ReturnStatement extends AstNode_2.Statement {
-    constructor(tokens, value) {
+    constructor(options) {
         super();
-        this.tokens = tokens;
-        this.value = value;
         this.kind = AstNode_1.AstNodeKind.ReturnStatement;
-        this.range = util_1.util.createBoundingRange(tokens.return, value);
+        this.tokens = {
+            return: options === null || options === void 0 ? void 0 : options.return
+        };
+        this.value = options === null || options === void 0 ? void 0 : options.value;
+        this.range = util_1.util.createBoundingRange(this.tokens.return, this.value);
     }
     transpile(state) {
         let result = [];
-        result.push(state.transpileToken(this.tokens.return));
+        result.push(state.transpileToken(this.tokens.return, 'return'));
         if (this.value) {
             result.push(' ');
             result.push(...this.value.transpile(state));
@@ -577,15 +620,18 @@ class ReturnStatement extends AstNode_2.Statement {
 }
 exports.ReturnStatement = ReturnStatement;
 class EndStatement extends AstNode_2.Statement {
-    constructor(tokens) {
+    constructor(options) {
+        var _a;
         super();
-        this.tokens = tokens;
         this.kind = AstNode_1.AstNodeKind.EndStatement;
-        this.range = tokens.end.range;
+        this.tokens = {
+            end: options === null || options === void 0 ? void 0 : options.end
+        };
+        this.range = (_a = this.tokens.end) === null || _a === void 0 ? void 0 : _a.range;
     }
     transpile(state) {
         return [
-            state.transpileToken(this.tokens.end)
+            state.transpileToken(this.tokens.end, 'end')
         ];
     }
     walk(visitor, options) {
@@ -594,16 +640,16 @@ class EndStatement extends AstNode_2.Statement {
 }
 exports.EndStatement = EndStatement;
 class StopStatement extends AstNode_2.Statement {
-    constructor(tokens) {
-        var _a;
+    constructor(options) {
+        var _a, _b;
         super();
-        this.tokens = tokens;
         this.kind = AstNode_1.AstNodeKind.StopStatement;
-        this.range = (_a = tokens === null || tokens === void 0 ? void 0 : tokens.stop) === null || _a === void 0 ? void 0 : _a.range;
+        this.tokens = { stop: options === null || options === void 0 ? void 0 : options.stop };
+        this.range = (_b = (_a = this.tokens) === null || _a === void 0 ? void 0 : _a.stop) === null || _b === void 0 ? void 0 : _b.range;
     }
     transpile(state) {
         return [
-            state.transpileToken(this.tokens.stop)
+            state.transpileToken(this.tokens.stop, 'stop')
         ];
     }
     walk(visitor, options) {
@@ -612,32 +658,34 @@ class StopStatement extends AstNode_2.Statement {
 }
 exports.StopStatement = StopStatement;
 class ForStatement extends AstNode_2.Statement {
-    constructor(forToken, counterDeclaration, toToken, finalValue, body, endForToken, stepToken, increment) {
+    constructor(options) {
         super();
-        this.forToken = forToken;
-        this.counterDeclaration = counterDeclaration;
-        this.toToken = toToken;
-        this.finalValue = finalValue;
-        this.body = body;
-        this.endForToken = endForToken;
-        this.stepToken = stepToken;
-        this.increment = increment;
         this.kind = AstNode_1.AstNodeKind.ForStatement;
-        this.range = util_1.util.createBoundingRange(forToken, counterDeclaration, toToken, finalValue, stepToken, increment, body, endForToken);
+        this.tokens = {
+            for: options.for,
+            to: options.to,
+            endFor: options.endFor,
+            step: options.step
+        };
+        this.counterDeclaration = options.counterDeclaration;
+        this.finalValue = options.finalValue;
+        this.body = options.body;
+        this.increment = options.increment;
+        this.range = util_1.util.createBoundingRange(this.tokens.for, this.counterDeclaration, this.tokens.to, this.finalValue, this.tokens.step, this.increment, this.body, this.tokens.endFor);
     }
     transpile(state) {
         let result = [];
         //for
-        result.push(state.transpileToken(this.forToken), ' ');
+        result.push(state.transpileToken(this.tokens.for, 'for'), ' ');
         //i=1
         result.push(...this.counterDeclaration.transpile(state), ' ');
         //to
-        result.push(state.transpileToken(this.toToken), ' ');
+        result.push(state.transpileToken(this.tokens.to, 'to'), ' ');
         //final value
         result.push(this.finalValue.transpile(state));
         //step
-        if (this.stepToken) {
-            result.push(' ', state.transpileToken(this.stepToken), ' ', this.increment.transpile(state));
+        if (this.increment) {
+            result.push(' ', state.transpileToken(this.tokens.step, 'step'), ' ', this.increment.transpile(state));
         }
         //loop body
         state.lineage.unshift(this);
@@ -646,7 +694,7 @@ class ForStatement extends AstNode_2.Statement {
         // add new line before "end for"
         result.push('\n');
         //end for
-        result.push(state.indent(), state.transpileToken(this.endForToken));
+        result.push(state.indent(), state.transpileToken(this.tokens.endFor, 'end for'));
         return result;
     }
     walk(visitor, options) {
@@ -664,23 +712,27 @@ class ForStatement extends AstNode_2.Statement {
 }
 exports.ForStatement = ForStatement;
 class ForEachStatement extends AstNode_2.Statement {
-    constructor(tokens, item, target, body) {
+    constructor(options) {
         super();
-        this.tokens = tokens;
-        this.item = item;
-        this.target = target;
-        this.body = body;
         this.kind = AstNode_1.AstNodeKind.ForEachStatement;
-        this.range = util_1.util.createBoundingRange(tokens.forEach, item, tokens.in, target, body, tokens.endFor);
+        this.tokens = {
+            forEach: options.forEach,
+            item: options.item,
+            in: options.in,
+            endFor: options.endFor
+        };
+        this.body = options.body;
+        this.target = options.target;
+        this.range = util_1.util.createBoundingRange(this.tokens.forEach, this.tokens.item, this.tokens.in, this.target, this.body, this.tokens.endFor);
     }
     transpile(state) {
         let result = [];
         //for each
-        result.push(state.transpileToken(this.tokens.forEach), ' ');
+        result.push(state.transpileToken(this.tokens.forEach, 'for each'), ' ');
         //item
-        result.push(state.transpileToken(this.item), ' ');
+        result.push(state.transpileToken(this.tokens.item), ' ');
         //in
-        result.push(state.transpileToken(this.tokens.in), ' ');
+        result.push(state.transpileToken(this.tokens.in, 'in'), ' ');
         //target
         result.push(...this.target.transpile(state));
         //body
@@ -690,7 +742,7 @@ class ForEachStatement extends AstNode_2.Statement {
         // add new line before "end for"
         result.push('\n');
         //end for
-        result.push(state.indent(), state.transpileToken(this.tokens.endFor));
+        result.push(state.indent(), state.transpileToken(this.tokens.endFor, 'end for'));
         return result;
     }
     walk(visitor, options) {
@@ -704,18 +756,21 @@ class ForEachStatement extends AstNode_2.Statement {
 }
 exports.ForEachStatement = ForEachStatement;
 class WhileStatement extends AstNode_2.Statement {
-    constructor(tokens, condition, body) {
+    constructor(options) {
         super();
-        this.tokens = tokens;
-        this.condition = condition;
-        this.body = body;
         this.kind = AstNode_1.AstNodeKind.WhileStatement;
-        this.range = util_1.util.createBoundingRange(tokens.while, condition, body, tokens.endWhile);
+        this.tokens = {
+            while: options.while,
+            endWhile: options.endWhile
+        };
+        this.body = options.body;
+        this.condition = options.condition;
+        this.range = util_1.util.createBoundingRange(this.tokens.while, this.condition, this.body, this.tokens.endWhile);
     }
     transpile(state) {
         let result = [];
         //while
-        result.push(state.transpileToken(this.tokens.while), ' ');
+        result.push(state.transpileToken(this.tokens.while, 'while'), ' ');
         //condition
         result.push(...this.condition.transpile(state));
         state.lineage.unshift(this);
@@ -725,7 +780,7 @@ class WhileStatement extends AstNode_2.Statement {
         //trailing newline only if we have body statements
         result.push('\n');
         //end while
-        result.push(state.indent(), state.transpileToken(this.tokens.endWhile));
+        result.push(state.indent(), state.transpileToken(this.tokens.endWhile, 'end while'));
         return result;
     }
     walk(visitor, options) {
@@ -739,28 +794,30 @@ class WhileStatement extends AstNode_2.Statement {
 }
 exports.WhileStatement = WhileStatement;
 class DottedSetStatement extends AstNode_2.Statement {
-    constructor(obj, name, value, dot) {
+    constructor(options) {
         super();
-        this.obj = obj;
-        this.name = name;
-        this.value = value;
-        this.dot = dot;
         this.kind = AstNode_1.AstNodeKind.DottedSetStatement;
-        this.range = util_1.util.createBoundingRange(obj, dot, name, value);
+        this.tokens = {
+            name: options.name,
+            dot: options.dot
+        };
+        this.obj = options.obj;
+        this.value = options.value;
+        this.range = util_1.util.createBoundingRange(this.obj, this.tokens.dot, this.tokens.name, this.value);
     }
     transpile(state) {
-        var _a, _b;
+        var _a, _b, _c;
         //if the value is a compound assignment, don't add the obj, dot, name, or operator...the expression will handle that
-        if (TokenKind_1.CompoundAssignmentOperators.includes((_b = (_a = this.value) === null || _a === void 0 ? void 0 : _a.operator) === null || _b === void 0 ? void 0 : _b.kind)) {
+        if (TokenKind_1.CompoundAssignmentOperators.includes((_c = (_b = (_a = this.value) === null || _a === void 0 ? void 0 : _a.tokens) === null || _b === void 0 ? void 0 : _b.operator) === null || _c === void 0 ? void 0 : _c.kind)) {
             return this.value.transpile(state);
         }
         else {
             return [
                 //object
                 ...this.obj.transpile(state),
-                this.dot ? state.tokenToSourceNode(this.dot) : '.',
+                this.tokens.dot ? state.tokenToSourceNode(this.tokens.dot) : '.',
                 //name
-                state.transpileToken(this.name),
+                state.transpileToken(this.tokens.name),
                 ' = ',
                 //right-hand-side of assignment
                 ...this.value.transpile(state)
@@ -776,60 +833,67 @@ class DottedSetStatement extends AstNode_2.Statement {
     getType(options) {
         var _a, _b, _c, _d, _e, _f;
         const objType = (_a = this.obj) === null || _a === void 0 ? void 0 : _a.getType(options);
-        const result = objType === null || objType === void 0 ? void 0 : objType.getMemberType((_b = this.name) === null || _b === void 0 ? void 0 : _b.text, options);
-        (_c = options.typeChain) === null || _c === void 0 ? void 0 : _c.push(new interfaces_1.TypeChainEntry((_d = this.name) === null || _d === void 0 ? void 0 : _d.text, result, options.data, (_f = (_e = this.name) === null || _e === void 0 ? void 0 : _e.range) !== null && _f !== void 0 ? _f : this.range));
+        const result = objType === null || objType === void 0 ? void 0 : objType.getMemberType((_b = this.tokens.name) === null || _b === void 0 ? void 0 : _b.text, options);
+        (_c = options.typeChain) === null || _c === void 0 ? void 0 : _c.push(new interfaces_1.TypeChainEntry((_d = this.tokens.name) === null || _d === void 0 ? void 0 : _d.text, result, options.data, (_f = (_e = this.tokens.name) === null || _e === void 0 ? void 0 : _e.range) !== null && _f !== void 0 ? _f : this.range));
         return result;
     }
 }
 exports.DottedSetStatement = DottedSetStatement;
 class IndexedSetStatement extends AstNode_2.Statement {
-    constructor(obj, index, value, openingSquare, closingSquare) {
+    constructor(options) {
         super();
-        this.obj = obj;
-        this.index = index;
-        this.value = value;
-        this.openingSquare = openingSquare;
-        this.closingSquare = closingSquare;
         this.kind = AstNode_1.AstNodeKind.IndexedSetStatement;
-        this.range = util_1.util.createBoundingRange(obj, openingSquare, index, closingSquare, value);
+        this.tokens = {
+            openingSquare: options.openingSquare,
+            closingSquare: options.closingSquare
+        };
+        this.obj = options.obj;
+        this.indexes = options.indexes;
+        this.value = options.value;
+        this.range = util_1.util.createBoundingRange(this.obj, this.tokens.openingSquare, ...this.indexes, this.tokens.closingSquare, this.value);
     }
     transpile(state) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         //if the value is a component assignment, don't add the obj, index or operator...the expression will handle that
-        if (TokenKind_1.CompoundAssignmentOperators.includes((_b = (_a = this.value) === null || _a === void 0 ? void 0 : _a.operator) === null || _b === void 0 ? void 0 : _b.kind)) {
+        if (TokenKind_1.CompoundAssignmentOperators.includes((_c = (_b = (_a = this.value) === null || _a === void 0 ? void 0 : _a.tokens) === null || _b === void 0 ? void 0 : _b.operator) === null || _c === void 0 ? void 0 : _c.kind)) {
             return this.value.transpile(state);
         }
         else {
-            return [
-                //obj
-                ...this.obj.transpile(state),
-                //   [
-                state.transpileToken(this.openingSquare),
-                //    index
-                ...this.index.transpile(state),
-                //         ]
-                state.transpileToken(this.closingSquare),
-                //           =
-                ' = ',
-                //             value
-                ...this.value.transpile(state)
-            ];
+            const result = [];
+            result.push(
+            //obj
+            ...this.obj.transpile(state), 
+            //   [
+            state.transpileToken(this.tokens.openingSquare));
+            for (let i = 0; i < this.indexes.length; i++) {
+                //add comma between indexes
+                if (i > 0) {
+                    result.push(', ');
+                }
+                let index = this.indexes[i];
+                result.push(...((_d = index === null || index === void 0 ? void 0 : index.transpile(state)) !== null && _d !== void 0 ? _d : []));
+            }
+            result.push(state.transpileToken(this.tokens.closingSquare), ' = ', ...this.value.transpile(state));
+            return result;
         }
     }
     walk(visitor, options) {
         if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
             (0, visitors_1.walk)(this, 'obj', visitor, options);
-            (0, visitors_1.walk)(this, 'index', visitor, options);
+            (0, visitors_1.walkArray)(this.indexes, visitor, options, this);
             (0, visitors_1.walk)(this, 'value', visitor, options);
         }
     }
 }
 exports.IndexedSetStatement = IndexedSetStatement;
 class LibraryStatement extends AstNode_2.Statement {
-    constructor(tokens) {
+    constructor(options) {
         super();
-        this.tokens = tokens;
         this.kind = AstNode_1.AstNodeKind.LibraryStatement;
+        this.tokens = {
+            library: options.library,
+            filePath: options.filePath
+        };
         this.range = util_1.util.createBoundingRange(this.tokens.library, this.tokens.filePath);
     }
     transpile(state) {
@@ -850,13 +914,15 @@ class LibraryStatement extends AstNode_2.Statement {
 }
 exports.LibraryStatement = LibraryStatement;
 class NamespaceStatement extends AstNode_2.Statement {
-    constructor(keyword, nameExpression, body, endKeyword) {
+    constructor(options) {
         super();
-        this.keyword = keyword;
-        this.nameExpression = nameExpression;
-        this.body = body;
-        this.endKeyword = endKeyword;
         this.kind = AstNode_1.AstNodeKind.NamespaceStatement;
+        this.tokens = {
+            namespace: options.namespace,
+            endNamespace: options.endNamespace
+        };
+        this.nameExpression = options.nameExpression;
+        this.body = options.body;
         this.name = this.getName(Parser_1.ParseMode.BrighterScript);
         this.symbolTable = new SymbolTable_2.SymbolTable(`NamespaceStatement: '${this.name}'`, () => { var _a; return (_a = this.parent) === null || _a === void 0 ? void 0 : _a.getSymbolTable(); });
     }
@@ -866,7 +932,7 @@ class NamespaceStatement extends AstNode_2.Statement {
     cacheRange() {
         var _a;
         if (!this._range) {
-            this._range = (_a = util_1.util.createBoundingRange(this.keyword, this.nameExpression, this.body, this.endKeyword)) !== null && _a !== void 0 ? _a : creators_1.interpolatedRange;
+            this._range = (_a = util_1.util.createBoundingRange(this.tokens.namespace, this.nameExpression, this.body, this.tokens.endNamespace)) !== null && _a !== void 0 ? _a : creators_1.interpolatedRange;
         }
         return this._range;
     }
@@ -880,7 +946,8 @@ class NamespaceStatement extends AstNode_2.Statement {
         return name;
     }
     getLeadingTrivia() {
-        return util_1.util.concatAnnotationLeadingTrivia(this, this.keyword.leadingTrivia);
+        var _a;
+        return util_1.util.concatAnnotationLeadingTrivia(this, (_a = this.tokens.namespace) === null || _a === void 0 ? void 0 : _a.leadingTrivia);
     }
     getNameParts() {
         var _a, _b;
@@ -921,17 +988,19 @@ class NamespaceStatement extends AstNode_2.Statement {
 }
 exports.NamespaceStatement = NamespaceStatement;
 class ImportStatement extends AstNode_2.Statement {
-    constructor(importToken, filePathToken) {
+    constructor(options) {
         super();
-        this.importToken = importToken;
-        this.filePathToken = filePathToken;
         this.kind = AstNode_1.AstNodeKind.ImportStatement;
-        this.range = util_1.util.createBoundingRange(importToken, filePathToken);
-        if (this.filePathToken) {
+        this.tokens = {
+            import: options.import,
+            filePath: options.filePath
+        };
+        this.range = util_1.util.createBoundingRange(this.tokens.import, this.tokens.filePath);
+        if (this.tokens.filePath) {
             //remove quotes
-            this.filePath = this.filePathToken.text.replace(/"/g, '');
+            this.filePath = this.tokens.filePath.text.replace(/"/g, '');
             //adjust the range to exclude the quotes
-            this.filePathToken.range = util_1.util.createRange(this.filePathToken.range.start.line, this.filePathToken.range.start.character + 1, this.filePathToken.range.end.line, this.filePathToken.range.end.character - 1);
+            this.tokens.filePath.range = util_1.util.createRange(this.tokens.filePath.range.start.line, this.tokens.filePath.range.start.character + 1, this.tokens.filePath.range.end.line, this.tokens.filePath.range.end.character - 1);
         }
     }
     transpile(state) {
@@ -939,20 +1008,21 @@ class ImportStatement extends AstNode_2.Statement {
         //add the import statement as a comment just for debugging purposes
         return [
             `'`,
-            state.transpileToken(this.importToken),
+            state.transpileToken(this.tokens.import, 'import'),
             ' ',
-            state.transpileToken(this.filePathToken)
+            state.transpileToken(this.tokens.filePath)
         ];
     }
     /**
      * Get the typedef for this statement
      */
     getTypedef(state) {
+        var _a, _b;
         return [
-            this.importToken.text,
+            (_b = (_a = this.tokens.import) === null || _a === void 0 ? void 0 : _a.text) !== null && _b !== void 0 ? _b : 'import',
             ' ',
             //replace any `.bs` extension with `.brs`
-            this.filePathToken.text.replace(/\.bs"?$/i, '.brs"')
+            this.tokens.filePath.text.replace(/\.bs"?$/i, '.brs"')
         ];
     }
     walk(visitor, options) {
@@ -961,16 +1031,18 @@ class ImportStatement extends AstNode_2.Statement {
 }
 exports.ImportStatement = ImportStatement;
 class InterfaceStatement extends AstNode_2.Statement {
-    constructor(interfaceToken, name, extendsToken, parentInterfaceName, body, endInterfaceToken) {
+    constructor(options) {
         super();
-        this.parentInterfaceName = parentInterfaceName;
-        this.body = body;
         this.kind = AstNode_1.AstNodeKind.InterfaceStatement;
         this.tokens = {};
-        this.tokens.interface = interfaceToken;
-        this.tokens.name = name;
-        this.tokens.extends = extendsToken;
-        this.tokens.endInterface = endInterfaceToken;
+        this.tokens = {
+            interface: options.interface,
+            name: options.name,
+            extends: options.extends,
+            endInterface: options.endInterface
+        };
+        this.parentInterfaceName = options.parentInterfaceName;
+        this.body = options.body;
         this.range = util_1.util.createBoundingRange(this.tokens.interface, this.tokens.name, this.tokens.extends, this.parentInterfaceName, ...this.body, this.tokens.endInterface);
     }
     get fields() {
@@ -1087,14 +1159,15 @@ class InterfaceStatement extends AstNode_2.Statement {
 }
 exports.InterfaceStatement = InterfaceStatement;
 class InterfaceFieldStatement extends AstNode_2.Statement {
-    constructor(nameToken, asToken, typeExpression, optionalToken) {
+    constructor(options) {
         super();
-        this.typeExpression = typeExpression;
         this.kind = AstNode_1.AstNodeKind.InterfaceFieldStatement;
-        this.tokens = {};
-        this.tokens.optional = optionalToken;
-        this.tokens.name = nameToken;
-        this.tokens.as = asToken;
+        this.tokens = {
+            optional: options.optional,
+            name: options.name,
+            as: options.as
+        };
+        this.typeExpression = options.typeExpression;
         this.range = util_1.util.createBoundingRange(this.tokens.optional, this.tokens.name, this.tokens.as, this.typeExpression);
     }
     transpile(state) {
@@ -1139,18 +1212,20 @@ exports.InterfaceFieldStatement = InterfaceFieldStatement;
 //TODO: there is much that is similar with this and FunctionExpression.
 //It would be nice to refactor this so there is less duplicated code
 class InterfaceMethodStatement extends AstNode_2.Statement {
-    constructor(functionTypeToken, nameToken, leftParen, params, rightParen, asToken, returnTypeExpression, optionalToken) {
+    constructor(options) {
+        var _a;
         super();
-        this.params = params;
-        this.returnTypeExpression = returnTypeExpression;
         this.kind = AstNode_1.AstNodeKind.InterfaceMethodStatement;
-        this.tokens = {};
-        this.tokens.optional = optionalToken;
-        this.tokens.functionType = functionTypeToken;
-        this.tokens.name = nameToken;
-        this.tokens.leftParen = leftParen;
-        this.tokens.rightParen = rightParen;
-        this.tokens.as = asToken;
+        this.tokens = {
+            optional: options.optional,
+            functionType: options.functionType,
+            name: options.name,
+            leftParen: options.leftParen,
+            rightParen: options.rightParen,
+            as: options.as
+        };
+        this.params = (_a = options.params) !== null && _a !== void 0 ? _a : [];
+        this.returnTypeExpression = options.returnTypeExpression;
     }
     transpile(state) {
         throw new Error('Method not implemented.');
@@ -1178,7 +1253,7 @@ class InterfaceMethodStatement extends AstNode_2.Statement {
         }
     }
     getTypedef(state) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         const result = [];
         for (let annotation of (_a = this.annotations) !== null && _a !== void 0 ? _a : []) {
             result.push(...annotation.getTypedef(state), state.newline, state.indent());
@@ -1186,14 +1261,14 @@ class InterfaceMethodStatement extends AstNode_2.Statement {
         if (this.isOptional) {
             result.push(this.tokens.optional.text, ' ');
         }
-        result.push(this.tokens.functionType.text, ' ', this.tokens.name.text, '(');
-        const params = (_b = this.params) !== null && _b !== void 0 ? _b : [];
+        result.push((_c = (_b = this.tokens.functionType) === null || _b === void 0 ? void 0 : _b.text) !== null && _c !== void 0 ? _c : 'function', ' ', this.tokens.name.text, '(');
+        const params = (_d = this.params) !== null && _d !== void 0 ? _d : [];
         for (let i = 0; i < params.length; i++) {
             if (i > 0) {
                 result.push(', ');
             }
             const param = params[i];
-            result.push(param.name.text);
+            result.push(param.tokens.name.text);
             if (param.typeExpression) {
                 result.push(' as ', ...param.typeExpression.getTypedef(state));
             }
@@ -1205,10 +1280,10 @@ class InterfaceMethodStatement extends AstNode_2.Statement {
         return result;
     }
     getType(options) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         //if there's a defined return type, use that
         let returnType = (_a = this.returnTypeExpression) === null || _a === void 0 ? void 0 : _a.getType(options);
-        const isSub = this.tokens.functionType.kind === TokenKind_1.TokenKind.Sub;
+        const isSub = ((_b = this.tokens.functionType) === null || _b === void 0 ? void 0 : _b.kind) === TokenKind_1.TokenKind.Sub || !returnType;
         //if we don't have a return type and this is a sub, set the return type to `void`. else use `dynamic`
         if (!returnType) {
             returnType = isSub ? VoidType_1.VoidType.instance : DynamicType_1.DynamicType.instance;
@@ -1216,54 +1291,51 @@ class InterfaceMethodStatement extends AstNode_2.Statement {
         const resultType = new TypedFunctionType_1.TypedFunctionType(returnType);
         resultType.isSub = isSub;
         for (let param of this.params) {
-            resultType.addParameter(param.name.text, param.getType(options), !!param.defaultValue);
+            resultType.addParameter(param.tokens.name.text, param.getType(options), !!param.defaultValue);
         }
         if (options.typeChain) {
             // need Interface type for type chain
-            (_b = this.parent) === null || _b === void 0 ? void 0 : _b.getType(options);
+            (_c = this.parent) === null || _c === void 0 ? void 0 : _c.getType(options);
         }
         let funcName = this.getName(Parser_1.ParseMode.BrighterScript);
         resultType.setName(funcName);
-        (_c = options.typeChain) === null || _c === void 0 ? void 0 : _c.push(new interfaces_1.TypeChainEntry(resultType.name, resultType, options.data, this.range));
+        (_d = options.typeChain) === null || _d === void 0 ? void 0 : _d.push(new interfaces_1.TypeChainEntry(resultType.name, resultType, options.data, this.range));
         return resultType;
     }
 }
 exports.InterfaceMethodStatement = InterfaceMethodStatement;
 class ClassStatement extends AstNode_2.Statement {
-    constructor(classKeyword, 
-    /**
-     * The name of the class (without namespace prefix)
-     */
-    name, body, end, extendsKeyword, parentClassName) {
-        var _a, _b, _c, _d;
+    constructor(options) {
+        var _a, _b, _c, _d, _e;
         super();
-        this.classKeyword = classKeyword;
-        this.name = name;
-        this.body = body;
-        this.end = end;
-        this.extendsKeyword = extendsKeyword;
-        this.parentClassName = parentClassName;
         this.kind = AstNode_1.AstNodeKind.ClassStatement;
         this.memberMap = {};
         this.methods = [];
         this.fields = [];
-        this.body = (_a = this.body) !== null && _a !== void 0 ? _a : [];
-        this.symbolTable = new SymbolTable_2.SymbolTable(`ClassStatement: '${(_b = this.name) === null || _b === void 0 ? void 0 : _b.text}'`, () => { var _a; return (_a = this.parent) === null || _a === void 0 ? void 0 : _a.getSymbolTable(); });
+        this.body = (_a = options.body) !== null && _a !== void 0 ? _a : [];
+        this.tokens = {
+            name: options.name,
+            class: options.class,
+            endClass: options.endClass,
+            extends: options.extends
+        };
+        this.parentClassName = options.parentClassName;
+        this.symbolTable = new SymbolTable_2.SymbolTable(`ClassStatement: '${(_b = this.tokens.name) === null || _b === void 0 ? void 0 : _b.text}'`, () => { var _a; return (_a = this.parent) === null || _a === void 0 ? void 0 : _a.getSymbolTable(); });
         for (let statement of this.body) {
             if ((0, reflection_1.isMethodStatement)(statement)) {
                 this.methods.push(statement);
-                this.memberMap[(_c = statement === null || statement === void 0 ? void 0 : statement.name) === null || _c === void 0 ? void 0 : _c.text.toLowerCase()] = statement;
+                this.memberMap[(_c = statement === null || statement === void 0 ? void 0 : statement.tokens.name) === null || _c === void 0 ? void 0 : _c.text.toLowerCase()] = statement;
             }
             else if ((0, reflection_1.isFieldStatement)(statement)) {
                 this.fields.push(statement);
-                this.memberMap[(_d = statement === null || statement === void 0 ? void 0 : statement.name) === null || _d === void 0 ? void 0 : _d.text.toLowerCase()] = statement;
+                this.memberMap[(_d = statement === null || statement === void 0 ? void 0 : statement.tokens.name) === null || _d === void 0 ? void 0 : _d.text.toLowerCase()] = statement;
             }
         }
-        this.range = util_1.util.createBoundingRange(classKeyword, name, extendsKeyword, parentClassName, ...(body !== null && body !== void 0 ? body : []), end);
+        this.range = util_1.util.createBoundingRange(this.parentClassName, ...((_e = this.body) !== null && _e !== void 0 ? _e : []), util_1.util.createBoundingRangeFromTokens(this.tokens));
     }
     getName(parseMode) {
         var _a;
-        const name = (_a = this.name) === null || _a === void 0 ? void 0 : _a.text;
+        const name = (_a = this.tokens.name) === null || _a === void 0 ? void 0 : _a.text;
         if (name) {
             const namespace = this.findAncestor(reflection_1.isNamespaceStatement);
             if (namespace) {
@@ -1281,7 +1353,8 @@ class ClassStatement extends AstNode_2.Statement {
         }
     }
     getLeadingTrivia() {
-        return util_1.util.concatAnnotationLeadingTrivia(this, this.classKeyword.leadingTrivia);
+        var _a;
+        return util_1.util.concatAnnotationLeadingTrivia(this, (_a = this.tokens.class) === null || _a === void 0 ? void 0 : _a.leadingTrivia);
     }
     transpile(state) {
         let result = [];
@@ -1298,8 +1371,8 @@ class ClassStatement extends AstNode_2.Statement {
         for (let annotation of (_a = this.annotations) !== null && _a !== void 0 ? _a : []) {
             result.push(...annotation.getTypedef(state), state.newline, state.indent());
         }
-        result.push('class ', this.name.text);
-        if (this.extendsKeyword && this.parentClassName) {
+        result.push('class ', this.tokens.name.text);
+        if (this.parentClassName) {
             const namespace = this.findAncestor(reflection_1.isNamespaceStatement);
             const fqName = util_1.util.getFullyQualifiedClassName(this.parentClassName.getName(), namespace === null || namespace === void 0 ? void 0 : namespace.getName(Parser_1.ParseMode.BrighterScript));
             result.push(` extends ${fqName}`);
@@ -1396,7 +1469,7 @@ class ClassStatement extends AstNode_2.Statement {
     getConstructorFunction() {
         return this.body.find((stmt) => {
             var _a, _b;
-            return ((_b = (_a = stmt === null || stmt === void 0 ? void 0 : stmt.name) === null || _a === void 0 ? void 0 : _a.text) === null || _b === void 0 ? void 0 : _b.toLowerCase()) === 'new';
+            return ((_b = (_a = stmt === null || stmt === void 0 ? void 0 : stmt.tokens.name) === null || _a === void 0 ? void 0 : _a.text) === null || _b === void 0 ? void 0 : _b.toLowerCase()) === 'new';
         });
     }
     /**
@@ -1457,13 +1530,13 @@ class ClassStatement extends AstNode_2.Statement {
                 //store overridden parent methods as super{parentIndex}_{methodName}
                 if (
                 //is override method
-                statement.override ||
+                statement.tokens.override ||
                     //is constructor function in child class
-                    (statement.name.text.toLowerCase() === 'new' && ancestors[0])) {
-                    result.push(`instance.super${parentClassIndex}_${statement.name.text} = instance.${statement.name.text}`, state.newline, state.indent());
+                    (statement.tokens.name.text.toLowerCase() === 'new' && ancestors[0])) {
+                    result.push(`instance.super${parentClassIndex}_${statement.tokens.name.text} = instance.${statement.tokens.name.text}`, state.newline, state.indent());
                 }
                 state.classStatement = this;
-                result.push('instance.', state.transpileToken(statement.name), ' = ', ...statement.transpile(state), state.newline, state.indent());
+                result.push('instance.', state.transpileToken(statement.tokens.name), ' = ', ...statement.transpile(state), state.newline, state.indent());
                 delete state.classStatement;
             }
             else {
@@ -1487,7 +1560,7 @@ class ClassStatement extends AstNode_2.Statement {
         let result = [];
         const constructorFunction = this.getConstructorFunction();
         const constructorParams = constructorFunction ? constructorFunction.func.parameters : [];
-        result.push(state.sourceNode(this.classKeyword, 'function'), state.sourceNode(this.classKeyword, ' '), state.sourceNode(this.name, this.getName(Parser_1.ParseMode.BrightScript)), `(`);
+        result.push(state.sourceNode(this, 'function'), state.sourceNode(this, ' '), state.sourceNode(this.tokens.name, this.getName(Parser_1.ParseMode.BrightScript)), `(`);
         let i = 0;
         for (let param of constructorParams) {
             if (i > 0) {
@@ -1508,7 +1581,7 @@ class ClassStatement extends AstNode_2.Statement {
             if (i > 0) {
                 result.push(', ');
             }
-            result.push(state.transpileToken(param.name));
+            result.push(state.transpileToken(param.tokens.name));
             i++;
         }
         result.push(')', '\n');
@@ -1539,7 +1612,7 @@ class ClassStatement extends AstNode_2.Statement {
             if (((_c = statement.accessModifier) === null || _c === void 0 ? void 0 : _c.kind) === TokenKind_1.TokenKind.Protected) {
                 flag |= SymbolTable_1.SymbolTypeFlag.protected;
             }
-            resultType.addMember((_d = statement === null || statement === void 0 ? void 0 : statement.name) === null || _d === void 0 ? void 0 : _d.text, { definingNode: statement }, funcType, flag);
+            resultType.addMember((_d = statement === null || statement === void 0 ? void 0 : statement.tokens.name) === null || _d === void 0 ? void 0 : _d.text, { definingNode: statement }, funcType, flag);
         }
         for (const statement of this.fields) {
             const fieldType = statement.getType(Object.assign(Object.assign({}, options), { typeChain: undefined })); //no typechain needed
@@ -1547,13 +1620,13 @@ class ClassStatement extends AstNode_2.Statement {
             if (statement.isOptional) {
                 flag |= SymbolTable_1.SymbolTypeFlag.optional;
             }
-            if (((_e = statement.accessModifier) === null || _e === void 0 ? void 0 : _e.kind) === TokenKind_1.TokenKind.Private) {
+            if (((_e = statement.tokens.accessModifier) === null || _e === void 0 ? void 0 : _e.kind) === TokenKind_1.TokenKind.Private) {
                 flag |= SymbolTable_1.SymbolTypeFlag.private;
             }
-            if (((_f = statement.accessModifier) === null || _f === void 0 ? void 0 : _f.kind) === TokenKind_1.TokenKind.Protected) {
+            if (((_f = statement.tokens.accessModifier) === null || _f === void 0 ? void 0 : _f.kind) === TokenKind_1.TokenKind.Protected) {
                 flag |= SymbolTable_1.SymbolTypeFlag.protected;
             }
-            resultType.addMember((_g = statement === null || statement === void 0 ? void 0 : statement.name) === null || _g === void 0 ? void 0 : _g.text, { definingNode: statement }, fieldType, flag);
+            resultType.addMember((_g = statement === null || statement === void 0 ? void 0 : statement.tokens.name) === null || _g === void 0 ? void 0 : _g.text, { definingNode: statement }, fieldType, flag);
         }
         (_h = options.typeChain) === null || _h === void 0 ? void 0 : _h.push(new interfaces_1.TypeChainEntry(resultType.name, resultType, options.data, this.range));
         return resultType;
@@ -1566,20 +1639,20 @@ const accessModifiers = [
     TokenKind_1.TokenKind.Private
 ];
 class MethodStatement extends FunctionStatement {
-    constructor(modifiers, name, func, override) {
-        super(name, func);
-        this.override = override;
+    constructor(options) {
+        super(options);
         this.kind = AstNode_1.AstNodeKind.MethodStatement;
         this.modifiers = [];
-        if (modifiers) {
-            if (Array.isArray(modifiers)) {
-                this.modifiers.push(...modifiers);
+        if (options.modifiers) {
+            if (Array.isArray(options.modifiers)) {
+                this.modifiers.push(...options.modifiers);
             }
             else {
-                this.modifiers.push(modifiers);
+                this.modifiers.push(options.modifiers);
             }
         }
-        this.range = util_1.util.createBoundingRange(...(this.modifiers), override, func);
+        this.tokens = Object.assign(Object.assign({}, this.tokens), { override: options.override });
+        this.range = util_1.util.createBoundingRange(...(this.modifiers), util_1.util.createBoundingRangeFromTokens(this.tokens), this.func);
     }
     get accessModifier() {
         return this.modifiers.find(x => accessModifiers.includes(x.kind));
@@ -1588,13 +1661,13 @@ class MethodStatement extends FunctionStatement {
      * Get the name of this method.
      */
     getName(parseMode) {
-        return this.name.text;
+        return this.tokens.name.text;
     }
     getLeadingTrivia() {
         return util_1.util.concatAnnotationLeadingTrivia(this, this.func.getLeadingTrivia());
     }
     transpile(state) {
-        if (this.name.text.toLowerCase() === 'new') {
+        if (this.tokens.name.text.toLowerCase() === 'new') {
             this.ensureSuperConstructorCall(state);
             //TODO we need to undo this at the bottom of this method
             this.injectFieldInitializersForConstructor(state);
@@ -1604,16 +1677,16 @@ class MethodStatement extends FunctionStatement {
         const parentClassIndex = state.classStatement.getParentClassIndex(state);
         const visitor = (0, visitors_1.createVisitor)({
             VariableExpression: e => {
-                if (e.name.text.toLocaleLowerCase() === 'super') {
-                    state.editor.setProperty(e.name, 'text', `m.super${parentClassIndex}_new`);
+                if (e.tokens.name.text.toLocaleLowerCase() === 'super') {
+                    state.editor.setProperty(e.tokens.name, 'text', `m.super${parentClassIndex}_new`);
                 }
             },
             DottedGetExpression: e => {
                 const beginningVariable = util_1.util.findBeginningVariableExpression(e);
                 const lowerName = beginningVariable === null || beginningVariable === void 0 ? void 0 : beginningVariable.getName(Parser_1.ParseMode.BrighterScript).toLowerCase();
                 if (lowerName === 'super') {
-                    state.editor.setProperty(beginningVariable.name, 'text', 'm');
-                    state.editor.setProperty(e.name, 'text', `super${parentClassIndex}_${e.name.text}`);
+                    state.editor.setProperty(beginningVariable.tokens.name, 'text', 'm');
+                    state.editor.setProperty(e.tokens.name, 'text', `super${parentClassIndex}_${e.tokens.name.text}`);
                 }
             }
         });
@@ -1633,7 +1706,7 @@ class MethodStatement extends FunctionStatement {
         if (this.accessModifier) {
             result.push(this.accessModifier.text, ' ');
         }
-        if (this.override) {
+        if (this.tokens.override) {
             result.push('override ');
         }
         result.push(...this.func.getTypedef(state));
@@ -1653,35 +1726,44 @@ class MethodStatement extends FunctionStatement {
             //is a call statement
             return (0, reflection_1.isExpressionStatement)(x) && (0, reflection_1.isCallExpression)(x.expression) &&
                 //is a call to super
-                util_1.util.findBeginningVariableExpression(x.expression.callee).name.text.toLowerCase() === 'super';
+                util_1.util.findBeginningVariableExpression(x.expression.callee).tokens.name.text.toLowerCase() === 'super';
         }) !== -1;
         //if a call to super exists, quit here
         if (containsSuperCall) {
             return;
         }
         //this is a child class, and the constructor doesn't contain a call to super. Inject one
-        const superCall = new ExpressionStatement(new Expression_1.CallExpression(new Expression_1.VariableExpression({
-            kind: TokenKind_1.TokenKind.Identifier,
-            text: 'super',
-            isReserved: false,
-            range: state.classStatement.name.range,
-            leadingWhitespace: '',
-            leadingTrivia: []
-        }), {
-            kind: TokenKind_1.TokenKind.LeftParen,
-            text: '(',
-            isReserved: false,
-            range: state.classStatement.name.range,
-            leadingWhitespace: '',
-            leadingTrivia: []
-        }, {
-            kind: TokenKind_1.TokenKind.RightParen,
-            text: ')',
-            isReserved: false,
-            range: state.classStatement.name.range,
-            leadingWhitespace: '',
-            leadingTrivia: []
-        }, []));
+        const superCall = new ExpressionStatement({
+            expression: new Expression_1.CallExpression({
+                callee: new Expression_1.VariableExpression({
+                    name: {
+                        kind: TokenKind_1.TokenKind.Identifier,
+                        text: 'super',
+                        isReserved: false,
+                        range: state.classStatement.tokens.name.range,
+                        leadingWhitespace: '',
+                        leadingTrivia: []
+                    }
+                }),
+                openingParen: {
+                    kind: TokenKind_1.TokenKind.LeftParen,
+                    text: '(',
+                    isReserved: false,
+                    range: state.classStatement.tokens.name.range,
+                    leadingWhitespace: '',
+                    leadingTrivia: []
+                },
+                closingParen: {
+                    kind: TokenKind_1.TokenKind.RightParen,
+                    text: ')',
+                    isReserved: false,
+                    range: state.classStatement.tokens.name.range,
+                    leadingWhitespace: '',
+                    leadingTrivia: []
+                },
+                args: []
+            })
+        });
         state.editor.arrayUnshift(this.func.body.statements, superCall);
     }
     /**
@@ -1692,13 +1774,20 @@ class MethodStatement extends FunctionStatement {
         let newStatements = [];
         //insert the field initializers in order
         for (let field of state.classStatement.fields) {
-            let thisQualifiedName = Object.assign({}, field.name);
-            thisQualifiedName.text = 'm.' + field.name.text;
+            let thisQualifiedName = Object.assign({}, field.tokens.name);
+            thisQualifiedName.text = 'm.' + field.tokens.name.text;
             const fieldAssignment = field.initialValue
-                ? new AssignmentStatement(field.equal, thisQualifiedName, field.initialValue)
-                : new AssignmentStatement((0, creators_1.createToken)(TokenKind_1.TokenKind.Equal, '=', field.name.range), thisQualifiedName, 
-                //if there is no initial value, set the initial value to `invalid`
-                (0, creators_1.createInvalidLiteral)('invalid', field.name.range));
+                ? new AssignmentStatement({
+                    equals: field.tokens.equals,
+                    name: thisQualifiedName,
+                    value: field.initialValue
+                })
+                : new AssignmentStatement({
+                    equals: (0, creators_1.createToken)(TokenKind_1.TokenKind.Equal, '=', field.tokens.name.range),
+                    name: thisQualifiedName,
+                    //if there is no initial value, set the initial value to `invalid`
+                    value: (0, creators_1.createInvalidLiteral)('invalid', field.tokens.name.range)
+                });
             // Add parent so namespace lookups work
             fieldAssignment.parent = state.classStatement;
             newStatements.push(fieldAssignment);
@@ -1713,17 +1802,19 @@ class MethodStatement extends FunctionStatement {
 }
 exports.MethodStatement = MethodStatement;
 class FieldStatement extends AstNode_2.Statement {
-    constructor(accessModifier, name, as, typeExpression, equal, initialValue, optional) {
+    constructor(options) {
         super();
-        this.accessModifier = accessModifier;
-        this.name = name;
-        this.as = as;
-        this.typeExpression = typeExpression;
-        this.equal = equal;
-        this.initialValue = initialValue;
-        this.optional = optional;
         this.kind = AstNode_1.AstNodeKind.FieldStatement;
-        this.range = util_1.util.createBoundingRange(accessModifier, optional, name, as, typeExpression, equal, initialValue);
+        this.tokens = {
+            accessModifier: options.accessModifier,
+            name: options.name,
+            as: options.as,
+            equals: options.equals,
+            optional: options.optional
+        };
+        this.typeExpression = options.typeExpression;
+        this.initialValue = options.initialValue;
+        this.range = util_1.util.createBoundingRange(util_1.util.createBoundingRangeFromTokens(this.tokens), this.typeExpression, this.initialValue);
     }
     /**
      * Derive a ValueKind from the type token, or the initial value.
@@ -1735,10 +1826,10 @@ class FieldStatement extends AstNode_2.Statement {
     }
     getLeadingTrivia() {
         var _a, _b, _c, _d, _e, _f;
-        return util_1.util.concatAnnotationLeadingTrivia(this, (_f = (_d = (_b = (_a = this.accessModifier) === null || _a === void 0 ? void 0 : _a.leadingTrivia) !== null && _b !== void 0 ? _b : (_c = this.optional) === null || _c === void 0 ? void 0 : _c.leadingTrivia) !== null && _d !== void 0 ? _d : (_e = this.name) === null || _e === void 0 ? void 0 : _e.leadingTrivia) !== null && _f !== void 0 ? _f : []);
+        return util_1.util.concatAnnotationLeadingTrivia(this, (_f = (_d = (_b = (_a = this.tokens.accessModifier) === null || _a === void 0 ? void 0 : _a.leadingTrivia) !== null && _b !== void 0 ? _b : (_c = this.tokens.optional) === null || _c === void 0 ? void 0 : _c.leadingTrivia) !== null && _d !== void 0 ? _d : (_e = this.tokens.name) === null || _e === void 0 ? void 0 : _e.leadingTrivia) !== null && _f !== void 0 ? _f : []);
     }
     get isOptional() {
-        return !!this.optional;
+        return !!this.tokens.optional;
     }
     transpile(state) {
         throw new Error('transpile not implemented for ' + Object.getPrototypeOf(this).constructor.name);
@@ -1746,7 +1837,7 @@ class FieldStatement extends AstNode_2.Statement {
     getTypedef(state) {
         var _a, _b, _c, _d;
         const result = [];
-        if (this.name) {
+        if (this.tokens.name) {
             for (let annotation of (_a = this.annotations) !== null && _a !== void 0 ? _a : []) {
                 result.push(...annotation.getTypedef(state), state.newline, state.indent());
             }
@@ -1754,11 +1845,11 @@ class FieldStatement extends AstNode_2.Statement {
             if ((0, reflection_1.isInvalidType)(type) || (0, reflection_1.isVoidType)(type)) {
                 type = new DynamicType_1.DynamicType();
             }
-            result.push((_c = (_b = this.accessModifier) === null || _b === void 0 ? void 0 : _b.text) !== null && _c !== void 0 ? _c : 'public', ' ');
+            result.push((_c = (_b = this.tokens.accessModifier) === null || _b === void 0 ? void 0 : _b.text) !== null && _c !== void 0 ? _c : 'public', ' ');
             if (this.isOptional) {
-                result.push(this.optional.text, ' ');
+                result.push(this.tokens.optional.text, ' ');
             }
-            result.push((_d = this.name) === null || _d === void 0 ? void 0 : _d.text, ' as ', type.toTypeString());
+            result.push((_d = this.tokens.name) === null || _d === void 0 ? void 0 : _d.text, ' as ', type.toTypeString());
         }
         return result;
     }
@@ -1771,25 +1862,28 @@ class FieldStatement extends AstNode_2.Statement {
 }
 exports.FieldStatement = FieldStatement;
 class TryCatchStatement extends AstNode_2.Statement {
-    constructor(tokens, tryBranch, catchStatement) {
+    constructor(options) {
         super();
-        this.tokens = tokens;
-        this.tryBranch = tryBranch;
-        this.catchStatement = catchStatement;
         this.kind = AstNode_1.AstNodeKind.TryCatchStatement;
-        this.range = util_1.util.createBoundingRange(tokens.try, tryBranch, catchStatement, tokens.endTry);
+        this.tokens = {
+            try: options.try,
+            endTry: options.endTry
+        };
+        this.tryBranch = options.tryBranch;
+        this.catchStatement = options.catchStatement;
+        this.range = util_1.util.createBoundingRange(this.tokens.try, this.tryBranch, this.catchStatement, this.tokens.endTry);
     }
     transpile(state) {
         var _a, _b;
         return [
-            state.transpileToken(this.tokens.try),
+            state.transpileToken(this.tokens.try, 'try'),
             ...this.tryBranch.transpile(state),
             state.newline,
             state.indent(),
             ...((_b = (_a = this.catchStatement) === null || _a === void 0 ? void 0 : _a.transpile(state)) !== null && _b !== void 0 ? _b : ['catch']),
             state.newline,
             state.indent(),
-            state.transpileToken(this.tokens.endTry)
+            state.transpileToken(this.tokens.endTry, 'end try')
         ];
     }
     walk(visitor, options) {
@@ -1801,20 +1895,22 @@ class TryCatchStatement extends AstNode_2.Statement {
 }
 exports.TryCatchStatement = TryCatchStatement;
 class CatchStatement extends AstNode_2.Statement {
-    constructor(tokens, exceptionVariable, catchBranch) {
+    constructor(options) {
         super();
-        this.tokens = tokens;
-        this.exceptionVariable = exceptionVariable;
-        this.catchBranch = catchBranch;
         this.kind = AstNode_1.AstNodeKind.CatchStatement;
-        this.range = util_1.util.createBoundingRange(tokens.catch, exceptionVariable, catchBranch);
+        this.tokens = {
+            catch: options === null || options === void 0 ? void 0 : options.catch,
+            exceptionVariable: options === null || options === void 0 ? void 0 : options.exceptionVariable
+        };
+        this.catchBranch = options === null || options === void 0 ? void 0 : options.catchBranch;
+        this.range = util_1.util.createBoundingRange(this.tokens.catch, this.tokens.exceptionVariable, this.catchBranch);
     }
     transpile(state) {
         var _a, _b, _c, _d;
         return [
-            state.transpileToken(this.tokens.catch),
+            state.transpileToken(this.tokens.catch, 'catch'),
             ' ',
-            (_b = (_a = this.exceptionVariable) === null || _a === void 0 ? void 0 : _a.text) !== null && _b !== void 0 ? _b : 'e',
+            (_b = (_a = this.tokens.exceptionVariable) === null || _a === void 0 ? void 0 : _a.text) !== null && _b !== void 0 ? _b : 'e',
             ...((_d = (_c = this.catchBranch) === null || _c === void 0 ? void 0 : _c.transpile(state)) !== null && _d !== void 0 ? _d : [])
         ];
     }
@@ -1826,16 +1922,18 @@ class CatchStatement extends AstNode_2.Statement {
 }
 exports.CatchStatement = CatchStatement;
 class ThrowStatement extends AstNode_2.Statement {
-    constructor(throwToken, expression) {
+    constructor(options) {
         super();
-        this.throwToken = throwToken;
-        this.expression = expression;
         this.kind = AstNode_1.AstNodeKind.ThrowStatement;
-        this.range = util_1.util.createBoundingRange(throwToken, expression);
+        this.tokens = {
+            throw: options.throw
+        };
+        this.expression = options.expression;
+        this.range = util_1.util.createBoundingRange(this.tokens.throw, this.expression);
     }
     transpile(state) {
         const result = [
-            state.transpileToken(this.throwToken),
+            state.transpileToken(this.tokens.throw, 'throw'),
             ' '
         ];
         //if we have an expression, transpile it
@@ -1856,13 +1954,16 @@ class ThrowStatement extends AstNode_2.Statement {
 }
 exports.ThrowStatement = ThrowStatement;
 class EnumStatement extends AstNode_2.Statement {
-    constructor(tokens, body) {
+    constructor(options) {
         var _a;
         super();
-        this.tokens = tokens;
-        this.body = body;
         this.kind = AstNode_1.AstNodeKind.EnumStatement;
         this.symbolTable = new SymbolTable_2.SymbolTable('Enum');
+        this.tokens = {
+            enum: options.enum,
+            name: options.name,
+            endEnum: options.endEnum
+        };
         this.body = (_a = this.body) !== null && _a !== void 0 ? _a : [];
     }
     get range() {
@@ -1885,7 +1986,7 @@ class EnumStatement extends AstNode_2.Statement {
      * All values are stored as their AST LiteralExpression representation (i.e. string enum values include the wrapping quotes)
      */
     getMemberValueMap() {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         const result = new Map();
         const members = this.getMembers();
         let currentIntValue = 0;
@@ -1896,22 +1997,22 @@ class EnumStatement extends AstNode_2.Statement {
                 currentIntValue++;
                 //if explicit integer value, use it and increment the int counter
             }
-            else if ((0, reflection_1.isLiteralExpression)(member.value) && member.value.token.kind === TokenKind_1.TokenKind.IntegerLiteral) {
+            else if ((0, reflection_1.isLiteralExpression)(member.value) && member.value.tokens.value.kind === TokenKind_1.TokenKind.IntegerLiteral) {
                 //try parsing as integer literal, then as hex integer literal.
-                let tokenIntValue = (_b = util_1.util.parseInt(member.value.token.text)) !== null && _b !== void 0 ? _b : util_1.util.parseInt(member.value.token.text.replace(/&h/i, '0x'));
+                let tokenIntValue = (_b = util_1.util.parseInt(member.value.tokens.value.text)) !== null && _b !== void 0 ? _b : util_1.util.parseInt(member.value.tokens.value.text.replace(/&h/i, '0x'));
                 if (tokenIntValue !== undefined) {
                     currentIntValue = tokenIntValue;
                     currentIntValue++;
                 }
-                result.set((_c = member.name) === null || _c === void 0 ? void 0 : _c.toLowerCase(), member.value.token.text);
+                result.set((_c = member.name) === null || _c === void 0 ? void 0 : _c.toLowerCase(), member.value.tokens.value.text);
                 //simple unary expressions (like `-1`)
             }
             else if ((0, reflection_1.isUnaryExpression)(member.value) && (0, reflection_1.isLiteralExpression)(member.value.right)) {
-                result.set((_d = member.name) === null || _d === void 0 ? void 0 : _d.toLowerCase(), member.value.operator.text + member.value.right.token.text);
+                result.set((_d = member.name) === null || _d === void 0 ? void 0 : _d.toLowerCase(), member.value.tokens.operator.text + member.value.right.tokens.value.text);
                 //all other values
             }
             else {
-                result.set((_e = member.name) === null || _e === void 0 ? void 0 : _e.toLowerCase(), (_h = (_g = (_f = member.value) === null || _f === void 0 ? void 0 : _f.token) === null || _g === void 0 ? void 0 : _g.text) !== null && _h !== void 0 ? _h : 'invalid');
+                result.set((_e = member.name) === null || _e === void 0 ? void 0 : _e.toLowerCase(), (_j = (_h = (_g = (_f = member.value) === null || _f === void 0 ? void 0 : _f.tokens) === null || _g === void 0 ? void 0 : _g.value) === null || _h === void 0 ? void 0 : _h.text) !== null && _j !== void 0 ? _j : 'invalid');
             }
         }
         return result;
@@ -1952,12 +2053,12 @@ class EnumStatement extends AstNode_2.Statement {
         return [];
     }
     getTypedef(state) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         const result = [];
         for (let annotation of (_a = this.annotations) !== null && _a !== void 0 ? _a : []) {
             result.push(...annotation.getTypedef(state), state.newline, state.indent());
         }
-        result.push((_b = this.tokens.enum.text) !== null && _b !== void 0 ? _b : 'enum', ' ', this.tokens.name.text);
+        result.push((_c = (_b = this.tokens.enum) === null || _b === void 0 ? void 0 : _b.text) !== null && _c !== void 0 ? _c : 'enum', ' ', this.tokens.name.text);
         result.push(state.newline);
         state.blockDepth++;
         for (const member of this.body) {
@@ -1966,7 +2067,7 @@ class EnumStatement extends AstNode_2.Statement {
             }
         }
         state.blockDepth--;
-        result.push(state.indent(), (_c = this.tokens.endEnum.text) !== null && _c !== void 0 ? _c : 'end enum');
+        result.push(state.indent(), (_e = (_d = this.tokens.endEnum) === null || _d === void 0 ? void 0 : _d.text) !== null && _e !== void 0 ? _e : 'end enum');
         return result;
     }
     walk(visitor, options) {
@@ -1987,14 +2088,17 @@ class EnumStatement extends AstNode_2.Statement {
 }
 exports.EnumStatement = EnumStatement;
 class EnumMemberStatement extends AstNode_2.Statement {
-    constructor(tokens, value) {
+    constructor(options) {
         super();
-        this.tokens = tokens;
-        this.value = value;
         this.kind = AstNode_1.AstNodeKind.EnumMemberStatement;
+        this.tokens = {
+            name: options.name,
+            equals: options.equals
+        };
+        this.value = options.value;
     }
     get range() {
-        return util_1.util.createBoundingRange(this.tokens.name, this.tokens.equal, this.value);
+        return util_1.util.createBoundingRange(this.tokens.name, this.tokens.equals, this.value);
     }
     /**
      * The name of the member
@@ -2012,8 +2116,8 @@ class EnumMemberStatement extends AstNode_2.Statement {
         const result = [
             this.tokens.name.text
         ];
-        if (this.tokens.equal) {
-            result.push(' ', this.tokens.equal.text, ' ');
+        if (this.tokens.equals) {
+            result.push(' ', this.tokens.equals.text, ' ');
             if (this.value) {
                 result.push(...this.value.transpile(state));
             }
@@ -2032,11 +2136,15 @@ class EnumMemberStatement extends AstNode_2.Statement {
 }
 exports.EnumMemberStatement = EnumMemberStatement;
 class ConstStatement extends AstNode_2.Statement {
-    constructor(tokens, value) {
+    constructor(options) {
         super();
-        this.tokens = tokens;
-        this.value = value;
         this.kind = AstNode_1.AstNodeKind.ConstStatement;
+        this.tokens = {
+            const: options.const,
+            name: options.name,
+            equals: options.equals
+        };
+        this.value = options.value;
         this.range = util_1.util.createBoundingRange(this.tokens.const, this.tokens.name, this.tokens.equals, this.value);
     }
     get name() {
@@ -2072,11 +2180,11 @@ class ConstStatement extends AstNode_2.Statement {
     }
     getTypedef(state) {
         return [
-            state.tokenToSourceNode(this.tokens.const),
+            this.tokens.const ? state.tokenToSourceNode(this.tokens.const) : 'const',
             ' ',
             state.tokenToSourceNode(this.tokens.name),
             ' ',
-            state.tokenToSourceNode(this.tokens.equals),
+            this.tokens.equals ? state.tokenToSourceNode(this.tokens.equals) : '=',
             ' ',
             ...this.value.transpile(state)
         ];
@@ -2092,11 +2200,14 @@ class ConstStatement extends AstNode_2.Statement {
 }
 exports.ConstStatement = ConstStatement;
 class ContinueStatement extends AstNode_2.Statement {
-    constructor(tokens) {
+    constructor(options) {
         super();
-        this.tokens = tokens;
         this.kind = AstNode_1.AstNodeKind.ContinueStatement;
-        this.range = util_1.util.createBoundingRange(tokens.continue, tokens.loopType);
+        this.tokens = {
+            continue: options.continue,
+            loopType: options.loopType
+        };
+        this.range = util_1.util.createBoundingRange(this.tokens.continue, this.tokens.loopType);
     }
     transpile(state) {
         var _a, _b, _c, _d, _e;