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(Foo, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, Foo)
        parseClass(Foo, class, class, Foo)
          parseClassHeaderOpt(Foo, class, class)
            parseClassExtendsOpt(Foo)
              listener: handleNoType(Foo)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(Foo)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(Foo)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(Foo, DeclarationKind.Class, Foo)
            listener: beginClassOrMixinBody(DeclarationKind.Class, {)
            notEofOrValue(}, foo)
            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, Foo)
              parseMetadataStar({)
                listener: beginMetadataStar(foo)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(.)
              parseMethod({, null, null, null, null, null, null, {, Instance of 'NoType', null, foo, DeclarationKind.Class, Foo, false)
                listener: beginMethod(null, null, null, null, null, foo)
                listener: handleNoType({)
                ensureIdentifierPotentiallyRecovered({, methodDeclaration, false)
                  listener: handleIdentifier(foo, methodDeclaration)
                parseQualifiedRestOpt(foo, methodDeclarationContinuation)
                  parseQualifiedRest(foo, methodDeclarationContinuation)
                    ensureIdentifier(., methodDeclarationContinuation)
                      listener: handleIdentifier(x, methodDeclarationContinuation)
                    listener: handleQualified(.)
                parseMethodTypeVar(x)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(x, foo, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(x, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(0, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(0, {, })
                reportRecoverableError(foo, ConstructorWithWrongName)
                  listener: handleRecoverableError(ConstructorWithWrongName, foo, foo)
                listener: endClassConstructor(null, foo, (, null, })
              listener: endMember()
            notEofOrValue(}, foo)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
              parseMetadataStar(})
                listener: beginMetadataStar(foo)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(.)
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'NoType', null, foo, DeclarationKind.Class, Foo, false)
                listener: beginMethod(null, null, null, null, null, foo)
                listener: handleNoType(})
                ensureIdentifierPotentiallyRecovered(}, methodDeclaration, false)
                  listener: handleIdentifier(foo, methodDeclaration)
                parseQualifiedRestOpt(foo, methodDeclarationContinuation)
                  parseQualifiedRest(foo, methodDeclarationContinuation)
                    ensureIdentifier(., methodDeclarationContinuation)
                      listener: handleIdentifier(x, methodDeclarationContinuation)
                    listener: handleQualified(.)
                parseMethodTypeVar(x)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(x, foo, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(x, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(0, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  parseInitializers(:)
                    listener: beginInitializers(:)
                    parseInitializer(:)
                      listener: beginInitializer(initializer)
                      parseInitializerExpressionRest(:)
                        parseExpression(:)
                          parsePrecedenceExpression(:, 1, true)
                            parseUnaryExpression(:, true)
                              parsePrimary(:, expression)
                                parseSendOrFunctionLiteral(:, expression)
                                  parseSend(:, expression)
                                    ensureIdentifier(:, expression)
                                      listener: handleIdentifier(initializer, expression)
                                    listener: handleNoTypeArguments(=)
                                    parseArgumentsOpt(initializer)
                                      listener: handleNoArguments(=)
                                    listener: handleSend(initializer, =)
                            parsePrecedenceExpression(=, 1, true)
                              parseUnaryExpression(=, true)
                                parsePrimary(=, expression)
                                  parseLiteralBool(=)
                                    listener: handleLiteralBool(true)
                            listener: handleAssignmentExpression(=)
                        listener: endInitializer({)
                    listener: endInitializers(1, :, {)
                parseAsyncModifierOpt(true)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(true, false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(0, {, })
                reportRecoverableError(foo, ConstructorWithWrongName)
                  listener: handleRecoverableError(ConstructorWithWrongName, foo, foo)
                listener: endClassConstructor(null, foo, (, :, })
              listener: endMember()
            notEofOrValue(}, foo)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
              parseMetadataStar(})
                listener: beginMetadataStar(foo)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'NoType', null, foo, DeclarationKind.Class, Foo, false)
                listener: beginMethod(null, null, null, null, null, foo)
                listener: handleNoType(})
                ensureIdentifierPotentiallyRecovered(}, methodDeclaration, false)
                  listener: handleIdentifier(foo, methodDeclaration)
                parseQualifiedRestOpt(foo, methodDeclarationContinuation)
                parseMethodTypeVar(foo)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(foo, foo, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(foo, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(0, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  parseInitializers(:)
                    listener: beginInitializers(:)
                    parseInitializer(:)
                      listener: beginInitializer(initializer)
                      parseInitializerExpressionRest(:)
                        parseExpression(:)
                          parsePrecedenceExpression(:, 1, true)
                            parseUnaryExpression(:, true)
                              parsePrimary(:, expression)
                                parseSendOrFunctionLiteral(:, expression)
                                  parseSend(:, expression)
                                    ensureIdentifier(:, expression)
                                      listener: handleIdentifier(initializer, expression)
                                    listener: handleNoTypeArguments(=)
                                    parseArgumentsOpt(initializer)
                                      listener: handleNoArguments(=)
                                    listener: handleSend(initializer, =)
                            parsePrecedenceExpression(=, 1, true)
                              parseUnaryExpression(=, true)
                                parsePrimary(=, expression)
                                  parseLiteralBool(=)
                                    listener: handleLiteralBool(true)
                            listener: handleAssignmentExpression(=)
                        listener: endInitializer({)
                    listener: endInitializers(1, :, {)
                parseAsyncModifierOpt(true)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(true, false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(0, {, })
                reportRecoverableError(foo, ConstructorWithWrongName)
                  listener: handleRecoverableError(ConstructorWithWrongName, foo, foo)
                listener: endClassConstructor(null, foo, (, :, })
              listener: endMember()
            notEofOrValue(}, get)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
              parseMetadataStar(})
                listener: beginMetadataStar(get)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'NoType', get, Foo, DeclarationKind.Class, Foo, false)
                listener: beginMethod(null, null, null, null, get, Foo)
                listener: handleNoType(})
                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
                  listener: handleIdentifier(Foo, methodDeclaration)
                parseQualifiedRestOpt(Foo, methodDeclarationContinuation)
                listener: handleNoTypeVariables(=>)
                parseGetterOrFormalParameters(Foo, Foo, true, MemberKind.NonStaticMethod)
                  listener: handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
                parseInitializersOpt(Foo)
                  listener: handleNoInitializers()
                parseAsyncModifierOpt(Foo)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(Foo, false, true)
                  parseExpressionFunctionBody(=>, false)
                    parseExpression(=>)
                      parsePrecedenceExpression(=>, 1, true)
                        parseUnaryExpression(=>, true)
                          parsePrimary(=>, expression)
                            parseLiteralInt(=>)
                              listener: handleLiteralInt(0)
                    ensureSemicolon(0)
                    listener: handleExpressionFunctionBody(=>, ;)
                    inGenerator()
                reportRecoverableError(Foo, MemberWithSameNameAsClass)
                  listener: handleRecoverableError(MemberWithSameNameAsClass, Foo, Foo)
                listener: endClassMethod(get, get, =>, null, ;)
              listener: endMember()
            notEofOrValue(}, get)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Foo)
              parseMetadataStar(;)
                listener: beginMetadataStar(get)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'NoType', get, Foo, DeclarationKind.Class, Foo, false)
                listener: beginMethod(null, null, null, null, get, Foo)
                listener: handleNoType(;)
                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
                  listener: handleIdentifier(Foo, methodDeclaration)
                parseQualifiedRestOpt(Foo, methodDeclarationContinuation)
                listener: handleNoTypeVariables({)
                parseGetterOrFormalParameters(Foo, Foo, true, MemberKind.NonStaticMethod)
                  listener: handleNoFormalParameters({, MemberKind.NonStaticMethod)
                parseInitializersOpt(Foo)
                  listener: handleNoInitializers()
                parseAsyncModifierOpt(Foo)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(Foo, false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, return)
                  parseStatement({)
                    parseStatementX({)
                      parseReturnStatement({)
                        listener: beginReturnStatement(return)
                        parseExpression(return)
                          parsePrecedenceExpression(return, 1, true)
                            parseUnaryExpression(return, true)
                              parsePrimary(return, expression)
                                parseLiteralInt(return)
                                  listener: handleLiteralInt(0)
                        ensureSemicolon(0)
                        listener: endReturnStatement(true, return, ;)
                        inGenerator()
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(1, {, })
                reportRecoverableError(Foo, MemberWithSameNameAsClass)
                  listener: handleRecoverableError(MemberWithSameNameAsClass, Foo, Foo)
                listener: endClassMethod(get, get, {, null, })
              listener: endMember()
            notEofOrValue(}, get)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
              parseMetadataStar(})
                listener: beginMetadataStar(get)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'NoType', get, Foo, DeclarationKind.Class, Foo, false)
                listener: beginMethod(null, null, null, null, get, Foo)
                listener: handleNoType(})
                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
                  listener: handleIdentifier(Foo, methodDeclaration)
                parseQualifiedRestOpt(Foo, methodDeclarationContinuation)
                  parseQualifiedRest(Foo, methodDeclarationContinuation)
                    ensureIdentifier(., methodDeclarationContinuation)
                      listener: handleIdentifier(X, methodDeclarationContinuation)
                    listener: handleQualified(.)
                listener: handleNoTypeVariables(=>)
                parseGetterOrFormalParameters(X, Foo, false, MemberKind.NonStaticMethod)
                  missingParameterMessage(MemberKind.NonStaticMethod)
                  reportRecoverableError(Foo, MissingMethodParameters)
                    listener: handleRecoverableError(MissingMethodParameters, Foo, Foo)
                  rewriter()
                  parseFormalParametersRest((, MemberKind.NonStaticMethod)
                    listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                    listener: endFormalParameters(0, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  parseExpressionFunctionBody(=>, false)
                    parseExpression(=>)
                      parsePrecedenceExpression(=>, 1, true)
                        parseUnaryExpression(=>, true)
                          parsePrimary(=>, expression)
                            parseLiteralInt(=>)
                              listener: handleLiteralInt(0)
                    ensureSemicolon(0)
                    listener: handleExpressionFunctionBody(=>, ;)
                    inGenerator()
                reportRecoverableError(get, GetterConstructor)
                  listener: handleRecoverableError(GetterConstructor, get, get)
                listener: endClassConstructor(get, get, (, null, ;)
              listener: endMember()
            notEofOrValue(}, get)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Foo)
              parseMetadataStar(;)
                listener: beginMetadataStar(get)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'NoType', get, Foo, DeclarationKind.Class, Foo, false)
                listener: beginMethod(null, null, null, null, get, Foo)
                listener: handleNoType(;)
                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
                  listener: handleIdentifier(Foo, methodDeclaration)
                parseQualifiedRestOpt(Foo, methodDeclarationContinuation)
                  parseQualifiedRest(Foo, methodDeclarationContinuation)
                    ensureIdentifier(., methodDeclarationContinuation)
                      listener: handleIdentifier(X, methodDeclarationContinuation)
                    listener: handleQualified(.)
                listener: handleNoTypeVariables({)
                parseGetterOrFormalParameters(X, Foo, false, MemberKind.NonStaticMethod)
                  missingParameterMessage(MemberKind.NonStaticMethod)
                  reportRecoverableError(Foo, MissingMethodParameters)
                    listener: handleRecoverableError(MissingMethodParameters, Foo, Foo)
                  rewriter()
                  parseFormalParametersRest((, MemberKind.NonStaticMethod)
                    listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                    listener: endFormalParameters(0, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, return)
                  parseStatement({)
                    parseStatementX({)
                      parseReturnStatement({)
                        listener: beginReturnStatement(return)
                        parseExpression(return)
                          parsePrecedenceExpression(return, 1, true)
                            parseUnaryExpression(return, true)
                              parsePrimary(return, expression)
                                parseLiteralInt(return)
                                  listener: handleLiteralInt(0)
                        ensureSemicolon(0)
                        listener: endReturnStatement(true, return, ;)
                        inGenerator()
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(1, {, })
                reportRecoverableError(get, GetterConstructor)
                  listener: handleRecoverableError(GetterConstructor, get, get)
                listener: endClassConstructor(get, get, (, null, })
              listener: endMember()
            notEofOrValue(}, get)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
              parseMetadataStar(})
                listener: beginMetadataStar(get)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'NoType', get, Foo, DeclarationKind.Class, Foo, false)
                listener: beginMethod(null, null, null, null, get, Foo)
                listener: handleNoType(})
                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
                  listener: handleIdentifier(Foo, methodDeclaration)
                parseQualifiedRestOpt(Foo, methodDeclarationContinuation)
                listener: handleNoTypeVariables(:)
                parseGetterOrFormalParameters(Foo, Foo, false, MemberKind.NonStaticMethod)
                  missingParameterMessage(MemberKind.NonStaticMethod)
                  reportRecoverableError(Foo, MissingMethodParameters)
                    listener: handleRecoverableError(MissingMethodParameters, Foo, Foo)
                  rewriter()
                  parseFormalParametersRest((, MemberKind.NonStaticMethod)
                    listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                    listener: endFormalParameters(0, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  parseInitializers(:)
                    listener: beginInitializers(:)
                    parseInitializer(:)
                      listener: beginInitializer(bla)
                      parseInitializerExpressionRest(:)
                        parseExpression(:)
                          parsePrecedenceExpression(:, 1, true)
                            parseUnaryExpression(:, true)
                              parsePrimary(:, expression)
                                parseSendOrFunctionLiteral(:, expression)
                                  parseSend(:, expression)
                                    ensureIdentifier(:, expression)
                                      listener: handleIdentifier(bla, expression)
                                    listener: handleNoTypeArguments(=)
                                    parseArgumentsOpt(bla)
                                      listener: handleNoArguments(=)
                                    listener: handleSend(bla, =)
                            parsePrecedenceExpression(=, 1, true)
                              parseUnaryExpression(=, true)
                                parsePrimary(=, expression)
                                  parseLiteralNull(=)
                                    listener: handleLiteralNull(null)
                            listener: handleAssignmentExpression(=)
                        listener: endInitializer(=>)
                    listener: endInitializers(1, :, =>)
                parseAsyncModifierOpt(null)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(null, false, true)
                  parseExpressionFunctionBody(=>, false)
                    parseExpression(=>)
                      parsePrecedenceExpression(=>, 1, true)
                        parseUnaryExpression(=>, true)
                          parsePrimary(=>, expression)
                            parseLiteralInt(=>)
                              listener: handleLiteralInt(0)
                    ensureSemicolon(0)
                    listener: handleExpressionFunctionBody(=>, ;)
                    inGenerator()
                reportRecoverableError(get, GetterConstructor)
                  listener: handleRecoverableError(GetterConstructor, get, get)
                listener: endClassConstructor(get, get, (, :, ;)
              listener: endMember()
            notEofOrValue(}, get)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Foo)
              parseMetadataStar(;)
                listener: beginMetadataStar(get)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'NoType', get, Foo, DeclarationKind.Class, Foo, false)
                listener: beginMethod(null, null, null, null, get, Foo)
                listener: handleNoType(;)
                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
                  listener: handleIdentifier(Foo, methodDeclaration)
                parseQualifiedRestOpt(Foo, methodDeclarationContinuation)
                  parseQualifiedRest(Foo, methodDeclarationContinuation)
                    ensureIdentifier(., methodDeclarationContinuation)
                      listener: handleIdentifier(X, methodDeclarationContinuation)
                    listener: handleQualified(.)
                listener: handleNoTypeVariables(:)
                parseGetterOrFormalParameters(X, Foo, false, MemberKind.NonStaticMethod)
                  missingParameterMessage(MemberKind.NonStaticMethod)
                  reportRecoverableError(Foo, MissingMethodParameters)
                    listener: handleRecoverableError(MissingMethodParameters, Foo, Foo)
                  rewriter()
                  parseFormalParametersRest((, MemberKind.NonStaticMethod)
                    listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                    listener: endFormalParameters(0, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  parseInitializers(:)
                    listener: beginInitializers(:)
                    parseInitializer(:)
                      listener: beginInitializer(bla)
                      parseInitializerExpressionRest(:)
                        parseExpression(:)
                          parsePrecedenceExpression(:, 1, true)
                            parseUnaryExpression(:, true)
                              parsePrimary(:, expression)
                                parseSendOrFunctionLiteral(:, expression)
                                  parseSend(:, expression)
                                    ensureIdentifier(:, expression)
                                      listener: handleIdentifier(bla, expression)
                                    listener: handleNoTypeArguments(=)
                                    parseArgumentsOpt(bla)
                                      listener: handleNoArguments(=)
                                    listener: handleSend(bla, =)
                            parsePrecedenceExpression(=, 1, true)
                              parseUnaryExpression(=, true)
                                parsePrimary(=, expression)
                                  parseLiteralNull(=)
                                    listener: handleLiteralNull(null)
                            listener: handleAssignmentExpression(=)
                        listener: endInitializer({)
                    listener: endInitializers(1, :, {)
                parseAsyncModifierOpt(null)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(null, false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, return)
                  parseStatement({)
                    parseStatementX({)
                      parseReturnStatement({)
                        listener: beginReturnStatement(return)
                        parseExpression(return)
                          parsePrecedenceExpression(return, 1, true)
                            parseUnaryExpression(return, true)
                              parsePrimary(return, expression)
                                parseLiteralInt(return)
                                  listener: handleLiteralInt(0)
                        ensureSemicolon(0)
                        listener: endReturnStatement(true, return, ;)
                        inGenerator()
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(1, {, })
                reportRecoverableError(get, GetterConstructor)
                  listener: handleRecoverableError(GetterConstructor, get, get)
                listener: endClassConstructor(get, get, (, :, })
              listener: endMember()
            notEofOrValue(}, set)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
              parseMetadataStar(})
                listener: beginMetadataStar(set)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'NoType', set, Foo, DeclarationKind.Class, Foo, false)
                listener: beginMethod(null, null, null, null, set, Foo)
                listener: handleNoType(})
                ensureIdentifierPotentiallyRecovered(set, methodDeclaration, false)
                  listener: handleIdentifier(Foo, methodDeclaration)
                parseQualifiedRestOpt(Foo, methodDeclarationContinuation)
                listener: handleNoTypeVariables(=>)
                parseGetterOrFormalParameters(Foo, Foo, false, MemberKind.NonStaticMethod)
                  missingParameterMessage(MemberKind.NonStaticMethod)
                  reportRecoverableError(Foo, MissingMethodParameters)
                    listener: handleRecoverableError(MissingMethodParameters, Foo, Foo)
                  rewriter()
                  parseFormalParametersRest((, MemberKind.NonStaticMethod)
                    listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                    listener: endFormalParameters(0, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  parseExpressionFunctionBody(=>, false)
                    parseExpression(=>)
                      parsePrecedenceExpression(=>, 1, true)
                        parseUnaryExpression(=>, true)
                          parsePrimary(=>, expression)
                            parseLiteralInt(=>)
                              listener: handleLiteralInt(0)
                    ensureSemicolon(0)
                    listener: handleExpressionFunctionBody(=>, ;)
                    inGenerator()
                reportRecoverableError(Foo, MemberWithSameNameAsClass)
                  listener: handleRecoverableError(MemberWithSameNameAsClass, Foo, Foo)
                listener: endClassMethod(set, set, (, null, ;)
              listener: endMember()
            notEofOrValue(}, set)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Foo)
              parseMetadataStar(;)
                listener: beginMetadataStar(set)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'NoType', set, Foo, DeclarationKind.Class, Foo, false)
                listener: beginMethod(null, null, null, null, set, Foo)
                listener: handleNoType(;)
                ensureIdentifierPotentiallyRecovered(set, methodDeclaration, false)
                  listener: handleIdentifier(Foo, methodDeclaration)
                parseQualifiedRestOpt(Foo, methodDeclarationContinuation)
                listener: handleNoTypeVariables({)
                parseGetterOrFormalParameters(Foo, Foo, false, MemberKind.NonStaticMethod)
                  missingParameterMessage(MemberKind.NonStaticMethod)
                  reportRecoverableError(Foo, MissingMethodParameters)
                    listener: handleRecoverableError(MissingMethodParameters, Foo, Foo)
                  rewriter()
                  parseFormalParametersRest((, MemberKind.NonStaticMethod)
                    listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                    listener: endFormalParameters(0, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, return)
                  parseStatement({)
                    parseStatementX({)
                      parseReturnStatement({)
                        listener: beginReturnStatement(return)
                        parseExpression(return)
                          parsePrecedenceExpression(return, 1, true)
                            parseUnaryExpression(return, true)
                              parsePrimary(return, expression)
                                parseLiteralInt(return)
                                  listener: handleLiteralInt(0)
                        ensureSemicolon(0)
                        listener: endReturnStatement(true, return, ;)
                        inGenerator()
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(1, {, })
                reportRecoverableError(Foo, MemberWithSameNameAsClass)
                  listener: handleRecoverableError(MemberWithSameNameAsClass, Foo, Foo)
                listener: endClassMethod(set, set, (, null, })
              listener: endMember()
            notEofOrValue(}, set)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
              parseMetadataStar(})
                listener: beginMetadataStar(set)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'NoType', set, Foo, DeclarationKind.Class, Foo, false)
                listener: beginMethod(null, null, null, null, set, Foo)
                listener: handleNoType(})
                ensureIdentifierPotentiallyRecovered(set, methodDeclaration, false)
                  listener: handleIdentifier(Foo, methodDeclaration)
                parseQualifiedRestOpt(Foo, methodDeclarationContinuation)
                  parseQualifiedRest(Foo, methodDeclarationContinuation)
                    ensureIdentifier(., methodDeclarationContinuation)
                      listener: handleIdentifier(X, methodDeclarationContinuation)
                    listener: handleQualified(.)
                listener: handleNoTypeVariables(=>)
                parseGetterOrFormalParameters(X, Foo, false, MemberKind.NonStaticMethod)
                  missingParameterMessage(MemberKind.NonStaticMethod)
                  reportRecoverableError(Foo, MissingMethodParameters)
                    listener: handleRecoverableError(MissingMethodParameters, Foo, Foo)
                  rewriter()
                  parseFormalParametersRest((, MemberKind.NonStaticMethod)
                    listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                    listener: endFormalParameters(0, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  parseExpressionFunctionBody(=>, false)
                    parseExpression(=>)
                      parsePrecedenceExpression(=>, 1, true)
                        parseUnaryExpression(=>, true)
                          parsePrimary(=>, expression)
                            parseLiteralInt(=>)
                              listener: handleLiteralInt(0)
                    ensureSemicolon(0)
                    listener: handleExpressionFunctionBody(=>, ;)
                    inGenerator()
                reportRecoverableError(set, SetterConstructor)
                  listener: handleRecoverableError(SetterConstructor, set, set)
                listener: endClassConstructor(set, set, (, null, ;)
              listener: endMember()
            notEofOrValue(}, set)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Foo)
              parseMetadataStar(;)
                listener: beginMetadataStar(set)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'NoType', set, Foo, DeclarationKind.Class, Foo, false)
                listener: beginMethod(null, null, null, null, set, Foo)
                listener: handleNoType(;)
                ensureIdentifierPotentiallyRecovered(set, methodDeclaration, false)
                  listener: handleIdentifier(Foo, methodDeclaration)
                parseQualifiedRestOpt(Foo, methodDeclarationContinuation)
                  parseQualifiedRest(Foo, methodDeclarationContinuation)
                    ensureIdentifier(., methodDeclarationContinuation)
                      listener: handleIdentifier(X, methodDeclarationContinuation)
                    listener: handleQualified(.)
                listener: handleNoTypeVariables({)
                parseGetterOrFormalParameters(X, Foo, false, MemberKind.NonStaticMethod)
                  missingParameterMessage(MemberKind.NonStaticMethod)
                  reportRecoverableError(Foo, MissingMethodParameters)
                    listener: handleRecoverableError(MissingMethodParameters, Foo, Foo)
                  rewriter()
                  parseFormalParametersRest((, MemberKind.NonStaticMethod)
                    listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                    listener: endFormalParameters(0, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, return)
                  parseStatement({)
                    parseStatementX({)
                      parseReturnStatement({)
                        listener: beginReturnStatement(return)
                        parseExpression(return)
                          parsePrecedenceExpression(return, 1, true)
                            parseUnaryExpression(return, true)
                              parsePrimary(return, expression)
                                parseLiteralInt(return)
                                  listener: handleLiteralInt(0)
                        ensureSemicolon(0)
                        listener: endReturnStatement(true, return, ;)
                        inGenerator()
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(1, {, })
                reportRecoverableError(set, SetterConstructor)
                  listener: handleRecoverableError(SetterConstructor, set, set)
                listener: endClassConstructor(set, set, (, null, })
              listener: endMember()
            notEofOrValue(}, set)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
              parseMetadataStar(})
                listener: beginMetadataStar(set)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'NoType', set, Foo, DeclarationKind.Class, Foo, false)
                listener: beginMethod(null, null, null, null, set, Foo)
                listener: handleNoType(})
                ensureIdentifierPotentiallyRecovered(set, methodDeclaration, false)
                  listener: handleIdentifier(Foo, methodDeclaration)
                parseQualifiedRestOpt(Foo, methodDeclarationContinuation)
                listener: handleNoTypeVariables(:)
                parseGetterOrFormalParameters(Foo, Foo, false, MemberKind.NonStaticMethod)
                  missingParameterMessage(MemberKind.NonStaticMethod)
                  reportRecoverableError(Foo, MissingMethodParameters)
                    listener: handleRecoverableError(MissingMethodParameters, Foo, Foo)
                  rewriter()
                  parseFormalParametersRest((, MemberKind.NonStaticMethod)
                    listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                    listener: endFormalParameters(0, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  parseInitializers(:)
                    listener: beginInitializers(:)
                    parseInitializer(:)
                      listener: beginInitializer(bla)
                      parseInitializerExpressionRest(:)
                        parseExpression(:)
                          parsePrecedenceExpression(:, 1, true)
                            parseUnaryExpression(:, true)
                              parsePrimary(:, expression)
                                parseSendOrFunctionLiteral(:, expression)
                                  parseSend(:, expression)
                                    ensureIdentifier(:, expression)
                                      listener: handleIdentifier(bla, expression)
                                    listener: handleNoTypeArguments(=)
                                    parseArgumentsOpt(bla)
                                      listener: handleNoArguments(=)
                                    listener: handleSend(bla, =)
                            parsePrecedenceExpression(=, 1, true)
                              parseUnaryExpression(=, true)
                                parsePrimary(=, expression)
                                  parseLiteralNull(=)
                                    listener: handleLiteralNull(null)
                            listener: handleAssignmentExpression(=)
                        listener: endInitializer(=>)
                    listener: endInitializers(1, :, =>)
                parseAsyncModifierOpt(null)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(null, false, true)
                  parseExpressionFunctionBody(=>, false)
                    parseExpression(=>)
                      parsePrecedenceExpression(=>, 1, true)
                        parseUnaryExpression(=>, true)
                          parsePrimary(=>, expression)
                            parseLiteralInt(=>)
                              listener: handleLiteralInt(0)
                    ensureSemicolon(0)
                    listener: handleExpressionFunctionBody(=>, ;)
                    inGenerator()
                reportRecoverableError(set, SetterConstructor)
                  listener: handleRecoverableError(SetterConstructor, set, set)
                listener: endClassConstructor(set, set, (, :, ;)
              listener: endMember()
            notEofOrValue(}, set)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Foo)
              parseMetadataStar(;)
                listener: beginMetadataStar(set)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'NoType', set, Foo, DeclarationKind.Class, Foo, false)
                listener: beginMethod(null, null, null, null, set, Foo)
                listener: handleNoType(;)
                ensureIdentifierPotentiallyRecovered(set, methodDeclaration, false)
                  listener: handleIdentifier(Foo, methodDeclaration)
                parseQualifiedRestOpt(Foo, methodDeclarationContinuation)
                  parseQualifiedRest(Foo, methodDeclarationContinuation)
                    ensureIdentifier(., methodDeclarationContinuation)
                      listener: handleIdentifier(X, methodDeclarationContinuation)
                    listener: handleQualified(.)
                listener: handleNoTypeVariables(:)
                parseGetterOrFormalParameters(X, Foo, false, MemberKind.NonStaticMethod)
                  missingParameterMessage(MemberKind.NonStaticMethod)
                  reportRecoverableError(Foo, MissingMethodParameters)
                    listener: handleRecoverableError(MissingMethodParameters, Foo, Foo)
                  rewriter()
                  parseFormalParametersRest((, MemberKind.NonStaticMethod)
                    listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                    listener: endFormalParameters(0, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  parseInitializers(:)
                    listener: beginInitializers(:)
                    parseInitializer(:)
                      listener: beginInitializer(bla)
                      parseInitializerExpressionRest(:)
                        parseExpression(:)
                          parsePrecedenceExpression(:, 1, true)
                            parseUnaryExpression(:, true)
                              parsePrimary(:, expression)
                                parseSendOrFunctionLiteral(:, expression)
                                  parseSend(:, expression)
                                    ensureIdentifier(:, expression)
                                      listener: handleIdentifier(bla, expression)
                                    listener: handleNoTypeArguments(=)
                                    parseArgumentsOpt(bla)
                                      listener: handleNoArguments(=)
                                    listener: handleSend(bla, =)
                            parsePrecedenceExpression(=, 1, true)
                              parseUnaryExpression(=, true)
                                parsePrimary(=, expression)
                                  parseLiteralNull(=)
                                    listener: handleLiteralNull(null)
                            listener: handleAssignmentExpression(=)
                        listener: endInitializer({)
                    listener: endInitializers(1, :, {)
                parseAsyncModifierOpt(null)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(null, false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, return)
                  parseStatement({)
                    parseStatementX({)
                      parseReturnStatement({)
                        listener: beginReturnStatement(return)
                        parseExpression(return)
                          parsePrecedenceExpression(return, 1, true)
                            parseUnaryExpression(return, true)
                              parsePrimary(return, expression)
                                parseLiteralInt(return)
                                  listener: handleLiteralInt(0)
                        ensureSemicolon(0)
                        listener: endReturnStatement(true, return, ;)
                        inGenerator()
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(1, {, })
                reportRecoverableError(set, SetterConstructor)
                  listener: handleRecoverableError(SetterConstructor, set, set)
                listener: endClassConstructor(set, set, (, :, })
              listener: endMember()
            notEofOrValue(}, external)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
              parseMetadataStar(})
                listener: beginMetadataStar(external)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(()
              parseMethod(}, null, external, null, null, null, null, external, Instance of 'NoType', null, Foo, DeclarationKind.Class, Foo, false)
                listener: beginMethod(external, null, null, null, null, Foo)
                listener: handleNoType(external)
                ensureIdentifierPotentiallyRecovered(external, methodDeclaration, false)
                  listener: handleIdentifier(Foo, methodDeclaration)
                parseQualifiedRestOpt(Foo, methodDeclarationContinuation)
                parseMethodTypeVar(Foo)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(Foo, Foo, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(Foo, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(0, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  parseInitializers(:)
                    listener: beginInitializers(:)
                    parseInitializer(:)
                      listener: beginInitializer(bla)
                      parseInitializerExpressionRest(:)
                        parseExpression(:)
                          parsePrecedenceExpression(:, 1, true)
                            parseUnaryExpression(:, true)
                              parsePrimary(:, expression)
                                parseSendOrFunctionLiteral(:, expression)
                                  parseSend(:, expression)
                                    ensureIdentifier(:, expression)
                                      listener: handleIdentifier(bla, expression)
                                    listener: handleNoTypeArguments(=)
                                    parseArgumentsOpt(bla)
                                      listener: handleNoArguments(=)
                                    listener: handleSend(bla, =)
                            parsePrecedenceExpression(=, 1, true)
                              parseUnaryExpression(=, true)
                                parsePrimary(=, expression)
                                  parseLiteralNull(=)
                                    listener: handleLiteralNull(null)
                            listener: handleAssignmentExpression(=)
                        listener: endInitializer(;)
                    listener: endInitializers(1, :, ;)
                parseAsyncModifierOpt(null)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(null, false, true)
                  listener: handleEmptyFunctionBody(;)
                reportRecoverableError(:, ExternalConstructorWithInitializer)
                  listener: handleRecoverableError(ExternalConstructorWithInitializer, :, :)
                listener: endClassConstructor(null, external, (, :, ;)
              listener: endMember()
            notEofOrValue(}, external)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Foo)
              parseMetadataStar(;)
                listener: beginMetadataStar(external)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(.)
              parseMethod(;, null, external, null, null, null, null, external, Instance of 'NoType', null, Foo, DeclarationKind.Class, Foo, false)
                listener: beginMethod(external, null, null, null, null, Foo)
                listener: handleNoType(external)
                ensureIdentifierPotentiallyRecovered(external, methodDeclaration, false)
                  listener: handleIdentifier(Foo, methodDeclaration)
                parseQualifiedRestOpt(Foo, methodDeclarationContinuation)
                  parseQualifiedRest(Foo, methodDeclarationContinuation)
                    ensureIdentifier(., methodDeclarationContinuation)
                      listener: handleIdentifier(X, methodDeclarationContinuation)
                    listener: handleQualified(.)
                parseMethodTypeVar(X)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(X, Foo, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(X, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(0, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  parseInitializers(:)
                    listener: beginInitializers(:)
                    parseInitializer(:)
                      listener: beginInitializer(bla)
                      parseInitializerExpressionRest(:)
                        parseExpression(:)
                          parsePrecedenceExpression(:, 1, true)
                            parseUnaryExpression(:, true)
                              parsePrimary(:, expression)
                                parseSendOrFunctionLiteral(:, expression)
                                  parseSend(:, expression)
                                    ensureIdentifier(:, expression)
                                      listener: handleIdentifier(bla, expression)
                                    listener: handleNoTypeArguments(=)
                                    parseArgumentsOpt(bla)
                                      listener: handleNoArguments(=)
                                    listener: handleSend(bla, =)
                            parsePrecedenceExpression(=, 1, true)
                              parseUnaryExpression(=, true)
                                parsePrimary(=, expression)
                                  parseLiteralNull(=)
                                    listener: handleLiteralNull(null)
                            listener: handleAssignmentExpression(=)
                        listener: endInitializer({)
                    listener: endInitializers(1, :, {)
                parseAsyncModifierOpt(null)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                reportRecoverableError({, ExternalMethodWithBody)
                  listener: handleRecoverableError(ExternalMethodWithBody, {, {)
                inPlainSync()
                parseFunctionBody(null, false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, return)
                  parseStatement({)
                    parseStatementX({)
                      parseReturnStatement({)
                        listener: beginReturnStatement(return)
                        parseExpression(return)
                          parsePrecedenceExpression(return, 1, true)
                            parseUnaryExpression(return, true)
                              parsePrimary(return, expression)
                                parseLiteralInt(return)
                                  listener: handleLiteralInt(0)
                        ensureSemicolon(0)
                        listener: endReturnStatement(true, return, ;)
                        inGenerator()
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(1, {, })
                reportRecoverableError(:, ExternalConstructorWithInitializer)
                  listener: handleRecoverableError(ExternalConstructorWithInitializer, :, :)
                listener: endClassConstructor(null, external, (, :, })
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
              parseMetadataStar(})
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(}, null, null, null, null, null, null, }, Instance of 'SimpleType', Foo, DeclarationKind.Class, Foo, false)
                listener: beginFields(})
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(Foo)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, fieldDeclaration, false)
                  listener: handleIdentifier(Foo, fieldDeclaration)
                parseFieldInitializerOpt(Foo, Foo, null, null, null, null, DeclarationKind.Class, Foo)
                  reportRecoverableError(Foo, MemberWithSameNameAsClass)
                    listener: handleRecoverableError(MemberWithSameNameAsClass, Foo, Foo)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, null, null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Foo)
              parseMetadataStar(;)
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', A, DeclarationKind.Class, Foo, false)
                listener: beginFields(;)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(A)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, fieldDeclaration, false)
                  listener: handleIdentifier(A, fieldDeclaration)
                parseFieldInitializerOpt(A, A, null, null, null, null, DeclarationKind.Class, Foo)
                  listener: handleNoFieldInitializer(,)
                ensureIdentifier(,, fieldDeclaration)
                  listener: handleIdentifier(Foo, fieldDeclaration)
                parseFieldInitializerOpt(Foo, Foo, null, null, null, null, DeclarationKind.Class, Foo)
                  reportRecoverableError(Foo, MemberWithSameNameAsClass)
                    listener: handleRecoverableError(MemberWithSameNameAsClass, Foo, Foo)
                  listener: handleNoFieldInitializer(,)
                ensureIdentifier(,, fieldDeclaration)
                  listener: handleIdentifier(B, fieldDeclaration)
                parseFieldInitializerOpt(B, B, null, null, null, null, DeclarationKind.Class, Foo)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, null, null, null, null, null, 3, int, ;)
              listener: endMember()
            notEofOrValue(}, })
            listener: endClassOrMixinBody(DeclarationKind.Class, 19, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration()
  reportAllErrorTokens(class)
  listener: endCompilationUnit(1, )