brighterscript 1.0.0-alpha.50 → 1.0.0-alpha.51

package/dist/parser/Parser.d.ts

@@ -5,6 +5,11 @@ import type { Logger } from '../logging';
 import type { Statement } from './AstNode';
 import type { BsDiagnostic } from '../interfaces';
 export declare class Parser {
+    /**
+     * The minimum Roku firmware version that added native support for multi-line expressions
+     * (line continuation) in plain BrightScript (`.brs`) files.
+     */
+    private static readonly LINE_CONTINUATION_MIN_FIRMWARE_VERSION;
     /**
      * The array of tokens passed to `parse()`
      */
@@ -34,6 +39,16 @@ export declare class Parser {
      * The options used to parse the file
      */
     options: ParseOptions;
+    /**
+     * Whether line continuation after binary operators is allowed.
+     * Enabled in BrighterScript mode, or when minFirmwareVersion >= 15.3.
+     */
+    private allowLineContinuation;
+    /**
+     * If line continuation is enabled, consumes all immediately following Newline tokens.
+     * Call this after matching a binary operator to allow the right-hand operand on the next line.
+     */
+    private consumeNewlinesIfAllowed;
     private globalTerminators;
     /**
      * A list of identifiers that are permitted to be used as local variables. We store this in a property because we augment the list in the constructor
@@ -231,6 +246,7 @@ export declare class Parser {
      * @returns an expression that was successfully parsed
      */
     private getTypeExpressionPart;
+    private typedFunctionTypeExpression;
     private inlineInterface;
     private inlineInterfaceMember;
     private primary;
@@ -325,7 +341,14 @@ export interface ParseOptions {
      */
     trackLocations?: boolean;
     /**
-     *
+     * A map of BrightScript constants. If a constant is present in this map, it will be treated as a compile-time constant.
      */
     bsConsts?: Map<string, boolean>;
+    /**
+     * The minimum Roku firmware version required to run this project.
+     * When set to '15.3' or higher, line continuation (multi-line expressions in `.brs` files)
+     * is enabled even in BrightScript mode because Roku OS 15.3 added native support for it.
+     * Should be a semver-compatible string (e.g. '15.3.0').
+     */
+    minFirmwareVersion?: string;
 }

package/dist/parser/Parser.js

@@ -11,6 +11,7 @@ const Expression_1 = require("./Expression");
 const logging_1 = require("../logging");
 const reflection_1 = require("../astUtils/reflection");
 const creators_1 = require("../astUtils/creators");
+const semver = require("semver");
 const declarableTypesLower = TokenKind_1.DeclarableTypes.map(tokenKind => tokenKind.toLowerCase());
 class Parser {
     constructor() {
@@ -42,6 +43,15 @@ class Parser {
     get symbolTable() {
         return this.ast.symbolTable;
     }
+    /**
+     * If line continuation is enabled, consumes all immediately following Newline tokens.
+     * Call this after matching a binary operator to allow the right-hand operand on the next line.
+     */
+    consumeNewlinesIfAllowed() {
+        if (this.allowLineContinuation) {
+            while (this.match(TokenKind_1.TokenKind.Newline)) { }
+        }
+    }
     /**
      * Get the currently active global terminators
      */
@@ -65,6 +75,8 @@ class Parser {
         this.logger = (_a = options === null || options === void 0 ? void 0 : options.logger) !== null && _a !== void 0 ? _a : (0, logging_1.createLogger)();
         options = this.sanitizeParseOptions(options);
         this.options = options;
+        const coercedMinFirmwareVersion = semver.coerce(this.options.minFirmwareVersion);
+        this.allowLineContinuation = options.mode === ParseMode.BrighterScript || (!!coercedMinFirmwareVersion && semver.gte(coercedMinFirmwareVersion, Parser.LINE_CONTINUATION_MIN_FIRMWARE_VERSION));
         let tokens;
         if (typeof toParse === 'string') {
             tokens = Lexer_1.Lexer.scan(toParse, {
@@ -791,6 +803,9 @@ class Parser {
         if (this.checkAlias()) {
             return this.aliasStatement();
         }
+        if (this.checkTypeStatement()) {
+            return this.typeStatement();
+        }
         if (this.check(TokenKind_1.TokenKind.Stop)) {
             return this.stopStatement();
         }
@@ -896,20 +911,27 @@ class Parser {
         return this.setStatement();
     }
     whileStatement() {
+        var _a, _b;
         const whileKeyword = this.advance();
         const condition = this.expression();
         this.consumeStatementSeparators();
-        const whileBlock = this.block(TokenKind_1.TokenKind.EndWhile);
+        const whileBlock = this.block(TokenKind_1.TokenKind.EndWhile, TokenKind_1.TokenKind.Next);
         let endWhile;
-        if (!whileBlock || this.peek().kind !== TokenKind_1.TokenKind.EndWhile) {
-            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.couldNotFindMatchingEndKeyword('while')), { location: this.peek().location }));
+        if (whileBlock && this.peek().kind === TokenKind_1.TokenKind.EndWhile) {
+            endWhile = this.advance();
+        }
+        else if (whileBlock && this.peek().kind === TokenKind_1.TokenKind.Next) {
+            //recover: a stray `next` is a common mistake when the user means `end while`.
+            //emit a targeted diagnostic and consume the `next` so the rest of the file parses cleanly.
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.mismatchedEndingToken(['end while'], 'next')), { location: (_a = this.peek()) === null || _a === void 0 ? void 0 : _a.location }));
+            endWhile = this.advance();
+        }
+        else {
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.couldNotFindMatchingEndKeyword('while')), { location: (_b = this.peek()) === null || _b === void 0 ? void 0 : _b.location }));
             if (!whileBlock) {
                 throw this.lastDiagnosticAsError();
             }
         }
-        else {
-            endWhile = this.advance();
-        }
         return new Statement_1.WhileStatement({
             while: whileKeyword,
             endWhile: endWhile,
@@ -941,6 +963,7 @@ class Parser {
         });
     }
     forStatement() {
+        var _a, _b;
         const forToken = this.advance();
         const initializer = this.assignment();
         //TODO: newline allowed?
@@ -956,17 +979,22 @@ class Parser {
             // BrightScript for/to/step loops default to a step of 1 if no `step` is provided
         }
         this.consumeStatementSeparators();
-        let body = this.block(TokenKind_1.TokenKind.EndFor, TokenKind_1.TokenKind.Next);
+        let body = this.block(TokenKind_1.TokenKind.EndFor, TokenKind_1.TokenKind.Next, TokenKind_1.TokenKind.EndWhile);
         let endForToken;
-        if (!body || !this.checkAny(TokenKind_1.TokenKind.EndFor, TokenKind_1.TokenKind.Next)) {
-            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedEndForOrNextToTerminateForLoop(forToken.text)), { location: this.peek().location }));
+        if (body && this.checkAny(TokenKind_1.TokenKind.EndFor, TokenKind_1.TokenKind.Next)) {
+            endForToken = this.advance();
+        }
+        else if (body && this.peek().kind === TokenKind_1.TokenKind.EndWhile) {
+            //recover: a stray `end while` is a common mistake when the user means `end for`.
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.mismatchedEndingToken(['end for', 'next'], 'end while')), { location: (_a = this.peek()) === null || _a === void 0 ? void 0 : _a.location }));
+            endForToken = this.advance();
+        }
+        else {
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedEndForOrNextToTerminateForLoop(forToken.text)), { location: (_b = this.peek()) === null || _b === void 0 ? void 0 : _b.location }));
             if (!body) {
                 throw this.lastDiagnosticAsError();
             }
         }
-        else {
-            endForToken = this.advance();
-        }
         // WARNING: BrightScript doesn't delete the loop initial value after a for/to loop! It just
         // stays around in scope with whatever value it was when the loop exited.
         return new Statement_1.ForStatement({
@@ -981,6 +1009,7 @@ class Parser {
         });
     }
     forEachStatement() {
+        var _a;
         let forEach = this.advance();
         let name = this.advance();
         let asToken;
@@ -1004,19 +1033,26 @@ class Parser {
             throw this.lastDiagnosticAsError();
         }
         this.consumeStatementSeparators();
-        let body = this.block(TokenKind_1.TokenKind.EndFor, TokenKind_1.TokenKind.Next);
-        let endForToken;
-        if (!body || !this.checkAny(TokenKind_1.TokenKind.EndFor, TokenKind_1.TokenKind.Next)) {
+        let body = this.block(TokenKind_1.TokenKind.EndFor, TokenKind_1.TokenKind.Next, TokenKind_1.TokenKind.EndWhile);
+        let endFor;
+        if (body && this.checkAny(TokenKind_1.TokenKind.EndFor, TokenKind_1.TokenKind.Next)) {
+            endFor = this.advance();
+        }
+        else if (body && this.peek().kind === TokenKind_1.TokenKind.EndWhile) {
+            //recover: a stray `end while` is a common mistake when the user means `end for`.
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.mismatchedEndingToken(['end for', 'next'], 'end while')), { location: (_a = this.peek()) === null || _a === void 0 ? void 0 : _a.location }));
+            endFor = this.advance();
+        }
+        else {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedEndForOrNextToTerminateForLoop(forEach.text)), { location: this.peek().location }));
             throw this.lastDiagnosticAsError();
         }
-        endForToken = this.advance();
         return new Statement_1.ForEachStatement({
             forEach: forEach,
             as: asToken,
             typeExpression: typeExpression,
             in: maybeIn,
-            endFor: endForToken,
+            endFor: endFor,
             item: name,
             target: target,
             body: body
@@ -1821,7 +1857,25 @@ class Parser {
         if (this.checkAny(...TokenKind_1.BinaryExpressionOperatorTokens)) {
             expr = new Expression_1.BinaryExpression({ left: expr, operator: this.advance(), right: this.expression() });
         }
-        //at this point, it's probably an error. However, we recover a little more gracefully by creating an inclosing ExpressionStatement
+        //you're not allowed to do dottedGet or XmlAttrGet after a function call
+        if ((0, reflection_1.isDottedGetExpression)(expr)) {
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.propAccessNotPermittedAfterFunctionCallInExpressionStatement('Property')), { location: util_1.util.createBoundingLocation(expr.tokens.dot, expr.tokens.name) }));
+            //we can recover gracefully here even though it's invalid syntax
+            return new Statement_1.ExpressionStatement({ expression: expr });
+            //you're not allowed to do indexedGet expressions after a function call
+        }
+        else if ((0, reflection_1.isIndexedGetExpression)(expr)) {
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.propAccessNotPermittedAfterFunctionCallInExpressionStatement('Index')), { location: util_1.util.createBoundingLocation(expr.tokens.openingSquare, ...expr.indexes, expr.tokens.closingSquare) }));
+            //we can recover gracefully here even though it's invalid syntax
+            return new Statement_1.ExpressionStatement({ expression: expr });
+            //you're not allowed to do XmlAttrGet after a function call
+        }
+        else if ((0, reflection_1.isXmlAttributeGetExpression)(expr)) {
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.propAccessNotPermittedAfterFunctionCallInExpressionStatement('XML attribute')), { location: util_1.util.createBoundingLocation(expr.tokens.at, expr.tokens.name) }));
+            //we can recover gracefully here even though it's invalid syntax
+            return new Statement_1.ExpressionStatement({ expression: expr });
+        }
+        //at this point, it's probably an error. However, we recover a little more gracefully by creating an assignment
         this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedStatement()), { location: expressionStart.location }));
         return new Statement_1.ExpressionStatement({ expression: expr });
     }
@@ -2086,6 +2140,7 @@ class Parser {
         let expr = this.relational();
         while (this.matchAny(TokenKind_1.TokenKind.And, TokenKind_1.TokenKind.Or)) {
             let operator = this.previous();
+            this.consumeNewlinesIfAllowed();
             let right = this.relational();
             expr = new Expression_1.BinaryExpression({ left: expr, operator: operator, right: right });
         }
@@ -2095,6 +2150,7 @@ class Parser {
         let expr = this.additive();
         while (this.matchAny(TokenKind_1.TokenKind.Equal, TokenKind_1.TokenKind.LessGreater, TokenKind_1.TokenKind.Greater, TokenKind_1.TokenKind.GreaterEqual, TokenKind_1.TokenKind.Less, TokenKind_1.TokenKind.LessEqual)) {
             let operator = this.previous();
+            this.consumeNewlinesIfAllowed();
             let right = this.additive();
             expr = new Expression_1.BinaryExpression({ left: expr, operator: operator, right: right });
         }
@@ -2105,6 +2161,7 @@ class Parser {
         let expr = this.multiplicative();
         while (this.matchAny(TokenKind_1.TokenKind.Plus, TokenKind_1.TokenKind.Minus)) {
             let operator = this.previous();
+            this.consumeNewlinesIfAllowed();
             let right = this.multiplicative();
             expr = new Expression_1.BinaryExpression({ left: expr, operator: operator, right: right });
         }
@@ -2114,6 +2171,7 @@ class Parser {
         let expr = this.exponential();
         while (this.matchAny(TokenKind_1.TokenKind.Forwardslash, TokenKind_1.TokenKind.Backslash, TokenKind_1.TokenKind.Star, TokenKind_1.TokenKind.Mod, TokenKind_1.TokenKind.LeftShift, TokenKind_1.TokenKind.RightShift)) {
             let operator = this.previous();
+            this.consumeNewlinesIfAllowed();
             let right = this.exponential();
             expr = new Expression_1.BinaryExpression({ left: expr, operator: operator, right: right });
         }
@@ -2123,6 +2181,7 @@ class Parser {
         let expr = this.prefixUnary();
         while (this.match(TokenKind_1.TokenKind.Caret)) {
             let operator = this.previous();
+            this.consumeNewlinesIfAllowed();
             let right = this.prefixUnary();
             expr = new Expression_1.BinaryExpression({ left: expr, operator: operator, right: right });
         }
@@ -2269,16 +2328,31 @@ class Parser {
         return expr;
     }
     finishCall(openingParen, callee, addToCallExpressionList = true) {
-        var _a;
+        var _a, _b, _c;
         let args = [];
-        while (this.match(TokenKind_1.TokenKind.Newline)) { }
+        this.consumeNewlinesIfAllowed();
         if (!this.check(TokenKind_1.TokenKind.RightParen)) {
             do {
-                while (this.match(TokenKind_1.TokenKind.Newline)) { }
+                this.consumeNewlinesIfAllowed();
                 if (args.length >= Expression_1.CallExpression.MaximumArguments) {
                     this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.tooManyCallableArguments(args.length, Expression_1.CallExpression.MaximumArguments)), { location: (_a = this.peek()) === null || _a === void 0 ? void 0 : _a.location }));
                     throw this.lastDiagnosticAsError();
                 }
+                //if a newline appears where we'd next read an argument and line continuation isn't
+                //allowed in this mode, peek past the newlines: if the following token can't begin an
+                //argument expression (e.g. `end function`, `end sub`, EOF), this is clearly an
+                //unclosed-paren situation and we swallow the newlines so the diagnostic from
+                //expression() reports the surprising token rather than the newline itself.
+                if (!this.allowLineContinuation && this.check(TokenKind_1.TokenKind.Newline)) {
+                    let lookahead = this.current;
+                    while (((_b = this.tokens[lookahead]) === null || _b === void 0 ? void 0 : _b.kind) === TokenKind_1.TokenKind.Newline) {
+                        lookahead++;
+                    }
+                    const followingKind = (_c = this.tokens[lookahead]) === null || _c === void 0 ? void 0 : _c.kind;
+                    if (followingKind === TokenKind_1.TokenKind.EndFunction || followingKind === TokenKind_1.TokenKind.EndSub || followingKind === TokenKind_1.TokenKind.Eof) {
+                        while (this.match(TokenKind_1.TokenKind.Newline)) { }
+                    }
+                }
                 try {
                     args.push(this.expression());
                 }
@@ -2289,7 +2363,16 @@ class Parser {
                 }
             } while (this.match(TokenKind_1.TokenKind.Comma));
         }
-        while (this.match(TokenKind_1.TokenKind.Newline)) { }
+        this.consumeNewlinesIfAllowed();
+        //if no closing `)` is in sight (e.g. we hit a newline that line-continuation is not allowed
+        //to swallow), consume newlines anyway as part of error recovery so the unmatched-left-token
+        //diagnostic points at the surprising token (e.g. `end sub`) rather than the `\n`. This also
+        //ensures the surrounding block sees a non-separator next token and emits its own
+        //`expectedNewlineOrColon` diagnostic.
+        const recoveredFromMissingRightParen = !this.check(TokenKind_1.TokenKind.RightParen);
+        if (recoveredFromMissingRightParen) {
+            while (this.match(TokenKind_1.TokenKind.Newline)) { }
+        }
         const closingParen = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftToken(openingParen.text, 'function call arguments'), TokenKind_1.TokenKind.RightParen);
         let expression = new Expression_1.CallExpression({
             callee: callee,
@@ -2362,16 +2445,25 @@ class Parser {
     getTypeExpressionPart(changedTokens) {
         var _a, _b;
         let expr;
-        if (this.checkAny(...TokenKind_1.DeclarableTypes)) {
+        if (this.checkAny(TokenKind_1.TokenKind.Sub, TokenKind_1.TokenKind.Function) && this.checkNext(TokenKind_1.TokenKind.LeftParen)) {
+            // this is a tyyed function type expression, eg. "function(type1, type2) as type3"
+            this.warnIfNotBrighterScriptMode('typed function types');
+            expr = this.typedFunctionTypeExpression();
+        }
+        else if (this.checkAny(...TokenKind_1.DeclarableTypes)) {
             // if this is just a type, just use directly
             expr = new Expression_1.VariableExpression({ name: this.advance() });
         }
         else {
             if (this.options.mode === ParseMode.BrightScript && !declarableTypesLower.includes((_b = (_a = this.peek()) === null || _a === void 0 ? void 0 : _a.text) === null || _b === void 0 ? void 0 : _b.toLowerCase())) {
-                // custom types arrays not allowed in Brightscript
-                this.warnIfNotBrighterScriptMode('custom types');
-                this.advance(); // skip custom type token
-                return expr;
+                //inline interfaces have their own diagnostic ('inline interface'); let `{`
+                //flow through to the matcher below so it fires the more-specific warning.
+                if (!this.check(TokenKind_1.TokenKind.LeftCurlyBrace)) {
+                    // custom types arrays not allowed in Brightscript
+                    this.warnIfNotBrighterScriptMode('custom types');
+                    this.advance(); // skip custom type token
+                    return expr;
+                }
             }
             if (this.match(TokenKind_1.TokenKind.LeftCurlyBrace)) {
                 expr = this.inlineInterface();
@@ -2413,9 +2505,37 @@ class Parser {
         }
         return expr;
     }
+    typedFunctionTypeExpression() {
+        const funcOrSub = this.advance();
+        const openParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedToken(TokenKind_1.TokenKind.LeftParen), TokenKind_1.TokenKind.LeftParen);
+        const params = [];
+        if (!this.check(TokenKind_1.TokenKind.RightParen)) {
+            do {
+                if (params.length >= Expression_1.CallExpression.MaximumArguments) {
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.tooManyCallableParameters(params.length, Expression_1.CallExpression.MaximumArguments)), { location: this.peek().location }));
+                }
+                params.push(this.functionParameter());
+            } while (this.match(TokenKind_1.TokenKind.Comma));
+        }
+        const closeParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftToken(openParen.text, 'function type expression'), TokenKind_1.TokenKind.RightParen);
+        let asToken;
+        let returnType;
+        if (this.check(TokenKind_1.TokenKind.As)) {
+            [asToken, returnType] = this.consumeAsTokenAndTypeExpression();
+        }
+        return new Expression_1.TypedFunctionTypeExpression({
+            functionType: funcOrSub,
+            rightParen: openParen,
+            params: params,
+            leftParen: closeParen,
+            as: asToken,
+            returnType: returnType
+        });
+    }
     inlineInterface() {
         let expr;
         const openToken = this.previous();
+        this.warnIfNotBrighterScriptMode('inline interface');
         const members = [];
         while (this.match(TokenKind_1.TokenKind.Newline)) { }
         while (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties, TokenKind_1.TokenKind.StringLiteral, TokenKind_1.TokenKind.Optional)) {
@@ -2560,12 +2680,22 @@ class Parser {
         let openingBrace = this.previous();
         let members = [];
         let key = () => {
+            var _a;
             let result = {
-                colonToken: null,
+                colon: null,
                 keyToken: null,
+                key: null,
+                leftBracket: null,
+                rightBracket: null,
                 range: null
             };
-            if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties)) {
+            if (this.check(TokenKind_1.TokenKind.LeftSquareBracket)) {
+                // Computed key: [expr]
+                result.leftBracket = this.advance();
+                result.key = this.expression();
+                result.rightBracket = this.tryConsumeToken(TokenKind_1.TokenKind.RightSquareBracket);
+            }
+            else if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties)) {
                 result.keyToken = this.identifier(...TokenKind_1.AllowedProperties);
             }
             else if (this.check(TokenKind_1.TokenKind.StringLiteral)) {
@@ -2575,8 +2705,8 @@ class Parser {
                 this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedAAKey()), { location: this.peek().location }));
                 throw this.lastDiagnosticAsError();
             }
-            result.colonToken = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedColonBetweenAAKeyAndvalue(), TokenKind_1.TokenKind.Colon);
-            result.range = util_1.util.createBoundingRange(result.keyToken, result.colonToken);
+            result.colon = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedColonBetweenAAKeyAndvalue(), TokenKind_1.TokenKind.Colon);
+            result.range = util_1.util.createBoundingRange((_a = result.keyToken) !== null && _a !== void 0 ? _a : result.leftBracket, result.colon);
             return result;
         };
         while (this.match(TokenKind_1.TokenKind.Newline)) { }
@@ -2586,11 +2716,13 @@ class Parser {
             try {
                 let k = key();
                 let expr = this.expression();
-                lastAAMember = new Expression_1.AAMemberExpression({
-                    key: k.keyToken,
-                    colon: k.colonToken,
-                    value: expr
-                });
+                lastAAMember = k.key
+                    ? new Expression_1.AAIndexedMemberExpression({ leftBracket: k.leftBracket, key: k.key, rightBracket: k.rightBracket, colon: k.colon, value: expr })
+                    : new Expression_1.AAMemberExpression({
+                        key: k.keyToken,
+                        colon: k.colon,
+                        value: expr
+                    });
                 members.push(lastAAMember);
                 while (this.matchAny(TokenKind_1.TokenKind.Comma, TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon, TokenKind_1.TokenKind.Comment)) {
                     // collect comma at end of expression
@@ -2603,11 +2735,13 @@ class Parser {
                     }
                     let k = key();
                     let expr = this.expression();
-                    lastAAMember = new Expression_1.AAMemberExpression({
-                        key: k.keyToken,
-                        colon: k.colonToken,
-                        value: expr
-                    });
+                    lastAAMember = k.key
+                        ? new Expression_1.AAIndexedMemberExpression({ leftBracket: k.leftBracket, key: k.key, rightBracket: k.rightBracket, colon: k.colon, value: expr })
+                        : new Expression_1.AAMemberExpression({
+                            key: k.keyToken,
+                            colon: k.colon,
+                            value: expr
+                        });
                     members.push(lastAAMember);
                 }
             }
@@ -2834,6 +2968,11 @@ class Parser {
     }
 }
 exports.Parser = Parser;
+/**
+ * The minimum Roku firmware version that added native support for multi-line expressions
+ * (line continuation) in plain BrightScript (`.brs`) files.
+ */
+Parser.LINE_CONTINUATION_MIN_FIRMWARE_VERSION = '15.3.0';
 var ParseMode;
 (function (ParseMode) {
     ParseMode["BrightScript"] = "BrightScript";