parseUnit(class)
  skipErrorTokens(class)
  listener: beginCompilationUnit(class)
  syntheticPreviousToken(class)
  parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext')
    parseMetadataStar()
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(WrapperClass, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, WrapperClass)
        parseClass(WrapperClass, class, class, WrapperClass)
          parseClassHeaderOpt(WrapperClass, class, class)
            parseClassExtendsOpt(WrapperClass)
              listener: handleNoType(WrapperClass)
              listener: handleClassExtends(null)
            parseWithClauseOpt(WrapperClass)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(WrapperClass)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(WrapperClass, DeclarationKind.Class, WrapperClass)
            listener: beginClassOrMixinBody(DeclarationKind.Class, {)
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, WrapperClass)
              parseMetadataStar({)
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields({, null, null, null, null, null, {, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType({)
                ensureIdentifier({, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(assert)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, assert)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(assert)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(;, ;, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                reportRecoverableErrorWithToken(assert, Instance of 'Template<(Token) => Message>')
                  listener: handleRecoverableError(Message[ExpectedClassMember, Expected a class member, but got 'assert'., null, {token: assert}], assert, assert)
                listener: handleInvalidMember(assert)
                listener: endMember()
            notEofOrValue(}, ()
            parseClassOrMixinOrExtensionMemberImpl(assert, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(assert)
                listener: beginMetadataStar(()
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(assert, assert, null, null, null, null, null, assert, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(assert, null, null, null, null, null, assert, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(assert)
                  ensureIdentifier(assert, methodDeclaration)
                    insertSyntheticIdentifier(assert, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  inPlainSync()
                                  parseAssert(return, Assert.Expression)
                                    listener: beginAssert(assert, Assert.Expression)
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          parsePrimary((, expression)
                                            parseSendOrFunctionLiteral((, expression)
                                              parseSend((, expression)
                                                ensureIdentifier((, expression)
                                                  listener: handleIdentifier(x, expression)
                                                listener: handleNoTypeArguments(-)
                                                parseArgumentsOpt(x)
                                                  listener: handleNoArguments(-)
                                                listener: handleSend(x, -)
                                        listener: beginBinaryExpression(-)
                                        parsePrecedenceExpression(-, 14, true)
                                          parseUnaryExpression(-, true)
                                            parsePrimary(-, expression)
                                              parseLiteralInt(-)
                                                listener: handleLiteralInt(1)
                                        listener: endBinaryExpression(-)
                                    reportRecoverableError(assert, AssertAsExpression)
                                      listener: handleRecoverableError(AssertAsExpression, assert, assert)
                                    listener: endAssert(assert, Assert.Expression, (, null, +)
                              listener: beginBinaryExpression(+)
                              parsePrecedenceExpression(+, 14, true)
                                parseUnaryExpression(+, true)
                                  parsePrimary(+, expression)
                                    parseLiteralInt(+)
                                      listener: handleLiteralInt(1)
                              listener: endBinaryExpression(+)
                          ensureSemicolon(1)
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(2, {, })
                  listener: endClassMethod(null, , (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(break)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, break)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(break)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(;, ;, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                reportRecoverableErrorWithToken(break, Instance of 'Template<(Token) => Message>')
                  listener: handleRecoverableError(Message[ExpectedClassMember, Expected a class member, but got 'break'., null, {token: break}], break, break)
                listener: handleInvalidMember(break)
                listener: endMember()
            notEofOrValue(}, ()
            parseClassOrMixinOrExtensionMemberImpl(break, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(break)
                listener: beginMetadataStar(()
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(break, break, null, null, null, null, null, break, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(break, null, null, null, null, null, break, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(break)
                  ensureIdentifier(break, methodDeclaration)
                    insertSyntheticIdentifier(break, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  inPlainSync()
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      reportRecoverableErrorWithToken(break, Instance of 'Template<(Token) => Message>')
                                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'break'., null, {token: break}], break, break)
                                      rewriter()
                                      listener: handleIdentifier(, expression)
                                    listener: handleNoTypeArguments(break)
                                    parseArgumentsOpt()
                                      listener: handleNoArguments(break)
                                    listener: handleSend(, break)
                          ensureSemicolon()
                            reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                              listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], break, break)
                            rewriter()
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, break)
                    parseStatement(;)
                      parseStatementX(;)
                        parseBreakStatement(;)
                          isBreakAllowed()
                          reportRecoverableError(break, BreakOutsideOfLoop)
                            listener: handleRecoverableError(BreakOutsideOfLoop, break, break)
                          ensureSemicolon(break)
                            reportRecoverableError(break, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                              listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], break, break)
                            rewriter()
                          listener: handleBreakStatement(false, break, ;)
                    notEofOrValue(}, ()
                    parseStatement(;)
                      parseStatementX(;)
                        parseExpressionStatementOrDeclaration(;, false)
                          parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                            looksLikeLocalFunction(()
                            parseExpressionStatement(;)
                              parseExpression(;)
                                parsePrecedenceExpression(;, 1, true)
                                  parseUnaryExpression(;, true)
                                    parsePrimary(;, expression)
                                      parseParenthesizedExpressionOrFunctionLiteral(;)
                                        parseParenthesizedExpression(;)
                                          parseExpressionInParenthesis(;)
                                            parseExpressionInParenthesisRest(()
                                              parseExpression(()
                                                parsePrecedenceExpression((, 1, true)
                                                  parseUnaryExpression((, true)
                                                    parsePrimary((, expression)
                                                      parseSendOrFunctionLiteral((, expression)
                                                        parseSend((, expression)
                                                          ensureIdentifier((, expression)
                                                            listener: handleIdentifier(x, expression)
                                                          listener: handleNoTypeArguments(-)
                                                          parseArgumentsOpt(x)
                                                            listener: handleNoArguments(-)
                                                          listener: handleSend(x, -)
                                                  listener: beginBinaryExpression(-)
                                                  parsePrecedenceExpression(-, 14, true)
                                                    parseUnaryExpression(-, true)
                                                      parsePrimary(-, expression)
                                                        parseLiteralInt(-)
                                                          listener: handleLiteralInt(1)
                                                  listener: endBinaryExpression(-)
                                              ensureCloseParen(1, ()
                                          listener: handleParenthesizedExpression(()
                                  listener: beginBinaryExpression(+)
                                  parsePrecedenceExpression(+, 14, true)
                                    parseUnaryExpression(+, true)
                                      parsePrimary(+, expression)
                                        parseLiteralInt(+)
                                          listener: handleLiteralInt(1)
                                  listener: endBinaryExpression(+)
                              ensureSemicolon(1)
                              listener: handleExpressionStatement(;)
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(4, {, })
                  listener: endClassMethod(null, , (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(case)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, case)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(case)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(;, ;, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                reportRecoverableErrorWithToken(case, Instance of 'Template<(Token) => Message>')
                  listener: handleRecoverableError(Message[ExpectedClassMember, Expected a class member, but got 'case'., null, {token: case}], case, case)
                listener: handleInvalidMember(case)
                listener: endMember()
            notEofOrValue(}, ()
            parseClassOrMixinOrExtensionMemberImpl(case, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(case)
                listener: beginMetadataStar(()
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(case, case, null, null, null, null, null, case, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(case, null, null, null, null, null, case, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(case)
                  ensureIdentifier(case, methodDeclaration)
                    insertSyntheticIdentifier(case, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  inPlainSync()
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      reportRecoverableErrorWithToken(case, Instance of 'Template<(Token) => Message>')
                                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'case'., null, {token: case}], case, case)
                                      listener: handleIdentifier(case, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(case)
                                      parseArguments(case)
                                        parseArgumentsRest(()
                                          listener: beginArguments(()
                                          parseExpression(()
                                            parsePrecedenceExpression((, 1, true)
                                              parseUnaryExpression((, true)
                                                parsePrimary((, expression)
                                                  parseSendOrFunctionLiteral((, expression)
                                                    parseSend((, expression)
                                                      ensureIdentifier((, expression)
                                                        listener: handleIdentifier(x, expression)
                                                      listener: handleNoTypeArguments(-)
                                                      parseArgumentsOpt(x)
                                                        listener: handleNoArguments(-)
                                                      listener: handleSend(x, -)
                                              listener: beginBinaryExpression(-)
                                              parsePrecedenceExpression(-, 14, true)
                                                parseUnaryExpression(-, true)
                                                  parsePrimary(-, expression)
                                                    parseLiteralInt(-)
                                                      listener: handleLiteralInt(1)
                                              listener: endBinaryExpression(-)
                                          listener: endArguments(1, (, ))
                                    listener: handleSend(case, +)
                              listener: beginBinaryExpression(+)
                              parsePrecedenceExpression(+, 14, true)
                                parseUnaryExpression(+, true)
                                  parsePrimary(+, expression)
                                    parseLiteralInt(+)
                                      listener: handleLiteralInt(1)
                              listener: endBinaryExpression(+)
                          ensureSemicolon(1)
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(2, {, })
                  listener: endClassMethod(null, , (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(catch)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, catch)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(catch)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(;, ;, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                reportRecoverableErrorWithToken(catch, Instance of 'Template<(Token) => Message>')
                  listener: handleRecoverableError(Message[ExpectedClassMember, Expected a class member, but got 'catch'., null, {token: catch}], catch, catch)
                listener: handleInvalidMember(catch)
                listener: endMember()
            notEofOrValue(}, ()
            parseClassOrMixinOrExtensionMemberImpl(catch, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(catch)
                listener: beginMetadataStar(()
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(catch, catch, null, null, null, null, null, catch, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(catch, null, null, null, null, null, catch, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(catch)
                  ensureIdentifier(catch, methodDeclaration)
                    insertSyntheticIdentifier(catch, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  inPlainSync()
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      reportRecoverableErrorWithToken(catch, Instance of 'Template<(Token) => Message>')
                                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'catch'., null, {token: catch}], catch, catch)
                                      listener: handleIdentifier(catch, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(catch)
                                      parseArguments(catch)
                                        parseArgumentsRest(()
                                          listener: beginArguments(()
                                          parseExpression(()
                                            parsePrecedenceExpression((, 1, true)
                                              parseUnaryExpression((, true)
                                                parsePrimary((, expression)
                                                  parseSendOrFunctionLiteral((, expression)
                                                    parseSend((, expression)
                                                      ensureIdentifier((, expression)
                                                        listener: handleIdentifier(x, expression)
                                                      listener: handleNoTypeArguments(-)
                                                      parseArgumentsOpt(x)
                                                        listener: handleNoArguments(-)
                                                      listener: handleSend(x, -)
                                              listener: beginBinaryExpression(-)
                                              parsePrecedenceExpression(-, 14, true)
                                                parseUnaryExpression(-, true)
                                                  parsePrimary(-, expression)
                                                    parseLiteralInt(-)
                                                      listener: handleLiteralInt(1)
                                              listener: endBinaryExpression(-)
                                          listener: endArguments(1, (, ))
                                    listener: handleSend(catch, +)
                              listener: beginBinaryExpression(+)
                              parsePrecedenceExpression(+, 14, true)
                                parseUnaryExpression(+, true)
                                  parsePrimary(+, expression)
                                    parseLiteralInt(+)
                                      listener: handleLiteralInt(1)
                              listener: endBinaryExpression(+)
                          ensureSemicolon(1)
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(2, {, })
                  listener: endClassMethod(null, , (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(class)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, class)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(class)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(;, ;, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                reportAndSkipClassInClass(class)
                  reportRecoverableError(class, ClassInClass)
                    listener: handleRecoverableError(ClassInClass, class, class)
                  listener: handleInvalidMember(class)
            notEofOrValue(}, ()
            parseClassOrMixinOrExtensionMemberImpl(class, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(class)
                listener: beginMetadataStar(()
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(class, class, null, null, null, null, null, class, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(class, null, null, null, null, null, class, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(class)
                  ensureIdentifier(class, methodDeclaration)
                    insertSyntheticIdentifier(class, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  inPlainSync()
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      reportRecoverableErrorWithToken(class, Instance of 'Template<(Token) => Message>')
                                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'class'., null, {token: class}], class, class)
                                      listener: handleIdentifier(class, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(class)
                                      parseArguments(class)
                                        parseArgumentsRest(()
                                          listener: beginArguments(()
                                          parseExpression(()
                                            parsePrecedenceExpression((, 1, true)
                                              parseUnaryExpression((, true)
                                                parsePrimary((, expression)
                                                  parseSendOrFunctionLiteral((, expression)
                                                    parseSend((, expression)
                                                      ensureIdentifier((, expression)
                                                        listener: handleIdentifier(x, expression)
                                                      listener: handleNoTypeArguments(-)
                                                      parseArgumentsOpt(x)
                                                        listener: handleNoArguments(-)
                                                      listener: handleSend(x, -)
                                              listener: beginBinaryExpression(-)
                                              parsePrecedenceExpression(-, 14, true)
                                                parseUnaryExpression(-, true)
                                                  parsePrimary(-, expression)
                                                    parseLiteralInt(-)
                                                      listener: handleLiteralInt(1)
                                              listener: endBinaryExpression(-)
                                          listener: endArguments(1, (, ))
                                    listener: handleSend(class, +)
                              listener: beginBinaryExpression(+)
                              parsePrecedenceExpression(+, 14, true)
                                parseUnaryExpression(+, true)
                                  parsePrimary(+, expression)
                                    parseLiteralInt(+)
                                      listener: handleLiteralInt(1)
                              listener: endBinaryExpression(+)
                          ensureSemicolon(1)
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(2, {, })
                  listener: endClassMethod(null, , (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(const)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, const)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(const)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(const, ;, null, null, null, null, const, const, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(;, null, null, null, null, const, const, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, const, null, ()
                  listener: handleNoType(const)
                  ensureIdentifier(const, methodDeclaration)
                    insertSyntheticIdentifier(const, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  parseConstExpression(return)
                                    listener: beginConstExpression(const)
                                    parseConstructorReference(const, null)
                                      ensureIdentifier(const, constructorReference)
                                        insertSyntheticIdentifier(const, constructorReference, message: Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], messageOnToken: null)
                                          reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                                            listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                                          rewriter()
                                        listener: handleIdentifier(, constructorReference)
                                      listener: beginConstructorReference()
                                      parseQualifiedRestOpt(, constructorReferenceContinuation)
                                      listener: handleNoTypeArguments(()
                                      listener: handleNoConstructorReferenceContinuationAfterTypeArguments(()
                                      listener: endConstructorReference(, null, ()
                                    parseConstructorInvocationArguments()
                                      parseArgumentsRest(()
                                        listener: beginArguments(()
                                        parseExpression(()
                                          parsePrecedenceExpression((, 1, true)
                                            parseUnaryExpression((, true)
                                              parsePrimary((, expression)
                                                parseSendOrFunctionLiteral((, expression)
                                                  parseSend((, expression)
                                                    ensureIdentifier((, expression)
                                                      listener: handleIdentifier(x, expression)
                                                    listener: handleNoTypeArguments(-)
                                                    parseArgumentsOpt(x)
                                                      listener: handleNoArguments(-)
                                                    listener: handleSend(x, -)
                                            listener: beginBinaryExpression(-)
                                            parsePrecedenceExpression(-, 14, true)
                                              parseUnaryExpression(-, true)
                                                parsePrimary(-, expression)
                                                  parseLiteralInt(-)
                                                    listener: handleLiteralInt(1)
                                            listener: endBinaryExpression(-)
                                        listener: endArguments(1, (, ))
                                    listener: endConstExpression(const)
                              listener: beginBinaryExpression(+)
                              parsePrecedenceExpression(+, 14, true)
                                parseUnaryExpression(+, true)
                                  parsePrimary(+, expression)
                                    parseLiteralInt(+)
                                      listener: handleLiteralInt(1)
                              listener: endBinaryExpression(+)
                          ensureSemicolon(1)
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(2, {, })
                  reportRecoverableError(const, ConstMethod)
                    listener: handleRecoverableError(ConstMethod, const, const)
                  listener: endClassMethod(null, const, (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(continue)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, continue)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(continue)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(;, ;, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                reportRecoverableErrorWithToken(continue, Instance of 'Template<(Token) => Message>')
                  listener: handleRecoverableError(Message[ExpectedClassMember, Expected a class member, but got 'continue'., null, {token: continue}], continue, continue)
                listener: handleInvalidMember(continue)
                listener: endMember()
            notEofOrValue(}, ()
            parseClassOrMixinOrExtensionMemberImpl(continue, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(continue)
                listener: beginMetadataStar(()
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(continue, continue, null, null, null, null, null, continue, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(continue, null, null, null, null, null, continue, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(continue)
                  ensureIdentifier(continue, methodDeclaration)
                    insertSyntheticIdentifier(continue, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  inPlainSync()
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      reportRecoverableErrorWithToken(continue, Instance of 'Template<(Token) => Message>')
                                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'continue'., null, {token: continue}], continue, continue)
                                      rewriter()
                                      listener: handleIdentifier(, expression)
                                    listener: handleNoTypeArguments(continue)
                                    parseArgumentsOpt()
                                      listener: handleNoArguments(continue)
                                    listener: handleSend(, continue)
                          ensureSemicolon()
                            reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                              listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], continue, continue)
                            rewriter()
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, continue)
                    parseStatement(;)
                      parseStatementX(;)
                        parseContinueStatement(;)
                          isContinueAllowed()
                          reportRecoverableError(continue, ContinueOutsideOfLoop)
                            listener: handleRecoverableError(ContinueOutsideOfLoop, continue, continue)
                          ensureSemicolon(continue)
                            reportRecoverableError(continue, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                              listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], continue, continue)
                            rewriter()
                          listener: handleContinueStatement(false, continue, ;)
                    notEofOrValue(}, ()
                    parseStatement(;)
                      parseStatementX(;)
                        parseExpressionStatementOrDeclaration(;, false)
                          parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                            looksLikeLocalFunction(()
                            parseExpressionStatement(;)
                              parseExpression(;)
                                parsePrecedenceExpression(;, 1, true)
                                  parseUnaryExpression(;, true)
                                    parsePrimary(;, expression)
                                      parseParenthesizedExpressionOrFunctionLiteral(;)
                                        parseParenthesizedExpression(;)
                                          parseExpressionInParenthesis(;)
                                            parseExpressionInParenthesisRest(()
                                              parseExpression(()
                                                parsePrecedenceExpression((, 1, true)
                                                  parseUnaryExpression((, true)
                                                    parsePrimary((, expression)
                                                      parseSendOrFunctionLiteral((, expression)
                                                        parseSend((, expression)
                                                          ensureIdentifier((, expression)
                                                            listener: handleIdentifier(x, expression)
                                                          listener: handleNoTypeArguments(-)
                                                          parseArgumentsOpt(x)
                                                            listener: handleNoArguments(-)
                                                          listener: handleSend(x, -)
                                                  listener: beginBinaryExpression(-)
                                                  parsePrecedenceExpression(-, 14, true)
                                                    parseUnaryExpression(-, true)
                                                      parsePrimary(-, expression)
                                                        parseLiteralInt(-)
                                                          listener: handleLiteralInt(1)
                                                  listener: endBinaryExpression(-)
                                              ensureCloseParen(1, ()
                                          listener: handleParenthesizedExpression(()
                                  listener: beginBinaryExpression(+)
                                  parsePrecedenceExpression(+, 14, true)
                                    parseUnaryExpression(+, true)
                                      parsePrimary(+, expression)
                                        parseLiteralInt(+)
                                          listener: handleLiteralInt(1)
                                  listener: endBinaryExpression(+)
                              ensureSemicolon(1)
                              listener: handleExpressionStatement(;)
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(4, {, })
                  listener: endClassMethod(null, , (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(default)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, default)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(default)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(;, ;, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                reportRecoverableErrorWithToken(default, Instance of 'Template<(Token) => Message>')
                  listener: handleRecoverableError(Message[ExpectedClassMember, Expected a class member, but got 'default'., null, {token: default}], default, default)
                listener: handleInvalidMember(default)
                listener: endMember()
            notEofOrValue(}, ()
            parseClassOrMixinOrExtensionMemberImpl(default, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(default)
                listener: beginMetadataStar(()
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(default, default, null, null, null, null, null, default, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(default, null, null, null, null, null, default, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(default)
                  ensureIdentifier(default, methodDeclaration)
                    insertSyntheticIdentifier(default, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  inPlainSync()
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      reportRecoverableErrorWithToken(default, Instance of 'Template<(Token) => Message>')
                                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'default'., null, {token: default}], default, default)
                                      listener: handleIdentifier(default, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(default)
                                      parseArguments(default)
                                        parseArgumentsRest(()
                                          listener: beginArguments(()
                                          parseExpression(()
                                            parsePrecedenceExpression((, 1, true)
                                              parseUnaryExpression((, true)
                                                parsePrimary((, expression)
                                                  parseSendOrFunctionLiteral((, expression)
                                                    parseSend((, expression)
                                                      ensureIdentifier((, expression)
                                                        listener: handleIdentifier(x, expression)
                                                      listener: handleNoTypeArguments(-)
                                                      parseArgumentsOpt(x)
                                                        listener: handleNoArguments(-)
                                                      listener: handleSend(x, -)
                                              listener: beginBinaryExpression(-)
                                              parsePrecedenceExpression(-, 14, true)
                                                parseUnaryExpression(-, true)
                                                  parsePrimary(-, expression)
                                                    parseLiteralInt(-)
                                                      listener: handleLiteralInt(1)
                                              listener: endBinaryExpression(-)
                                          listener: endArguments(1, (, ))
                                    listener: handleSend(default, +)
                              listener: beginBinaryExpression(+)
                              parsePrecedenceExpression(+, 14, true)
                                parseUnaryExpression(+, true)
                                  parsePrimary(+, expression)
                                    parseLiteralInt(+)
                                      listener: handleLiteralInt(1)
                              listener: endBinaryExpression(+)
                          ensureSemicolon(1)
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(2, {, })
                  listener: endClassMethod(null, , (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(do)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, do)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(do)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(;, ;, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                reportRecoverableErrorWithToken(do, Instance of 'Template<(Token) => Message>')
                  listener: handleRecoverableError(Message[ExpectedClassMember, Expected a class member, but got 'do'., null, {token: do}], do, do)
                listener: handleInvalidMember(do)
                listener: endMember()
            notEofOrValue(}, ()
            parseClassOrMixinOrExtensionMemberImpl(do, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(do)
                listener: beginMetadataStar(()
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(do, do, null, null, null, null, null, do, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(do, null, null, null, null, null, do, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(do)
                  ensureIdentifier(do, methodDeclaration)
                    insertSyntheticIdentifier(do, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  inPlainSync()
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      reportRecoverableErrorWithToken(do, Instance of 'Template<(Token) => Message>')
                                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'do'., null, {token: do}], do, do)
                                      rewriter()
                                      listener: handleIdentifier(, expression)
                                    listener: handleNoTypeArguments(do)
                                    parseArgumentsOpt()
                                      listener: handleNoArguments(do)
                                    listener: handleSend(, do)
                          ensureSemicolon()
                            reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                              listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], do, do)
                            rewriter()
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, do)
                    parseStatement(;)
                      parseStatementX(;)
                        parseDoWhileStatement(;)
                          listener: beginDoWhileStatement(do)
                          listener: beginDoWhileStatementBody(()
                          parseStatement(do)
                            parseStatementX(do)
                              parseExpressionStatementOrDeclaration(do, false)
                                parseExpressionStatementOrDeclarationAfterModifiers(do, do, null, null, null, false)
                                  looksLikeLocalFunction(()
                                  parseExpressionStatement(do)
                                    parseExpression(do)
                                      parsePrecedenceExpression(do, 1, true)
                                        parseUnaryExpression(do, true)
                                          parsePrimary(do, expression)
                                            parseParenthesizedExpressionOrFunctionLiteral(do)
                                              parseParenthesizedExpression(do)
                                                parseExpressionInParenthesis(do)
                                                  parseExpressionInParenthesisRest(()
                                                    parseExpression(()
                                                      parsePrecedenceExpression((, 1, true)
                                                        parseUnaryExpression((, true)
                                                          parsePrimary((, expression)
                                                            parseSendOrFunctionLiteral((, expression)
                                                              parseSend((, expression)
                                                                ensureIdentifier((, expression)
                                                                  listener: handleIdentifier(x, expression)
                                                                listener: handleNoTypeArguments(-)
                                                                parseArgumentsOpt(x)
                                                                  listener: handleNoArguments(-)
                                                                listener: handleSend(x, -)
                                                        listener: beginBinaryExpression(-)
                                                        parsePrecedenceExpression(-, 14, true)
                                                          parseUnaryExpression(-, true)
                                                            parsePrimary(-, expression)
                                                              parseLiteralInt(-)
                                                                listener: handleLiteralInt(1)
                                                        listener: endBinaryExpression(-)
                                                    ensureCloseParen(1, ()
                                                listener: handleParenthesizedExpression(()
                                        listener: beginBinaryExpression(+)
                                        parsePrecedenceExpression(+, 14, true)
                                          parseUnaryExpression(+, true)
                                            parsePrimary(+, expression)
                                              parseLiteralInt(+)
                                                listener: handleLiteralInt(1)
                                        listener: endBinaryExpression(+)
                                    ensureSemicolon(1)
                                    listener: handleExpressionStatement(;)
                          listener: endDoWhileStatementBody(;)
                          reportRecoverableError(}, Message[ExpectedButGot, Expected 'while' before this., null, {string: while}])
                            listener: handleRecoverableError(Message[ExpectedButGot, Expected 'while' before this., null, {string: while}], }, })
                          rewriter()
                          ensureParenthesizedCondition(while)
                            reportRecoverableError(}, Message[ExpectedToken, Expected to find '('., null, {string: (}])
                              listener: handleRecoverableError(Message[ExpectedToken, Expected to find '('., null, {string: (}], }, })
                            rewriter()
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSend((, expression)
                                        ensureIdentifier((, expression)
                                          reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                            listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '}'., null, {token: }}], }, })
                                          rewriter()
                                          listener: handleIdentifier(, expression)
                                        listener: handleNoTypeArguments())
                                        parseArgumentsOpt()
                                          listener: handleNoArguments())
                                        listener: handleSend(, ))
                              ensureCloseParen(, ()
                            listener: handleParenthesizedCondition(()
                          ensureSemicolon())
                            reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                              listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], }, })
                            rewriter()
                          listener: endDoWhileStatement(do, while, ;)
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(3, {, })
                  listener: endClassMethod(null, , (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(else)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, else)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(else)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(;, ;, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                reportRecoverableErrorWithToken(else, Instance of 'Template<(Token) => Message>')
                  listener: handleRecoverableError(Message[ExpectedClassMember, Expected a class member, but got 'else'., null, {token: else}], else, else)
                listener: handleInvalidMember(else)
                listener: endMember()
            notEofOrValue(}, ()
            parseClassOrMixinOrExtensionMemberImpl(else, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(else)
                listener: beginMetadataStar(()
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(else, else, null, null, null, null, null, else, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(else, null, null, null, null, null, else, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(else)
                  ensureIdentifier(else, methodDeclaration)
                    insertSyntheticIdentifier(else, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  inPlainSync()
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      reportRecoverableErrorWithToken(else, Instance of 'Template<(Token) => Message>')
                                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'else'., null, {token: else}], else, else)
                                      rewriter()
                                      listener: handleIdentifier(, expression)
                                    listener: handleNoTypeArguments(else)
                                    parseArgumentsOpt()
                                      listener: handleNoArguments(else)
                                    listener: handleSend(, else)
                          ensureSemicolon()
                            reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                              listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], else, else)
                            rewriter()
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, else)
                    parseStatement(;)
                      parseStatementX(;)
                        parseExpressionStatementOrDeclaration(;, false)
                          parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                            looksLikeLocalFunction(else)
                            parseExpressionStatement(;)
                              parseExpression(;)
                                parsePrecedenceExpression(;, 1, true)
                                  parseUnaryExpression(;, true)
                                    parsePrimary(;, expression)
                                      inPlainSync()
                                      parseSend(;, expression)
                                        ensureIdentifier(;, expression)
                                          reportRecoverableErrorWithToken(else, Instance of 'Template<(Token) => Message>')
                                            listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'else'., null, {token: else}], else, else)
                                          rewriter()
                                          listener: handleIdentifier(, expression)
                                        listener: handleNoTypeArguments(else)
                                        parseArgumentsOpt()
                                          listener: handleNoArguments(else)
                                        listener: handleSend(, else)
                              ensureSemicolon()
                                reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                                  listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], else, else)
                                rewriter()
                              listener: handleExpressionStatement(;)
                    reportRecoverableError(;, Message[UnexpectedToken, Unexpected token ';'., null, {token: ;}])
                      listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {token: ;}], else, else)
                    notEofOrValue(}, ()
                    parseStatement(else)
                      parseStatementX(else)
                        parseExpressionStatementOrDeclaration(else, false)
                          parseExpressionStatementOrDeclarationAfterModifiers(else, else, null, null, null, false)
                            looksLikeLocalFunction(()
                            parseExpressionStatement(else)
                              parseExpression(else)
                                parsePrecedenceExpression(else, 1, true)
                                  parseUnaryExpression(else, true)
                                    parsePrimary(else, expression)
                                      parseParenthesizedExpressionOrFunctionLiteral(else)
                                        parseParenthesizedExpression(else)
                                          parseExpressionInParenthesis(else)
                                            parseExpressionInParenthesisRest(()
                                              parseExpression(()
                                                parsePrecedenceExpression((, 1, true)
                                                  parseUnaryExpression((, true)
                                                    parsePrimary((, expression)
                                                      parseSendOrFunctionLiteral((, expression)
                                                        parseSend((, expression)
                                                          ensureIdentifier((, expression)
                                                            listener: handleIdentifier(x, expression)
                                                          listener: handleNoTypeArguments(-)
                                                          parseArgumentsOpt(x)
                                                            listener: handleNoArguments(-)
                                                          listener: handleSend(x, -)
                                                  listener: beginBinaryExpression(-)
                                                  parsePrecedenceExpression(-, 14, true)
                                                    parseUnaryExpression(-, true)
                                                      parsePrimary(-, expression)
                                                        parseLiteralInt(-)
                                                          listener: handleLiteralInt(1)
                                                  listener: endBinaryExpression(-)
                                              ensureCloseParen(1, ()
                                          listener: handleParenthesizedExpression(()
                                  listener: beginBinaryExpression(+)
                                  parsePrecedenceExpression(+, 14, true)
                                    parseUnaryExpression(+, true)
                                      parsePrimary(+, expression)
                                        parseLiteralInt(+)
                                          listener: handleLiteralInt(1)
                                  listener: endBinaryExpression(+)
                              ensureSemicolon(1)
                              listener: handleExpressionStatement(;)
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(4, {, })
                  listener: endClassMethod(null, , (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(enum)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, enum)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(enum)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(;, ;, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                reportAndSkipEnumInClass(enum)
                  reportRecoverableError(enum, EnumInClass)
                    listener: handleRecoverableError(EnumInClass, enum, enum)
                  listener: handleInvalidMember(enum)
            notEofOrValue(}, ()
            parseClassOrMixinOrExtensionMemberImpl(enum, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(enum)
                listener: beginMetadataStar(()
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(enum, enum, null, null, null, null, null, enum, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(enum, null, null, null, null, null, enum, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(enum)
                  ensureIdentifier(enum, methodDeclaration)
                    insertSyntheticIdentifier(enum, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  inPlainSync()
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      reportRecoverableErrorWithToken(enum, Instance of 'Template<(Token) => Message>')
                                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'enum'., null, {token: enum}], enum, enum)
                                      listener: handleIdentifier(enum, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(enum)
                                      parseArguments(enum)
                                        parseArgumentsRest(()
                                          listener: beginArguments(()
                                          parseExpression(()
                                            parsePrecedenceExpression((, 1, true)
                                              parseUnaryExpression((, true)
                                                parsePrimary((, expression)
                                                  parseSendOrFunctionLiteral((, expression)
                                                    parseSend((, expression)
                                                      ensureIdentifier((, expression)
                                                        listener: handleIdentifier(x, expression)
                                                      listener: handleNoTypeArguments(-)
                                                      parseArgumentsOpt(x)
                                                        listener: handleNoArguments(-)
                                                      listener: handleSend(x, -)
                                              listener: beginBinaryExpression(-)
                                              parsePrecedenceExpression(-, 14, true)
                                                parseUnaryExpression(-, true)
                                                  parsePrimary(-, expression)
                                                    parseLiteralInt(-)
                                                      listener: handleLiteralInt(1)
                                              listener: endBinaryExpression(-)
                                          listener: endArguments(1, (, ))
                                    listener: handleSend(enum, +)
                              listener: beginBinaryExpression(+)
                              parsePrecedenceExpression(+, 14, true)
                                parseUnaryExpression(+, true)
                                  parsePrimary(+, expression)
                                    parseLiteralInt(+)
                                      listener: handleLiteralInt(1)
                              listener: endBinaryExpression(+)
                          ensureSemicolon(1)
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(2, {, })
                  listener: endClassMethod(null, , (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(extends)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, extends)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(extends)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(;, ;, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                reportRecoverableErrorWithToken(extends, Instance of 'Template<(Token) => Message>')
                  listener: handleRecoverableError(Message[ExpectedClassMember, Expected a class member, but got 'extends'., null, {token: extends}], extends, extends)
                listener: handleInvalidMember(extends)
                listener: endMember()
            notEofOrValue(}, ()
            parseClassOrMixinOrExtensionMemberImpl(extends, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(extends)
                listener: beginMetadataStar(()
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(extends, extends, null, null, null, null, null, extends, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(extends, null, null, null, null, null, extends, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(extends)
                  ensureIdentifier(extends, methodDeclaration)
                    insertSyntheticIdentifier(extends, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  inPlainSync()
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      reportRecoverableErrorWithToken(extends, Instance of 'Template<(Token) => Message>')
                                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'extends'., null, {token: extends}], extends, extends)
                                      listener: handleIdentifier(extends, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(extends)
                                      parseArguments(extends)
                                        parseArgumentsRest(()
                                          listener: beginArguments(()
                                          parseExpression(()
                                            parsePrecedenceExpression((, 1, true)
                                              parseUnaryExpression((, true)
                                                parsePrimary((, expression)
                                                  parseSendOrFunctionLiteral((, expression)
                                                    parseSend((, expression)
                                                      ensureIdentifier((, expression)
                                                        listener: handleIdentifier(x, expression)
                                                      listener: handleNoTypeArguments(-)
                                                      parseArgumentsOpt(x)
                                                        listener: handleNoArguments(-)
                                                      listener: handleSend(x, -)
                                              listener: beginBinaryExpression(-)
                                              parsePrecedenceExpression(-, 14, true)
                                                parseUnaryExpression(-, true)
                                                  parsePrimary(-, expression)
                                                    parseLiteralInt(-)
                                                      listener: handleLiteralInt(1)
                                              listener: endBinaryExpression(-)
                                          listener: endArguments(1, (, ))
                                    listener: handleSend(extends, +)
                              listener: beginBinaryExpression(+)
                              parsePrecedenceExpression(+, 14, true)
                                parseUnaryExpression(+, true)
                                  parsePrimary(+, expression)
                                    parseLiteralInt(+)
                                      listener: handleLiteralInt(1)
                              listener: endBinaryExpression(+)
                          ensureSemicolon(1)
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(2, {, })
                  listener: endClassMethod(null, , (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(false)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, false)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(false)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(;, ;, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                reportRecoverableErrorWithToken(false, Instance of 'Template<(Token) => Message>')
                  listener: handleRecoverableError(Message[ExpectedClassMember, Expected a class member, but got 'false'., null, {token: false}], false, false)
                listener: handleInvalidMember(false)
                listener: endMember()
            notEofOrValue(}, ()
            parseClassOrMixinOrExtensionMemberImpl(false, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(false)
                listener: beginMetadataStar(()
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(false, false, null, null, null, null, null, false, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(false, null, null, null, null, null, false, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(false)
                  ensureIdentifier(false, methodDeclaration)
                    insertSyntheticIdentifier(false, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  parseLiteralBool(return)
                                    listener: handleLiteralBool(false)
                              parseArgumentOrIndexStar(false, Instance of 'NoTypeParamOrArg', false)
                                listener: handleNoTypeArguments(()
                                parseArguments(false)
                                  parseArgumentsRest(()
                                    listener: beginArguments(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          parsePrimary((, expression)
                                            parseSendOrFunctionLiteral((, expression)
                                              parseSend((, expression)
                                                ensureIdentifier((, expression)
                                                  listener: handleIdentifier(x, expression)
                                                listener: handleNoTypeArguments(-)
                                                parseArgumentsOpt(x)
                                                  listener: handleNoArguments(-)
                                                listener: handleSend(x, -)
                                        listener: beginBinaryExpression(-)
                                        parsePrecedenceExpression(-, 14, true)
                                          parseUnaryExpression(-, true)
                                            parsePrimary(-, expression)
                                              parseLiteralInt(-)
                                                listener: handleLiteralInt(1)
                                        listener: endBinaryExpression(-)
                                    listener: endArguments(1, (, ))
                                listener: handleSend((, ))
                              listener: beginBinaryExpression(+)
                              parsePrecedenceExpression(+, 14, true)
                                parseUnaryExpression(+, true)
                                  parsePrimary(+, expression)
                                    parseLiteralInt(+)
                                      listener: handleLiteralInt(1)
                              listener: endBinaryExpression(+)
                          ensureSemicolon(1)
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(2, {, })
                  listener: endClassMethod(null, , (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(final)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, final)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(final)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(final, ;, null, null, null, null, final, final, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(;, null, null, null, null, final, final, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  reportRecoverableErrorWithToken(final, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExtraneousModifier, Can't have modifier 'final' here., Try removing 'final'., {token: final}], final, final)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(final)
                  ensureIdentifier(final, methodDeclaration)
                    insertSyntheticIdentifier(final, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  inPlainSync()
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      reportRecoverableErrorWithToken(final, Instance of 'Template<(Token) => Message>')
                                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'final'., null, {token: final}], final, final)
                                      rewriter()
                                      listener: handleIdentifier(, expression)
                                    listener: handleNoTypeArguments(final)
                                    parseArgumentsOpt()
                                      listener: handleNoArguments(final)
                                    listener: handleSend(, final)
                          ensureSemicolon()
                            reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                              listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], final, final)
                            rewriter()
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, final)
                    parseStatement(;)
                      parseStatementX(;)
                        parseExpressionStatementOrDeclarationAfterModifiers(final, ;, null, final, null, false)
                          looksLikeLocalFunction(()
                          listener: beginMetadataStar(final)
                          listener: endMetadataStar(0)
                          listener: handleNoType(final)
                          listener: beginVariablesDeclaration((, null, final)
                          parseVariablesDeclarationRest(final, true)
                            parseOptionallyInitializedIdentifier(final)
                              ensureIdentifier(final, localVariableDeclaration)
                                reportRecoverableErrorWithToken((, Instance of 'Template<(Token) => Message>')
                                  listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                                rewriter()
                                listener: handleIdentifier(, localVariableDeclaration)
                              listener: beginInitializedIdentifier()
                              parseVariableInitializerOpt()
                                listener: handleNoVariableInitializer(x)
                              listener: endInitializedIdentifier()
                            ensureSemicolon()
                              reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                                listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], x, x)
                              rewriter()
                            listener: endVariablesDeclaration(1, ;)
                    notEofOrValue(}, x)
                    parseStatement(;)
                      parseStatementX(;)
                        parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                          looksLikeLocalFunction(x)
                          parseExpressionStatement(;)
                            parseExpression(;)
                              parsePrecedenceExpression(;, 1, true)
                                parseUnaryExpression(;, true)
                                  parsePrimary(;, expression)
                                    parseSendOrFunctionLiteral(;, expression)
                                      parseSend(;, expression)
                                        ensureIdentifier(;, expression)
                                          listener: handleIdentifier(x, expression)
                                        listener: handleNoTypeArguments(-)
                                        parseArgumentsOpt(x)
                                          listener: handleNoArguments(-)
                                        listener: handleSend(x, -)
                                listener: beginBinaryExpression(-)
                                parsePrecedenceExpression(-, 14, true)
                                  parseUnaryExpression(-, true)
                                    parsePrimary(-, expression)
                                      parseLiteralInt(-)
                                        listener: handleLiteralInt(1)
                                listener: endBinaryExpression(-)
                            ensureSemicolon(1)
                              reportRecoverableError(1, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                                listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1)
                              rewriter()
                            listener: handleExpressionStatement(;)
                    notEofOrValue(}, ))
                    parseStatement(;)
                      parseStatementX(;)
                        parseExpressionStatementOrDeclaration(;, false)
                          parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                            looksLikeLocalFunction())
                            parseExpressionStatement(;)
                              parseExpression(;)
                                parsePrecedenceExpression(;, 1, true)
                                  parseUnaryExpression(;, true)
                                    parsePrimary(;, expression)
                                      parseSend(;, expression)
                                        ensureIdentifier(;, expression)
                                          reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                            listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., null, {token: )}], ), ))
                                          rewriter()
                                          listener: handleIdentifier(, expression)
                                        listener: handleNoTypeArguments())
                                        parseArgumentsOpt()
                                          listener: handleNoArguments())
                                        listener: handleSend(, ))
                              ensureSemicolon()
                                reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                                  listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], ), ))
                                rewriter()
                              listener: handleExpressionStatement(;)
                    reportRecoverableError(;, Message[UnexpectedToken, Unexpected token ';'., null, {token: ;}])
                      listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {token: ;}], ), ))
                    notEofOrValue(}, +)
                    parseStatement())
                      parseStatementX())
                        parseExpressionStatementOrDeclaration(), false)
                          parseExpressionStatementOrDeclarationAfterModifiers(), ), null, null, null, false)
                            looksLikeLocalFunction(+)
                            parseExpressionStatement())
                              parseExpression())
                                parsePrecedenceExpression(), 1, true)
                                  parseUnaryExpression(), true)
                                    rewriteAndRecover(), UnsupportedPrefixPlus, )
                                      reportRecoverableError(+, UnsupportedPrefixPlus)
                                        listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                                      rewriter()
                                    parsePrimary(), expression)
                                      parseSendOrFunctionLiteral(), expression)
                                        parseSend(), expression)
                                          ensureIdentifier(), expression)
                                            listener: handleIdentifier(, expression)
                                          listener: handleNoTypeArguments(+)
                                          parseArgumentsOpt()
                                            listener: handleNoArguments(+)
                                          listener: handleSend(, +)
                                  listener: beginBinaryExpression(+)
                                  parsePrecedenceExpression(+, 14, true)
                                    parseUnaryExpression(+, true)
                                      parsePrimary(+, expression)
                                        parseLiteralInt(+)
                                          listener: handleLiteralInt(1)
                                  listener: endBinaryExpression(+)
                              ensureSemicolon(1)
                              listener: handleExpressionStatement(;)
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(6, {, })
                  listener: endClassMethod(null, final, (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(finally)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, finally)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(finally)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(;, ;, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                reportRecoverableErrorWithToken(finally, Instance of 'Template<(Token) => Message>')
                  listener: handleRecoverableError(Message[ExpectedClassMember, Expected a class member, but got 'finally'., null, {token: finally}], finally, finally)
                listener: handleInvalidMember(finally)
                listener: endMember()
            notEofOrValue(}, ()
            parseClassOrMixinOrExtensionMemberImpl(finally, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(finally)
                listener: beginMetadataStar(()
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(finally, finally, null, null, null, null, null, finally, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(finally, null, null, null, null, null, finally, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(finally)
                  ensureIdentifier(finally, methodDeclaration)
                    insertSyntheticIdentifier(finally, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  inPlainSync()
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      reportRecoverableErrorWithToken(finally, Instance of 'Template<(Token) => Message>')
                                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'finally'., null, {token: finally}], finally, finally)
                                      listener: handleIdentifier(finally, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(finally)
                                      parseArguments(finally)
                                        parseArgumentsRest(()
                                          listener: beginArguments(()
                                          parseExpression(()
                                            parsePrecedenceExpression((, 1, true)
                                              parseUnaryExpression((, true)
                                                parsePrimary((, expression)
                                                  parseSendOrFunctionLiteral((, expression)
                                                    parseSend((, expression)
                                                      ensureIdentifier((, expression)
                                                        listener: handleIdentifier(x, expression)
                                                      listener: handleNoTypeArguments(-)
                                                      parseArgumentsOpt(x)
                                                        listener: handleNoArguments(-)
                                                      listener: handleSend(x, -)
                                              listener: beginBinaryExpression(-)
                                              parsePrecedenceExpression(-, 14, true)
                                                parseUnaryExpression(-, true)
                                                  parsePrimary(-, expression)
                                                    parseLiteralInt(-)
                                                      listener: handleLiteralInt(1)
                                              listener: endBinaryExpression(-)
                                          listener: endArguments(1, (, ))
                                    listener: handleSend(finally, +)
                              listener: beginBinaryExpression(+)
                              parsePrecedenceExpression(+, 14, true)
                                parseUnaryExpression(+, true)
                                  parsePrimary(+, expression)
                                    parseLiteralInt(+)
                                      listener: handleLiteralInt(1)
                              listener: endBinaryExpression(+)
                          ensureSemicolon(1)
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(2, {, })
                  listener: endClassMethod(null, , (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(for)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, for)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(for)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(;, ;, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                reportRecoverableErrorWithToken(for, Instance of 'Template<(Token) => Message>')
                  listener: handleRecoverableError(Message[ExpectedClassMember, Expected a class member, but got 'for'., null, {token: for}], for, for)
                listener: handleInvalidMember(for)
                listener: endMember()
            notEofOrValue(}, ()
            parseClassOrMixinOrExtensionMemberImpl(for, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(for)
                listener: beginMetadataStar(()
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(for, for, null, null, null, null, null, for, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(for, null, null, null, null, null, for, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(for)
                  ensureIdentifier(for, methodDeclaration)
                    insertSyntheticIdentifier(for, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  inPlainSync()
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      reportRecoverableErrorWithToken(for, Instance of 'Template<(Token) => Message>')
                                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'for'., null, {token: for}], for, for)
                                      rewriter()
                                      listener: handleIdentifier(, expression)
                                    listener: handleNoTypeArguments(for)
                                    parseArgumentsOpt()
                                      listener: handleNoArguments(for)
                                    listener: handleSend(, for)
                          ensureSemicolon()
                            reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                              listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], for, for)
                            rewriter()
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, for)
                    parseStatement(;)
                      parseStatementX(;)
                        parseForStatement(;, null)
                          listener: beginForStatement(for)
                          parseForLoopPartsStart(null, for)
                            parseExpressionStatementOrDeclaration((, true)
                              parseExpressionStatementOrDeclarationAfterModifiers((, (, null, null, null, true)
                          parseForLoopPartsMid((, null, for)
                            parseExpression(()
                              parsePrecedenceExpression((, 1, true)
                                parseUnaryExpression((, true)
                                  parsePrimary((, expression)
                                    parseSendOrFunctionLiteral((, expression)
                                      parseSend((, expression)
                                        ensureIdentifier((, expression)
                                          listener: handleIdentifier(x, expression)
                                        listener: handleNoTypeArguments(-)
                                        parseArgumentsOpt(x)
                                          listener: handleNoArguments(-)
                                        listener: handleSend(x, -)
                                listener: beginBinaryExpression(-)
                                parsePrecedenceExpression(-, 14, true)
                                  parseUnaryExpression(-, true)
                                    parsePrimary(-, expression)
                                      parseLiteralInt(-)
                                        listener: handleLiteralInt(1)
                                listener: endBinaryExpression(-)
                            listener: handleForInitializerExpressionStatement(1, false)
                          parseForRest(null, 1, for)
                            parseForLoopPartsRest(1, for, null)
                              ensureSemicolon(1)
                                reportRecoverableError(1, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                                  listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1)
                                rewriter()
                              parseExpressionStatement(;)
                                parseExpression(;)
                                  parsePrecedenceExpression(;, 1, true)
                                    parseUnaryExpression(;, true)
                                      parsePrimary(;, expression)
                                        parseSend(;, expression)
                                          ensureIdentifier(;, expression)
                                            reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                              listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., null, {token: )}], ), ))
                                            rewriter()
                                            listener: handleIdentifier(, expression)
                                          listener: handleNoTypeArguments())
                                          parseArgumentsOpt()
                                            listener: handleNoArguments())
                                          listener: handleSend(, ))
                                ensureSemicolon()
                                  reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], ), ))
                                  rewriter()
                                listener: handleExpressionStatement(;)
                              listener: handleForLoopParts(for, (, ;, 0)
                            listener: beginForStatementBody(+)
                            parseStatement())
                              parseStatementX())
                                parseExpressionStatementOrDeclaration(), false)
                                  parseExpressionStatementOrDeclarationAfterModifiers(), ), null, null, null, false)
                                    looksLikeLocalFunction(+)
                                    parseExpressionStatement())
                                      parseExpression())
                                        parsePrecedenceExpression(), 1, true)
                                          parseUnaryExpression(), true)
                                            rewriteAndRecover(), UnsupportedPrefixPlus, )
                                              reportRecoverableError(+, UnsupportedPrefixPlus)
                                                listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                                              rewriter()
                                            parsePrimary(), expression)
                                              parseSendOrFunctionLiteral(), expression)
                                                parseSend(), expression)
                                                  ensureIdentifier(), expression)
                                                    listener: handleIdentifier(, expression)
                                                  listener: handleNoTypeArguments(+)
                                                  parseArgumentsOpt()
                                                    listener: handleNoArguments(+)
                                                  listener: handleSend(, +)
                                          listener: beginBinaryExpression(+)
                                          parsePrecedenceExpression(+, 14, true)
                                            parseUnaryExpression(+, true)
                                              parsePrimary(+, expression)
                                                parseLiteralInt(+)
                                                  listener: handleLiteralInt(1)
                                          listener: endBinaryExpression(+)
                                      ensureSemicolon(1)
                                      listener: handleExpressionStatement(;)
                            listener: endForStatementBody(})
                            listener: endForStatement(})
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(3, {, })
                  listener: endClassMethod(null, , (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(if)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, if)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(if)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(;, ;, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                reportRecoverableErrorWithToken(if, Instance of 'Template<(Token) => Message>')
                  listener: handleRecoverableError(Message[ExpectedClassMember, Expected a class member, but got 'if'., null, {token: if}], if, if)
                listener: handleInvalidMember(if)
                listener: endMember()
            notEofOrValue(}, ()
            parseClassOrMixinOrExtensionMemberImpl(if, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(if)
                listener: beginMetadataStar(()
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(if, if, null, null, null, null, null, if, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(if, null, null, null, null, null, if, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(if)
                  ensureIdentifier(if, methodDeclaration)
                    insertSyntheticIdentifier(if, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  inPlainSync()
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      reportRecoverableErrorWithToken(if, Instance of 'Template<(Token) => Message>')
                                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'if'., null, {token: if}], if, if)
                                      rewriter()
                                      listener: handleIdentifier(, expression)
                                    listener: handleNoTypeArguments(if)
                                    parseArgumentsOpt()
                                      listener: handleNoArguments(if)
                                    listener: handleSend(, if)
                          ensureSemicolon()
                            reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                              listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], if, if)
                            rewriter()
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, if)
                    parseStatement(;)
                      parseStatementX(;)
                        parseIfStatement(;)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(-)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(-)
                                          listener: handleSend(x, -)
                                  listener: beginBinaryExpression(-)
                                  parsePrecedenceExpression(-, 14, true)
                                    parseUnaryExpression(-, true)
                                      parsePrimary(-, expression)
                                        parseLiteralInt(-)
                                          listener: handleLiteralInt(1)
                                  listener: endBinaryExpression(-)
                              ensureCloseParen(1, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(+)
                          parseStatement())
                            parseStatementX())
                              parseExpressionStatementOrDeclaration(), false)
                                parseExpressionStatementOrDeclarationAfterModifiers(), ), null, null, null, false)
                                  looksLikeLocalFunction(+)
                                  parseExpressionStatement())
                                    parseExpression())
                                      parsePrecedenceExpression(), 1, true)
                                        parseUnaryExpression(), true)
                                          rewriteAndRecover(), UnsupportedPrefixPlus, )
                                            reportRecoverableError(+, UnsupportedPrefixPlus)
                                              listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                                            rewriter()
                                          parsePrimary(), expression)
                                            parseSendOrFunctionLiteral(), expression)
                                              parseSend(), expression)
                                                ensureIdentifier(), expression)
                                                  listener: handleIdentifier(, expression)
                                                listener: handleNoTypeArguments(+)
                                                parseArgumentsOpt()
                                                  listener: handleNoArguments(+)
                                                listener: handleSend(, +)
                                        listener: beginBinaryExpression(+)
                                        parsePrecedenceExpression(+, 14, true)
                                          parseUnaryExpression(+, true)
                                            parsePrimary(+, expression)
                                              parseLiteralInt(+)
                                                listener: handleLiteralInt(1)
                                        listener: endBinaryExpression(+)
                                    ensureSemicolon(1)
                                    listener: handleExpressionStatement(;)
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(3, {, })
                  listener: endClassMethod(null, , (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(in)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, in)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(in)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(;, ;, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                reportRecoverableErrorWithToken(in, Instance of 'Template<(Token) => Message>')
                  listener: handleRecoverableError(Message[ExpectedClassMember, Expected a class member, but got 'in'., null, {token: in}], in, in)
                listener: handleInvalidMember(in)
                listener: endMember()
            notEofOrValue(}, ()
            parseClassOrMixinOrExtensionMemberImpl(in, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(in)
                listener: beginMetadataStar(()
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(in, in, null, null, null, null, null, in, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(in, null, null, null, null, null, in, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(in)
                  ensureIdentifier(in, methodDeclaration)
                    insertSyntheticIdentifier(in, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  inPlainSync()
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      reportRecoverableErrorWithToken(in, Instance of 'Template<(Token) => Message>')
                                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'in'., null, {token: in}], in, in)
                                      listener: handleIdentifier(in, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(in)
                                      parseArguments(in)
                                        parseArgumentsRest(()
                                          listener: beginArguments(()
                                          parseExpression(()
                                            parsePrecedenceExpression((, 1, true)
                                              parseUnaryExpression((, true)
                                                parsePrimary((, expression)
                                                  parseSendOrFunctionLiteral((, expression)
                                                    parseSend((, expression)
                                                      ensureIdentifier((, expression)
                                                        listener: handleIdentifier(x, expression)
                                                      listener: handleNoTypeArguments(-)
                                                      parseArgumentsOpt(x)
                                                        listener: handleNoArguments(-)
                                                      listener: handleSend(x, -)
                                              listener: beginBinaryExpression(-)
                                              parsePrecedenceExpression(-, 14, true)
                                                parseUnaryExpression(-, true)
                                                  parsePrimary(-, expression)
                                                    parseLiteralInt(-)
                                                      listener: handleLiteralInt(1)
                                              listener: endBinaryExpression(-)
                                          listener: endArguments(1, (, ))
                                    listener: handleSend(in, +)
                              listener: beginBinaryExpression(+)
                              parsePrecedenceExpression(+, 14, true)
                                parseUnaryExpression(+, true)
                                  parsePrimary(+, expression)
                                    parseLiteralInt(+)
                                      listener: handleLiteralInt(1)
                              listener: endBinaryExpression(+)
                          ensureSemicolon(1)
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(2, {, })
                  listener: endClassMethod(null, , (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(is)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, is)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(is)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(;, ;, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                reportRecoverableErrorWithToken(is, Instance of 'Template<(Token) => Message>')
                  listener: handleRecoverableError(Message[ExpectedClassMember, Expected a class member, but got 'is'., null, {token: is}], is, is)
                listener: handleInvalidMember(is)
                listener: endMember()
            notEofOrValue(}, ()
            parseClassOrMixinOrExtensionMemberImpl(is, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(is)
                listener: beginMetadataStar(()
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(is, is, null, null, null, null, null, is, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(is, null, null, null, null, null, is, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(is)
                  ensureIdentifier(is, methodDeclaration)
                    insertSyntheticIdentifier(is, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  inPlainSync()
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      reportRecoverableErrorWithToken(is, Instance of 'Template<(Token) => Message>')
                                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'is'., null, {token: is}], is, is)
                                      rewriter()
                                      listener: handleIdentifier(, expression)
                                    listener: handleNoTypeArguments(is)
                                    parseArgumentsOpt()
                                      listener: handleNoArguments(is)
                                    listener: handleSend(, is)
                              parseIsOperatorRest()
                                listener: beginIsOperatorType(is)
                                computeTypeAfterIsOrAs(is)
                                reportRecoverableErrorWithToken((, Instance of 'Template<(Token) => Message>')
                                  listener: handleRecoverableError(Message[ExpectedType, Expected a type, but got '('., null, {token: (}], (, ()
                                rewriter()
                                listener: handleIdentifier(, typeReference)
                                listener: handleNoTypeArguments(()
                                listener: handleType(, null)
                                listener: endIsOperatorType(is)
                                listener: handleIsOperator(is, null)
                                skipChainedAsIsOperators()
                          ensureSemicolon()
                            reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                              listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], (, ()
                            rewriter()
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, ()
                    parseStatement(;)
                      parseStatementX(;)
                        parseExpressionStatementOrDeclaration(;, false)
                          parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                            looksLikeLocalFunction(()
                            parseExpressionStatement(;)
                              parseExpression(;)
                                parsePrecedenceExpression(;, 1, true)
                                  parseUnaryExpression(;, true)
                                    parsePrimary(;, expression)
                                      parseParenthesizedExpressionOrFunctionLiteral(;)
                                        parseParenthesizedExpression(;)
                                          parseExpressionInParenthesis(;)
                                            parseExpressionInParenthesisRest(()
                                              parseExpression(()
                                                parsePrecedenceExpression((, 1, true)
                                                  parseUnaryExpression((, true)
                                                    parsePrimary((, expression)
                                                      parseSendOrFunctionLiteral((, expression)
                                                        parseSend((, expression)
                                                          ensureIdentifier((, expression)
                                                            listener: handleIdentifier(x, expression)
                                                          listener: handleNoTypeArguments(-)
                                                          parseArgumentsOpt(x)
                                                            listener: handleNoArguments(-)
                                                          listener: handleSend(x, -)
                                                  listener: beginBinaryExpression(-)
                                                  parsePrecedenceExpression(-, 14, true)
                                                    parseUnaryExpression(-, true)
                                                      parsePrimary(-, expression)
                                                        parseLiteralInt(-)
                                                          listener: handleLiteralInt(1)
                                                  listener: endBinaryExpression(-)
                                              ensureCloseParen(1, ()
                                          listener: handleParenthesizedExpression(()
                                  listener: beginBinaryExpression(+)
                                  parsePrecedenceExpression(+, 14, true)
                                    parseUnaryExpression(+, true)
                                      parsePrimary(+, expression)
                                        parseLiteralInt(+)
                                          listener: handleLiteralInt(1)
                                  listener: endBinaryExpression(+)
                              ensureSemicolon(1)
                              listener: handleExpressionStatement(;)
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(3, {, })
                  listener: endClassMethod(null, , (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(new)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, new)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(new)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(;, ;, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                reportRecoverableErrorWithToken(new, Instance of 'Template<(Token) => Message>')
                  listener: handleRecoverableError(Message[ExpectedClassMember, Expected a class member, but got 'new'., null, {token: new}], new, new)
                listener: handleInvalidMember(new)
                listener: endMember()
            notEofOrValue(}, ()
            parseClassOrMixinOrExtensionMemberImpl(new, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(new)
                listener: beginMetadataStar(()
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(new, new, null, null, null, null, null, new, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(new, null, null, null, null, null, new, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(new)
                  ensureIdentifier(new, methodDeclaration)
                    insertSyntheticIdentifier(new, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  parseNewExpression(return)
                                    listener: beginNewExpression(new)
                                    parseConstructorReference(new, null)
                                      ensureIdentifier(new, constructorReference)
                                        insertSyntheticIdentifier(new, constructorReference, message: Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], messageOnToken: null)
                                          reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                                            listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                                          rewriter()
                                        listener: handleIdentifier(, constructorReference)
                                      listener: beginConstructorReference()
                                      parseQualifiedRestOpt(, constructorReferenceContinuation)
                                      listener: handleNoTypeArguments(()
                                      listener: handleNoConstructorReferenceContinuationAfterTypeArguments(()
                                      listener: endConstructorReference(, null, ()
                                    parseConstructorInvocationArguments()
                                      parseArgumentsRest(()
                                        listener: beginArguments(()
                                        parseExpression(()
                                          parsePrecedenceExpression((, 1, true)
                                            parseUnaryExpression((, true)
                                              parsePrimary((, expression)
                                                parseSendOrFunctionLiteral((, expression)
                                                  parseSend((, expression)
                                                    ensureIdentifier((, expression)
                                                      listener: handleIdentifier(x, expression)
                                                    listener: handleNoTypeArguments(-)
                                                    parseArgumentsOpt(x)
                                                      listener: handleNoArguments(-)
                                                    listener: handleSend(x, -)
                                            listener: beginBinaryExpression(-)
                                            parsePrecedenceExpression(-, 14, true)
                                              parseUnaryExpression(-, true)
                                                parsePrimary(-, expression)
                                                  parseLiteralInt(-)
                                                    listener: handleLiteralInt(1)
                                            listener: endBinaryExpression(-)
                                        listener: endArguments(1, (, ))
                                    listener: endNewExpression(new)
                              listener: beginBinaryExpression(+)
                              parsePrecedenceExpression(+, 14, true)
                                parseUnaryExpression(+, true)
                                  parsePrimary(+, expression)
                                    parseLiteralInt(+)
                                      listener: handleLiteralInt(1)
                              listener: endBinaryExpression(+)
                          ensureSemicolon(1)
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(2, {, })
                  listener: endClassMethod(null, , (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(null)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, null)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(null)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(;, ;, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                reportRecoverableErrorWithToken(null, Instance of 'Template<(Token) => Message>')
                  listener: handleRecoverableError(Message[ExpectedClassMember, Expected a class member, but got 'null'., null, {token: null}], null, null)
                listener: handleInvalidMember(null)
                listener: endMember()
            notEofOrValue(}, ()
            parseClassOrMixinOrExtensionMemberImpl(null, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(null)
                listener: beginMetadataStar(()
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(null, null, null, null, null, null, null, null, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(null, null, null, null, null, null, null, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(null)
                  ensureIdentifier(null, methodDeclaration)
                    insertSyntheticIdentifier(null, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  parseLiteralNull(return)
                                    listener: handleLiteralNull(null)
                              parseArgumentOrIndexStar(null, Instance of 'NoTypeParamOrArg', false)
                                listener: handleNoTypeArguments(()
                                parseArguments(null)
                                  parseArgumentsRest(()
                                    listener: beginArguments(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          parsePrimary((, expression)
                                            parseSendOrFunctionLiteral((, expression)
                                              parseSend((, expression)
                                                ensureIdentifier((, expression)
                                                  listener: handleIdentifier(x, expression)
                                                listener: handleNoTypeArguments(-)
                                                parseArgumentsOpt(x)
                                                  listener: handleNoArguments(-)
                                                listener: handleSend(x, -)
                                        listener: beginBinaryExpression(-)
                                        parsePrecedenceExpression(-, 14, true)
                                          parseUnaryExpression(-, true)
                                            parsePrimary(-, expression)
                                              parseLiteralInt(-)
                                                listener: handleLiteralInt(1)
                                        listener: endBinaryExpression(-)
                                    listener: endArguments(1, (, ))
                                listener: handleSend((, ))
                              listener: beginBinaryExpression(+)
                              parsePrecedenceExpression(+, 14, true)
                                parseUnaryExpression(+, true)
                                  parsePrimary(+, expression)
                                    parseLiteralInt(+)
                                      listener: handleLiteralInt(1)
                              listener: endBinaryExpression(+)
                          ensureSemicolon(1)
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(2, {, })
                  listener: endClassMethod(null, , (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(rethrow)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, rethrow)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(rethrow)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(;, ;, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                reportRecoverableErrorWithToken(rethrow, Instance of 'Template<(Token) => Message>')
                  listener: handleRecoverableError(Message[ExpectedClassMember, Expected a class member, but got 'rethrow'., null, {token: rethrow}], rethrow, rethrow)
                listener: handleInvalidMember(rethrow)
                listener: endMember()
            notEofOrValue(}, ()
            parseClassOrMixinOrExtensionMemberImpl(rethrow, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(rethrow)
                listener: beginMetadataStar(()
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(rethrow, rethrow, null, null, null, null, null, rethrow, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(rethrow, null, null, null, null, null, rethrow, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(rethrow)
                  ensureIdentifier(rethrow, methodDeclaration)
                    insertSyntheticIdentifier(rethrow, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  inPlainSync()
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      reportRecoverableErrorWithToken(rethrow, Instance of 'Template<(Token) => Message>')
                                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'rethrow'., null, {token: rethrow}], rethrow, rethrow)
                                      listener: handleIdentifier(rethrow, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(rethrow)
                                      parseArguments(rethrow)
                                        parseArgumentsRest(()
                                          listener: beginArguments(()
                                          parseExpression(()
                                            parsePrecedenceExpression((, 1, true)
                                              parseUnaryExpression((, true)
                                                parsePrimary((, expression)
                                                  parseSendOrFunctionLiteral((, expression)
                                                    parseSend((, expression)
                                                      ensureIdentifier((, expression)
                                                        listener: handleIdentifier(x, expression)
                                                      listener: handleNoTypeArguments(-)
                                                      parseArgumentsOpt(x)
                                                        listener: handleNoArguments(-)
                                                      listener: handleSend(x, -)
                                              listener: beginBinaryExpression(-)
                                              parsePrecedenceExpression(-, 14, true)
                                                parseUnaryExpression(-, true)
                                                  parsePrimary(-, expression)
                                                    parseLiteralInt(-)
                                                      listener: handleLiteralInt(1)
                                              listener: endBinaryExpression(-)
                                          listener: endArguments(1, (, ))
                                    listener: handleSend(rethrow, +)
                              listener: beginBinaryExpression(+)
                              parsePrecedenceExpression(+, 14, true)
                                parseUnaryExpression(+, true)
                                  parsePrimary(+, expression)
                                    parseLiteralInt(+)
                                      listener: handleLiteralInt(1)
                              listener: endBinaryExpression(+)
                          ensureSemicolon(1)
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(2, {, })
                  listener: endClassMethod(null, , (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(return)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, return)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(return)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(;, ;, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                reportRecoverableErrorWithToken(return, Instance of 'Template<(Token) => Message>')
                  listener: handleRecoverableError(Message[ExpectedClassMember, Expected a class member, but got 'return'., null, {token: return}], return, return)
                listener: handleInvalidMember(return)
                listener: endMember()
            notEofOrValue(}, ()
            parseClassOrMixinOrExtensionMemberImpl(return, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(return)
                listener: beginMetadataStar(()
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(return, return, null, null, null, null, null, return, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(return, null, null, null, null, null, return, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(return)
                  ensureIdentifier(return, methodDeclaration)
                    insertSyntheticIdentifier(return, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  inPlainSync()
                                  reportRecoverableErrorWithToken(return, Instance of 'Template<(Token) => Message>')
                                    listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token 'return'., null, {token: return}], return, return)
                                  parsePrimary(return, expression)
                                    parseParenthesizedExpressionOrFunctionLiteral(return)
                                      parseParenthesizedExpression(return)
                                        parseExpressionInParenthesis(return)
                                          parseExpressionInParenthesisRest(()
                                            parseExpression(()
                                              parsePrecedenceExpression((, 1, true)
                                                parseUnaryExpression((, true)
                                                  parsePrimary((, expression)
                                                    parseSendOrFunctionLiteral((, expression)
                                                      parseSend((, expression)
                                                        ensureIdentifier((, expression)
                                                          listener: handleIdentifier(x, expression)
                                                        listener: handleNoTypeArguments(-)
                                                        parseArgumentsOpt(x)
                                                          listener: handleNoArguments(-)
                                                        listener: handleSend(x, -)
                                                listener: beginBinaryExpression(-)
                                                parsePrecedenceExpression(-, 14, true)
                                                  parseUnaryExpression(-, true)
                                                    parsePrimary(-, expression)
                                                      parseLiteralInt(-)
                                                        listener: handleLiteralInt(1)
                                                listener: endBinaryExpression(-)
                                            ensureCloseParen(1, ()
                                        listener: handleParenthesizedExpression(()
                              listener: beginBinaryExpression(+)
                              parsePrecedenceExpression(+, 14, true)
                                parseUnaryExpression(+, true)
                                  parsePrimary(+, expression)
                                    parseLiteralInt(+)
                                      listener: handleLiteralInt(1)
                              listener: endBinaryExpression(+)
                          ensureSemicolon(1)
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(2, {, })
                  listener: endClassMethod(null, , (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(super)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, super)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(super)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(;, ;, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                reportRecoverableErrorWithToken(super, Instance of 'Template<(Token) => Message>')
                  listener: handleRecoverableError(Message[ExpectedClassMember, Expected a class member, but got 'super'., null, {token: super}], super, super)
                listener: handleInvalidMember(super)
                listener: endMember()
            notEofOrValue(}, ()
            parseClassOrMixinOrExtensionMemberImpl(super, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(super)
                listener: beginMetadataStar(()
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(super, super, null, null, null, null, null, super, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(super, null, null, null, null, null, super, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(super)
                  ensureIdentifier(super, methodDeclaration)
                    insertSyntheticIdentifier(super, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  parseSuperExpression(return, expression)
                                    listener: handleSuperExpression(super, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArguments(super)
                                      parseArgumentsRest(()
                                        listener: beginArguments(()
                                        parseExpression(()
                                          parsePrecedenceExpression((, 1, true)
                                            parseUnaryExpression((, true)
                                              parsePrimary((, expression)
                                                parseSendOrFunctionLiteral((, expression)
                                                  parseSend((, expression)
                                                    ensureIdentifier((, expression)
                                                      listener: handleIdentifier(x, expression)
                                                    listener: handleNoTypeArguments(-)
                                                    parseArgumentsOpt(x)
                                                      listener: handleNoArguments(-)
                                                    listener: handleSend(x, -)
                                            listener: beginBinaryExpression(-)
                                            parsePrecedenceExpression(-, 14, true)
                                              parseUnaryExpression(-, true)
                                                parsePrimary(-, expression)
                                                  parseLiteralInt(-)
                                                    listener: handleLiteralInt(1)
                                            listener: endBinaryExpression(-)
                                        listener: endArguments(1, (, ))
                                    listener: handleSend(super, +)
                              listener: beginBinaryExpression(+)
                              parsePrecedenceExpression(+, 14, true)
                                parseUnaryExpression(+, true)
                                  parsePrimary(+, expression)
                                    parseLiteralInt(+)
                                      listener: handleLiteralInt(1)
                              listener: endBinaryExpression(+)
                          ensureSemicolon(1)
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(2, {, })
                  listener: endClassMethod(null, , (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(switch)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, switch)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(switch)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(;, ;, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                reportRecoverableErrorWithToken(switch, Instance of 'Template<(Token) => Message>')
                  listener: handleRecoverableError(Message[ExpectedClassMember, Expected a class member, but got 'switch'., null, {token: switch}], switch, switch)
                listener: handleInvalidMember(switch)
                listener: endMember()
            notEofOrValue(}, ()
            parseClassOrMixinOrExtensionMemberImpl(switch, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(switch)
                listener: beginMetadataStar(()
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(switch, switch, null, null, null, null, null, switch, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(switch, null, null, null, null, null, switch, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(switch)
                  ensureIdentifier(switch, methodDeclaration)
                    insertSyntheticIdentifier(switch, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  inPlainSync()
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      reportRecoverableErrorWithToken(switch, Instance of 'Template<(Token) => Message>')
                                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'switch'., null, {token: switch}], switch, switch)
                                      rewriter()
                                      listener: handleIdentifier(, expression)
                                    listener: handleNoTypeArguments(switch)
                                    parseArgumentsOpt()
                                      listener: handleNoArguments(switch)
                                    listener: handleSend(, switch)
                          ensureSemicolon()
                            reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                              listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], switch, switch)
                            rewriter()
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, switch)
                    parseStatement(;)
                      parseStatementX(;)
                        parseSwitchStatement(;)
                          listener: beginSwitchStatement(switch)
                          ensureParenthesizedCondition(switch)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(-)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(-)
                                          listener: handleSend(x, -)
                                  listener: beginBinaryExpression(-)
                                  parsePrecedenceExpression(-, 14, true)
                                    parseUnaryExpression(-, true)
                                      parsePrimary(-, expression)
                                        parseLiteralInt(-)
                                          listener: handleLiteralInt(1)
                                  listener: endBinaryExpression(-)
                              ensureCloseParen(1, ()
                            listener: handleParenthesizedCondition(()
                          parseSwitchBlock())
                            ensureBlock(), null, switch statement)
                              reportRecoverableError(), Message[ExpectedClassOrMixinBody, A switch statement must have a body, even if it is empty., Try adding an empty body., {string: switch statement}])
                                listener: handleRecoverableError(Message[ExpectedClassOrMixinBody, A switch statement must have a body, even if it is empty., Try adding an empty body., {string: switch statement}], ), ))
                              insertBlock())
                                rewriter()
                                rewriter()
                            listener: beginSwitchBlock({)
                            notEofOrValue(}, })
                            listener: endSwitchBlock(0, {, })
                          listener: endSwitchStatement(switch, })
                    notEofOrValue(}, +)
                    parseStatement(})
                      parseStatementX(})
                        parseExpressionStatementOrDeclaration(}, false)
                          parseExpressionStatementOrDeclarationAfterModifiers(}, }, null, null, null, false)
                            looksLikeLocalFunction(+)
                            parseExpressionStatement(})
                              parseExpression(})
                                parsePrecedenceExpression(}, 1, true)
                                  parseUnaryExpression(}, true)
                                    rewriteAndRecover(}, UnsupportedPrefixPlus, )
                                      reportRecoverableError(+, UnsupportedPrefixPlus)
                                        listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                                      rewriter()
                                    parsePrimary(}, expression)
                                      parseSendOrFunctionLiteral(}, expression)
                                        parseSend(}, expression)
                                          ensureIdentifier(}, expression)
                                            listener: handleIdentifier(, expression)
                                          listener: handleNoTypeArguments(+)
                                          parseArgumentsOpt()
                                            listener: handleNoArguments(+)
                                          listener: handleSend(, +)
                                  listener: beginBinaryExpression(+)
                                  parsePrecedenceExpression(+, 14, true)
                                    parseUnaryExpression(+, true)
                                      parsePrimary(+, expression)
                                        parseLiteralInt(+)
                                          listener: handleLiteralInt(1)
                                  listener: endBinaryExpression(+)
                              ensureSemicolon(1)
                              listener: handleExpressionStatement(;)
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(4, {, })
                  listener: endClassMethod(null, , (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(int, }, null, null, null, null, null, }, Instance of 'SimpleType', null, DeclarationKind.Class, WrapperClass)
                parseFields(}, null, null, null, null, null, }, Instance of 'SimpleType', this, DeclarationKind.Class, WrapperClass)
                  listener: handleIdentifier(int, typeReference)
                  listener: handleNoTypeArguments(this)
                  listener: handleType(int, null)
                  ensureIdentifier(int, fieldDeclaration)
                    reportRecoverableErrorWithToken(this, Instance of 'Template<(Token) => Message>')
                      listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'this'., null, {token: this}], this, this)
                    listener: handleIdentifier(this, fieldDeclaration)
                  parseFieldInitializerOpt(this, this, null, null, DeclarationKind.Class, WrapperClass)
                    listener: handleNoFieldInitializer(()
                  ensureSemicolon(this)
                    reportRecoverableError(this, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                      listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], this, this)
                    rewriter()
                  listener: endClassFields(null, null, null, null, 1, int, ;)
                listener: endMember()
            notEofOrValue(}, ()
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(()
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(;, ;, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(;, null, null, null, null, null, ;, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(;)
                  ensureIdentifier(;, methodDeclaration)
                    insertSyntheticIdentifier(;, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  parseThisExpression(return, expression)
                                    listener: handleThisExpression(this, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArguments(this)
                                      parseArgumentsRest(()
                                        listener: beginArguments(()
                                        parseExpression(()
                                          parsePrecedenceExpression((, 1, true)
                                            parseUnaryExpression((, true)
                                              parsePrimary((, expression)
                                                parseSendOrFunctionLiteral((, expression)
                                                  parseSend((, expression)
                                                    ensureIdentifier((, expression)
                                                      listener: handleIdentifier(x, expression)
                                                    listener: handleNoTypeArguments(-)
                                                    parseArgumentsOpt(x)
                                                      listener: handleNoArguments(-)
                                                    listener: handleSend(x, -)
                                            listener: beginBinaryExpression(-)
                                            parsePrecedenceExpression(-, 14, true)
                                              parseUnaryExpression(-, true)
                                                parsePrimary(-, expression)
                                                  parseLiteralInt(-)
                                                    listener: handleLiteralInt(1)
                                            listener: endBinaryExpression(-)
                                        listener: endArguments(1, (, ))
                                    listener: handleSend(this, +)
                              listener: beginBinaryExpression(+)
                              parsePrecedenceExpression(+, 14, true)
                                parseUnaryExpression(+, true)
                                  parsePrimary(+, expression)
                                    parseLiteralInt(+)
                                      listener: handleLiteralInt(1)
                              listener: endBinaryExpression(+)
                          ensureSemicolon(1)
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(2, {, })
                  listener: endClassMethod(null, , (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(throw)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, throw)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(throw)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(;, ;, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                reportRecoverableErrorWithToken(throw, Instance of 'Template<(Token) => Message>')
                  listener: handleRecoverableError(Message[ExpectedClassMember, Expected a class member, but got 'throw'., null, {token: throw}], throw, throw)
                listener: handleInvalidMember(throw)
                listener: endMember()
            notEofOrValue(}, ()
            parseClassOrMixinOrExtensionMemberImpl(throw, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(throw)
                listener: beginMetadataStar(()
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(throw, throw, null, null, null, null, null, throw, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(throw, null, null, null, null, null, throw, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(throw)
                  ensureIdentifier(throw, methodDeclaration)
                    insertSyntheticIdentifier(throw, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parseThrowExpression(return, true)
                              parseExpression(throw)
                                parsePrecedenceExpression(throw, 1, true)
                                  parseUnaryExpression(throw, true)
                                    parsePrimary(throw, expression)
                                      parseParenthesizedExpressionOrFunctionLiteral(throw)
                                        parseParenthesizedExpression(throw)
                                          parseExpressionInParenthesis(throw)
                                            parseExpressionInParenthesisRest(()
                                              parseExpression(()
                                                parsePrecedenceExpression((, 1, true)
                                                  parseUnaryExpression((, true)
                                                    parsePrimary((, expression)
                                                      parseSendOrFunctionLiteral((, expression)
                                                        parseSend((, expression)
                                                          ensureIdentifier((, expression)
                                                            listener: handleIdentifier(x, expression)
                                                          listener: handleNoTypeArguments(-)
                                                          parseArgumentsOpt(x)
                                                            listener: handleNoArguments(-)
                                                          listener: handleSend(x, -)
                                                  listener: beginBinaryExpression(-)
                                                  parsePrecedenceExpression(-, 14, true)
                                                    parseUnaryExpression(-, true)
                                                      parsePrimary(-, expression)
                                                        parseLiteralInt(-)
                                                          listener: handleLiteralInt(1)
                                                  listener: endBinaryExpression(-)
                                              ensureCloseParen(1, ()
                                          listener: handleParenthesizedExpression(()
                                  listener: beginBinaryExpression(+)
                                  parsePrecedenceExpression(+, 14, true)
                                    parseUnaryExpression(+, true)
                                      parsePrimary(+, expression)
                                        parseLiteralInt(+)
                                          listener: handleLiteralInt(1)
                                  listener: endBinaryExpression(+)
                              listener: handleThrowExpression(throw, ;)
                          ensureSemicolon(1)
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(2, {, })
                  listener: endClassMethod(null, , (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(true)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, true)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(true)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(;, ;, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                reportRecoverableErrorWithToken(true, Instance of 'Template<(Token) => Message>')
                  listener: handleRecoverableError(Message[ExpectedClassMember, Expected a class member, but got 'true'., null, {token: true}], true, true)
                listener: handleInvalidMember(true)
                listener: endMember()
            notEofOrValue(}, ()
            parseClassOrMixinOrExtensionMemberImpl(true, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(true)
                listener: beginMetadataStar(()
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(true, true, null, null, null, null, null, true, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(true, null, null, null, null, null, true, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(true)
                  ensureIdentifier(true, methodDeclaration)
                    insertSyntheticIdentifier(true, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  parseLiteralBool(return)
                                    listener: handleLiteralBool(true)
                              parseArgumentOrIndexStar(true, Instance of 'NoTypeParamOrArg', false)
                                listener: handleNoTypeArguments(()
                                parseArguments(true)
                                  parseArgumentsRest(()
                                    listener: beginArguments(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          parsePrimary((, expression)
                                            parseSendOrFunctionLiteral((, expression)
                                              parseSend((, expression)
                                                ensureIdentifier((, expression)
                                                  listener: handleIdentifier(x, expression)
                                                listener: handleNoTypeArguments(-)
                                                parseArgumentsOpt(x)
                                                  listener: handleNoArguments(-)
                                                listener: handleSend(x, -)
                                        listener: beginBinaryExpression(-)
                                        parsePrecedenceExpression(-, 14, true)
                                          parseUnaryExpression(-, true)
                                            parsePrimary(-, expression)
                                              parseLiteralInt(-)
                                                listener: handleLiteralInt(1)
                                        listener: endBinaryExpression(-)
                                    listener: endArguments(1, (, ))
                                listener: handleSend((, ))
                              listener: beginBinaryExpression(+)
                              parsePrecedenceExpression(+, 14, true)
                                parseUnaryExpression(+, true)
                                  parsePrimary(+, expression)
                                    parseLiteralInt(+)
                                      listener: handleLiteralInt(1)
                              listener: endBinaryExpression(+)
                          ensureSemicolon(1)
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(2, {, })
                  listener: endClassMethod(null, , (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(try)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, try)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(try)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(;, ;, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                reportRecoverableErrorWithToken(try, Instance of 'Template<(Token) => Message>')
                  listener: handleRecoverableError(Message[ExpectedClassMember, Expected a class member, but got 'try'., null, {token: try}], try, try)
                listener: handleInvalidMember(try)
                listener: endMember()
            notEofOrValue(}, ()
            parseClassOrMixinOrExtensionMemberImpl(try, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(try)
                listener: beginMetadataStar(()
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(try, try, null, null, null, null, null, try, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(try, null, null, null, null, null, try, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(try)
                  ensureIdentifier(try, methodDeclaration)
                    insertSyntheticIdentifier(try, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  inPlainSync()
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      reportRecoverableErrorWithToken(try, Instance of 'Template<(Token) => Message>')
                                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'try'., null, {token: try}], try, try)
                                      rewriter()
                                      listener: handleIdentifier(, expression)
                                    listener: handleNoTypeArguments(try)
                                    parseArgumentsOpt()
                                      listener: handleNoArguments(try)
                                    listener: handleSend(, try)
                          ensureSemicolon()
                            reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                              listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], try, try)
                            rewriter()
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, try)
                    parseStatement(;)
                      parseStatementX(;)
                        parseTryStatement(;)
                          listener: beginTryStatement(try)
                          parseBlock(try, BlockKind(try statement))
                            ensureBlock(try, null, try statement)
                              reportRecoverableError(try, Message[ExpectedClassOrMixinBody, A try statement must have a body, even if it is empty., Try adding an empty body., {string: try statement}])
                                listener: handleRecoverableError(Message[ExpectedClassOrMixinBody, A try statement must have a body, even if it is empty., Try adding an empty body., {string: try statement}], try, try)
                              insertBlock(try)
                                rewriter()
                                rewriter()
                            listener: beginBlock({, BlockKind(try statement))
                            notEofOrValue(}, })
                            listener: endBlock(0, {, }, BlockKind(try statement))
                          reportRecoverableError(try, OnlyTry)
                            listener: handleRecoverableError(OnlyTry, try, try)
                          listener: endTryStatement(0, try, null)
                    notEofOrValue(}, ()
                    parseStatement(})
                      parseStatementX(})
                        parseExpressionStatementOrDeclaration(}, false)
                          parseExpressionStatementOrDeclarationAfterModifiers(}, }, null, null, null, false)
                            looksLikeLocalFunction(()
                            parseExpressionStatement(})
                              parseExpression(})
                                parsePrecedenceExpression(}, 1, true)
                                  parseUnaryExpression(}, true)
                                    parsePrimary(}, expression)
                                      parseParenthesizedExpressionOrFunctionLiteral(})
                                        parseParenthesizedExpression(})
                                          parseExpressionInParenthesis(})
                                            parseExpressionInParenthesisRest(()
                                              parseExpression(()
                                                parsePrecedenceExpression((, 1, true)
                                                  parseUnaryExpression((, true)
                                                    parsePrimary((, expression)
                                                      parseSendOrFunctionLiteral((, expression)
                                                        parseSend((, expression)
                                                          ensureIdentifier((, expression)
                                                            listener: handleIdentifier(x, expression)
                                                          listener: handleNoTypeArguments(-)
                                                          parseArgumentsOpt(x)
                                                            listener: handleNoArguments(-)
                                                          listener: handleSend(x, -)
                                                  listener: beginBinaryExpression(-)
                                                  parsePrecedenceExpression(-, 14, true)
                                                    parseUnaryExpression(-, true)
                                                      parsePrimary(-, expression)
                                                        parseLiteralInt(-)
                                                          listener: handleLiteralInt(1)
                                                  listener: endBinaryExpression(-)
                                              ensureCloseParen(1, ()
                                          listener: handleParenthesizedExpression(()
                                  listener: beginBinaryExpression(+)
                                  parsePrecedenceExpression(+, 14, true)
                                    parseUnaryExpression(+, true)
                                      parsePrimary(+, expression)
                                        parseLiteralInt(+)
                                          listener: handleLiteralInt(1)
                                  listener: endBinaryExpression(+)
                              ensureSemicolon(1)
                              listener: handleExpressionStatement(;)
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(4, {, })
                  listener: endClassMethod(null, , (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(var)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, var)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(var)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(var, ;, null, null, null, null, var, var, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(;, null, null, null, null, var, var, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  reportRecoverableError(var, VarReturnType)
                    listener: handleRecoverableError(VarReturnType, var, var)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(var)
                  ensureIdentifier(var, methodDeclaration)
                    insertSyntheticIdentifier(var, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  inPlainSync()
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      reportRecoverableErrorWithToken(var, Instance of 'Template<(Token) => Message>')
                                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'var'., null, {token: var}], var, var)
                                      rewriter()
                                      listener: handleIdentifier(, expression)
                                    listener: handleNoTypeArguments(var)
                                    parseArgumentsOpt()
                                      listener: handleNoArguments(var)
                                    listener: handleSend(, var)
                          ensureSemicolon()
                            reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                              listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], var, var)
                            rewriter()
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, var)
                    parseStatement(;)
                      parseStatementX(;)
                        parseExpressionStatementOrDeclarationAfterModifiers(var, ;, null, var, null, false)
                          looksLikeLocalFunction(()
                          listener: beginMetadataStar(var)
                          listener: endMetadataStar(0)
                          listener: handleNoType(var)
                          listener: beginVariablesDeclaration((, null, var)
                          parseVariablesDeclarationRest(var, true)
                            parseOptionallyInitializedIdentifier(var)
                              ensureIdentifier(var, localVariableDeclaration)
                                reportRecoverableErrorWithToken((, Instance of 'Template<(Token) => Message>')
                                  listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                                rewriter()
                                listener: handleIdentifier(, localVariableDeclaration)
                              listener: beginInitializedIdentifier()
                              parseVariableInitializerOpt()
                                listener: handleNoVariableInitializer(x)
                              listener: endInitializedIdentifier()
                            ensureSemicolon()
                              reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                                listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], x, x)
                              rewriter()
                            listener: endVariablesDeclaration(1, ;)
                    notEofOrValue(}, x)
                    parseStatement(;)
                      parseStatementX(;)
                        parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                          looksLikeLocalFunction(x)
                          parseExpressionStatement(;)
                            parseExpression(;)
                              parsePrecedenceExpression(;, 1, true)
                                parseUnaryExpression(;, true)
                                  parsePrimary(;, expression)
                                    parseSendOrFunctionLiteral(;, expression)
                                      parseSend(;, expression)
                                        ensureIdentifier(;, expression)
                                          listener: handleIdentifier(x, expression)
                                        listener: handleNoTypeArguments(-)
                                        parseArgumentsOpt(x)
                                          listener: handleNoArguments(-)
                                        listener: handleSend(x, -)
                                listener: beginBinaryExpression(-)
                                parsePrecedenceExpression(-, 14, true)
                                  parseUnaryExpression(-, true)
                                    parsePrimary(-, expression)
                                      parseLiteralInt(-)
                                        listener: handleLiteralInt(1)
                                listener: endBinaryExpression(-)
                            ensureSemicolon(1)
                              reportRecoverableError(1, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                                listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1)
                              rewriter()
                            listener: handleExpressionStatement(;)
                    notEofOrValue(}, ))
                    parseStatement(;)
                      parseStatementX(;)
                        parseExpressionStatementOrDeclaration(;, false)
                          parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                            looksLikeLocalFunction())
                            parseExpressionStatement(;)
                              parseExpression(;)
                                parsePrecedenceExpression(;, 1, true)
                                  parseUnaryExpression(;, true)
                                    parsePrimary(;, expression)
                                      parseSend(;, expression)
                                        ensureIdentifier(;, expression)
                                          reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                            listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., null, {token: )}], ), ))
                                          rewriter()
                                          listener: handleIdentifier(, expression)
                                        listener: handleNoTypeArguments())
                                        parseArgumentsOpt()
                                          listener: handleNoArguments())
                                        listener: handleSend(, ))
                              ensureSemicolon()
                                reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                                  listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], ), ))
                                rewriter()
                              listener: handleExpressionStatement(;)
                    reportRecoverableError(;, Message[UnexpectedToken, Unexpected token ';'., null, {token: ;}])
                      listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {token: ;}], ), ))
                    notEofOrValue(}, +)
                    parseStatement())
                      parseStatementX())
                        parseExpressionStatementOrDeclaration(), false)
                          parseExpressionStatementOrDeclarationAfterModifiers(), ), null, null, null, false)
                            looksLikeLocalFunction(+)
                            parseExpressionStatement())
                              parseExpression())
                                parsePrecedenceExpression(), 1, true)
                                  parseUnaryExpression(), true)
                                    rewriteAndRecover(), UnsupportedPrefixPlus, )
                                      reportRecoverableError(+, UnsupportedPrefixPlus)
                                        listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                                      rewriter()
                                    parsePrimary(), expression)
                                      parseSendOrFunctionLiteral(), expression)
                                        parseSend(), expression)
                                          ensureIdentifier(), expression)
                                            listener: handleIdentifier(, expression)
                                          listener: handleNoTypeArguments(+)
                                          parseArgumentsOpt()
                                            listener: handleNoArguments(+)
                                          listener: handleSend(, +)
                                  listener: beginBinaryExpression(+)
                                  parsePrecedenceExpression(+, 14, true)
                                    parseUnaryExpression(+, true)
                                      parsePrimary(+, expression)
                                        parseLiteralInt(+)
                                          listener: handleLiteralInt(1)
                                  listener: endBinaryExpression(+)
                              ensureSemicolon(1)
                              listener: handleExpressionStatement(;)
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(6, {, })
                  listener: endClassMethod(null, var, (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(void)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, void)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(void)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(void, ;, null, null, null, null, null, ;, Instance of 'VoidType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(;, null, null, null, null, null, ;, Instance of 'VoidType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleVoidKeyword(void)
                  ensureIdentifier(void, methodDeclaration)
                    insertSyntheticIdentifier(void, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  parseSendOrFunctionLiteral(return, expression)
                                    parseSend(return, expression)
                                      ensureIdentifier(return, expression)
                                        reportRecoverableErrorWithToken(void, Instance of 'Template<(Token) => Message>')
                                          listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'void'., null, {token: void}], void, void)
                                        rewriter()
                                        listener: handleIdentifier(, expression)
                                      listener: handleNoTypeArguments(void)
                                      parseArgumentsOpt()
                                        listener: handleNoArguments(void)
                                      listener: handleSend(, void)
                          ensureSemicolon()
                            reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                              listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], void, void)
                            rewriter()
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, void)
                    parseStatement(;)
                      parseStatementX(;)
                        parseExpressionStatementOrDeclaration(;, false)
                          parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                            looksLikeLocalFunction(()
                            listener: beginMetadataStar(void)
                            listener: endMetadataStar(0)
                            listener: handleVoidKeyword(void)
                            listener: beginVariablesDeclaration((, null, null)
                            parseVariablesDeclarationRest(void, true)
                              parseOptionallyInitializedIdentifier(void)
                                ensureIdentifier(void, localVariableDeclaration)
                                  reportRecoverableErrorWithToken((, Instance of 'Template<(Token) => Message>')
                                    listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                                  rewriter()
                                  listener: handleIdentifier(, localVariableDeclaration)
                                listener: beginInitializedIdentifier()
                                parseVariableInitializerOpt()
                                  listener: handleNoVariableInitializer(x)
                                listener: endInitializedIdentifier()
                              ensureSemicolon()
                                reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                                  listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], x, x)
                                rewriter()
                              listener: endVariablesDeclaration(1, ;)
                    notEofOrValue(}, x)
                    parseStatement(;)
                      parseStatementX(;)
                        parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                          looksLikeLocalFunction(x)
                          parseExpressionStatement(;)
                            parseExpression(;)
                              parsePrecedenceExpression(;, 1, true)
                                parseUnaryExpression(;, true)
                                  parsePrimary(;, expression)
                                    parseSendOrFunctionLiteral(;, expression)
                                      parseSend(;, expression)
                                        ensureIdentifier(;, expression)
                                          listener: handleIdentifier(x, expression)
                                        listener: handleNoTypeArguments(-)
                                        parseArgumentsOpt(x)
                                          listener: handleNoArguments(-)
                                        listener: handleSend(x, -)
                                listener: beginBinaryExpression(-)
                                parsePrecedenceExpression(-, 14, true)
                                  parseUnaryExpression(-, true)
                                    parsePrimary(-, expression)
                                      parseLiteralInt(-)
                                        listener: handleLiteralInt(1)
                                listener: endBinaryExpression(-)
                            ensureSemicolon(1)
                              reportRecoverableError(1, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                                listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1)
                              rewriter()
                            listener: handleExpressionStatement(;)
                    notEofOrValue(}, ))
                    parseStatement(;)
                      parseStatementX(;)
                        parseExpressionStatementOrDeclaration(;, false)
                          parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                            looksLikeLocalFunction())
                            parseExpressionStatement(;)
                              parseExpression(;)
                                parsePrecedenceExpression(;, 1, true)
                                  parseUnaryExpression(;, true)
                                    parsePrimary(;, expression)
                                      parseSend(;, expression)
                                        ensureIdentifier(;, expression)
                                          reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                            listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., null, {token: )}], ), ))
                                          rewriter()
                                          listener: handleIdentifier(, expression)
                                        listener: handleNoTypeArguments())
                                        parseArgumentsOpt()
                                          listener: handleNoArguments())
                                        listener: handleSend(, ))
                              ensureSemicolon()
                                reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                                  listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], ), ))
                                rewriter()
                              listener: handleExpressionStatement(;)
                    reportRecoverableError(;, Message[UnexpectedToken, Unexpected token ';'., null, {token: ;}])
                      listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {token: ;}], ), ))
                    notEofOrValue(}, +)
                    parseStatement())
                      parseStatementX())
                        parseExpressionStatementOrDeclaration(), false)
                          parseExpressionStatementOrDeclarationAfterModifiers(), ), null, null, null, false)
                            looksLikeLocalFunction(+)
                            parseExpressionStatement())
                              parseExpression())
                                parsePrecedenceExpression(), 1, true)
                                  parseUnaryExpression(), true)
                                    rewriteAndRecover(), UnsupportedPrefixPlus, )
                                      reportRecoverableError(+, UnsupportedPrefixPlus)
                                        listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                                      rewriter()
                                    parsePrimary(), expression)
                                      parseSendOrFunctionLiteral(), expression)
                                        parseSend(), expression)
                                          ensureIdentifier(), expression)
                                            listener: handleIdentifier(, expression)
                                          listener: handleNoTypeArguments(+)
                                          parseArgumentsOpt()
                                            listener: handleNoArguments(+)
                                          listener: handleSend(, +)
                                  listener: beginBinaryExpression(+)
                                  parsePrecedenceExpression(+, 14, true)
                                    parseUnaryExpression(+, true)
                                      parsePrimary(+, expression)
                                        parseLiteralInt(+)
                                          listener: handleLiteralInt(1)
                                  listener: endBinaryExpression(+)
                              ensureSemicolon(1)
                              listener: handleExpressionStatement(;)
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(6, {, })
                  listener: endClassMethod(null, void, (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(while)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, while)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(while)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(;, ;, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                reportRecoverableErrorWithToken(while, Instance of 'Template<(Token) => Message>')
                  listener: handleRecoverableError(Message[ExpectedClassMember, Expected a class member, but got 'while'., null, {token: while}], while, while)
                listener: handleInvalidMember(while)
                listener: endMember()
            notEofOrValue(}, ()
            parseClassOrMixinOrExtensionMemberImpl(while, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(while)
                listener: beginMetadataStar(()
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(while, while, null, null, null, null, null, while, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(while, null, null, null, null, null, while, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(while)
                  ensureIdentifier(while, methodDeclaration)
                    insertSyntheticIdentifier(while, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  inPlainSync()
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      reportRecoverableErrorWithToken(while, Instance of 'Template<(Token) => Message>')
                                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'while'., null, {token: while}], while, while)
                                      rewriter()
                                      listener: handleIdentifier(, expression)
                                    listener: handleNoTypeArguments(while)
                                    parseArgumentsOpt()
                                      listener: handleNoArguments(while)
                                    listener: handleSend(, while)
                          ensureSemicolon()
                            reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                              listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], while, while)
                            rewriter()
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, while)
                    parseStatement(;)
                      parseStatementX(;)
                        parseWhileStatement(;)
                          listener: beginWhileStatement(while)
                          ensureParenthesizedCondition(while)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(-)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(-)
                                          listener: handleSend(x, -)
                                  listener: beginBinaryExpression(-)
                                  parsePrecedenceExpression(-, 14, true)
                                    parseUnaryExpression(-, true)
                                      parsePrimary(-, expression)
                                        parseLiteralInt(-)
                                          listener: handleLiteralInt(1)
                                  listener: endBinaryExpression(-)
                              ensureCloseParen(1, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginWhileStatementBody(+)
                          parseStatement())
                            parseStatementX())
                              parseExpressionStatementOrDeclaration(), false)
                                parseExpressionStatementOrDeclarationAfterModifiers(), ), null, null, null, false)
                                  looksLikeLocalFunction(+)
                                  parseExpressionStatement())
                                    parseExpression())
                                      parsePrecedenceExpression(), 1, true)
                                        parseUnaryExpression(), true)
                                          rewriteAndRecover(), UnsupportedPrefixPlus, )
                                            reportRecoverableError(+, UnsupportedPrefixPlus)
                                              listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                                            rewriter()
                                          parsePrimary(), expression)
                                            parseSendOrFunctionLiteral(), expression)
                                              parseSend(), expression)
                                                ensureIdentifier(), expression)
                                                  listener: handleIdentifier(, expression)
                                                listener: handleNoTypeArguments(+)
                                                parseArgumentsOpt()
                                                  listener: handleNoArguments(+)
                                                listener: handleSend(, +)
                                        listener: beginBinaryExpression(+)
                                        parsePrecedenceExpression(+, 14, true)
                                          parseUnaryExpression(+, true)
                                            parsePrimary(+, expression)
                                              parseLiteralInt(+)
                                                listener: handleLiteralInt(1)
                                        listener: endBinaryExpression(+)
                                    ensureSemicolon(1)
                                    listener: handleExpressionStatement(;)
                          listener: endWhileStatementBody(})
                          listener: endWhileStatement(while, })
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(3, {, })
                  listener: endClassMethod(null, , (, null, })
                listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, }, Instance of 'NoType', int, DeclarationKind.Class, WrapperClass)
                reportRecoverableError(int, MissingConstFinalVarOrType)
                  listener: handleRecoverableError(MissingConstFinalVarOrType, int, int)
                listener: handleNoType(})
                ensureIdentifier(}, fieldDeclaration)
                  listener: handleIdentifier(int, fieldDeclaration)
                parseFieldInitializerOpt(int, int, null, null, DeclarationKind.Class, WrapperClass)
                  listener: handleNoFieldInitializer(with)
                ensureSemicolon(int)
                  reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                  rewriter()
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, with)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(;)
                listener: beginMetadataStar(with)
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(;, ;, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                reportRecoverableErrorWithToken(with, Instance of 'Template<(Token) => Message>')
                  listener: handleRecoverableError(Message[ExpectedClassMember, Expected a class member, but got 'with'., null, {token: with}], with, with)
                listener: handleInvalidMember(with)
                listener: endMember()
            notEofOrValue(}, ()
            parseClassOrMixinOrExtensionMemberImpl(with, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(with)
                listener: beginMetadataStar(()
                listener: endMetadataStar(0)
              listener: beginMember()
              recoverFromInvalidMember(with, with, null, null, null, null, null, with, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(with, null, null, null, null, null, with, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(with)
                  ensureIdentifier(with, methodDeclaration)
                    insertSyntheticIdentifier(with, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, ()
                      rewriter()
                    listener: handleIdentifier(, methodDeclaration)
                  parseQualifiedRestOpt(, methodDeclarationContinuation)
                  parseMethodTypeVar()
                    listener: handleNoTypeVariables(()
                  parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod)
                    parseFormalParameters(, MemberKind.NonStaticMethod)
                      parseFormalParametersRest((, MemberKind.NonStaticMethod)
                        listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                        parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                          parseMetadataStar(()
                            listener: beginMetadataStar(int)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleIdentifier(int, typeReference)
                          listener: handleNoTypeArguments(x)
                          listener: handleType(int, null)
                          ensureIdentifier(int, formalParameterDeclaration)
                            listener: handleIdentifier(x, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue())
                          listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                  parseInitializersOpt())
                    listener: handleNoInitializers()
                  parseAsyncModifierOpt())
                    listener: handleAsyncModifier(null, null)
                    inPlainSync()
                  inPlainSync()
                  parseFunctionBody(), false, true)
                    listener: beginBlockFunctionBody({)
                    notEofOrValue(}, if)
                    parseStatement({)
                      parseStatementX({)
                        parseIfStatement({)
                          listener: beginIfStatement(if)
                          ensureParenthesizedCondition(if)
                            parseExpressionInParenthesisRest(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(==)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(==)
                                          listener: handleSend(x, ==)
                                  listener: beginBinaryExpression(==)
                                  parsePrecedenceExpression(==, 8, true)
                                    parseUnaryExpression(==, true)
                                      parsePrimary(==, expression)
                                        parseLiteralInt(==)
                                          listener: handleLiteralInt(0)
                                  listener: endBinaryExpression(==)
                              ensureCloseParen(0, ()
                            listener: handleParenthesizedCondition(()
                          listener: beginThenStatement(return)
                          parseStatement())
                            parseStatementX())
                              parseReturnStatement())
                                listener: beginReturnStatement(return)
                                parseExpression(return)
                                  parsePrecedenceExpression(return, 1, true)
                                    parseUnaryExpression(return, true)
                                      parsePrimary(return, expression)
                                        parseLiteralInt(return)
                                          listener: handleLiteralInt(42)
                                ensureSemicolon(42)
                                listener: endReturnStatement(true, return, ;)
                                inGenerator()
                          listener: endThenStatement(;)
                          listener: endIfStatement(if, null)
                    notEofOrValue(}, return)
                    parseStatement(;)
                      parseStatementX(;)
                        parseReturnStatement(;)
                          listener: beginReturnStatement(return)
                          parseExpression(return)
                            parsePrecedenceExpression(return, 1, true)
                              parseUnaryExpression(return, true)
                                parsePrimary(return, expression)
                                  inPlainSync()
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      reportRecoverableErrorWithToken(with, Instance of 'Template<(Token) => Message>')
                                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'with'., null, {token: with}], with, with)
                                      listener: handleIdentifier(with, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(with)
                                      parseArguments(with)
                                        parseArgumentsRest(()
                                          listener: beginArguments(()
                                          parseExpression(()
                                            parsePrecedenceExpression((, 1, true)
                                              parseUnaryExpression((, true)
                                                parsePrimary((, expression)
                                                  parseSendOrFunctionLiteral((, expression)
                                                    parseSend((, expression)
                                                      ensureIdentifier((, expression)
                                                        listener: handleIdentifier(x, expression)
                                                      listener: handleNoTypeArguments(-)
                                                      parseArgumentsOpt(x)
                                                        listener: handleNoArguments(-)
                                                      listener: handleSend(x, -)
                                              listener: beginBinaryExpression(-)
                                              parsePrecedenceExpression(-, 14, true)
                                                parseUnaryExpression(-, true)
                                                  parsePrimary(-, expression)
                                                    parseLiteralInt(-)
                                                      listener: handleLiteralInt(1)
                                              listener: endBinaryExpression(-)
                                          listener: endArguments(1, (, ))
                                    listener: handleSend(with, +)
                              listener: beginBinaryExpression(+)
                              parsePrecedenceExpression(+, 14, true)
                                parseUnaryExpression(+, true)
                                  parsePrimary(+, expression)
                                    parseLiteralInt(+)
                                      listener: handleLiteralInt(1)
                              listener: endBinaryExpression(+)
                          ensureSemicolon(1)
                          listener: endReturnStatement(true, return, ;)
                          inGenerator()
                    notEofOrValue(}, })
                    listener: endBlockFunctionBody(2, {, })
                  listener: endClassMethod(null, , (, null, })
                listener: endMember()
            notEofOrValue(}, })
            listener: endClassOrMixinBody(DeclarationKind.Class, 94, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration()
  reportAllErrorTokens(class)
  listener: endCompilationUnit(1, )