brighterscript 1.0.0-alpha.18 → 1.0.0-alpha.20

package/dist/parser/Parser.js

@@ -1668,17 +1668,18 @@ class Parser {
     }
     indexedGet(expr) {
         let openingSquare = this.previous();
+        let questionDotToken = this.getMatchingTokenAtOffset(-2, TokenKind_1.TokenKind.QuestionDot);
         while (this.match(TokenKind_1.TokenKind.Newline)) { }
         let index = this.expression();
         while (this.match(TokenKind_1.TokenKind.Newline)) { }
         let closingSquare = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedRightSquareBraceAfterArrayOrObjectIndex(), TokenKind_1.TokenKind.RightSquareBracket);
-        return new Expression_1.IndexedGetExpression(expr, index, openingSquare, closingSquare);
+        return new Expression_1.IndexedGetExpression(expr, index, openingSquare, closingSquare, questionDotToken);
     }
     newExpression() {
         this.warnIfNotBrighterScriptMode(`using 'new' keyword to construct a class`);
         let newToken = this.advance();
         let nameExpr = this.getNamespacedVariableNameExpression();
-        let leftParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.unexpectedToken(this.peek().text), TokenKind_1.TokenKind.LeftParen);
+        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();
@@ -1707,12 +1708,12 @@ class Parser {
         //an expression to keep for _references
         let referenceCallExpression;
         while (true) {
-            if (this.match(TokenKind_1.TokenKind.LeftParen)) {
+            if (this.matchAny(TokenKind_1.TokenKind.LeftParen, TokenKind_1.TokenKind.QuestionLeftParen)) {
                 expr = this.finishCall(this.previous(), expr);
                 //store this call expression in references
                 referenceCallExpression = expr;
             }
-            else if (this.match(TokenKind_1.TokenKind.LeftSquareBracket)) {
+            else if (this.matchAny(TokenKind_1.TokenKind.LeftSquareBracket, TokenKind_1.TokenKind.QuestionLeftSquare) || this.matchSequence(TokenKind_1.TokenKind.QuestionDot, TokenKind_1.TokenKind.LeftSquareBracket)) {
                 expr = this.indexedGet(expr);
             }
             else if (this.match(TokenKind_1.TokenKind.Callfunc)) {
@@ -1720,7 +1721,7 @@ class Parser {
                 //store this callfunc expression in references
                 referenceCallExpression = expr;
             }
-            else if (this.match(TokenKind_1.TokenKind.Dot)) {
+            else if (this.matchAny(TokenKind_1.TokenKind.Dot, TokenKind_1.TokenKind.QuestionDot)) {
                 if (this.match(TokenKind_1.TokenKind.LeftSquareBracket)) {
                     expr = this.indexedGet(expr);
                 }
@@ -1733,7 +1734,7 @@ class Parser {
                     this.addPropertyHints(name);
                 }
             }
-            else if (this.check(TokenKind_1.TokenKind.At)) {
+            else if (this.checkAny(TokenKind_1.TokenKind.At, TokenKind_1.TokenKind.QuestionAt)) {
                 let dot = this.advance();
                 let name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedAttributeNameAfterAtSymbol(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
                 // force it into an identifier so the AST makes some sense
@@ -1754,8 +1755,7 @@ class Parser {
     }
     finishCall(openingParen, callee, addToCallExpressionList = true) {
         let args = [];
-        while (this.match(TokenKind_1.TokenKind.Newline)) {
-        }
+        while (this.match(TokenKind_1.TokenKind.Newline)) { }
         if (!this.check(TokenKind_1.TokenKind.RightParen)) {
             do {
                 while (this.match(TokenKind_1.TokenKind.Newline)) { }
@@ -1838,106 +1838,10 @@ class Parser {
                 let expr = this.expression();
                 let right = this.consume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftParenAfterExpression(), TokenKind_1.TokenKind.RightParen);
                 return new Expression_1.GroupingExpression({ left: left, right: right }, expr);
-            case this.match(TokenKind_1.TokenKind.LeftSquareBracket):
-                let elements = [];
-                let openingSquare = this.previous();
-                //add any comment found right after the opening square
-                if (this.check(TokenKind_1.TokenKind.Comment)) {
-                    elements.push(new Statement_1.CommentStatement([this.advance()]));
-                }
-                while (this.match(TokenKind_1.TokenKind.Newline)) {
-                }
-                if (!this.match(TokenKind_1.TokenKind.RightSquareBracket)) {
-                    elements.push(this.expression());
-                    while (this.matchAny(TokenKind_1.TokenKind.Comma, TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Comment)) {
-                        if (this.checkPrevious(TokenKind_1.TokenKind.Comment) || this.check(TokenKind_1.TokenKind.Comment)) {
-                            let comment = this.check(TokenKind_1.TokenKind.Comment) ? this.advance() : this.previous();
-                            elements.push(new Statement_1.CommentStatement([comment]));
-                        }
-                        while (this.match(TokenKind_1.TokenKind.Newline)) {
-                        }
-                        if (this.check(TokenKind_1.TokenKind.RightSquareBracket)) {
-                            break;
-                        }
-                        elements.push(this.expression());
-                    }
-                    this.consume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftSquareBraceAfterArrayLiteral(), TokenKind_1.TokenKind.RightSquareBracket);
-                }
-                let closingSquare = this.previous();
-                //this.consume("Expected newline or ':' after array literal", TokenKind.Newline, TokenKind.Colon, TokenKind.Eof);
-                return new Expression_1.ArrayLiteralExpression(elements, openingSquare, closingSquare);
+            case this.matchAny(TokenKind_1.TokenKind.LeftSquareBracket):
+                return this.arrayLiteral();
             case this.match(TokenKind_1.TokenKind.LeftCurlyBrace):
-                let openingBrace = this.previous();
-                let members = [];
-                let key = () => {
-                    let result = {
-                        colonToken: null,
-                        keyToken: null,
-                        range: null
-                    };
-                    if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties)) {
-                        result.keyToken = this.advance();
-                    }
-                    else if (this.check(TokenKind_1.TokenKind.StringLiteral)) {
-                        result.keyToken = this.advance();
-                    }
-                    else {
-                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedAAKey()), { range: this.peek().range }));
-                        throw this.lastDiagnosticAsError();
-                    }
-                    result.colonToken = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedColonBetweenAAKeyAndvalue(), TokenKind_1.TokenKind.Colon);
-                    result.range = util_1.util.getRange(result.keyToken, result.colonToken);
-                    return result;
-                };
-                while (this.match(TokenKind_1.TokenKind.Newline)) {
-                }
-                if (!this.match(TokenKind_1.TokenKind.RightCurlyBrace)) {
-                    let lastAAMember;
-                    if (this.check(TokenKind_1.TokenKind.Comment)) {
-                        lastAAMember = null;
-                        members.push(new Statement_1.CommentStatement([this.advance()]));
-                    }
-                    else {
-                        let k = key();
-                        let expr = this.expression();
-                        lastAAMember = new Expression_1.AAMemberExpression(k.keyToken, k.colonToken, expr, getBscTypeFromExpression(expr, this.currentFunctionExpression));
-                        members.push(lastAAMember);
-                    }
-                    while (this.matchAny(TokenKind_1.TokenKind.Comma, TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon, TokenKind_1.TokenKind.Comment)) {
-                        // collect comma at end of expression
-                        if (lastAAMember && this.checkPrevious(TokenKind_1.TokenKind.Comma)) {
-                            lastAAMember.commaToken = this.previous();
-                        }
-                        //check for comment at the end of the current line
-                        if (this.check(TokenKind_1.TokenKind.Comment) || this.checkPrevious(TokenKind_1.TokenKind.Comment)) {
-                            let token = this.checkPrevious(TokenKind_1.TokenKind.Comment) ? this.previous() : this.advance();
-                            members.push(new Statement_1.CommentStatement([token]));
-                        }
-                        else {
-                            this.consumeStatementSeparators(true);
-                            //check for a comment on its own line
-                            if (this.check(TokenKind_1.TokenKind.Comment) || this.checkPrevious(TokenKind_1.TokenKind.Comment)) {
-                                let token = this.checkPrevious(TokenKind_1.TokenKind.Comment) ? this.previous() : this.advance();
-                                lastAAMember = null;
-                                members.push(new Statement_1.CommentStatement([token]));
-                                continue;
-                            }
-                            if (this.check(TokenKind_1.TokenKind.RightCurlyBrace)) {
-                                break;
-                            }
-                            let k = key();
-                            let expr = this.expression();
-                            lastAAMember = new Expression_1.AAMemberExpression(k.keyToken, k.colonToken, expr, getBscTypeFromExpression(expr, this.currentFunctionExpression));
-                            members.push(lastAAMember);
-                        }
-                    }
-                    this.consume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftCurlyAfterAALiteral(), TokenKind_1.TokenKind.RightCurlyBrace);
-                }
-                let closingBrace = this.previous();
-                const aaExpr = new Expression_1.AALiteralExpression(members, openingBrace, closingBrace, this.currentFunctionExpression);
-                this._references.aaLiterals.push(aaExpr);
-                this.addPropertyHints(aaExpr);
-                return aaExpr;
+                return this.aaLiteral();
             case this.matchAny(TokenKind_1.TokenKind.Pos, TokenKind_1.TokenKind.Tab):
                 let token = Object.assign(this.previous(), {
                     kind: TokenKind_1.TokenKind.Identifier
@@ -1961,6 +1865,106 @@ class Parser {
                 }
         }
     }
+    arrayLiteral() {
+        let elements = [];
+        let openingSquare = this.previous();
+        //add any comment found right after the opening square
+        if (this.check(TokenKind_1.TokenKind.Comment)) {
+            elements.push(new Statement_1.CommentStatement([this.advance()]));
+        }
+        while (this.match(TokenKind_1.TokenKind.Newline)) {
+        }
+        if (!this.match(TokenKind_1.TokenKind.RightSquareBracket)) {
+            elements.push(this.expression());
+            while (this.matchAny(TokenKind_1.TokenKind.Comma, TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Comment)) {
+                if (this.checkPrevious(TokenKind_1.TokenKind.Comment) || this.check(TokenKind_1.TokenKind.Comment)) {
+                    let comment = this.check(TokenKind_1.TokenKind.Comment) ? this.advance() : this.previous();
+                    elements.push(new Statement_1.CommentStatement([comment]));
+                }
+                while (this.match(TokenKind_1.TokenKind.Newline)) {
+                }
+                if (this.check(TokenKind_1.TokenKind.RightSquareBracket)) {
+                    break;
+                }
+                elements.push(this.expression());
+            }
+            this.consume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftSquareBraceAfterArrayLiteral(), TokenKind_1.TokenKind.RightSquareBracket);
+        }
+        let closingSquare = this.previous();
+        //this.consume("Expected newline or ':' after array literal", TokenKind.Newline, TokenKind.Colon, TokenKind.Eof);
+        return new Expression_1.ArrayLiteralExpression(elements, openingSquare, closingSquare);
+    }
+    aaLiteral() {
+        let openingBrace = this.previous();
+        let members = [];
+        let key = () => {
+            let result = {
+                colonToken: null,
+                keyToken: null,
+                range: null
+            };
+            if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties)) {
+                result.keyToken = this.advance();
+            }
+            else if (this.check(TokenKind_1.TokenKind.StringLiteral)) {
+                result.keyToken = this.advance();
+            }
+            else {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedAAKey()), { range: this.peek().range }));
+                throw this.lastDiagnosticAsError();
+            }
+            result.colonToken = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedColonBetweenAAKeyAndvalue(), TokenKind_1.TokenKind.Colon);
+            result.range = util_1.util.getRange(result.keyToken, result.colonToken);
+            return result;
+        };
+        while (this.match(TokenKind_1.TokenKind.Newline)) { }
+        if (!this.match(TokenKind_1.TokenKind.RightCurlyBrace)) {
+            let lastAAMember;
+            if (this.check(TokenKind_1.TokenKind.Comment)) {
+                lastAAMember = null;
+                members.push(new Statement_1.CommentStatement([this.advance()]));
+            }
+            else {
+                let k = key();
+                let expr = this.expression();
+                lastAAMember = new Expression_1.AAMemberExpression(k.keyToken, k.colonToken, expr, getBscTypeFromExpression(expr, this.currentFunctionExpression));
+                members.push(lastAAMember);
+            }
+            while (this.matchAny(TokenKind_1.TokenKind.Comma, TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon, TokenKind_1.TokenKind.Comment)) {
+                // collect comma at end of expression
+                if (lastAAMember && this.checkPrevious(TokenKind_1.TokenKind.Comma)) {
+                    lastAAMember.commaToken = this.previous();
+                }
+                //check for comment at the end of the current line
+                if (this.check(TokenKind_1.TokenKind.Comment) || this.checkPrevious(TokenKind_1.TokenKind.Comment)) {
+                    let token = this.checkPrevious(TokenKind_1.TokenKind.Comment) ? this.previous() : this.advance();
+                    members.push(new Statement_1.CommentStatement([token]));
+                }
+                else {
+                    this.consumeStatementSeparators(true);
+                    //check for a comment on its own line
+                    if (this.check(TokenKind_1.TokenKind.Comment) || this.checkPrevious(TokenKind_1.TokenKind.Comment)) {
+                        let token = this.checkPrevious(TokenKind_1.TokenKind.Comment) ? this.previous() : this.advance();
+                        lastAAMember = null;
+                        members.push(new Statement_1.CommentStatement([token]));
+                        continue;
+                    }
+                    if (this.check(TokenKind_1.TokenKind.RightCurlyBrace)) {
+                        break;
+                    }
+                    let k = key();
+                    let expr = this.expression();
+                    lastAAMember = new Expression_1.AAMemberExpression(k.keyToken, k.colonToken, expr, getBscTypeFromExpression(expr, this.currentFunctionExpression));
+                    members.push(lastAAMember);
+                }
+            }
+            this.consume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftCurlyAfterAALiteral(), TokenKind_1.TokenKind.RightCurlyBrace);
+        }
+        let closingBrace = this.previous();
+        const aaExpr = new Expression_1.AALiteralExpression(members, openingBrace, closingBrace, this.currentFunctionExpression);
+        this.addPropertyHints(aaExpr);
+        return aaExpr;
+    }
     /**
      * Pop token if we encounter specified token
      */
@@ -1984,6 +1988,21 @@ class Parser {
         }
         return false;
     }
+    /**
+     * If the next series of tokens matches the given set of tokens, pop them all
+     * @param tokenKinds
+     */
+    matchSequence(...tokenKinds) {
+        var _a;
+        const endIndex = this.current + tokenKinds.length;
+        for (let i = 0; i < tokenKinds.length; i++) {
+            if (tokenKinds[i] !== ((_a = this.tokens[this.current + i]) === null || _a === void 0 ? void 0 : _a.kind)) {
+                return false;
+            }
+        }
+        this.current = endIndex;
+        return true;
+    }
     /**
      * Get next token matching a specified list, or fail with an error
      */
@@ -2086,6 +2105,21 @@ class Parser {
     previous() {
         return this.tokens[this.current - 1];
     }
+    /**
+     * Get the token that is {offset} indexes away from {this.current}
+     * @param offset the number of index steps away from current index to fetch
+     * @param tokenKinds the desired token must match one of these
+     * @example
+     * getToken(-1); //returns the previous token.
+     * getToken(0);  //returns current token.
+     * getToken(1);  //returns next token
+     */
+    getMatchingTokenAtOffset(offset, ...tokenKinds) {
+        const token = this.tokens[this.current + offset];
+        if (tokenKinds.includes(token.kind)) {
+            return token;
+        }
+    }
     synchronize() {
         this.advance(); // skip the erroneous token
         while (!this.isAtEnd()) {