brighterscript 0.57.2 → 0.59.0

package/dist/parser/Parser.js

@@ -13,8 +13,6 @@ const reflection_1 = require("../astUtils/reflection");
 const visitors_1 = require("../astUtils/visitors");
 const creators_1 = require("../astUtils/creators");
 const Cache_1 = require("../Cache");
-const SymbolTable_1 = require("../SymbolTable");
-const DynamicType_1 = require("../types/DynamicType");
 class Parser {
     constructor() {
         /**
@@ -25,10 +23,6 @@ class Parser {
          * The list of statements for the parsed file
          */
         this.ast = new Statement_1.Body([]);
-        /**
-         * The top-level symbol table for this file. Things like top-level namespaces, non-namespaced classes, enums, interfaces, and functions beling here.
-         */
-        this.symbolTable = new SymbolTable_1.SymbolTable();
         this._references = new References();
         this.globalTerminators = [];
         /**
@@ -39,9 +33,11 @@ class Parser {
     get statements() {
         return this.ast.statements;
     }
-    get currentSymbolTable() {
-        var _a, _b, _c, _d;
-        return (_d = (_b = (_a = this.currentFunctionExpression) === null || _a === void 0 ? void 0 : _a.symbolTable) !== null && _b !== void 0 ? _b : (_c = this.currentNamespace) === null || _c === void 0 ? void 0 : _c.symbolTable) !== null && _d !== void 0 ? _d : this.symbolTable;
+    /**
+     * The top-level symbol table for the body of this file.
+     */
+    get symbolTable() {
+        return this.ast.symbolTable;
     }
     /**
      * References for significant statements/expressions in the parser.
@@ -78,10 +74,6 @@ class Parser {
             }
         }
     }
-    get currentNamespaceName() {
-        var _a;
-        return (_a = this.currentNamespace) === null || _a === void 0 ? void 0 : _a.nameExpression;
-    }
     /**
      * Get the currently active global terminators
      */
@@ -126,7 +118,7 @@ class Parser {
     }
     body() {
         const parentAnnotations = this.enterAnnotationBlock();
-        let body = new Statement_1.Body([], this.symbolTable);
+        let body = new Statement_1.Body([]);
         if (this.tokens.length > 0) {
             this.consumeStatementSeparators(true);
             try {
@@ -333,13 +325,13 @@ class Parser {
         }
         //consume the final `end interface` token
         const endInterfaceToken = this.consumeToken(TokenKind_1.TokenKind.EndInterface);
-        const statement = new Statement_1.InterfaceStatement(interfaceToken, nameToken, extendsToken, parentInterfaceName, body, endInterfaceToken, this.currentNamespaceName);
+        const statement = new Statement_1.InterfaceStatement(interfaceToken, nameToken, extendsToken, parentInterfaceName, body, endInterfaceToken);
         this._references.interfaceStatements.push(statement);
         this.exitAnnotationBlock(parentAnnotations);
         return statement;
     }
     enumDeclaration() {
-        const result = new Statement_1.EnumStatement({}, [], this.currentNamespaceName);
+        const result = new Statement_1.EnumStatement({}, []);
         this.warnIfNotBrighterScriptMode('enum declarations');
         const parentAnnotations = this.enterAnnotationBlock();
         result.tokens.enum = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedKeyword(TokenKind_1.TokenKind.Enum), TokenKind_1.TokenKind.Enum);
@@ -383,9 +375,6 @@ class Parser {
         }
         //consume the final `end interface` token
         result.tokens.endEnum = this.consumeToken(TokenKind_1.TokenKind.EndEnum);
-        if (result.name) {
-            this.currentSymbolTable.addSymbol(result.tokens.name.text, result.tokens.name.range, DynamicType_1.DynamicType.instance);
-        }
         this._references.enumStatements.push(result);
         this.exitAnnotationBlock(parentAnnotations);
         return result;
@@ -437,8 +426,6 @@ class Parser {
                     decl = new Statement_1.MethodStatement(accessModifier, funcDeclaration.name, funcDeclaration.func, overrideKeyword);
                     //refer to this statement as parent of the expression
                     functionStatement.func.functionStatement = decl;
-                    //add the `super` symbol to class methods
-                    funcDeclaration.func.symbolTable.addSymbol('super', undefined, DynamicType_1.DynamicType.instance);
                     //fields
                 }
                 else if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties)) {
@@ -468,10 +455,7 @@ class Parser {
         if (endingKeyword.kind !== TokenKind_1.TokenKind.EndClass) {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.couldNotFindMatchingEndKeyword('class')), { range: endingKeyword.range }));
         }
-        const result = new Statement_1.ClassStatement(classKeyword, className, body, endingKeyword, extendsKeyword, parentClassName, this.currentNamespaceName);
-        if (className) {
-            this.currentSymbolTable.addSymbol(className.text, className.range, DynamicType_1.DynamicType.instance);
-        }
+        const result = new Statement_1.ClassStatement(classKeyword, className, body, endingKeyword, extendsKeyword, parentClassName);
         this._references.classStatements.push(result);
         this.exitAnnotationBlock(parentAnnotations);
         return result;
@@ -572,10 +556,7 @@ class Parser {
             this.consumeStatementSeparators(true);
             let func = new Expression_1.FunctionExpression(params, undefined, //body
             functionType, undefined, //ending keyword
-            leftParen, rightParen, asToken, typeToken, this.currentFunctionExpression, this.currentNamespaceName, this.currentSymbolTable);
-            if (!func.symbolTable.hasSymbol('m')) {
-                func.symbolTable.addSymbol('m', undefined, DynamicType_1.DynamicType.instance);
-            }
+            leftParen, rightParen, asToken, typeToken, this.currentFunctionExpression);
             //if there is a parent function, register this function with the parent
             if (this.currentFunctionExpression) {
                 this.currentFunctionExpression.childFunctionExpressions.push(func);
@@ -584,8 +565,6 @@ class Parser {
             if (!onlyCallableAsMember && name) {
                 const funcType = func.getFunctionType();
                 funcType.setName(name.text);
-                // add the function as declared to the current symbol table
-                this.currentSymbolTable.addSymbol(name.text, name.range, funcType);
             }
             this._references.functionExpressions.push(func);
             let previousFunctionExpression = this.currentFunctionExpression;
@@ -615,18 +594,9 @@ class Parser {
                 return func;
             }
             else {
-                let result = new Statement_1.FunctionStatement(name, func, this.currentNamespaceName);
+                let result = new Statement_1.FunctionStatement(name, func);
                 func.functionStatement = result;
                 this._references.functionStatements.push(result);
-                // Add the transpiled name for namespace functions
-                // to consider an edge case when defining namespaces in .bs files
-                // and using them in .brs files.
-                if (func.namespaceName) {
-                    const transpiledNamespaceFunctionName = result.getName(ParseMode.BrightScript);
-                    const funcType = func.getFunctionType();
-                    funcType.setName(transpiledNamespaceFunctionName);
-                    this.symbolTable.addSymbol(transpiledNamespaceFunctionName, name.range, funcType);
-                }
                 return result;
             }
         }
@@ -660,7 +630,7 @@ class Parser {
                 throw this.lastDiagnosticAsError();
             }
         }
-        return new Expression_1.FunctionParameterExpression(name, typeToken, defaultValue, asToken, this.currentNamespaceName);
+        return new Expression_1.FunctionParameterExpression(name, typeToken, defaultValue, asToken);
     }
     assignment() {
         let name = this.advance();
@@ -675,7 +645,7 @@ class Parser {
             result = new Statement_1.AssignmentStatement(operator, name, value, this.currentFunctionExpression);
         }
         else {
-            const nameExpression = new Expression_1.VariableExpression(name, this.currentNamespaceName);
+            const nameExpression = new Expression_1.VariableExpression(name);
             result = new Statement_1.AssignmentStatement(operator, name, new Expression_1.BinaryExpression(nameExpression, operator, value), this.currentFunctionExpression);
             this.addExpressionsToReferences(nameExpression);
             if ((0, reflection_1.isBinaryExpression)(value)) {
@@ -684,7 +654,6 @@ class Parser {
             }
             this._references.expressions.add(result);
         }
-        this.currentSymbolTable.addSymbol(name.text, name.range, DynamicType_1.DynamicType.instance);
         this._references.assignmentStatements.push(result);
         return result;
     }
@@ -754,6 +723,9 @@ class Parser {
         if (this.check(TokenKind_1.TokenKind.Goto)) {
             return this.gotoStatement();
         }
+        if (this.check(TokenKind_1.TokenKind.Continue)) {
+            return this.continueStatement();
+        }
         //does this line look like a label? (i.e.  `someIdentifier:` )
         if (this.check(TokenKind_1.TokenKind.Identifier) && this.checkNext(TokenKind_1.TokenKind.Colon) && this.checkPrevious(TokenKind_1.TokenKind.Newline)) {
             try {
@@ -857,7 +829,6 @@ class Parser {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedExpressionAfterForEachIn()), { range: this.peek().range }));
             throw this.lastDiagnosticAsError();
         }
-        this.currentSymbolTable.addSymbol(name.text, name.range, DynamicType_1.DynamicType.instance);
         this.consumeStatementSeparators();
         let body = this.block(TokenKind_1.TokenKind.EndFor, TokenKind_1.TokenKind.Next);
         if (!body) {
@@ -900,13 +871,10 @@ class Parser {
         this.namespaceAndFunctionDepth++;
         let name = this.getNamespacedVariableNameExpression();
         //set the current namespace name
-        let result = new Statement_1.NamespaceStatement(keyword, name, null, null, this.currentSymbolTable);
-        this.currentNamespace = result;
+        let result = new Statement_1.NamespaceStatement(keyword, name, null, null);
         this.globalTerminators.push([TokenKind_1.TokenKind.EndNamespace]);
         let body = this.body();
         this.globalTerminators.pop();
-        //unset the current namespace name
-        this.currentNamespace = undefined;
         let endKeyword;
         if (this.check(TokenKind_1.TokenKind.EndNamespace)) {
             endKeyword = this.advance();
@@ -921,9 +889,6 @@ class Parser {
         this._references.namespaceStatements.push(result);
         //cache the range property so that plugins can't affect it
         result.cacheRange();
-        if (result.name) {
-            this.symbolTable.addSymbol(result.name.split('.')[0], result.nameExpression.range, DynamicType_1.DynamicType.instance);
-        }
         return result;
     }
     /**
@@ -935,7 +900,7 @@ class Parser {
         if (firstIdentifier) {
             // force it into an identifier so the AST makes some sense
             firstIdentifier.kind = TokenKind_1.TokenKind.Identifier;
-            const varExpr = new Expression_1.VariableExpression(firstIdentifier, null);
+            const varExpr = new Expression_1.VariableExpression(firstIdentifier);
             expr = varExpr;
             //consume multiple dot identifiers (i.e. `Name.Space.Can.Have.Many.Parts`)
             while (this.check(TokenKind_1.TokenKind.Dot)) {
@@ -986,10 +951,7 @@ class Parser {
             const: constToken,
             name: nameToken,
             equals: equalToken
-        }, expression, this.currentNamespaceName);
-        if (nameToken) {
-            this.currentSymbolTable.addSymbol(nameToken.text, nameToken.range, DynamicType_1.DynamicType.instance);
-        }
+        }, expression);
         this._references.constStatements.push(statement);
         return statement;
     }
@@ -1161,9 +1123,6 @@ class Parser {
         else {
             statement.tokens.endTry = this.advance();
         }
-        if (exceptionVarToken) {
-            this.currentSymbolTable.addSymbol(exceptionVarToken.text, exceptionVarToken.range, DynamicType_1.DynamicType.instance);
-        }
         return statement;
     }
     throwStatement() {
@@ -1206,9 +1165,6 @@ class Parser {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.missingExpressionsInDimStatement()), { range: this.peek().range }));
         }
         let rightSquareBracket = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.missingRightSquareBracketAfterDimIdentifier(), TokenKind_1.TokenKind.RightSquareBracket);
-        if (identifier) {
-            this.currentSymbolTable.addSymbol(identifier.text, identifier.range, DynamicType_1.DynamicType.instance);
-        }
         return new Statement_1.DimStatement(dim, identifier, leftSquareBracket, expressions, rightSquareBracket);
     }
     ifStatement() {
@@ -1499,6 +1455,15 @@ class Parser {
         }
         return new Statement_1.LabelStatement(tokens);
     }
+    /**
+     * Parses a `continue` statement
+     */
+    continueStatement() {
+        return new Statement_1.ContinueStatement({
+            continue: this.advance(),
+            loopType: this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedToken(TokenKind_1.TokenKind.While, TokenKind_1.TokenKind.For), TokenKind_1.TokenKind.While, TokenKind_1.TokenKind.For)
+        });
+    }
     /**
      * Parses a `goto` statement
      * @returns an AST representation of an `goto` statement.
@@ -1700,10 +1665,17 @@ class Parser {
     indexedGet(expr) {
         let openingSquare = this.previous();
         let questionDotToken = this.getMatchingTokenAtOffset(-2, TokenKind_1.TokenKind.QuestionDot);
+        let index;
+        let closingSquare;
         while (this.match(TokenKind_1.TokenKind.Newline)) { }
-        let index = this.expression();
+        try {
+            index = this.expression();
+        }
+        catch (error) {
+            this.rethrowNonDiagnosticError(error);
+        }
         while (this.match(TokenKind_1.TokenKind.Newline)) { }
-        let closingSquare = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedRightSquareBraceAfterArrayOrObjectIndex(), TokenKind_1.TokenKind.RightSquareBracket);
+        closingSquare = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedRightSquareBraceAfterArrayOrObjectIndex(), TokenKind_1.TokenKind.RightSquareBracket);
         return new Expression_1.IndexedGetExpression(expr, index, openingSquare, closingSquare, questionDotToken);
     }
     newExpression() {
@@ -1758,7 +1730,10 @@ class Parser {
                 }
                 else {
                     let dot = this.previous();
-                    let name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedPropertyNameAfterPeriod(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
+                    let name = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedPropertyNameAfterPeriod(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
+                    if (!name) {
+                        break;
+                    }
                     // force it into an identifier so the AST makes some sense
                     name.kind = TokenKind_1.TokenKind.Identifier;
                     expr = new Expression_1.DottedGetExpression(expr, name, dot);
@@ -1767,9 +1742,12 @@ class Parser {
             }
             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);
+                let name = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedAttributeNameAfterAtSymbol(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
                 // force it into an identifier so the AST makes some sense
                 name.kind = TokenKind_1.TokenKind.Identifier;
+                if (!name) {
+                    break;
+                }
                 expr = new Expression_1.XmlAttributeGetExpression(expr, name, dot);
                 //only allow a single `@` expression
                 break;
@@ -1794,12 +1772,19 @@ class Parser {
                     this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.tooManyCallableArguments(args.length, Expression_1.CallExpression.MaximumArguments)), { range: this.peek().range }));
                     throw this.lastDiagnosticAsError();
                 }
-                args.push(this.expression());
+                try {
+                    args.push(this.expression());
+                }
+                catch (error) {
+                    this.rethrowNonDiagnosticError(error);
+                    // we were unable to get an expression, so don't continue
+                    break;
+                }
             } while (this.match(TokenKind_1.TokenKind.Comma));
         }
         while (this.match(TokenKind_1.TokenKind.Newline)) { }
-        const closingParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedRightParenAfterFunctionCallArguments(), TokenKind_1.TokenKind.RightParen);
-        let expression = new Expression_1.CallExpression(callee, openingParen, closingParen, args, this.currentNamespaceName);
+        const closingParen = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedRightParenAfterFunctionCallArguments(), TokenKind_1.TokenKind.RightParen);
+        let expression = new Expression_1.CallExpression(callee, openingParen, closingParen, args);
         if (addToCallExpressionList) {
             this.callExpressions.push(expression);
         }
@@ -1847,7 +1832,7 @@ class Parser {
             case this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedLocalIdentifiers) && this.checkNext(TokenKind_1.TokenKind.BackTick):
                 return this.templateString(true);
             case this.matchAny(TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers):
-                return new Expression_1.VariableExpression(this.previous(), this.currentNamespaceName);
+                return new Expression_1.VariableExpression(this.previous());
             case this.match(TokenKind_1.TokenKind.LeftParen):
                 let left = this.previous();
                 let expr = this.expression();
@@ -1861,7 +1846,7 @@ class Parser {
                 let token = Object.assign(this.previous(), {
                     kind: TokenKind_1.TokenKind.Identifier
                 });
-                return new Expression_1.VariableExpression(token, this.currentNamespaceName);
+                return new Expression_1.VariableExpression(token);
             case this.checkAny(TokenKind_1.TokenKind.Function, TokenKind_1.TokenKind.Sub):
                 return this.anonymousFunction();
             case this.check(TokenKind_1.TokenKind.RegexLiteral):
@@ -1889,23 +1874,31 @@ class Parser {
         }
         while (this.match(TokenKind_1.TokenKind.Newline)) {
         }
+        let closingSquare;
         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;
-                }
+            try {
                 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());
+                }
+            }
+            catch (error) {
+                this.rethrowNonDiagnosticError(error);
             }
-            this.consume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftSquareBraceAfterArrayLiteral(), TokenKind_1.TokenKind.RightSquareBracket);
+            closingSquare = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftSquareBraceAfterArrayLiteral(), TokenKind_1.TokenKind.RightSquareBracket);
+        }
+        else {
+            closingSquare = this.previous();
         }
-        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);
     }
@@ -1933,49 +1926,57 @@ class Parser {
             return result;
         };
         while (this.match(TokenKind_1.TokenKind.Newline)) { }
+        let closingBrace;
         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);
-                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]));
+            try {
+                if (this.check(TokenKind_1.TokenKind.Comment)) {
+                    lastAAMember = null;
+                    members.push(new Statement_1.CommentStatement([this.advance()]));
                 }
                 else {
-                    this.consumeStatementSeparators(true);
-                    //check for a comment on its own line
+                    let k = key();
+                    let expr = this.expression();
+                    lastAAMember = new Expression_1.AAMemberExpression(k.keyToken, k.colonToken, expr);
+                    members.push(lastAAMember);
+                }
+                while (this.matchAny(TokenKind_1.TokenKind.Comma, TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon, TokenKind_1.TokenKind.Comment)) {
+                    // collect comma at end of expression
+                    if (lastAAMember && this.checkPrevious(TokenKind_1.TokenKind.Comma)) {
+                        lastAAMember.commaToken = this.previous();
+                    }
+                    //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();
-                        lastAAMember = null;
                         members.push(new Statement_1.CommentStatement([token]));
-                        continue;
                     }
-                    if (this.check(TokenKind_1.TokenKind.RightCurlyBrace)) {
-                        break;
+                    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);
+                        members.push(lastAAMember);
                     }
-                    let k = key();
-                    let expr = this.expression();
-                    lastAAMember = new Expression_1.AAMemberExpression(k.keyToken, k.colonToken, expr);
-                    members.push(lastAAMember);
                 }
             }
-            this.consume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftCurlyAfterAALiteral(), TokenKind_1.TokenKind.RightCurlyBrace);
+            catch (error) {
+                this.rethrowNonDiagnosticError(error);
+            }
+            closingBrace = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.unmatchedLeftCurlyAfterAALiteral(), TokenKind_1.TokenKind.RightCurlyBrace);
+        }
+        else {
+            closingBrace = this.previous();
         }
-        let closingBrace = this.previous();
         const aaExpr = new Expression_1.AALiteralExpression(members, openingBrace, closingBrace);
         this.addPropertyHints(aaExpr);
         return aaExpr;
@@ -2120,6 +2121,18 @@ class Parser {
     previous() {
         return this.tokens[this.current - 1];
     }
+    /**
+     * Sometimes we catch an error that is a diagnostic.
+     * If that's the case, we want to continue parsing.
+     * Otherwise, re-throw the error
+     *
+     * @param error error caught in a try/catch
+     */
+    rethrowNonDiagnosticError(error) {
+        if (!error.isDiagnostic) {
+            throw error;
+        }
+    }
     /**
      * Get the token that is {offset} indexes away from {this.current}
      * @param offset the number of index steps away from current index to fetch
@@ -2229,7 +2242,7 @@ class Parser {
                 this._references.libraryStatements.push(s);
             },
             FunctionExpression: (expression, parent) => {
-                if (!(0, reflection_1.isClassMethodStatement)(parent)) {
+                if (!(0, reflection_1.isMethodStatement)(parent)) {
                     this._references.functionExpressions.push(expression);
                 }
             },