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(C, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, C)
        parseClass(C, class, class, C)
          parseClassHeaderOpt(C, class, class)
            parseClassExtendsOpt(C)
              listener: handleNoType(C)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(C)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(C)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(C, DeclarationKind.Class, C)
            listener: beginClassOrMixinBody(DeclarationKind.Class, {)
            notEofOrValue(}, C)
            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, C)
              parseMetadataStar({)
                listener: beginMetadataStar(C)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(()
              parseMethod({, null, null, null, null, null, null, {, Instance of 'NoType', null, C, DeclarationKind.Class, C, false)
                listener: beginMethod(null, null, null, null, null, C)
                listener: handleNoType({)
                ensureIdentifierPotentiallyRecovered({, methodDeclaration, false)
                  listener: handleIdentifier(C, methodDeclaration)
                parseQualifiedRestOpt(C, methodDeclarationContinuation)
                parseMethodTypeVar(C)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(C, C, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(C, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseOptionalNamedParameters((, MemberKind.NonStaticMethod)
                        listener: beginOptionalFormalParameters({)
                        parseFormalParameter({, FormalParameterKind.optionalNamed, MemberKind.NonStaticMethod)
                          parseMetadataStar({)
                            listener: beginMetadataStar(c)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(c, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleNoType({)
                          ensureIdentifier({, formalParameterDeclaration)
                            listener: handleIdentifier(c, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue(})
                          listener: endFormalParameter(null, null, c, null, null, FormalParameterKind.optionalNamed, MemberKind.NonStaticMethod)
                        listener: endOptionalFormalParameters(1, {, })
                      ensureCloseParen(}, ()
                      listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: handleEmptyFunctionBody(;)
                listener: endClassConstructor(null, C, (, null, ;)
              listener: endMember()
            notEofOrValue(}, C)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, C)
              parseMetadataStar(;)
                listener: beginMetadataStar(C)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', null, m, DeclarationKind.Class, C, false)
                listener: beginMethod(null, null, null, null, null, m)
                listener: handleIdentifier(C, typeReference)
                listener: handleNoTypeArguments(m)
                listener: handleType(C, null)
                ensureIdentifierPotentiallyRecovered(C, methodDeclaration, false)
                  listener: handleIdentifier(m, methodDeclaration)
                parseQualifiedRestOpt(m, methodDeclarationContinuation)
                parseMethodTypeVar(m)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(m, m, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(m, 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(}, return)
                  parseStatement({)
                    parseStatementX({)
                      parseReturnStatement({)
                        listener: beginReturnStatement(return)
                        parseExpression(return)
                          parsePrecedenceExpression(return, 1, true)
                            parseUnaryExpression(return, true)
                              parsePrimary(return, expression)
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(;)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      listener: handleIdentifier(C, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(C)
                                      parseArguments(C)
                                        parseArgumentsRest(()
                                          listener: beginArguments(()
                                          ensureIdentifier((, namedArgumentReference)
                                            listener: handleIdentifier(c, namedArgumentReference)
                                          parseExpression(:)
                                            parsePrecedenceExpression(:, 1, true)
                                              parseUnaryExpression(:, true)
                                                parsePrimary(:, expression)
                                                  listener: handleNoTypeArguments([)
                                                  parseLiteralListSuffix(:, null)
                                                    parseExpression([)
                                                      parsePrecedenceExpression([, 1, true)
                                                        parseUnaryExpression([, true)
                                                          parsePrimary([, expression)
                                                            parseSendOrFunctionLiteral([, expression)
                                                              looksLikeFunctionBody(,)
                                                              parseSend([, expression)
                                                                ensureIdentifier([, expression)
                                                                  listener: handleIdentifier(C, expression)
                                                                listener: handleNoTypeArguments(()
                                                                parseArgumentsOpt(C)
                                                                  parseArguments(C)
                                                                    parseArgumentsRest(()
                                                                      listener: beginArguments(()
                                                                      ensureIdentifier((, namedArgumentReference)
                                                                        listener: handleIdentifier(c, namedArgumentReference)
                                                                      parseExpression(:)
                                                                        parsePrecedenceExpression(:, 1, true)
                                                                          parseUnaryExpression(:, true)
                                                                            parsePrimary(:, expression)
                                                                              listener: handleNoTypeArguments([)
                                                                              parseLiteralListSuffix(:, null)
                                                                                parseExpression([)
                                                                                  parsePrecedenceExpression([, 1, true)
                                                                                    parseUnaryExpression([, true)
                                                                                      parsePrimary([, expression)
                                                                                        parseSendOrFunctionLiteral([, expression)
                                                                                          looksLikeFunctionBody(,)
                                                                                          parseSend([, expression)
                                                                                            ensureIdentifier([, expression)
                                                                                              listener: handleIdentifier(C, expression)
                                                                                            listener: handleNoTypeArguments(()
                                                                                            parseArgumentsOpt(C)
                                                                                              parseArguments(C)
                                                                                                parseArgumentsRest(()
                                                                                                  listener: beginArguments(()
                                                                                                  listener: endArguments(0, (, ))
                                                                                            listener: handleSend(C, ,)
                                                                                parseExpression(,)
                                                                                  parsePrecedenceExpression(,, 1, true)
                                                                                    parseUnaryExpression(,, true)
                                                                                      parsePrimary(,, expression)
                                                                                        parseSendOrFunctionLiteral(,, expression)
                                                                                          looksLikeFunctionBody(,)
                                                                                          parseSend(,, expression)
                                                                                            ensureIdentifier(,, expression)
                                                                                              listener: handleIdentifier(C, expression)
                                                                                            listener: handleNoTypeArguments(()
                                                                                            parseArgumentsOpt(C)
                                                                                              parseArguments(C)
                                                                                                parseArgumentsRest(()
                                                                                                  listener: beginArguments(()
                                                                                                  listener: endArguments(0, (, ))
                                                                                            listener: handleSend(C, ,)
                                                                                parseExpression(,)
                                                                                  parsePrecedenceExpression(,, 1, true)
                                                                                    parseUnaryExpression(,, true)
                                                                                      parsePrimary(,, expression)
                                                                                        parseSendOrFunctionLiteral(,, expression)
                                                                                          looksLikeFunctionBody(,)
                                                                                          parseSend(,, expression)
                                                                                            ensureIdentifier(,, expression)
                                                                                              listener: handleIdentifier(C, expression)
                                                                                            listener: handleNoTypeArguments(()
                                                                                            parseArgumentsOpt(C)
                                                                                              parseArguments(C)
                                                                                                parseArgumentsRest(()
                                                                                                  listener: beginArguments(()
                                                                                                  listener: endArguments(0, (, ))
                                                                                            listener: handleSend(C, ,)
                                                                                listener: handleLiteralList(3, [, null, ])
                                                                      listener: handleNamedArgument(:)
                                                                      listener: endArguments(1, (, ))
                                                                listener: handleSend(C, ,)
                                                    parseExpression(,)
                                                      parsePrecedenceExpression(,, 1, true)
                                                        parseUnaryExpression(,, true)
                                                          parsePrimary(,, expression)
                                                            parseSendOrFunctionLiteral(,, expression)
                                                              looksLikeFunctionBody(,)
                                                              parseSend(,, expression)
                                                                ensureIdentifier(,, expression)
                                                                  listener: handleIdentifier(C, expression)
                                                                listener: handleNoTypeArguments(()
                                                                parseArgumentsOpt(C)
                                                                  parseArguments(C)
                                                                    parseArgumentsRest(()
                                                                      listener: beginArguments(()
                                                                      listener: endArguments(0, (, ))
                                                                listener: handleSend(C, ,)
                                                    parseExpression(,)
                                                      parsePrecedenceExpression(,, 1, true)
                                                        parseUnaryExpression(,, true)
                                                          parsePrimary(,, expression)
                                                            parseSendOrFunctionLiteral(,, expression)
                                                              looksLikeFunctionBody(,)
                                                              parseSend(,, expression)
                                                                ensureIdentifier(,, expression)
                                                                  listener: handleIdentifier(C, expression)
                                                                listener: handleNoTypeArguments(()
                                                                parseArgumentsOpt(C)
                                                                  parseArguments(C)
                                                                    parseArgumentsRest(()
                                                                      listener: beginArguments(()
                                                                      listener: endArguments(0, (, ))
                                                                listener: handleSend(C, ,)
                                                    listener: handleLiteralList(3, [, null, ])
                                          listener: handleNamedArgument(:)
                                          listener: endArguments(1, (, ))
                                    listener: handleSend(C, ;)
                        ensureSemicolon())
                        listener: endReturnStatement(true, return, ;)
                        inGenerator()
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(1, {, })
                listener: endClassMethod(null, C, (, null, })
              listener: endMember()
            notEofOrValue(}, })
            listener: endClassOrMixinBody(DeclarationKind.Class, 2, {, })
          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(D, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, D)
        parseClass(D, class, class, D)
          parseClassHeaderOpt(D, class, class)
            parseClassExtendsOpt(D)
              listener: handleNoType(D)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(D)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(D)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(D, DeclarationKind.Class, D)
            listener: beginClassOrMixinBody(DeclarationKind.Class, {)
            notEofOrValue(}, D)
            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, D)
              parseMetadataStar({)
                listener: beginMetadataStar(D)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(()
              parseMethod({, null, null, null, null, null, null, {, Instance of 'NoType', null, D, DeclarationKind.Class, D, false)
                listener: beginMethod(null, null, null, null, null, D)
                listener: handleNoType({)
                ensureIdentifierPotentiallyRecovered({, methodDeclaration, false)
                  listener: handleIdentifier(D, methodDeclaration)
                parseQualifiedRestOpt(D, methodDeclarationContinuation)
                parseMethodTypeVar(D)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(D, D, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(D, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseOptionalNamedParameters((, MemberKind.NonStaticMethod)
                        listener: beginOptionalFormalParameters({)
                        parseFormalParameter({, FormalParameterKind.optionalNamed, MemberKind.NonStaticMethod)
                          parseMetadataStar({)
                            listener: beginMetadataStar(d)
                            listener: endMetadataStar(0)
                          listener: beginFormalParameter(d, MemberKind.NonStaticMethod, null, null, null)
                          listener: handleNoType({)
                          ensureIdentifier({, formalParameterDeclaration)
                            listener: handleIdentifier(d, formalParameterDeclaration)
                          listener: handleFormalParameterWithoutValue(})
                          listener: endFormalParameter(null, null, d, null, null, FormalParameterKind.optionalNamed, MemberKind.NonStaticMethod)
                        listener: endOptionalFormalParameters(1, {, })
                      ensureCloseParen(}, ()
                      listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: handleEmptyFunctionBody(;)
                listener: endClassConstructor(null, D, (, null, ;)
              listener: endMember()
            notEofOrValue(}, D)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, D)
              parseMetadataStar(;)
                listener: beginMetadataStar(D)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', null, m, DeclarationKind.Class, D, false)
                listener: beginMethod(null, null, null, null, null, m)
                listener: handleIdentifier(D, typeReference)
                listener: handleNoTypeArguments(m)
                listener: handleType(D, null)
                ensureIdentifierPotentiallyRecovered(D, methodDeclaration, false)
                  listener: handleIdentifier(m, methodDeclaration)
                parseQualifiedRestOpt(m, methodDeclarationContinuation)
                parseMethodTypeVar(m)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(m, m, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(m, 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(}, return)
                  parseStatement({)
                    parseStatementX({)
                      parseReturnStatement({)
                        listener: beginReturnStatement(return)
                        parseExpression(return)
                          parsePrecedenceExpression(return, 1, true)
                            parseUnaryExpression(return, true)
                              parsePrimary(return, expression)
                                parseSendOrFunctionLiteral(return, expression)
                                  looksLikeFunctionBody(;)
                                  parseSend(return, expression)
                                    ensureIdentifier(return, expression)
                                      listener: handleIdentifier(D, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(D)
                                      parseArguments(D)
                                        parseArgumentsRest(()
                                          listener: beginArguments(()
                                          ensureIdentifier((, namedArgumentReference)
                                            listener: handleIdentifier(d, namedArgumentReference)
                                          parseExpression(:)
                                            parsePrecedenceExpression(:, 1, true)
                                              parseUnaryExpression(:, true)
                                                parsePrimary(:, expression)
                                                  listener: handleNoTypeArguments([)
                                                  parseLiteralListSuffix(:, null)
                                                    parseExpression([)
                                                      parsePrecedenceExpression([, 1, true)
                                                        parseUnaryExpression([, true)
                                                          parsePrimary([, expression)
                                                            parseSendOrFunctionLiteral([, expression)
                                                              looksLikeFunctionBody(,)
                                                              parseSend([, expression)
                                                                ensureIdentifier([, expression)
                                                                  listener: handleIdentifier(D, expression)
                                                                listener: handleNoTypeArguments(()
                                                                parseArgumentsOpt(D)
                                                                  parseArguments(D)
                                                                    parseArgumentsRest(()
                                                                      listener: beginArguments(()
                                                                      ensureIdentifier((, namedArgumentReference)
                                                                        listener: handleIdentifier(d, namedArgumentReference)
                                                                      parseExpression(:)
                                                                        parsePrecedenceExpression(:, 1, true)
                                                                          parseUnaryExpression(:, true)
                                                                            parsePrimary(:, expression)
                                                                              parseSendOrFunctionLiteral(:, expression)
                                                                                looksLikeFunctionBody(,)
                                                                                parseSend(:, expression)
                                                                                  ensureIdentifier(:, expression)
                                                                                    listener: handleIdentifier(D, expression)
                                                                                  listener: handleNoTypeArguments(()
                                                                                  parseArgumentsOpt(D)
                                                                                    parseArguments(D)
                                                                                      parseArgumentsRest(()
                                                                                        listener: beginArguments(()
                                                                                        listener: endArguments(0, (, ))
                                                                                  listener: handleSend(D, ,)
                                                                      listener: handleNamedArgument(:)
                                                                      reportRecoverableError(D, PositionalAfterNamedArgument)
                                                                        listener: handleRecoverableError(PositionalAfterNamedArgument, D, D)
                                                                      parseExpression(,)
                                                                        parsePrecedenceExpression(,, 1, true)
                                                                          parseUnaryExpression(,, true)
                                                                            parsePrimary(,, expression)
                                                                              parseSendOrFunctionLiteral(,, expression)
                                                                                looksLikeFunctionBody(,)
                                                                                parseSend(,, expression)
                                                                                  ensureIdentifier(,, expression)
                                                                                    listener: handleIdentifier(D, expression)
                                                                                  listener: handleNoTypeArguments(()
                                                                                  parseArgumentsOpt(D)
                                                                                    parseArguments(D)
                                                                                      parseArgumentsRest(()
                                                                                        listener: beginArguments(()
                                                                                        listener: endArguments(0, (, ))
                                                                                  listener: handleSend(D, ,)
                                                                      reportRecoverableError(D, PositionalAfterNamedArgument)
                                                                        listener: handleRecoverableError(PositionalAfterNamedArgument, D, D)
                                                                      parseExpression(,)
                                                                        parsePrecedenceExpression(,, 1, true)
                                                                          parseUnaryExpression(,, true)
                                                                            parsePrimary(,, expression)
                                                                              parseSendOrFunctionLiteral(,, expression)
                                                                                looksLikeFunctionBody(,)
                                                                                parseSend(,, expression)
                                                                                  ensureIdentifier(,, expression)
                                                                                    listener: handleIdentifier(D, expression)
                                                                                  listener: handleNoTypeArguments(()
                                                                                  parseArgumentsOpt(D)
                                                                                    parseArguments(D)
                                                                                      parseArgumentsRest(()
                                                                                        listener: beginArguments(()
                                                                                        listener: endArguments(0, (, ))
                                                                                  listener: handleSend(D, ,)
                                                                      reportRecoverableError(], PositionalAfterNamedArgument)
                                                                        listener: handleRecoverableError(PositionalAfterNamedArgument, ], ])
                                                                      parseExpression(,)
                                                                        parsePrecedenceExpression(,, 1, true)
                                                                          parseUnaryExpression(,, true)
                                                                            parsePrimary(,, expression)
                                                                              parseSend(,, expression)
                                                                                ensureIdentifier(,, expression)
                                                                                  reportRecoverableErrorWithToken(], Instance of 'Template<(Token) => Message>')
                                                                                    listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ']'., Try inserting an identifier before ']'., {token: ]}], ], ])
                                                                                  rewriter()
                                                                                  listener: handleIdentifier(, expression)
                                                                                listener: handleNoTypeArguments(])
                                                                                parseArgumentsOpt()
                                                                                  listener: handleNoArguments(])
                                                                                listener: handleSend(, ])
                                                                      ensureCloseParen(, ()
                                                                        reportRecoverableError(], Message[ExpectedButGot, Expected ')' before this., null, {string: )}])
                                                                          listener: handleRecoverableError(Message[ExpectedButGot, Expected ')' before this., null, {string: )}], ], ])
                                                                      listener: endArguments(4, (, ))
                                                                listener: handleSend(D, ,)
                                                    parseExpression(,)
                                                      parsePrecedenceExpression(,, 1, true)
                                                        parseUnaryExpression(,, true)
                                                          parsePrimary(,, expression)
                                                            parseSendOrFunctionLiteral(,, expression)
                                                              looksLikeFunctionBody(,)
                                                              parseSend(,, expression)
                                                                ensureIdentifier(,, expression)
                                                                  listener: handleIdentifier(D, expression)
                                                                listener: handleNoTypeArguments(()
                                                                parseArgumentsOpt(D)
                                                                  parseArguments(D)
                                                                    parseArgumentsRest(()
                                                                      listener: beginArguments(()
                                                                      listener: endArguments(0, (, ))
                                                                listener: handleSend(D, ,)
                                                    parseExpression(,)
                                                      parsePrecedenceExpression(,, 1, true)
                                                        parseUnaryExpression(,, true)
                                                          parsePrimary(,, expression)
                                                            parseSendOrFunctionLiteral(,, expression)
                                                              looksLikeFunctionBody(,)
                                                              parseSend(,, expression)
                                                                ensureIdentifier(,, expression)
                                                                  listener: handleIdentifier(D, expression)
                                                                listener: handleNoTypeArguments(()
                                                                parseArgumentsOpt(D)
                                                                  parseArguments(D)
                                                                    parseArgumentsRest(()
                                                                      listener: beginArguments(()
                                                                      listener: endArguments(0, (, ))
                                                                listener: handleSend(D, ,)
                                                    listener: handleLiteralList(3, [, null, ])
                                          listener: handleNamedArgument(:)
                                          listener: endArguments(1, (, ))
                                    listener: handleSend(D, ;)
                        ensureSemicolon())
                        listener: endReturnStatement(true, return, ;)
                        inGenerator()
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(1, {, })
                listener: endClassMethod(null, D, (, null, })
              listener: endMember()
            notEofOrValue(}, })
            listener: endClassOrMixinBody(DeclarationKind.Class, 2, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration()
  reportAllErrorTokens(class)
  listener: endCompilationUnit(2, )