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(A, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, A)
        parseClass(A, class, class, A)
          parseClassHeaderOpt(A, class, class)
            parseClassExtendsOpt(A)
              listener: handleNoType(A)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(A)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(A)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(A, DeclarationKind.Class, A)
            listener: beginClassOrMixinBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(extension)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(extension)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, extension, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(}, extension)
      parseExtension(extension)
        listener: beginExtensionDeclarationPrelude(extension)
        listener: handleNoTypeVariables(on)
        listener: beginExtensionDeclaration(extension, type)
        listener: handleIdentifier(A, typeReference)
        listener: handleNoTypeArguments({)
        listener: handleType(A, null)
        parseClassOrMixinOrExtensionBody(A, DeclarationKind.Extension, type)
          listener: beginClassOrMixinBody(DeclarationKind.Extension, {)
          notEofOrValue(}, method)
          parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Extension, type)
            parseMetadataStar({)
              listener: beginMetadataStar(method)
              listener: endMetadataStar(0)
            listener: beginMember()
            isReservedKeyword(()
            parseMethod({, null, null, null, null, null, null, {, Instance of 'NoType', null, method, DeclarationKind.Extension, type, false)
              listener: beginMethod(null, null, null, null, null, method)
              listener: handleNoType({)
              ensureIdentifierPotentiallyRecovered({, methodDeclaration, false)
                listener: handleIdentifier(method, methodDeclaration)
              parseQualifiedRestOpt(method, methodDeclarationContinuation)
              parseMethodTypeVar(method)
                listener: handleNoTypeVariables(()
              parseGetterOrFormalParameters(method, method, false, MemberKind.ExtensionNonStaticMethod)
                parseFormalParameters(method, MemberKind.ExtensionNonStaticMethod)
                  parseFormalParametersRest((, MemberKind.ExtensionNonStaticMethod)
                    listener: beginFormalParameters((, MemberKind.ExtensionNonStaticMethod)
                    listener: endFormalParameters(0, (, ), MemberKind.ExtensionNonStaticMethod)
              parseInitializersOpt())
                listener: handleNoInitializers()
              parseAsyncModifierOpt())
                listener: handleAsyncModifier(null, null)
                inPlainSync()
              inPlainSync()
              parseFunctionBody(), false, true)
                listener: beginBlockFunctionBody({)
                notEofOrValue(}, })
                listener: endBlockFunctionBody(0, {, })
              listener: endExtensionMethod(null, method, (, null, })
            listener: endMember()
          notEofOrValue(}, })
          listener: endClassOrMixinBody(DeclarationKind.Extension, 1, {, })
        listener: endExtensionDeclaration(extension, null, on, })
  listener: endTopLevelDeclaration(test)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(test)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(test)
      isReservedKeyword(()
      parseTopLevelMethod(}, null, }, Instance of 'NoType', null, test, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleNoType(})
        ensureIdentifierPotentiallyRecovered(}, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(test, topLevelFunctionDeclaration)
        parseMethodTypeVar(test)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(test, test, false, MemberKind.TopLevelMethod)
          parseFormalParameters(test, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(A)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(A, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(A, typeReference)
                listener: handleNoTypeArguments(a)
                listener: handleType(A, null)
                ensureIdentifier(A, formalParameterDeclaration)
                  listener: handleIdentifier(a, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, a, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          parseExpressionFunctionBody(=>, false)
            parseExpression(=>)
              parsePrecedenceExpression(=>, 1, true)
                parseUnaryExpression(=>, true)
                  parsePrimary(=>, expression)
                    parseSendOrFunctionLiteral(=>, expression)
                      looksLikeFunctionBody(.)
                      parseSend(=>, expression)
                        isNextIdentifier(=>)
                        ensureIdentifier(=>, expression)
                          listener: handleIdentifier(type, expression)
                        listener: handleNoTypeArguments(()
                        parseArgumentsOpt(type)
                          parseArguments(type)
                            parseArgumentsRest(()
                              listener: beginArguments(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseNewExpression(()
                                        isNextIdentifier(new)
                                        listener: beginNewExpression(new)
                                        parseConstructorReference(new, null)
                                          ensureIdentifier(new, constructorReference)
                                            listener: handleIdentifier(A, constructorReference)
                                          listener: beginConstructorReference(A)
                                          parseQualifiedRestOpt(A, constructorReferenceContinuation)
                                          listener: handleNoTypeArguments(()
                                          listener: handleNoConstructorReferenceContinuationAfterTypeArguments(()
                                          listener: endConstructorReference(A, null, ()
                                        parseConstructorInvocationArguments(A)
                                          parseArgumentsRest(()
                                            listener: beginArguments(()
                                            listener: endArguments(0, (, ))
                                        listener: endNewExpression(new)
                              listener: endArguments(1, (, ))
                        listener: handleSend(type, .)
                parsePrimary(., expressionContinuation)
                  parseSendOrFunctionLiteral(., expressionContinuation)
                    looksLikeFunctionBody(;)
                    parseSend(., expressionContinuation)
                      isNextIdentifier(.)
                      ensureIdentifier(., expressionContinuation)
                        listener: handleIdentifier(method, expressionContinuation)
                      listener: handleNoTypeArguments(()
                      parseArgumentsOpt(method)
                        parseArguments(method)
                          parseArgumentsRest(()
                            listener: beginArguments(()
                            listener: endArguments(0, (, ))
                      listener: handleSend(method, ;)
                listener: handleEndingBinaryExpression(.)
            ensureSemicolon())
            listener: handleExpressionFunctionBody(=>, ;)
            inGenerator()
        listener: endTopLevelMethod(test, null, ;)
  listener: endTopLevelDeclaration()
  reportAllErrorTokens(class)
  listener: endCompilationUnit(3, )