parseUnit(const)
  skipErrorTokens(const)
  listener: beginCompilationUnit(const)
  syntheticPreviousToken(const)
  parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext')
    parseMetadataStar()
      listener: beginMetadataStar(const)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl()
      listener: beginTopLevelMember(const)
      parseFields(, null, null, null, null, null, const, const, Instance of 'NoType', annotation, DeclarationKind.TopLevel, null, false)
        listener: beginFields()
        listener: handleNoType(const)
        ensureIdentifierPotentiallyRecovered(const, topLevelVariableDeclaration, false)
          listener: handleIdentifier(annotation, topLevelVariableDeclaration)
        parseFieldInitializerOpt(annotation, annotation, null, null, null, const, DeclarationKind.TopLevel, null)
          listener: beginFieldInitializer(=)
          parseExpression(=)
            parsePrecedenceExpression(=, 1, true)
              parseUnaryExpression(=, true)
                parsePrimary(=, expression)
                  parseLiteralNull(=)
                    listener: handleLiteralNull(null)
          listener: endFieldInitializer(=, ;)
        listener: endTopLevelFields(null, null, null, null, const, 1, const, ;)
  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(Annotation, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, Annotation)
        parseClass(Annotation, class, class, Annotation)
          parseClassHeaderOpt(Annotation, class, class)
            parseClassExtendsOpt(Annotation)
              listener: handleNoType(Annotation)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(Annotation)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(Annotation)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(Annotation, DeclarationKind.Class, Annotation)
            listener: beginClassOrMixinBody(DeclarationKind.Class, {)
            notEofOrValue(}, final)
            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, Annotation)
              parseMetadataStar({)
                listener: beginMetadataStar(final)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields({, null, null, null, null, null, final, final, Instance of 'SimpleType', message, DeclarationKind.Class, Annotation, false)
                listener: beginFields({)
                listener: handleIdentifier(String, typeReference)
                listener: handleNoTypeArguments(message)
                listener: handleType(String, null)
                ensureIdentifierPotentiallyRecovered(String, fieldDeclaration, false)
                  listener: handleIdentifier(message, fieldDeclaration)
                parseFieldInitializerOpt(message, message, null, null, null, final, DeclarationKind.Class, Annotation)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
              listener: endMember()
            notEofOrValue(}, const)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Annotation)
              parseMetadataStar(;)
                listener: beginMetadataStar(const)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(;, null, null, null, null, null, const, const, Instance of 'NoType', null, Annotation, DeclarationKind.Class, Annotation, false)
                listener: beginMethod(null, null, null, const, null, Annotation)
                listener: handleNoType(const)
                ensureIdentifierPotentiallyRecovered(const, methodDeclaration, false)
                  listener: handleIdentifier(Annotation, methodDeclaration)
                parseQualifiedRestOpt(Annotation, methodDeclarationContinuation)
                parseMethodTypeVar(Annotation)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(Annotation, Annotation, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(Annotation, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(this)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(this, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleNoType(()
                        ensureIdentifier(., fieldInitializer)
                          listener: handleIdentifier(message, fieldInitializer)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(this, ., message, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: handleEmptyFunctionBody(;)
                listener: endClassConstructor(null, const, (, 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(A, classOrMixinDeclaration)
        listener: beginTypeVariables(<)
        listener: beginMetadataStar(E)
        listener: endMetadataStar(0)
        listener: handleIdentifier(E, typeVariableDeclaration)
        listener: beginTypeVariable(E)
        listener: handleTypeVariablesDefined(E, 1)
        listener: handleNoType(E)
        listener: endTypeVariable(>, 0, null, null)
        listener: endTypeVariables(<, >)
        listener: beginClassDeclaration(class, null, A)
        parseClass(>, class, class, A)
          parseClassHeaderOpt(>, class, class)
            parseClassExtendsOpt(>)
              listener: handleNoType(>)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(>)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(>)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(>, DeclarationKind.Class, A)
            listener: beginClassOrMixinBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, })
          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(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(}, m)
            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, C)
              parseMetadataStar({)
                listener: beginMetadataStar(m)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(()
              parseMethod({, null, null, null, null, null, null, {, Instance of 'NoType', null, m, DeclarationKind.Class, C, false)
                listener: beginMethod(null, null, null, null, null, m)
                listener: handleNoType({)
                ensureIdentifierPotentiallyRecovered({, 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)
                  parseExpressionFunctionBody(=>, false)
                    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: beginTypeArguments(<)
                                reportRecoverableErrorWithEnd(@, annotation, AnnotationOnTypeArgument)
                                  listener: handleRecoverableError(AnnotationOnTypeArgument, @, annotation)
                                reportRecoverableErrorWithEnd(@, ), AnnotationOnTypeArgument)
                                  listener: handleRecoverableError(AnnotationOnTypeArgument, @, ))
                                listener: handleIdentifier(C, typeReference)
                                listener: handleNoTypeArguments(>)
                                listener: handleType(C, null)
                                listener: endTypeArguments(1, <, >)
                                listener: handleNoConstructorReferenceContinuationAfterTypeArguments(()
                                listener: endConstructorReference(A, null, ()
                              parseConstructorInvocationArguments(>)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  listener: endArguments(0, (, ))
                              listener: endNewExpression(new)
                    ensureSemicolon())
                    listener: handleExpressionFunctionBody(=>, ;)
                    inGenerator()
                listener: endClassMethod(null, m, (, null, ;)
              listener: endMember()
            notEofOrValue(}, })
            listener: endClassOrMixinBody(DeclarationKind.Class, 1, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration()
  reportAllErrorTokens(const)
  listener: endCompilationUnit(4, )