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(ConfigurationService, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, ConfigurationService)
        parseClass(ConfigurationService, class, class, ConfigurationService)
          parseClassHeaderOpt(ConfigurationService, class, class)
            parseClassExtendsOpt(ConfigurationService)
              listener: handleNoType(ConfigurationService)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(ConfigurationService)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(ConfigurationService)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(ConfigurationService, DeclarationKind.Class, ConfigurationService)
            listener: beginClassOrMixinBody(DeclarationKind.Class, {)
            notEofOrValue(}, Configuration)
            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, ConfigurationService)
              parseMetadataStar({)
                listener: beginMetadataStar(Configuration)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields({, null, null, null, null, null, null, {, Instance of 'SimpleType', _configuration, DeclarationKind.Class, ConfigurationService, false)
                listener: beginFields({)
                listener: handleIdentifier(Configuration, typeReference)
                listener: handleNoTypeArguments(_configuration)
                listener: handleType(Configuration, null)
                ensureIdentifierPotentiallyRecovered(Configuration, fieldDeclaration, false)
                  listener: handleIdentifier(_configuration, fieldDeclaration)
                parseFieldInitializerOpt(_configuration, _configuration, null, null, null, null, DeclarationKind.Class, ConfigurationService)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, null, null, null, null, null, 1, Configuration, ;)
              listener: endMember()
            notEofOrValue(}, ConfigurationService)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, ConfigurationService)
              parseMetadataStar(;)
                listener: beginMetadataStar(ConfigurationService)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(()
              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'NoType', null, ConfigurationService, DeclarationKind.Class, ConfigurationService, false)
                listener: beginMethod(null, null, null, null, null, ConfigurationService)
                listener: handleNoType(;)
                ensureIdentifierPotentiallyRecovered(;, methodDeclaration, false)
                  listener: handleIdentifier(ConfigurationService, methodDeclaration)
                parseQualifiedRestOpt(ConfigurationService, methodDeclarationContinuation)
                parseMethodTypeVar(ConfigurationService)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(ConfigurationService, ConfigurationService, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(ConfigurationService, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(Configuration)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(Configuration, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleIdentifier(Configuration, typeReference)
                        listener: handleNoTypeArguments(configuration)
                        listener: handleType(Configuration, null)
                        ensureIdentifier(Configuration, formalParameterDeclaration)
                          listener: handleIdentifier(configuration, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, configuration, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  parseInitializers(:)
                    listener: beginInitializers(:)
                    parseInitializer(:)
                      listener: beginInitializer(assert)
                      parseAssert(:, Assert.Initializer)
                        listener: beginAssert(assert, Assert.Initializer)
                        parseExpression(()
                          parsePrecedenceExpression((, 1, true)
                            parseUnaryExpression((, true)
                              parsePrimary((, expression)
                                parseSendOrFunctionLiteral((, expression)
                                  parseSend((, expression)
                                    isNextIdentifier(()
                                    ensureIdentifier((, expression)
                                      listener: handleIdentifier(configuration, expression)
                                    listener: handleNoTypeArguments(!=)
                                    parseArgumentsOpt(configuration)
                                      listener: handleNoArguments(!=)
                                    listener: handleSend(configuration, !=)
                            listener: beginBinaryExpression(!=)
                            parsePrecedenceExpression(!=, 8, true)
                              parseUnaryExpression(!=, true)
                                parsePrimary(!=, expression)
                                  parseLiteralNull(!=)
                                    listener: handleLiteralNull(null)
                            listener: endBinaryExpression(!=)
                        listener: endAssert(assert, Assert.Initializer, (, null, ,)
                      listener: endInitializer(,)
                    parseInitializer(,)
                      listener: beginInitializer(_configuration)
                      parseInitializerExpressionRest(,)
                        parseExpression(,)
                          parsePrecedenceExpression(,, 1, true)
                            parseUnaryExpression(,, true)
                              parsePrimary(,, expression)
                                parseSendOrFunctionLiteral(,, expression)
                                  parseSend(,, expression)
                                    isNextIdentifier(,)
                                    ensureIdentifier(,, expression)
                                      listener: handleIdentifier(_configuration, expression)
                                    listener: handleNoTypeArguments(=)
                                    parseArgumentsOpt(_configuration)
                                      listener: handleNoArguments(=)
                                    listener: handleSend(_configuration, =)
                            parsePrecedenceExpression(=, 1, true)
                              parseUnaryExpression(=, true)
                                parsePrimary(=, expression)
                                  parseSendOrFunctionLiteral(=, expression)
                                    parseSend(=, expression)
                                      isNextIdentifier(=)
                                      ensureIdentifier(=, expression)
                                        listener: handleIdentifier(configuration, expression)
                                      listener: handleNoTypeArguments({)
                                      parseArgumentsOpt(configuration)
                                        listener: handleNoArguments({)
                                      listener: handleSend(configuration, {)
                            listener: handleAssignmentExpression(=)
                        listener: endInitializer({)
                    listener: endInitializers(2, :, {)
                parseAsyncModifierOpt(configuration)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(configuration, false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(0, {, })
                listener: endClassConstructor(null, ConfigurationService, (, :, })
              listener: endMember()
            notEofOrValue(}, void)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, ConfigurationService)
              parseMetadataStar(})
                listener: beginMetadataStar(void)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'VoidType', set, configuration, DeclarationKind.Class, ConfigurationService, false)
                listener: beginMethod(null, null, null, null, set, configuration)
                listener: handleVoidKeyword(void)
                ensureIdentifierPotentiallyRecovered(set, methodDeclaration, false)
                  listener: handleIdentifier(configuration, methodDeclaration)
                parseQualifiedRestOpt(configuration, methodDeclarationContinuation)
                listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(configuration, configuration, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(configuration, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(Configuration)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(Configuration, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleIdentifier(Configuration, typeReference)
                        listener: handleNoTypeArguments(configuration)
                        listener: handleType(Configuration, null)
                        ensureIdentifier(Configuration, formalParameterDeclaration)
                          listener: handleIdentifier(configuration, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, configuration, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  parseInitializers(:)
                    listener: beginInitializers(:)
                    parseInitializer(:)
                      listener: beginInitializer(assert)
                      parseAssert(:, Assert.Initializer)
                        listener: beginAssert(assert, Assert.Initializer)
                        parseExpression(()
                          parsePrecedenceExpression((, 1, true)
                            parseUnaryExpression((, true)
                              parsePrimary((, expression)
                                parseSendOrFunctionLiteral((, expression)
                                  parseSend((, expression)
                                    isNextIdentifier(()
                                    ensureIdentifier((, expression)
                                      listener: handleIdentifier(configuration, expression)
                                    listener: handleNoTypeArguments(!=)
                                    parseArgumentsOpt(configuration)
                                      listener: handleNoArguments(!=)
                                    listener: handleSend(configuration, !=)
                            listener: beginBinaryExpression(!=)
                            parsePrecedenceExpression(!=, 8, true)
                              parseUnaryExpression(!=, true)
                                parsePrimary(!=, expression)
                                  parseLiteralNull(!=)
                                    listener: handleLiteralNull(null)
                            listener: endBinaryExpression(!=)
                        listener: endAssert(assert, Assert.Initializer, (, null, ,)
                      listener: endInitializer(,)
                    parseInitializer(,)
                      listener: beginInitializer(_configuration)
                      parseInitializerExpressionRest(,)
                        parseExpression(,)
                          parsePrecedenceExpression(,, 1, true)
                            parseUnaryExpression(,, true)
                              parsePrimary(,, expression)
                                parseSendOrFunctionLiteral(,, expression)
                                  parseSend(,, expression)
                                    isNextIdentifier(,)
                                    ensureIdentifier(,, expression)
                                      listener: handleIdentifier(_configuration, expression)
                                    listener: handleNoTypeArguments(=)
                                    parseArgumentsOpt(_configuration)
                                      listener: handleNoArguments(=)
                                    listener: handleSend(_configuration, =)
                            parsePrecedenceExpression(=, 1, true)
                              parseUnaryExpression(=, true)
                                parsePrimary(=, expression)
                                  parseSendOrFunctionLiteral(=, expression)
                                    parseSend(=, expression)
                                      isNextIdentifier(=)
                                      ensureIdentifier(=, expression)
                                        listener: handleIdentifier(configuration, expression)
                                      listener: handleNoTypeArguments({)
                                      parseArgumentsOpt(configuration)
                                        listener: handleNoArguments({)
                                      listener: handleSend(configuration, {)
                            listener: handleAssignmentExpression(=)
                        listener: endInitializer({)
                    listener: endInitializers(2, :, {)
                parseAsyncModifierOpt(configuration)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                inPlainSync()
                parseFunctionBody(configuration, false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(0, {, })
                reportRecoverableError(configuration, ConstructorWithWrongName)
                  listener: handleRecoverableError(ConstructorWithWrongName, configuration, configuration)
                reportRecoverableError(set, SetterConstructor)
                  listener: handleRecoverableError(SetterConstructor, set, set)
                reportRecoverableError(void, ConstructorWithReturnType)
                  listener: handleRecoverableError(ConstructorWithReturnType, void, void)
                listener: endClassConstructor(set, void, (, :, })
              listener: endMember()
            notEofOrValue(}, Configuration)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, ConfigurationService)
              parseMetadataStar(})
                listener: beginMetadataStar(Configuration)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', get, configuration, DeclarationKind.Class, ConfigurationService, false)
                listener: beginMethod(null, null, null, null, get, configuration)
                listener: handleIdentifier(Configuration, typeReference)
                listener: handleNoTypeArguments(get)
                listener: handleType(Configuration, null)
                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
                  listener: handleIdentifier(configuration, methodDeclaration)
                parseQualifiedRestOpt(configuration, methodDeclarationContinuation)
                listener: handleNoTypeVariables(:)
                parseGetterOrFormalParameters(configuration, configuration, false, MemberKind.NonStaticMethod)
                  missingParameterMessage(MemberKind.NonStaticMethod)
                  reportRecoverableError(configuration, MissingMethodParameters)
                    listener: handleRecoverableError(MissingMethodParameters, configuration, configuration)
                  rewriter()
                  parseFormalParametersRest((, MemberKind.NonStaticMethod)
                    listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                    listener: endFormalParameters(0, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  parseInitializers(:)
                    listener: beginInitializers(:)
                    parseInitializer(:)
                      listener: beginInitializer(assert)
                      parseAssert(:, Assert.Initializer)
                        listener: beginAssert(assert, Assert.Initializer)
                        parseExpression(()
                          parsePrecedenceExpression((, 1, true)
                            parseUnaryExpression((, true)
                              parsePrimary((, expression)
                                parseSendOrFunctionLiteral((, expression)
                                  parseSend((, expression)
                                    isNextIdentifier(()
                                    ensureIdentifier((, expression)
                                      listener: handleIdentifier(_configuration, expression)
                                    listener: handleNoTypeArguments(!=)
                                    parseArgumentsOpt(_configuration)
                                      listener: handleNoArguments(!=)
                                    listener: handleSend(_configuration, !=)
                            listener: beginBinaryExpression(!=)
                            parsePrecedenceExpression(!=, 8, true)
                              parseUnaryExpression(!=, true)
                                parsePrimary(!=, expression)
                                  parseLiteralNull(!=)
                                    listener: handleLiteralNull(null)
                            listener: endBinaryExpression(!=)
                        listener: endAssert(assert, Assert.Initializer, (, null, ,)
                      listener: endInitializer(,)
                    parseInitializer(,)
                      listener: beginInitializer(_configuration)
                      parseInitializerExpressionRest(,)
                        parseExpression(,)
                          parsePrecedenceExpression(,, 1, true)
                            parseUnaryExpression(,, true)
                              parsePrimary(,, expression)
                                parseSendOrFunctionLiteral(,, expression)
                                  parseSend(,, expression)
                                    isNextIdentifier(,)
                                    ensureIdentifier(,, expression)
                                      listener: handleIdentifier(_configuration, expression)
                                    listener: handleNoTypeArguments(=)
                                    parseArgumentsOpt(_configuration)
                                      listener: handleNoArguments(=)
                                    listener: handleSend(_configuration, =)
                            parsePrecedenceExpression(=, 1, true)
                              parseUnaryExpression(=, true)
                                parsePrimary(=, expression)
                                  parseSendOrFunctionLiteral(=, expression)
                                    parseSend(=, expression)
                                      isNextIdentifier(=)
                                      ensureIdentifier(=, expression)
                                        listener: handleIdentifier(_configuration, expression)
                                      listener: handleNoTypeArguments(.)
                                      parseArgumentsOpt(_configuration)
                                        listener: handleNoArguments(.)
                                      listener: handleSend(_configuration, .)
                              parsePrimary(., expressionContinuation)
                                parseSendOrFunctionLiteral(., expressionContinuation)
                                  parseSend(., expressionContinuation)
                                    isNextIdentifier(.)
                                    ensureIdentifier(., expressionContinuation)
                                      listener: handleIdentifier(foo, expressionContinuation)
                                    listener: handleNoTypeArguments({)
                                    parseArgumentsOpt(foo)
                                      listener: handleNoArguments({)
                                    listener: handleSend(foo, {)
                              listener: handleEndingBinaryExpression(.)
                            listener: handleAssignmentExpression(=)
                        listener: endInitializer({)
                    listener: endInitializers(2, :, {)
                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)
                                parseSendOrFunctionLiteral(return, expression)
                                  parseSend(return, expression)
                                    isNextIdentifier(return)
                                    ensureIdentifier(return, expression)
                                      listener: handleIdentifier(_configuration, expression)
                                    listener: handleNoTypeArguments(;)
                                    parseArgumentsOpt(_configuration)
                                      listener: handleNoArguments(;)
                                    listener: handleSend(_configuration, ;)
                        ensureSemicolon(_configuration)
                        listener: endReturnStatement(true, return, ;)
                        inGenerator()
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(1, {, })
                reportRecoverableError(configuration, ConstructorWithWrongName)
                  listener: handleRecoverableError(ConstructorWithWrongName, configuration, configuration)
                reportRecoverableError(get, GetterConstructor)
                  listener: handleRecoverableError(GetterConstructor, get, get)
                reportRecoverableError(Configuration, ConstructorWithReturnType)
                  listener: handleRecoverableError(ConstructorWithReturnType, Configuration, Configuration)
                listener: endClassConstructor(get, Configuration, (, :, })
              listener: endMember()
            notEofOrValue(}, void)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, ConfigurationService)
              parseMetadataStar(})
                listener: beginMetadataStar(void)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'VoidType', null, method, DeclarationKind.Class, ConfigurationService, false)
                listener: beginMethod(null, null, null, null, null, method)
                listener: handleVoidKeyword(void)
                ensureIdentifierPotentiallyRecovered(void, methodDeclaration, false)
                  listener: handleIdentifier(method, methodDeclaration)
                parseQualifiedRestOpt(method, methodDeclarationContinuation)
                parseMethodTypeVar(method)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(method, method, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(method, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(0, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  parseInitializers(:)
                    listener: beginInitializers(:)
                    parseInitializer(:)
                      listener: beginInitializer(_configuration)
                      parseInitializerExpressionRest(:)
                        parseExpression(:)
                          parsePrecedenceExpression(:, 1, true)
                            parseUnaryExpression(:, true)
                              parsePrimary(:, expression)
                                parseSendOrFunctionLiteral(:, expression)
                                  parseSend(:, expression)
                                    isNextIdentifier(:)
                                    ensureIdentifier(:, expression)
                                      listener: handleIdentifier(_configuration, expression)
                                    listener: handleNoTypeArguments(=)
                                    parseArgumentsOpt(_configuration)
                                      listener: handleNoArguments(=)
                                    listener: handleSend(_configuration, =)
                            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: beginBlockFunctionBody({)
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(0, {, })
                reportRecoverableError(method, ConstructorWithWrongName)
                  listener: handleRecoverableError(ConstructorWithWrongName, method, method)
                reportRecoverableError(void, ConstructorWithReturnType)
                  listener: handleRecoverableError(ConstructorWithReturnType, void, void)
                listener: endClassConstructor(null, void, (, :, })
              listener: endMember()
            notEofOrValue(}, Foo)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, ConfigurationService)
              parseMetadataStar(})
                listener: beginMetadataStar(Foo)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'NoType', null, Foo, DeclarationKind.Class, ConfigurationService, 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(_configuration)
                      parseInitializerExpressionRest(:)
                        parseExpression(:)
                          parsePrecedenceExpression(:, 1, true)
                            parseUnaryExpression(:, true)
                              parsePrimary(:, expression)
                                parseSendOrFunctionLiteral(:, expression)
                                  parseSend(:, expression)
                                    isNextIdentifier(:)
                                    ensureIdentifier(:, expression)
                                      listener: handleIdentifier(_configuration, expression)
                                    listener: handleNoTypeArguments(=)
                                    parseArgumentsOpt(_configuration)
                                      listener: handleNoArguments(=)
                                    listener: handleSend(_configuration, =)
                            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: beginBlockFunctionBody({)
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(0, {, })
                reportRecoverableError(Foo, ConstructorWithWrongName)
                  listener: handleRecoverableError(ConstructorWithWrongName, Foo, Foo)
                listener: endClassConstructor(null, Foo, (, :, })
              listener: endMember()
            notEofOrValue(}, })
            listener: endClassOrMixinBody(DeclarationKind.Class, 6, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(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(Configuration, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, Configuration)
        parseClass(Configuration, class, class, Configuration)
          parseClassHeaderOpt(Configuration, class, class)
            parseClassExtendsOpt(Configuration)
              listener: handleNoType(Configuration)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(Configuration)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(Configuration)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(Configuration, DeclarationKind.Class, Configuration)
            listener: beginClassOrMixinBody(DeclarationKind.Class, {)
            notEofOrValue(}, Configuration)
            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, Configuration)
              parseMetadataStar({)
                listener: beginMetadataStar(Configuration)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod({, null, null, null, null, null, null, {, Instance of 'SimpleType', get, foo, DeclarationKind.Class, Configuration, false)
                listener: beginMethod(null, null, null, null, get, foo)
                listener: handleIdentifier(Configuration, typeReference)
                listener: handleNoTypeArguments(get)
                listener: handleType(Configuration, null)
                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)
                            parseThisExpression(=>, expression)
                              listener: handleThisExpression(this, expression)
                    ensureSemicolon(this)
                    listener: handleExpressionFunctionBody(=>, ;)
                    inGenerator()
                listener: endClassMethod(get, Configuration, =>, null, ;)
              listener: endMember()
            notEofOrValue(}, })
            listener: endClassOrMixinBody(DeclarationKind.Class, 1, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration()
  reportAllErrorTokens(class)
  listener: endCompilationUnit(2, )