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)
                                        isNextIdentifier(()
                                        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)
                                    isNextIdentifier(return)
                                    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)
                                                      isNextIdentifier(()
                                                      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, ;)
                        ensureSemicolon())
                        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)
                                        isNextIdentifier(()
                                        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)
                                    isNextIdentifier(return)
                                    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)
                                                      isNextIdentifier(()
                                                      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, ;)
                        ensureSemicolon())
                        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, 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)
                                        isNextIdentifier(()
                                        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)
                                    isNextIdentifier(return)
                                    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)
                                                      isNextIdentifier(()
                                                      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, ;)
                        ensureSemicolon())
                        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)
                                        isNextIdentifier(()
                                        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)
                                    isNextIdentifier(return)
                                    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)
                                                      isNextIdentifier(()
                                                      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, ;)
                        ensureSemicolon())
                        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, 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)
                                        isNextIdentifier(()
                                        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)
                                    isNextIdentifier(return)
                                    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)
                                                      isNextIdentifier(()
                                                      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, ;)
                        ensureSemicolon())
                        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)
                                        isNextIdentifier(()
                                        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)
                                    isNextIdentifier(return)
                                    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)
                                                      isNextIdentifier(()
                                                      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, ;)
                        ensureSemicolon())
                        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)
                                        isNextIdentifier(()
                                        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)
                                    isNextIdentifier(return)
                                    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)
                                                      isNextIdentifier(()
                                                      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, ;)
                        ensureSemicolon())
                        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)
                                        isNextIdentifier(()
                                        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)
                                    isNextIdentifier(return)
                                    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)
                                                      isNextIdentifier(()
                                                      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, ;)
                        ensureSemicolon())
                        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, 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)
                                        isNextIdentifier(()
                                        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)
                                    isNextIdentifier(return)
                                    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)
                                                      isNextIdentifier(()
                                                      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, ;)
                        ensureSemicolon())
                        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)
                                        isNextIdentifier(()
                                        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)
                                    isNextIdentifier(return)
                                    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)
                                                      isNextIdentifier(()
                                                      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, ;)
                        ensureSemicolon())
                        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, 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)
                                        isNextIdentifier(()
                                        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)
                                    isNextIdentifier(return)
                                    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)
                                                      isNextIdentifier(()
                                                      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, ;)
                        ensureSemicolon())
                        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)
                                        isNextIdentifier(()
                                        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)
                                    isNextIdentifier(return)
                                    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)
                                                      isNextIdentifier(()
                                                      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, ;)
                        ensureSemicolon())
                        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)
                                        isNextIdentifier(()
                                        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)
                                    isNextIdentifier(return)
                                    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)
                                                      isNextIdentifier(()
                                                      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, ;)
                        ensureSemicolon())
                        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)
                                        isNextIdentifier(()
                                        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)
                                    isNextIdentifier(return)
                                    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)
                                                      isNextIdentifier(()
                                                      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, ;)
                        ensureSemicolon())
                        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)
                                        isNextIdentifier(()
                                        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)
                                    isNextIdentifier(return)
                                    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)
                                                      isNextIdentifier(()
                                                      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, ;)
                        ensureSemicolon())
                        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)
                                        isNextIdentifier(()
                                        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)
                                    isNextIdentifier(return)
                                    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)
                                                      isNextIdentifier(()
                                                      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, ;)
                        ensureSemicolon())
                        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)
                                        isNextIdentifier(()
                                        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)
                                    isNextIdentifier(return)
                                    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)
                                                      isNextIdentifier(()
                                                      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, ;)
                        ensureSemicolon())
                        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)
                                        isNextIdentifier(()
                                        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)
                                    isNextIdentifier(return)
                                    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)
                                                      isNextIdentifier(()
                                                      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, ;)
                        ensureSemicolon())
                        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)
                                        isNextIdentifier(()
                                        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)
                                    isNextIdentifier(return)
                                    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)
                                                      isNextIdentifier(()
                                                      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, ;)
                        ensureSemicolon())
                        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, 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)
                                        isNextIdentifier(()
                                        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)
                                    isNextIdentifier(return)
                                    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)
                                                      isNextIdentifier(()
                                                      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, ;)
                        ensureSemicolon())
                        listener: endReturnStatement(true, return, ;)
                        inGenerator()
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(2, {, })
                listener: endClassMethod(null, int, (, null, })
              listener: endMember()
            notEofOrValue(}, })
            listener: endClassOrMixinBody(DeclarationKind.Class, 20, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration()
  reportAllErrorTokens(class)
  listener: endCompilationUnit(1, )