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, 1)
            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()
              parseMethod({, null, null, null, null, null, null, {, Instance of 'SimpleType', null, abstract, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, abstract)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(abstract)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(abstract, methodDeclaration)
                parseQualifiedRestOpt(abstract, methodDeclarationContinuation)
                parseMethodTypeVar(abstract)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(abstract, abstract, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(abstract, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(abstract, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(abstract)
                                      parseArguments(abstract)
                                        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(abstract, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, as, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, as)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(as)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(as, methodDeclaration)
                parseQualifiedRestOpt(as, methodDeclarationContinuation)
                parseMethodTypeVar(as)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(as, as, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(as, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(as, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(as)
                                      parseArguments(as)
                                        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(as, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(assert)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, assert, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, assert)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(assert)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(assert, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'assert' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: assert}], assert, assert)
                  listener: handleIdentifier(assert, methodDeclaration)
                parseQualifiedRestOpt(assert, methodDeclarationContinuation)
                parseMethodTypeVar(assert)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(assert, assert, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(assert, 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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, async, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, async)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(async)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(async, methodDeclaration)
                parseQualifiedRestOpt(async, methodDeclarationContinuation)
                parseMethodTypeVar(async)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(async, async, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(async, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(async, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(async)
                                      parseArguments(async)
                                        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(async, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, await, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, await)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(await)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(await, methodDeclaration)
                parseQualifiedRestOpt(await, methodDeclarationContinuation)
                parseMethodTypeVar(await)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(await, await, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(await, 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)
                              inPlainSync()
                              looksLikeAwaitExpression(return)
                                looksLikeExpression(await)
                              parsePrimary(return, expression)
                                inPlainSync()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(await, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(await)
                                      parseArguments(await)
                                        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(await, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(break)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, break, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, break)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(break)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(break, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'break' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: break}], break, break)
                  listener: handleIdentifier(break, methodDeclaration)
                parseQualifiedRestOpt(break, methodDeclarationContinuation)
                parseMethodTypeVar(break)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(break, break, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(break, 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'., Try inserting an identifier before 'break'., {lexeme: 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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(case)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, case, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, case)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(case)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(case, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'case' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: case}], case, case)
                  listener: handleIdentifier(case, methodDeclaration)
                parseQualifiedRestOpt(case, methodDeclarationContinuation)
                parseMethodTypeVar(case)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(case, case, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(case, 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[ExpectedIdentifierButGotKeyword, 'case' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(catch)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, catch, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, catch)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(catch)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(catch, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'catch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: catch}], catch, catch)
                  listener: handleIdentifier(catch, methodDeclaration)
                parseQualifiedRestOpt(catch, methodDeclarationContinuation)
                parseMethodTypeVar(catch)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(catch, catch, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(catch, 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[ExpectedIdentifierButGotKeyword, 'catch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(class)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, class, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, class)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(class)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(class, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'class' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: class}], class, class)
                  listener: handleIdentifier(class, methodDeclaration)
                parseQualifiedRestOpt(class, methodDeclarationContinuation)
                parseMethodTypeVar(class)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(class, class, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(class, 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[ExpectedIdentifierButGotKeyword, 'class' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(const)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, const, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, const)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(const)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(const, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'const' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: const}], const, const)
                  listener: handleIdentifier(const, methodDeclaration)
                parseQualifiedRestOpt(const, methodDeclarationContinuation)
                parseMethodTypeVar(const)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(const, const, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(const, 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 '('., Try inserting an identifier before '('., {lexeme: (}], messageOnToken: null)
                                        reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}])
                                          listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}], (, ()
                                        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, {, })
                listener: endClassMethod(null, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(continue)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, continue, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, continue)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(continue)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(continue, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'continue' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: continue}], continue, continue)
                  listener: handleIdentifier(continue, methodDeclaration)
                parseQualifiedRestOpt(continue, methodDeclarationContinuation)
                parseMethodTypeVar(continue)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(continue, continue, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(continue, 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'., Try inserting an identifier before 'continue'., {lexeme: 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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, covariant, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, covariant)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(covariant)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(covariant, methodDeclaration)
                parseQualifiedRestOpt(covariant, methodDeclarationContinuation)
                parseMethodTypeVar(covariant)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(covariant, covariant, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(covariant, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(covariant, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(covariant)
                                      parseArguments(covariant)
                                        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(covariant, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(default)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, default, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, default)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(default)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(default, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'default' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: default}], default, default)
                  listener: handleIdentifier(default, methodDeclaration)
                parseQualifiedRestOpt(default, methodDeclarationContinuation)
                parseMethodTypeVar(default)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(default, default, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(default, 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[ExpectedIdentifierButGotKeyword, 'default' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, deferred, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, deferred)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(deferred)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(deferred, methodDeclaration)
                parseQualifiedRestOpt(deferred, methodDeclarationContinuation)
                parseMethodTypeVar(deferred)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(deferred, deferred, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(deferred, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(deferred, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(deferred)
                                      parseArguments(deferred)
                                        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(deferred, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(do)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, do, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, do)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(do)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(do, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'do' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: do}], do, do)
                  listener: handleIdentifier(do, methodDeclaration)
                parseQualifiedRestOpt(do, methodDeclarationContinuation)
                parseMethodTypeVar(do)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(do, do, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(do, 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'., Try inserting an identifier before 'do'., {lexeme: 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 '}'., Try inserting an identifier before '}'., {lexeme: }}], }, })
                                        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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, dynamic, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, dynamic)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(dynamic)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(dynamic, methodDeclaration)
                parseQualifiedRestOpt(dynamic, methodDeclarationContinuation)
                parseMethodTypeVar(dynamic)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(dynamic, dynamic, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(dynamic, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(dynamic, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(dynamic)
                                      parseArguments(dynamic)
                                        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(dynamic, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(else)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, else, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, else)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(else)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(else, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'else' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: else}], else, else)
                  listener: handleIdentifier(else, methodDeclaration)
                parseQualifiedRestOpt(else, methodDeclarationContinuation)
                parseMethodTypeVar(else)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(else, else, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(else, 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'., Try inserting an identifier before 'else'., {lexeme: 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'., Try inserting an identifier before 'else'., {lexeme: 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, {lexeme: ;}])
                    listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {lexeme: ;}], 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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(enum)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, enum, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, enum)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(enum)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(enum, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'enum' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: enum}], enum, enum)
                  listener: handleIdentifier(enum, methodDeclaration)
                parseQualifiedRestOpt(enum, methodDeclarationContinuation)
                parseMethodTypeVar(enum)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(enum, enum, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(enum, 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[ExpectedIdentifierButGotKeyword, 'enum' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, export, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, export)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(export)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(export, methodDeclaration)
                parseQualifiedRestOpt(export, methodDeclarationContinuation)
                parseMethodTypeVar(export)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(export, export, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(export, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(export, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(export)
                                      parseArguments(export)
                                        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(export, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(extends)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, extends, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, extends)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(extends)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(extends, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'extends' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: extends}], extends, extends)
                  listener: handleIdentifier(extends, methodDeclaration)
                parseQualifiedRestOpt(extends, methodDeclarationContinuation)
                parseMethodTypeVar(extends)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(extends, extends, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(extends, 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[ExpectedIdentifierButGotKeyword, 'extends' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, extension, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, extension)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(extension)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(extension, methodDeclaration)
                parseQualifiedRestOpt(extension, methodDeclarationContinuation)
                parseMethodTypeVar(extension)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(extension, extension, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(extension, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(extension, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(extension)
                                      parseArguments(extension)
                                        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(extension, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, external, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, external)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(external)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(external, methodDeclaration)
                parseQualifiedRestOpt(external, methodDeclarationContinuation)
                parseMethodTypeVar(external)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(external, external, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(external, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(external, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(external)
                                      parseArguments(external)
                                        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(external, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, factory, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, factory)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(factory)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(factory, methodDeclaration)
                parseQualifiedRestOpt(factory, methodDeclarationContinuation)
                parseMethodTypeVar(factory)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(factory, factory, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(factory, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(factory, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(factory)
                                      parseArguments(factory)
                                        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(factory, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(false)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, false, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, false)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(false)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(false, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'false' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: false}], false, false)
                  listener: handleIdentifier(false, methodDeclaration)
                parseQualifiedRestOpt(false, methodDeclarationContinuation)
                parseMethodTypeVar(false)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(false, false, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(false, 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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(final)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, final, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, final)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(final)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(final, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'final' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: final}], final, final)
                  listener: handleIdentifier(final, methodDeclaration)
                parseQualifiedRestOpt(final, methodDeclarationContinuation)
                parseMethodTypeVar(final)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(final, final, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(final, 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'., Try inserting an identifier before 'final'., {lexeme: 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 '('., Try inserting an identifier before '('., {lexeme: (}], (, ()
                              rewriter()
                              listener: handleIdentifier(, localVariableDeclaration)
                            listener: beginInitializedIdentifier()
                            parseVariableInitializerOpt()
                              listener: handleNoVariableInitializer()
                            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 ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
                                        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, {lexeme: ;}])
                    listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {lexeme: ;}], ), ))
                  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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(finally)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, finally, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, finally)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(finally)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(finally, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'finally' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: finally}], finally, finally)
                  listener: handleIdentifier(finally, methodDeclaration)
                parseQualifiedRestOpt(finally, methodDeclarationContinuation)
                parseMethodTypeVar(finally)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(finally, finally, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(finally, 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[ExpectedIdentifierButGotKeyword, 'finally' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(for)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, for, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, for)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(for)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(for, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'for' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: for}], for, for)
                  listener: handleIdentifier(for, methodDeclaration)
                parseQualifiedRestOpt(for, methodDeclarationContinuation)
                parseMethodTypeVar(for)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(for, for, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(for, 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'., Try inserting an identifier before 'for'., {lexeme: 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 ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
                                          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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, Function, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, Function)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(Function)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(Function, methodDeclaration)
                parseQualifiedRestOpt(Function, methodDeclarationContinuation)
                parseMethodTypeVar(Function)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(Function, Function, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(Function, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(Function, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(Function)
                                      parseArguments(Function)
                                        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(Function, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, get, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, get)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(get)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(get, methodDeclaration)
                parseQualifiedRestOpt(get, methodDeclarationContinuation)
                parseMethodTypeVar(get)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(get, get, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(get, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(get, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(get)
                                      parseArguments(get)
                                        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(get, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, hide, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, hide)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(hide)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(hide, methodDeclaration)
                parseQualifiedRestOpt(hide, methodDeclarationContinuation)
                parseMethodTypeVar(hide)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(hide, hide, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(hide, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(hide, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(hide)
                                      parseArguments(hide)
                                        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(hide, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(if)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, if, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, if)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(if)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(if, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'if' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: if}], if, if)
                  listener: handleIdentifier(if, methodDeclaration)
                parseQualifiedRestOpt(if, methodDeclarationContinuation)
                parseMethodTypeVar(if)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(if, if, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(if, 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'., Try inserting an identifier before 'if'., {lexeme: 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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, implements, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, implements)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(implements)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(implements, methodDeclaration)
                parseQualifiedRestOpt(implements, methodDeclarationContinuation)
                parseMethodTypeVar(implements)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(implements, implements, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(implements, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(implements, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(implements)
                                      parseArguments(implements)
                                        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(implements, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, import, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, import)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(import)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(import, methodDeclaration)
                parseQualifiedRestOpt(import, methodDeclarationContinuation)
                parseMethodTypeVar(import)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(import, import, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(import, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(import, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(import)
                                      parseArguments(import)
                                        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(import, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(in)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, in, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, in)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(in)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(in, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'in' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: in}], in, in)
                  listener: handleIdentifier(in, methodDeclaration)
                parseQualifiedRestOpt(in, methodDeclarationContinuation)
                parseMethodTypeVar(in)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(in, in, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(in, 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[ExpectedIdentifierButGotKeyword, 'in' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, inout, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, inout)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(inout)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(inout, methodDeclaration)
                parseQualifiedRestOpt(inout, methodDeclarationContinuation)
                parseMethodTypeVar(inout)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(inout, inout, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(inout, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(inout, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(inout)
                                      parseArguments(inout)
                                        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(inout, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, interface, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, interface)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(interface)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(interface, methodDeclaration)
                parseQualifiedRestOpt(interface, methodDeclarationContinuation)
                parseMethodTypeVar(interface)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(interface, interface, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(interface, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(interface, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(interface)
                                      parseArguments(interface)
                                        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(interface, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(is)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, is, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, is)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(is)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(is, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'is' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: is}], is, is)
                  listener: handleIdentifier(is, methodDeclaration)
                parseQualifiedRestOpt(is, methodDeclarationContinuation)
                parseMethodTypeVar(is)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(is, is, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(is, 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'., Try inserting an identifier before 'is'., {lexeme: 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, {lexeme: (}], (, ()
                              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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, late, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, late)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(late)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(late, methodDeclaration)
                parseQualifiedRestOpt(late, methodDeclarationContinuation)
                parseMethodTypeVar(late)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(late, late, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(late, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(late, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(late)
                                      parseArguments(late)
                                        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(late, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, library, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, library)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(library)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(library, methodDeclaration)
                parseQualifiedRestOpt(library, methodDeclarationContinuation)
                parseMethodTypeVar(library)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(library, library, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(library, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(library, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(library)
                                      parseArguments(library)
                                        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(library, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, mixin, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, mixin)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(mixin)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(mixin, methodDeclaration)
                parseQualifiedRestOpt(mixin, methodDeclarationContinuation)
                parseMethodTypeVar(mixin)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(mixin, mixin, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(mixin, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(mixin, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(mixin)
                                      parseArguments(mixin)
                                        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(mixin, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, native, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, native)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(native)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(native, methodDeclaration)
                parseQualifiedRestOpt(native, methodDeclarationContinuation)
                parseMethodTypeVar(native)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(native, native, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(native, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(native, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(native)
                                      parseArguments(native)
                                        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(native, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(new)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, new, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, new)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(new)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(new, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'new' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: new}], new, new)
                  listener: handleIdentifier(new, methodDeclaration)
                parseQualifiedRestOpt(new, methodDeclarationContinuation)
                parseMethodTypeVar(new)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(new, new, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(new, 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 '('., Try inserting an identifier before '('., {lexeme: (}], messageOnToken: null)
                                        reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}])
                                          listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}], (, ()
                                        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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(null)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, null, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(null)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(null, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'null' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: null}], null, null)
                  listener: handleIdentifier(null, methodDeclaration)
                parseQualifiedRestOpt(null, methodDeclarationContinuation)
                parseMethodTypeVar(null)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(null, null, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(null, 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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, of, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, of)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(of)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(of, methodDeclaration)
                parseQualifiedRestOpt(of, methodDeclarationContinuation)
                parseMethodTypeVar(of)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(of, of, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(of, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(of, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(of)
                                      parseArguments(of)
                                        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(of, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, on, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, on)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(on)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(on, methodDeclaration)
                parseQualifiedRestOpt(on, methodDeclarationContinuation)
                parseMethodTypeVar(on)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(on, on, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(on, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(on, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(on)
                                      parseArguments(on)
                                        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(on, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isUnaryMinus(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, operator, DeclarationKind.Class, WrapperClass, false)
                isUnaryMinus(()
                listener: beginMethod(null, null, null, null, null, operator)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(operator)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(operator, methodDeclaration)
                parseQualifiedRestOpt(operator, methodDeclarationContinuation)
                parseMethodTypeVar(operator)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(operator, operator, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(operator, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(operator, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(operator)
                                      parseArguments(operator)
                                        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(operator, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, out, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, out)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(out)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(out, methodDeclaration)
                parseQualifiedRestOpt(out, methodDeclarationContinuation)
                parseMethodTypeVar(out)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(out, out, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(out, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(out, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(out)
                                      parseArguments(out)
                                        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(out, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, part, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, part)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(part)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(part, methodDeclaration)
                parseQualifiedRestOpt(part, methodDeclarationContinuation)
                parseMethodTypeVar(part)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(part, part, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(part, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(part, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(part)
                                      parseArguments(part)
                                        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(part, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, patch, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, patch)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(patch)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(patch, methodDeclaration)
                parseQualifiedRestOpt(patch, methodDeclarationContinuation)
                parseMethodTypeVar(patch)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(patch, patch, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(patch, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(patch, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(patch)
                                      parseArguments(patch)
                                        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(patch, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, required, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, required)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(required)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(required, methodDeclaration)
                parseQualifiedRestOpt(required, methodDeclarationContinuation)
                parseMethodTypeVar(required)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(required, required, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(required, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(required, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(required)
                                      parseArguments(required)
                                        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(required, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(rethrow)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, rethrow, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, rethrow)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(rethrow)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(rethrow, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'rethrow' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: rethrow}], rethrow, rethrow)
                  listener: handleIdentifier(rethrow, methodDeclaration)
                parseQualifiedRestOpt(rethrow, methodDeclarationContinuation)
                parseMethodTypeVar(rethrow)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(rethrow, rethrow, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(rethrow, 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[ExpectedIdentifierButGotKeyword, 'rethrow' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(return)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, return, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, return)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(return)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(return, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'return' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: return}], return, return)
                  listener: handleIdentifier(return, methodDeclaration)
                parseQualifiedRestOpt(return, methodDeclarationContinuation)
                parseMethodTypeVar(return)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(return, return, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(return, 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, {lexeme: 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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, set, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, set)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(set)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(set, methodDeclaration)
                parseQualifiedRestOpt(set, methodDeclarationContinuation)
                parseMethodTypeVar(set)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(set, set, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(set, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(set, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(set)
                                      parseArguments(set)
                                        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(set, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, show, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, show)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(show)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(show, methodDeclaration)
                parseQualifiedRestOpt(show, methodDeclarationContinuation)
                parseMethodTypeVar(show)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(show, show, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(show, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(show, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(show)
                                      parseArguments(show)
                                        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(show, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, source, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, source)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(source)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(source, methodDeclaration)
                parseQualifiedRestOpt(source, methodDeclarationContinuation)
                parseMethodTypeVar(source)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(source, source, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(source, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(source, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(source)
                                      parseArguments(source)
                                        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(source, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, static, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, static)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(static)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(static, methodDeclaration)
                parseQualifiedRestOpt(static, methodDeclarationContinuation)
                parseMethodTypeVar(static)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(static, static, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(static, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(static, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(static)
                                      parseArguments(static)
                                        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(static, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(super)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, super, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, super)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(super)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(super, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'super' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: super}], super, super)
                  listener: handleIdentifier(super, methodDeclaration)
                parseQualifiedRestOpt(super, methodDeclarationContinuation)
                parseMethodTypeVar(super)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(super, super, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(super, 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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(switch)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, switch, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, switch)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(switch)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(switch, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'switch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: switch}], switch, switch)
                  listener: handleIdentifier(switch, methodDeclaration)
                parseQualifiedRestOpt(switch, methodDeclarationContinuation)
                parseMethodTypeVar(switch)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(switch, switch, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(switch, 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'., Try inserting an identifier before 'switch'., {lexeme: 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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, sync, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, sync)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(sync)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(sync, methodDeclaration)
                parseQualifiedRestOpt(sync, methodDeclarationContinuation)
                parseMethodTypeVar(sync)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(sync, sync, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(sync, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(sync, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(sync)
                                      parseArguments(sync)
                                        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(sync, +)
                            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, int, (, 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, null, }, Instance of 'SimpleType', null, DeclarationKind.Class, WrapperClass)
                parseFields(}, null, null, null, null, null, null, }, Instance of 'SimpleType', this, DeclarationKind.Class, WrapperClass, false)
                  listener: beginFields(})
                  listener: handleIdentifier(int, typeReference)
                  listener: handleNoTypeArguments(this)
                  listener: handleType(int, null)
                  ensureIdentifierPotentiallyRecovered(int, fieldDeclaration, false)
                    reportRecoverableErrorWithToken(this, Instance of 'Template<(Token) => Message>')
                      listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'this' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: this}], this, this)
                    listener: handleIdentifier(this, fieldDeclaration)
                  parseFieldInitializerOpt(this, this, null, null, 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, 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, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass)
                parseMethod(;, null, null, null, null, null, null, ;, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass, false)
                  listener: beginMethod(null, null, null, null, null, ()
                  listener: handleNoType(;)
                  ensureIdentifierPotentiallyRecovered(;, methodDeclaration, false)
                    insertSyntheticIdentifier(;, methodDeclaration, message: null, messageOnToken: null)
                      reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}])
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}], (, ()
                      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()
              isReservedKeyword(throw)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, throw, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, throw)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(throw)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(throw, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'throw' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: throw}], throw, throw)
                  listener: handleIdentifier(throw, methodDeclaration)
                parseQualifiedRestOpt(throw, methodDeclarationContinuation)
                parseMethodTypeVar(throw)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(throw, throw, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(throw, 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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(true)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, true, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, true)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(true)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(true, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'true' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: true}], true, true)
                  listener: handleIdentifier(true, methodDeclaration)
                parseQualifiedRestOpt(true, methodDeclarationContinuation)
                parseMethodTypeVar(true)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(true, true, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(true, 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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(try)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, try, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, try)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(try)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(try, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'try' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: try}], try, try)
                  listener: handleIdentifier(try, methodDeclaration)
                parseQualifiedRestOpt(try, methodDeclarationContinuation)
                parseMethodTypeVar(try)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(try, try, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(try, 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'., Try inserting an identifier before 'try'., {lexeme: 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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, typedef, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, typedef)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(typedef)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(typedef, methodDeclaration)
                parseQualifiedRestOpt(typedef, methodDeclarationContinuation)
                parseMethodTypeVar(typedef)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(typedef, typedef, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(typedef, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(typedef, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(typedef)
                                      parseArguments(typedef)
                                        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(typedef, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(var)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, var, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, var)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(var)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(var, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'var' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: var}], var, var)
                  listener: handleIdentifier(var, methodDeclaration)
                parseQualifiedRestOpt(var, methodDeclarationContinuation)
                parseMethodTypeVar(var)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(var, var, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(var, 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'., Try inserting an identifier before 'var'., {lexeme: 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 '('., Try inserting an identifier before '('., {lexeme: (}], (, ()
                              rewriter()
                              listener: handleIdentifier(, localVariableDeclaration)
                            listener: beginInitializedIdentifier()
                            parseVariableInitializerOpt()
                              listener: handleNoVariableInitializer()
                            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 ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
                                        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, {lexeme: ;}])
                    listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {lexeme: ;}], ), ))
                  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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(void)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, void, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, void)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(void)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(void, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'void' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: void}], void, void)
                  listener: handleIdentifier(void, methodDeclaration)
                parseQualifiedRestOpt(void, methodDeclarationContinuation)
                parseMethodTypeVar(void)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(void, void, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(void, 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'., Try inserting an identifier before 'void'., {lexeme: 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 '('., Try inserting an identifier before '('., {lexeme: (}], (, ()
                                rewriter()
                                listener: handleIdentifier(, localVariableDeclaration)
                              listener: beginInitializedIdentifier()
                              parseVariableInitializerOpt()
                                listener: handleNoVariableInitializer()
                              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 ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
                                        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, {lexeme: ;}])
                    listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {lexeme: ;}], ), ))
                  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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(while)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, while, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, while)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(while)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(while, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'while' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: while}], while, while)
                  listener: handleIdentifier(while, methodDeclaration)
                parseQualifiedRestOpt(while, methodDeclarationContinuation)
                parseMethodTypeVar(while)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(while, while, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(while, 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'., Try inserting an identifier before 'while'., {lexeme: 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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(with)
              indicatesMethodOrField(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, with, DeclarationKind.Class, WrapperClass, true)
                listener: beginMethod(null, null, null, null, null, with)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(with)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true)
                  reportRecoverableErrorWithToken(with, Instance of 'Template<(Token) => Message>')
                    listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'with' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: with}], with, with)
                  listener: handleIdentifier(with, methodDeclaration)
                parseQualifiedRestOpt(with, methodDeclarationContinuation)
                parseMethodTypeVar(with)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(with, with, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(with, 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[ExpectedIdentifierButGotKeyword, 'with' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, yield, DeclarationKind.Class, WrapperClass, false)
                listener: beginMethod(null, null, null, null, null, yield)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(yield)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
                  listener: handleIdentifier(yield, methodDeclaration)
                parseQualifiedRestOpt(yield, methodDeclarationContinuation)
                parseMethodTypeVar(yield)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(yield, yield, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(yield, 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()
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(+)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      inPlainSync()
                                      listener: handleIdentifier(yield, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(yield)
                                      parseArguments(yield)
                                        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(yield, +)
                            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, int, (, null, })
              listener: endMember()
            notEofOrValue(}, })
            listener: endClassOrMixinBody(DeclarationKind.Class, 70, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration()
  reportAllErrorTokens(class)
  listener: endCompilationUnit(1, )