brighterscript 0.66.0-alpha.9 → 0.67.1

package/dist/parser/Parser.js

@@ -8,7 +8,7 @@ const Statement_1 = require("./Statement");
 const DiagnosticMessages_1 = require("../DiagnosticMessages");
 const util_1 = require("../util");
 const Expression_1 = require("./Expression");
-const Logger_1 = require("../Logger");
+const logging_1 = require("../logging");
 const reflection_1 = require("../astUtils/reflection");
 const visitors_1 = require("../astUtils/visitors");
 const creators_1 = require("../astUtils/creators");
@@ -95,16 +95,17 @@ class Parser {
      */
     parse(toParse, options) {
         var _a;
+        this.logger = (_a = options === null || options === void 0 ? void 0 : options.logger) !== null && _a !== void 0 ? _a : (0, logging_1.createLogger)();
+        options = this.sanitizeParseOptions(options);
+        this.options = options;
         let tokens;
         if (typeof toParse === 'string') {
-            tokens = Lexer_1.Lexer.scan(toParse).tokens;
+            tokens = Lexer_1.Lexer.scan(toParse, { trackLocations: options.trackLocations }).tokens;
         }
         else {
             tokens = toParse;
         }
-        this.logger = (_a = options === null || options === void 0 ? void 0 : options.logger) !== null && _a !== void 0 ? _a : new Logger_1.Logger();
         this.tokens = tokens;
-        this.options = this.sanitizeParseOptions(options);
         this.allowedLocalIdentifiers = [
             ...TokenKind_1.AllowedLocalIdentifiers,
             //when in plain brightscript mode, the BrighterScript source literals can be used as regular variables
@@ -153,7 +154,11 @@ class Parser {
         return body;
     }
     sanitizeParseOptions(options) {
-        return Object.assign({ mode: 'brightscript' }, (options || {}));
+        var _a, _b;
+        options !== null && options !== void 0 ? options : (options = {});
+        (_a = options.mode) !== null && _a !== void 0 ? _a : (options.mode = ParseMode.BrightScript);
+        (_b = options.trackLocations) !== null && _b !== void 0 ? _b : (options.trackLocations = true);
+        return options;
     }
     /**
      * Determine if the parser is currently parsing tokens at the root level.
@@ -243,30 +248,18 @@ class Parser {
     interfaceFieldStatement(optionalKeyword) {
         const name = this.identifier(...TokenKind_1.AllowedProperties);
         let asToken;
-        let typeExpression;
+        let typeToken;
+        let type;
         if (this.check(TokenKind_1.TokenKind.As)) {
-            [asToken, typeExpression] = this.consumeAsTokenAndTypeExpression();
-        }
-        return new Statement_1.InterfaceFieldStatement(name, asToken, typeExpression, optionalKeyword);
-    }
-    consumeAsTokenAndTypeExpression() {
-        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 }));
-                //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 }));
-            }
-            else {
-                typeExpression = this.typeExpression();
-            }
+            asToken = this.consumeToken(TokenKind_1.TokenKind.As);
+            typeToken = this.typeToken();
+            type = util_1.util.tokenToBscType(typeToken);
+        }
+        if (!type) {
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionParameterTypeIsInvalid(name.text, typeToken.text)), { range: typeToken.range }));
+            throw this.lastDiagnosticAsError();
         }
-        return [asToken, typeExpression];
+        return new Statement_1.InterfaceFieldStatement(name, asToken, typeToken, type, optionalKeyword);
     }
     /**
      * Create a new InterfaceMethodStatement. This should only be called from within `interfaceDeclaration()`
@@ -285,36 +278,39 @@ class Parser {
             } while (this.match(TokenKind_1.TokenKind.Comma));
         }
         const rightParen = this.consumeToken(TokenKind_1.TokenKind.RightParen);
-        // let asToken = null as Token;
-        // let returnTypeExpression: TypeExpression;
-        let asToken;
-        let returnTypeExpression;
+        let asToken = null;
+        let returnTypeToken = null;
         if (this.check(TokenKind_1.TokenKind.As)) {
-            [asToken, returnTypeExpression] = this.consumeAsTokenAndTypeExpression();
+            asToken = this.advance();
+            returnTypeToken = this.typeToken();
+            const returnType = util_1.util.tokenToBscType(returnTypeToken);
+            if (!returnType) {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionParameterTypeIsInvalid(name.text, returnTypeToken.text)), { range: returnTypeToken.range }));
+                throw this.lastDiagnosticAsError();
+            }
         }
-        return new Statement_1.InterfaceMethodStatement(functionType, name, leftParen, params, rightParen, asToken, returnTypeExpression, optionalKeyword);
+        return new Statement_1.InterfaceMethodStatement(functionType, name, leftParen, params, rightParen, asToken, returnTypeToken, util_1.util.tokenToBscType(returnTypeToken), optionalKeyword);
     }
     interfaceDeclaration() {
         this.warnIfNotBrighterScriptMode('interface declarations');
         const parentAnnotations = this.enterAnnotationBlock();
         const interfaceToken = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedKeyword(TokenKind_1.TokenKind.Interface), TokenKind_1.TokenKind.Interface);
-        const nameToken = this.identifier();
+        const nameToken = this.identifier(...this.allowedLocalIdentifiers);
         let extendsToken;
         let parentInterfaceName;
         if (this.peek().text.toLowerCase() === 'extends') {
             extendsToken = this.advance();
-            if (this.checkEndOfStatement()) {
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword(extendsToken.text)), { range: extendsToken.range }));
-            }
-            else {
-                parentInterfaceName = this.typeExpression();
-            }
+            parentInterfaceName = this.getNamespacedVariableNameExpression();
         }
         this.consumeStatementSeparators();
         //gather up all interface members (Fields, Methods)
         let body = [];
         while (this.checkAny(TokenKind_1.TokenKind.Comment, TokenKind_1.TokenKind.Identifier, TokenKind_1.TokenKind.At, ...TokenKind_1.AllowedProperties)) {
             try {
+                //break out of this loop if we encountered the `EndInterface` token not followed by `as`
+                if (this.check(TokenKind_1.TokenKind.EndInterface) && !this.checkNext(TokenKind_1.TokenKind.As)) {
+                    break;
+                }
                 let decl;
                 //collect leading annotations
                 if (this.check(TokenKind_1.TokenKind.At)) {
@@ -354,10 +350,6 @@ class Parser {
             }
             //ensure statement separator
             this.consumeStatementSeparators();
-            //break out of this loop if we encountered the `EndInterface` token not followed by `as`
-            if (this.check(TokenKind_1.TokenKind.EndInterface) && !this.checkNext(TokenKind_1.TokenKind.As)) {
-                break;
-            }
         }
         //consume the final `end interface` token
         const endInterfaceToken = this.consumeToken(TokenKind_1.TokenKind.EndInterface);
@@ -429,12 +421,7 @@ class Parser {
         //see if the class inherits from parent
         if (this.peek().text.toLowerCase() === 'extends') {
             extendsKeyword = this.advance();
-            if (this.checkEndOfStatement()) {
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword(extendsKeyword.text)), { range: extendsKeyword.range }));
-            }
-            else {
-                parentClassName = this.typeExpression();
-            }
+            parentClassName = this.getNamespacedVariableNameExpression();
         }
         //ensure statement separator
         this.consumeStatementSeparators();
@@ -530,10 +517,15 @@ class Parser {
         }
         let name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedClassFieldIdentifier(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
         let asToken;
-        let fieldTypeExpression;
+        let fieldType;
         //look for `as SOME_TYPE`
         if (this.check(TokenKind_1.TokenKind.As)) {
-            [asToken, fieldTypeExpression] = this.consumeAsTokenAndTypeExpression();
+            asToken = this.advance();
+            fieldType = this.typeToken();
+            //no field type specified
+            if (!util_1.util.tokenToBscType(fieldType)) {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedValidTypeToFollowAsKeyword()), { range: this.peek().range }));
+            }
         }
         let initialValue;
         let equal;
@@ -542,10 +534,10 @@ 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, name, asToken, fieldType, equal, initialValue, optionalKeyword);
     }
     functionDeclaration(isAnonymous, checkIdentifier = true, onlyCallableAsMember = false) {
-        var _a;
+        var _a, _b;
         let previousCallExpressions = this.callExpressions;
         this.callExpressions = [];
         try {
@@ -566,8 +558,7 @@ class Parser {
                         start: this.peek().range.start,
                         end: this.peek().range.start
                     },
-                    leadingWhitespace: '',
-                    leadingTrivia: []
+                    leadingWhitespace: ''
                 };
             }
             let isSub = (functionType === null || functionType === void 0 ? void 0 : functionType.kind) === TokenKind_1.TokenKind.Sub;
@@ -593,18 +584,19 @@ class Parser {
             }
             let params = [];
             let asToken;
-            let typeExpression;
+            let typeToken;
             if (!this.check(TokenKind_1.TokenKind.RightParen)) {
                 do {
-                    if (params.length >= Expression_1.CallExpression.MaximumArguments) {
-                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.tooManyCallableParameters(params.length, Expression_1.CallExpression.MaximumArguments)), { range: this.peek().range }));
-                    }
                     params.push(this.functionParameter());
                 } while (this.match(TokenKind_1.TokenKind.Comma));
             }
             let rightParen = this.advance();
             if (this.check(TokenKind_1.TokenKind.As)) {
-                [asToken, typeExpression] = this.consumeAsTokenAndTypeExpression();
+                asToken = this.advance();
+                typeToken = this.typeToken();
+                if (!util_1.util.tokenToBscType(typeToken, this.options.mode === ParseMode.BrighterScript)) {
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.invalidFunctionReturnType((_a = typeToken.text) !== null && _a !== void 0 ? _a : '')), { range: typeToken.range }));
+                }
             }
             params.reduce((haveFoundOptional, param) => {
                 if (haveFoundOptional && !param.defaultValue) {
@@ -615,7 +607,12 @@ class Parser {
             this.consumeStatementSeparators(true);
             let func = new Expression_1.FunctionExpression(params, undefined, //body
             functionType, undefined, //ending keyword
-            leftParen, rightParen, asToken, typeExpression);
+            leftParen, rightParen, asToken, typeToken);
+            // add the function to the relevant symbol tables
+            if (!onlyCallableAsMember && name) {
+                const funcType = func.getFunctionType();
+                funcType.setName(name.text);
+            }
             this._references.functionExpressions.push(func);
             //support ending the function with `end sub` OR `end function`
             func.body = this.block();
@@ -623,7 +620,7 @@ class Parser {
             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());
+            func.body.symbolTable = new SymbolTable_1.SymbolTable(`Block: Function '${(_b = name === null || name === void 0 ? void 0 : name.text) !== null && _b !== void 0 ? _b : ''}'`, () => func.getSymbolTable());
             if (!func.body) {
                 this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.callableBlockMissingEndKeyword(functionTypeText)), { range: this.peek().range }));
                 throw this.lastDiagnosticAsError();
@@ -662,19 +659,22 @@ class Parser {
         let name = this.advance();
         // force the name into an identifier so the AST makes some sense
         name.kind = TokenKind_1.TokenKind.Identifier;
-        let typeExpression;
+        let typeToken;
         let defaultValue;
-        let equalToken;
         // parse argument default value
-        if ((equalToken = this.consumeTokenIf(TokenKind_1.TokenKind.Equal))) {
+        if (this.match(TokenKind_1.TokenKind.Equal)) {
             // it seems any expression is allowed here -- including ones that operate on other arguments!
             defaultValue = this.expression(false);
         }
         let asToken = null;
         if (this.check(TokenKind_1.TokenKind.As)) {
-            [asToken, typeExpression] = this.consumeAsTokenAndTypeExpression();
+            asToken = this.advance();
+            typeToken = this.typeToken();
+            if (!util_1.util.tokenToBscType(typeToken, this.options.mode === ParseMode.BrighterScript)) {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionParameterTypeIsInvalid(name.text, typeToken.text)), { range: typeToken.range }));
+            }
         }
-        return new Expression_1.FunctionParameterExpression(name, equalToken, defaultValue, asToken, typeExpression);
+        return new Expression_1.FunctionParameterExpression(name, typeToken, defaultValue, asToken);
     }
     assignment() {
         let name = this.advance();
@@ -682,6 +682,12 @@ 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 }));
         }
+        if (this.check(TokenKind_1.TokenKind.As)) {
+            // v1 syntax allows type declaration on lhs of assignment
+            this.warnIfNotBrighterScriptMode('typed assignment');
+            this.advance(); // skip 'as'
+            this.typeToken(); // skip typeToken;
+        }
         let operator = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedOperatorAfterIdentifier(TokenKind_1.AssignmentOperators, name.text), ...TokenKind_1.AssignmentOperators);
         let value = this.expression();
         let result;
@@ -786,9 +792,35 @@ 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 - this is v1 syntax
+                const backtrack = this.current;
+                let validTypeExpression = false;
+                try {
+                    // skip the identifier, and check for valid type expression
+                    this.advance();
+                    // skip the 'as'
+                    this.advance();
+                    // check if there is a valid type
+                    const typeToken = this.typeToken(true);
+                    const allowedNameKinds = [TokenKind_1.TokenKind.Identifier, ...TokenKind_1.DeclarableTypes, ...this.allowedLocalIdentifiers];
+                    validTypeExpression = allowedNameKinds.includes(typeToken.kind);
+                }
+                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)) {
@@ -892,10 +924,11 @@ class Parser {
         return new Statement_1.ExitForStatement({ exitFor: keyword });
     }
     commentStatement() {
+        var _a, _b;
         //if this comment is on the same line as the previous statement,
         //then this comment should be treated as a single-line comment
         let prev = this.previous();
-        if ((prev === null || prev === void 0 ? void 0 : prev.range.end.line) === this.peek().range.start.line) {
+        if (((_a = prev === null || prev === void 0 ? void 0 : prev.range) === null || _a === void 0 ? void 0 : _a.end.line) === ((_b = this.peek().range) === null || _b === void 0 ? void 0 : _b.start.line)) {
             return new Statement_1.CommentStatement([this.advance()]);
         }
         else {
@@ -911,7 +944,7 @@ class Parser {
         this.warnIfNotBrighterScriptMode('namespace');
         let keyword = this.advance();
         this.namespaceAndFunctionDepth++;
-        let name = this.identifyingExpression();
+        let name = this.getNamespacedVariableNameExpression();
         //set the current namespace name
         let result = new Statement_1.NamespaceStatement(keyword, name, null, null);
         this.globalTerminators.push([TokenKind_1.TokenKind.EndNamespace]);
@@ -937,9 +970,19 @@ class Parser {
     /**
      * Get an expression with identifiers separated by periods. Useful for namespaces and class extends
      */
-    identifyingExpression(allowedTokenKinds) {
-        allowedTokenKinds = allowedTokenKinds !== null && allowedTokenKinds !== void 0 ? allowedTokenKinds : this.allowedLocalIdentifiers;
-        let firstIdentifier = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword(this.previous().text), TokenKind_1.TokenKind.Identifier, ...allowedTokenKinds);
+    getNamespacedVariableNameExpression(ignoreDiagnostics = false) {
+        let firstIdentifier;
+        if (ignoreDiagnostics) {
+            if (this.checkAny(...this.allowedLocalIdentifiers)) {
+                firstIdentifier = this.advance();
+            }
+            else {
+                throw new Error();
+            }
+        }
+        else {
+            firstIdentifier = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword(this.previous().text), TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers);
+        }
         let expr;
         if (firstIdentifier) {
             // force it into an identifier so the AST makes some sense
@@ -952,7 +995,7 @@ class Parser {
                 if (!dot) {
                     break;
                 }
-                let identifier = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), TokenKind_1.TokenKind.Identifier, ...allowedTokenKinds, ...TokenKind_1.AllowedProperties);
+                let identifier = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers, ...TokenKind_1.AllowedProperties);
                 if (!identifier) {
                     break;
                 }
@@ -961,7 +1004,7 @@ class Parser {
                 expr = new Expression_1.DottedGetExpression(expr, identifier, dot);
             }
         }
-        return expr;
+        return new Expression_1.NamespacedVariableNameExpression(expr);
     }
     /**
      * Add an 'unexpected token' diagnostic for any token found between current and the first stopToken found.
@@ -1412,9 +1455,9 @@ class Parser {
         if ((0, reflection_1.isCallExpression)(expr) || (0, reflection_1.isCallfuncExpression)(expr)) {
             return new Statement_1.ExpressionStatement(expr);
         }
-        //at this point, it's probably an error. However, we recover a little more gracefully by creating an inclosing ExpressionStatement
+        //at this point, it's probably an error. However, we recover a little more gracefully by creating an assignment
         this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedStatementOrFunctionCallButReceivedExpression()), { range: expressionStart.range }));
-        return new Statement_1.ExpressionStatement(expr);
+        throw this.lastDiagnosticAsError();
     }
     setStatement() {
         /**
@@ -1432,7 +1475,7 @@ class Parser {
             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);
+                    : new Expression_1.BinaryExpression(left, operator, right), left.openingSquare, left.closingSquare, left.additionalIndexes);
             }
             else if ((0, reflection_1.isDottedGetExpression)(left)) {
                 return new Statement_1.DottedSetStatement(left.obj, left.name, operator.kind === TokenKind_1.TokenKind.Equal
@@ -1443,7 +1486,6 @@ class Parser {
         return this.expressionStatement(expr);
     }
     printStatement() {
-        var _a;
         let printKeyword = this.advance();
         let values = [];
         while (!this.checkEndOfStatement()) {
@@ -1462,8 +1504,7 @@ class Parser {
         }
         //print statements can be empty, so look for empty print conditions
         if (!values.length) {
-            const endOfStatementRange = util_1.util.createRangeFromPositions(printKeyword.range.end, (_a = this.peek()) === null || _a === void 0 ? void 0 : _a.range.end);
-            let emptyStringLiteral = (0, creators_1.createStringLiteral)('', endOfStatementRange);
+            let emptyStringLiteral = (0, creators_1.createStringLiteral)('');
             values.push(emptyStringLiteral);
         }
         let last = values[values.length - 1];
@@ -1616,7 +1657,7 @@ class Parser {
     expression(findTypeCast = true) {
         let expression = this.anonymousFunction();
         let asToken;
-        let typeExpression;
+        let typeToken;
         if (findTypeCast) {
             do {
                 if (this.check(TokenKind_1.TokenKind.As)) {
@@ -1624,15 +1665,16 @@ class Parser {
                     // Check if this expression is wrapped in any type casts
                     // allows for multiple casts:
                     // myVal = foo() as dynamic as string
-                    [asToken, typeExpression] = this.consumeAsTokenAndTypeExpression();
-                    if (asToken && typeExpression) {
-                        expression = new Expression_1.TypeCastExpression(expression, asToken, typeExpression);
+                    asToken = this.advance();
+                    typeToken = this.typeToken();
+                    if (asToken && typeToken) {
+                        expression = new Expression_1.TypeCastExpression(expression, asToken, typeToken);
                     }
                 }
                 else {
                     break;
                 }
-            } while (asToken && typeExpression);
+            } while (asToken && typeToken);
         }
         this._references.expressions.add(expression);
         return expression;
@@ -1728,9 +1770,7 @@ class Parser {
         else if (nextKind === TokenKind_1.TokenKind.Minus || nextKind === TokenKind_1.TokenKind.Plus) {
             this.current++; //advance
             let operator = this.previous();
-            let right = nextKind === TokenKind_1.TokenKind.Not
-                ? this.boolean()
-                : this.prefixUnary();
+            let right = this.prefixUnary();
             return new Expression_1.UnaryExpression(operator, right);
         }
         return this.call();
@@ -1738,32 +1778,31 @@ class Parser {
     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(expr, indexes.shift(), openingSquare, closingSquare, questionDotToken, indexes);
     }
     newExpression() {
-        var _a;
         this.warnIfNotBrighterScriptMode(`using 'new' keyword to construct a class`);
         let newToken = this.advance();
-        let nameExpr = this.identifyingExpression();
-        let leftParen = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.unexpectedToken(this.peek().text), TokenKind_1.TokenKind.LeftParen, TokenKind_1.TokenKind.QuestionLeftParen);
-        if (!leftParen) {
-            // new expression without a following call expression
-            // wrap the name in an expression
-            const endOfStatementRange = util_1.util.createRangeFromPositions(newToken.range.end, (_a = this.peek()) === null || _a === void 0 ? void 0 : _a.range.end);
-            const exprStmt = nameExpr !== null && nameExpr !== void 0 ? nameExpr : (0, creators_1.createStringLiteral)('', endOfStatementRange);
-            return new Statement_1.ExpressionStatement(exprStmt);
-        }
+        let nameExpr = this.getNamespacedVariableNameExpression();
+        let leftParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.unexpectedToken(this.peek().text), TokenKind_1.TokenKind.LeftParen, TokenKind_1.TokenKind.QuestionLeftParen);
         let call = this.finishCall(leftParen, nameExpr);
         //pop the call from the  callExpressions list because this is technically something else
         this.callExpressions.pop();
@@ -1872,81 +1911,58 @@ class Parser {
         return expression;
     }
     /**
-     * Creates a TypeExpression, which wraps standard ASTNodes that represent a BscType
+     * Tries to get the next token as a type
+     * Allows for built-in types (double, string, etc.) or namespaced custom types in Brighterscript mode
+     * Will return a token of whatever is next to be parsed
+     * Will allow v1 type syntax (typed arrays, union types), but there is no validation on types used this way
      */
-    typeExpression() {
-        const changedTokens = [];
-        try {
-            let expr = this.getTypeExpressionPart(changedTokens);
-            while (this.options.mode === ParseMode.BrighterScript && this.matchAny(TokenKind_1.TokenKind.Or)) {
-                // If we're in Brighterscript mode, allow union types with "or" between types
-                // TODO: Handle Union types in parens? eg. "(string or integer)"
-                let operator = this.previous();
-                let right = this.getTypeExpressionPart(changedTokens);
-                if (right) {
-                    expr = new Expression_1.BinaryExpression(expr, operator, right);
+    typeToken(ignoreDiagnostics = false) {
+        let typeToken;
+        let lookForUnions = true;
+        let isAUnion = false;
+        let resultToken;
+        while (lookForUnions) {
+            lookForUnions = false;
+            if (this.checkAny(...TokenKind_1.DeclarableTypes)) {
+                // Token is a built in type
+                typeToken = this.advance();
+            }
+            else if (this.options.mode === ParseMode.BrighterScript) {
+                try {
+                    // see if we can get a namespaced identifer
+                    const qualifiedType = this.getNamespacedVariableNameExpression(ignoreDiagnostics);
+                    typeToken = (0, creators_1.createToken)(TokenKind_1.TokenKind.Identifier, qualifiedType.getName(this.options.mode), qualifiedType.range);
                 }
-                else {
-                    break;
+                catch (_a) {
+                    //could not get an identifier - just get whatever's next
+                    typeToken = this.advance();
                 }
             }
-            if (expr) {
-                return new Expression_1.TypeExpression(expr);
-            }
-        }
-        catch (error) {
-            // Something went wrong - reset the kind to what it was previously
-            for (const changedToken of changedTokens) {
-                changedToken.token.kind = changedToken.oldKind;
-            }
-            throw error;
-        }
-    }
-    /**
-     * Gets a single "part" of a type of a potential Union type
-     * Note: this does not NEED to be part of a union type, but the logic is the same
-     *
-     * @param changedTokens an array that is modified with any tokens that have been changed from their default kind to identifiers - eg. when a keyword is used as type
-     * @returns an expression that was successfully parsed
-     */
-    getTypeExpressionPart(changedTokens) {
-        let expr;
-        if (this.checkAny(...TokenKind_1.DeclarableTypes)) {
-            // if this is just a type, just use directly
-            expr = new Expression_1.VariableExpression(this.advance());
-        }
-        else {
-            if (this.checkAny(...TokenKind_1.AllowedTypeIdentifiers)) {
-                // Since the next token is allowed as a type identifier, change the kind
-                let nextToken = this.peek();
-                changedTokens.push({ token: nextToken, oldKind: nextToken.kind });
-                nextToken.kind = TokenKind_1.TokenKind.Identifier;
-            }
-            expr = this.identifyingExpression(TokenKind_1.AllowedTypeIdentifiers);
-            if (expr) {
-                this._references.expressions.add(expr);
-            }
-        }
-        //Check if it has square brackets, thus making it an array
-        if (expr && this.check(TokenKind_1.TokenKind.LeftSquareBracket)) {
-            if (this.options.mode === ParseMode.BrightScript) {
-                // typed arrays not allowed in Brightscript
-                this.warnIfNotBrighterScriptMode('typed arrays');
-                return expr;
-            }
-            // Check if it is an array - that is, if it has `[]` after the type
-            // eg. `string[]` or `SomeKlass[]`
-            // This is while loop, so it supports multidimensional arrays (eg. integer[][])
-            while (this.check(TokenKind_1.TokenKind.LeftSquareBracket)) {
-                const leftBracket = this.advance();
-                if (this.check(TokenKind_1.TokenKind.RightSquareBracket)) {
+            else {
+                // just get whatever's next
+                typeToken = this.advance();
+            }
+            resultToken = resultToken !== null && resultToken !== void 0 ? resultToken : typeToken;
+            if (resultToken && this.options.mode === ParseMode.BrighterScript) {
+                // check for brackets
+                while (this.check(TokenKind_1.TokenKind.LeftSquareBracket) && this.peekNext().kind === TokenKind_1.TokenKind.RightSquareBracket) {
+                    const leftBracket = this.advance();
                     const rightBracket = this.advance();
-                    expr = new Expression_1.TypedArrayExpression(expr, leftBracket, rightBracket);
-                    this._references.expressions.add(expr);
+                    typeToken = (0, creators_1.createToken)(TokenKind_1.TokenKind.Identifier, typeToken.text + leftBracket.text + rightBracket.text, util_1.util.createBoundingRange(typeToken, leftBracket, rightBracket));
+                    resultToken = (0, creators_1.createToken)(TokenKind_1.TokenKind.Dynamic, null, typeToken.range);
+                }
+                if (this.check(TokenKind_1.TokenKind.Or)) {
+                    lookForUnions = true;
+                    let orToken = this.advance();
+                    resultToken = (0, creators_1.createToken)(TokenKind_1.TokenKind.Dynamic, null, util_1.util.createBoundingRange(resultToken, typeToken, orToken));
+                    isAUnion = true;
                 }
             }
         }
-        return expr;
+        if (isAUnion) {
+            resultToken = (0, creators_1.createToken)(TokenKind_1.TokenKind.Dynamic, null, util_1.util.createBoundingRange(resultToken, typeToken));
+        }
+        return resultToken;
     }
     primary() {
         switch (true) {
@@ -2217,6 +2233,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) {
@@ -2362,7 +2383,7 @@ class Parser {
             ClassStatement: s => {
                 this._references.classStatements.push(s);
             },
-            FieldStatement: s => {
+            ClassFieldStatement: s => {
                 if (s.initialValue) {
                     this._references.expressions.add(s.initialValue);
                 }