parseUnit(class)
  skipErrorTokens(class)
  listener: beginCompilationUnit(class)
  syntheticPreviousToken(class)
  parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext')
    parseMetadataStar()
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(, class, null, Instance of 'DirectiveContext')
      parseClassOrNamedMixinApplication(null, null, null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(A, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, null, null, A)
        parseClass(A, class, class, A)
          parseClassHeaderOpt(A, class, class)
            parseClassExtendsOpt(A)
              listener: handleNoType(A)
              listener: handleClassExtends(null, 1)
            parseClassWithClauseOpt(A)
              listener: handleClassNoWithClause()
            parseClassOrMixinOrEnumImplementsOpt(A)
              listener: handleImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(A, DeclarationKind.Class, A)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, A)
            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, A)
              parseMetadataStar({)
                listener: beginMetadataStar(A)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(()
              parseMethod({, null, null, null, null, null, null, null, {, Instance of 'NoType', null, A, DeclarationKind.Class, A, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, A)
                listener: handleNoType({)
                ensureIdentifierPotentiallyRecovered({, methodDeclaration, false)
                  listener: handleIdentifier(A, methodDeclaration)
                parseQualifiedRestOpt(A, methodDeclarationContinuation)
                parseMethodTypeVar(A)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(A, A, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(A, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleIdentifier(int, typeReference)
                        listener: handleNoTypeArguments(x)
                        listener: handleType(int, null)
                        ensureIdentifier(int, formalParameterDeclaration)
                          listener: handleIdentifier(x, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, x, 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, A, (, null, ;)
              listener: endMember()
            notEofOrValue(}, A)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, A)
              parseMetadataStar(;)
                listener: beginMetadataStar(A)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(.)
              parseMethod(;, null, null, null, null, null, null, null, ;, Instance of 'NoType', null, A, DeclarationKind.Class, A, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, A)
                listener: handleNoType(;)
                ensureIdentifierPotentiallyRecovered(;, methodDeclaration, false)
                  listener: handleIdentifier(A, methodDeclaration)
                parseQualifiedRestOpt(A, methodDeclarationContinuation)
                  parseQualifiedRest(A, methodDeclarationContinuation)
                    ensureIdentifier(., methodDeclarationContinuation)
                      listener: handleIdentifier(y, methodDeclarationContinuation)
                    listener: handleQualified(.)
                parseMethodTypeVar(y)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(y, A, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(y, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleIdentifier(int, typeReference)
                        listener: handleNoTypeArguments(x)
                        listener: handleType(int, null)
                        ensureIdentifier(int, formalParameterDeclaration)
                          listener: handleIdentifier(x, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, x, 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, A, (, null, ;)
              listener: endMember()
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 2, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, null, Instance of 'DirectiveContext')
      parseClassOrNamedMixinApplication(null, null, null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(B, classOrMixinDeclaration)
        listener: handleNoTypeVariables(extends)
        listener: beginClassDeclaration(class, null, null, null, B)
        parseClass(B, class, class, B)
          parseClassHeaderOpt(B, class, class)
            parseClassExtendsOpt(B)
              parseClassExtendsSeenExtendsClause(extends, B)
                listener: handleIdentifier(A, typeReference)
                listener: handleNoTypeArguments({)
                listener: handleType(A, null)
                listener: handleClassExtends(extends, 1)
            parseClassWithClauseOpt(A)
              listener: handleClassNoWithClause()
            parseClassOrMixinOrEnumImplementsOpt(A)
              listener: handleImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(A, DeclarationKind.Class, B)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, B)
            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, B)
              parseMetadataStar({)
                listener: beginMetadataStar(B)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(()
              parseMethod({, null, null, null, null, null, null, null, {, Instance of 'NoType', null, B, DeclarationKind.Class, B, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, B)
                listener: handleNoType({)
                ensureIdentifierPotentiallyRecovered({, methodDeclaration, false)
                  listener: handleIdentifier(B, methodDeclaration)
                parseQualifiedRestOpt(B, methodDeclarationContinuation)
                parseMethodTypeVar(B)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(B, B, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(B, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleIdentifier(int, typeReference)
                        listener: handleNoTypeArguments(x)
                        listener: handleType(int, null)
                        ensureIdentifier(int, formalParameterDeclaration)
                          listener: handleIdentifier(x, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, x, 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(x, expression)
                                    listener: handleNoTypeArguments(>)
                                    parseArgumentsOpt(x)
                                      listener: handleNoArguments(>)
                                    listener: handleSend(x, >)
                            listener: beginBinaryExpression(>)
                            parsePrecedenceExpression(>, 9, true)
                              parseUnaryExpression(>, true)
                                parsePrimary(>, expression)
                                  parseLiteralInt(>)
                                    listener: handleLiteralInt(0)
                            listener: endBinaryExpression(>)
                        listener: endAssert(assert, Assert.Initializer, (, null, super)
                      listener: endInitializer(super)
                    reportRecoverableError(), Message[ExpectedAfterButGot, Expected ',' after this., null, {string: ,}])
                      listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ',' after this., null, {string: ,}], ), ))
                    rewriter()
                    parseInitializer(,)
                      listener: beginInitializer(super)
                      parseSuperInitializerExpression(,)
                        parseInitializerExpressionRest(,)
                          parseExpression(,)
                            parsePrecedenceExpression(,, 1, true)
                              parseUnaryExpression(,, true)
                                parsePrimary(,, expression)
                                  parseSuperExpression(,, expression)
                                    listener: handleSuperExpression(super, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArguments(super)
                                      parseArgumentsRest(()
                                        listener: beginArguments(()
                                        parseExpression(()
                                          parsePrecedenceExpression((, 1, true)
                                            parseUnaryExpression((, true)
                                              parsePrimary((, expression)
                                                parseSendOrFunctionLiteral((, expression)
                                                  parseSend((, expression)
                                                    isNextIdentifier(()
                                                    ensureIdentifier((, expression)
                                                      listener: handleIdentifier(x, expression)
                                                    listener: handleNoTypeArguments())
                                                    parseArgumentsOpt(x)
                                                      listener: handleNoArguments())
                                                    listener: handleSend(x, ))
                                        listener: endArguments(1, (, ))
                                    listener: handleSend(super, ;)
                          listener: endInitializer(;)
                    listener: endInitializers(2, :, ;)
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: handleEmptyFunctionBody(;)
                listener: endClassConstructor(null, B, (, :, ;)
              listener: endMember()
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 1, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, null, Instance of 'DirectiveContext')
      parseClassOrNamedMixinApplication(null, null, null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(B2, classOrMixinDeclaration)
        listener: handleNoTypeVariables(extends)
        listener: beginClassDeclaration(class, null, null, null, B2)
        parseClass(B2, class, class, B2)
          parseClassHeaderOpt(B2, class, class)
            parseClassExtendsOpt(B2)
              parseClassExtendsSeenExtendsClause(extends, B2)
                listener: handleIdentifier(A, typeReference)
                listener: handleNoTypeArguments({)
                listener: handleType(A, null)
                listener: handleClassExtends(extends, 1)
            parseClassWithClauseOpt(A)
              listener: handleClassNoWithClause()
            parseClassOrMixinOrEnumImplementsOpt(A)
              listener: handleImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(A, DeclarationKind.Class, B2)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, B2)
            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, B2)
              parseMetadataStar({)
                listener: beginMetadataStar(B2)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(()
              parseMethod({, null, null, null, null, null, null, null, {, Instance of 'NoType', null, B2, DeclarationKind.Class, B2, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, B2)
                listener: handleNoType({)
                ensureIdentifierPotentiallyRecovered({, methodDeclaration, false)
                  listener: handleIdentifier(B2, methodDeclaration)
                parseQualifiedRestOpt(B2, methodDeclarationContinuation)
                parseMethodTypeVar(B2)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(B2, B2, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(B2, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleIdentifier(int, typeReference)
                        listener: handleNoTypeArguments(x)
                        listener: handleType(int, null)
                        ensureIdentifier(int, formalParameterDeclaration)
                          listener: handleIdentifier(x, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, x, 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(x, expression)
                                    listener: handleNoTypeArguments(>)
                                    parseArgumentsOpt(x)
                                      listener: handleNoArguments(>)
                                    listener: handleSend(x, >)
                            listener: beginBinaryExpression(>)
                            parsePrecedenceExpression(>, 9, true)
                              parseUnaryExpression(>, true)
                                parsePrimary(>, expression)
                                  parseLiteralInt(>)
                                    listener: handleLiteralInt(0)
                            listener: endBinaryExpression(>)
                        listener: endAssert(assert, Assert.Initializer, (, null, super)
                      listener: endInitializer(super)
                    reportRecoverableError(), Message[ExpectedAfterButGot, Expected ',' after this., null, {string: ,}])
                      listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ',' after this., null, {string: ,}], ), ))
                    rewriter()
                    parseInitializer(,)
                      listener: beginInitializer(super)
                      parseSuperInitializerExpression(,)
                        parseInitializerExpressionRest(,)
                          parseExpression(,)
                            parsePrecedenceExpression(,, 1, true)
                              parseUnaryExpression(,, true)
                                parsePrimary(,, expression)
                                  parseSuperExpression(,, expression)
                                    listener: handleSuperExpression(super, expression)
                              parsePrimary(., expressionContinuation)
                                parseSendOrFunctionLiteral(., expressionContinuation)
                                  parseSend(., expressionContinuation)
                                    isNextIdentifier(.)
                                    ensureIdentifier(., expressionContinuation)
                                      listener: handleIdentifier(y, expressionContinuation)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(y)
                                      parseArguments(y)
                                        parseArgumentsRest(()
                                          listener: beginArguments(()
                                          parseExpression(()
                                            parsePrecedenceExpression((, 1, true)
                                              parseUnaryExpression((, true)
                                                parsePrimary((, expression)
                                                  parseSendOrFunctionLiteral((, expression)
                                                    parseSend((, expression)
                                                      isNextIdentifier(()
                                                      ensureIdentifier((, expression)
                                                        listener: handleIdentifier(x, expression)
                                                      listener: handleNoTypeArguments())
                                                      parseArgumentsOpt(x)
                                                        listener: handleNoArguments())
                                                      listener: handleSend(x, ))
                                          listener: endArguments(1, (, ))
                                    listener: handleSend(y, ;)
                              listener: handleEndingBinaryExpression(.)
                          listener: endInitializer(;)
                    listener: endInitializers(2, :, ;)
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: handleEmptyFunctionBody(;)
                listener: endClassConstructor(null, B2, (, :, ;)
              listener: endMember()
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 1, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, null, Instance of 'DirectiveContext')
      parseClassOrNamedMixinApplication(null, null, null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(B3, classOrMixinDeclaration)
        listener: handleNoTypeVariables(extends)
        listener: beginClassDeclaration(class, null, null, null, B3)
        parseClass(B3, class, class, B3)
          parseClassHeaderOpt(B3, class, class)
            parseClassExtendsOpt(B3)
              parseClassExtendsSeenExtendsClause(extends, B3)
                listener: handleIdentifier(A, typeReference)
                listener: handleNoTypeArguments({)
                listener: handleType(A, null)
                listener: handleClassExtends(extends, 1)
            parseClassWithClauseOpt(A)
              listener: handleClassNoWithClause()
            parseClassOrMixinOrEnumImplementsOpt(A)
              listener: handleImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(A, DeclarationKind.Class, B3)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, B3)
            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, B3)
              parseMetadataStar({)
                listener: beginMetadataStar(B3)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(()
              parseMethod({, null, null, null, null, null, null, null, {, Instance of 'NoType', null, B3, DeclarationKind.Class, B3, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, B3)
                listener: handleNoType({)
                ensureIdentifierPotentiallyRecovered({, methodDeclaration, false)
                  listener: handleIdentifier(B3, methodDeclaration)
                parseQualifiedRestOpt(B3, methodDeclarationContinuation)
                parseMethodTypeVar(B3)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(B3, B3, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(B3, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleIdentifier(int, typeReference)
                        listener: handleNoTypeArguments(x)
                        listener: handleType(int, null)
                        ensureIdentifier(int, formalParameterDeclaration)
                          listener: handleIdentifier(x, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, x, 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(x, expression)
                                    listener: handleNoTypeArguments(>)
                                    parseArgumentsOpt(x)
                                      listener: handleNoArguments(>)
                                    listener: handleSend(x, >)
                            listener: beginBinaryExpression(>)
                            parsePrecedenceExpression(>, 9, true)
                              parseUnaryExpression(>, true)
                                parsePrimary(>, expression)
                                  parseLiteralInt(>)
                                    listener: handleLiteralInt(0)
                            listener: endBinaryExpression(>)
                        listener: endAssert(assert, Assert.Initializer, (, null, this)
                      listener: endInitializer(this)
                    reportRecoverableError(), Message[ExpectedAfterButGot, Expected ',' after this., null, {string: ,}])
                      listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ',' after this., null, {string: ,}], ), ))
                    rewriter()
                    parseInitializer(,)
                      listener: beginInitializer(this)
                      parseInitializerExpressionRest(,)
                        parseExpression(,)
                          parsePrecedenceExpression(,, 1, true)
                            parseUnaryExpression(,, true)
                              parsePrimary(,, expression)
                                parseThisExpression(,, expression)
                                  listener: handleThisExpression(this, expression)
                            parsePrimary(., expressionContinuation)
                              parseSendOrFunctionLiteral(., expressionContinuation)
                                parseSend(., expressionContinuation)
                                  isNextIdentifier(.)
                                  ensureIdentifier(., expressionContinuation)
                                    listener: handleIdentifier(y, expressionContinuation)
                                  listener: handleNoTypeArguments(()
                                  parseArgumentsOpt(y)
                                    parseArguments(y)
                                      parseArgumentsRest(()
                                        listener: beginArguments(()
                                        parseExpression(()
                                          parsePrecedenceExpression((, 1, true)
                                            parseUnaryExpression((, true)
                                              parsePrimary((, expression)
                                                parseSendOrFunctionLiteral((, expression)
                                                  parseSend((, expression)
                                                    isNextIdentifier(()
                                                    ensureIdentifier((, expression)
                                                      listener: handleIdentifier(x, expression)
                                                    listener: handleNoTypeArguments())
                                                    parseArgumentsOpt(x)
                                                      listener: handleNoArguments())
                                                    listener: handleSend(x, ))
                                        listener: endArguments(1, (, ))
                                  listener: handleSend(y, ;)
                            listener: handleEndingBinaryExpression(.)
                        listener: endInitializer(;)
                    listener: endInitializers(2, :, ;)
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: handleEmptyFunctionBody(;)
                listener: endClassConstructor(null, B3, (, :, ;)
              listener: endMember()
            notEofOrValue(}, B3)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, B3)
              parseMetadataStar(;)
                listener: beginMetadataStar(B3)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(.)
              parseMethod(;, null, null, null, null, null, null, null, ;, Instance of 'NoType', null, B3, DeclarationKind.Class, B3, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, B3)
                listener: handleNoType(;)
                ensureIdentifierPotentiallyRecovered(;, methodDeclaration, false)
                  listener: handleIdentifier(B3, methodDeclaration)
                parseQualifiedRestOpt(B3, methodDeclarationContinuation)
                  parseQualifiedRest(B3, methodDeclarationContinuation)
                    ensureIdentifier(., methodDeclarationContinuation)
                      listener: handleIdentifier(y, methodDeclarationContinuation)
                    listener: handleQualified(.)
                parseMethodTypeVar(y)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(y, B3, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(y, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleIdentifier(int, typeReference)
                        listener: handleNoTypeArguments(x)
                        listener: handleType(int, null)
                        ensureIdentifier(int, formalParameterDeclaration)
                          listener: handleIdentifier(x, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, x, 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, B3, (, null, ;)
              listener: endMember()
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 2, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, null, Instance of 'DirectiveContext')
      parseClassOrNamedMixinApplication(null, null, null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(C, classOrMixinDeclaration)
        listener: handleNoTypeVariables(extends)
        listener: beginClassDeclaration(class, null, null, null, C)
        parseClass(C, class, class, C)
          parseClassHeaderOpt(C, class, class)
            parseClassExtendsOpt(C)
              parseClassExtendsSeenExtendsClause(extends, C)
                listener: handleIdentifier(A, typeReference)
                listener: handleNoTypeArguments({)
                listener: handleType(A, null)
                listener: handleClassExtends(extends, 1)
            parseClassWithClauseOpt(A)
              listener: handleClassNoWithClause()
            parseClassOrMixinOrEnumImplementsOpt(A)
              listener: handleImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(A, DeclarationKind.Class, C)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, C)
              parseMetadataStar({)
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields({, null, null, null, null, null, null, null, {, Instance of 'SimpleType', y, DeclarationKind.Class, C, false)
                listener: beginFields(DeclarationKind.Class, null, null, null, null, null, null, null, {)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(y)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, fieldDeclaration, false)
                  listener: handleIdentifier(y, fieldDeclaration)
                parseFieldInitializerOpt(y, y, null, null, null, null, null, DeclarationKind.Class, C)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, null, null, null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, C)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, C)
              parseMetadataStar(;)
                listener: beginMetadataStar(C)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(()
              parseMethod(;, null, null, null, null, null, null, null, ;, Instance of 'NoType', null, C, DeclarationKind.Class, C, false)
                listener: beginMethod(DeclarationKind.Class, null, 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)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleIdentifier(int, typeReference)
                        listener: handleNoTypeArguments(x)
                        listener: handleType(int, null)
                        ensureIdentifier(int, formalParameterDeclaration)
                          listener: handleIdentifier(x, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, x, 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(x, expression)
                                    listener: handleNoTypeArguments(>)
                                    parseArgumentsOpt(x)
                                      listener: handleNoArguments(>)
                                    listener: handleSend(x, >)
                            listener: beginBinaryExpression(>)
                            parsePrecedenceExpression(>, 9, true)
                              parseUnaryExpression(>, true)
                                parsePrimary(>, expression)
                                  parseLiteralInt(>)
                                    listener: handleLiteralInt(0)
                            listener: endBinaryExpression(>)
                        listener: endAssert(assert, Assert.Initializer, (, null, y)
                      listener: endInitializer(y)
                    reportRecoverableError(), Message[ExpectedAfterButGot, Expected ',' after this., null, {string: ,}])
                      listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ',' after this., null, {string: ,}], ), ))
                    rewriter()
                    parseInitializer(,)
                      listener: beginInitializer(y)
                      parseInitializerExpressionRest(,)
                        parseExpression(,)
                          parsePrecedenceExpression(,, 1, true)
                            parseUnaryExpression(,, true)
                              parsePrimary(,, expression)
                                parseSendOrFunctionLiteral(,, expression)
                                  parseSend(,, expression)
                                    isNextIdentifier(,)
                                    ensureIdentifier(,, expression)
                                      listener: handleIdentifier(y, expression)
                                    listener: handleNoTypeArguments(=)
                                    parseArgumentsOpt(y)
                                      listener: handleNoArguments(=)
                                    listener: handleSend(y, =)
                            parsePrecedenceExpression(=, 1, true)
                              parseUnaryExpression(=, true)
                                parsePrimary(=, expression)
                                  parseLiteralInt(=)
                                    listener: handleLiteralInt(2)
                              listener: beginBinaryExpression(*)
                              parsePrecedenceExpression(*, 15, true)
                                parseUnaryExpression(*, true)
                                  parsePrimary(*, expression)
                                    parseLiteralInt(*)
                                      listener: handleLiteralInt(21)
                              listener: endBinaryExpression(*)
                            listener: handleAssignmentExpression(=)
                        listener: endInitializer(;)
                    listener: endInitializers(2, :, ;)
                parseAsyncModifierOpt(21)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(21, false, true)
                  listener: handleEmptyFunctionBody(;)
                listener: endClassConstructor(null, C, (, :, ;)
              listener: endMember()
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 2, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, null, Instance of 'DirectiveContext')
      parseClassOrNamedMixinApplication(null, null, null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(D, classOrMixinDeclaration)
        listener: handleNoTypeVariables(extends)
        listener: beginClassDeclaration(class, null, null, null, D)
        parseClass(D, class, class, D)
          parseClassHeaderOpt(D, class, class)
            parseClassExtendsOpt(D)
              parseClassExtendsSeenExtendsClause(extends, D)
                listener: handleIdentifier(A, typeReference)
                listener: handleNoTypeArguments({)
                listener: handleType(A, null)
                listener: handleClassExtends(extends, 1)
            parseClassWithClauseOpt(A)
              listener: handleClassNoWithClause()
            parseClassOrMixinOrEnumImplementsOpt(A)
              listener: handleImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(A, DeclarationKind.Class, D)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, D)
            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, D)
              parseMetadataStar({)
                listener: beginMetadataStar(D)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(()
              parseMethod({, null, null, null, null, null, null, null, {, Instance of 'NoType', null, D, DeclarationKind.Class, D, false)
                listener: beginMethod(DeclarationKind.Class, null, 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)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleIdentifier(int, typeReference)
                        listener: handleNoTypeArguments(x)
                        listener: handleType(int, null)
                        ensureIdentifier(int, formalParameterDeclaration)
                          listener: handleIdentifier(x, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, x, 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(x, expression)
                                    listener: handleNoTypeArguments(>)
                                    parseArgumentsOpt(x)
                                      listener: handleNoArguments(>)
                                    listener: handleSend(x, >)
                            listener: beginBinaryExpression(>)
                            parsePrecedenceExpression(>, 9, true)
                              parseUnaryExpression(>, true)
                                parsePrimary(>, expression)
                                  parseLiteralInt(>)
                                    listener: handleLiteralInt(0)
                            listener: endBinaryExpression(>)
                        listener: endAssert(assert, Assert.Initializer, (, null, assert)
                      listener: endInitializer(assert)
                    reportRecoverableError(), Message[ExpectedAfterButGot, Expected ',' after this., null, {string: ,}])
                      listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ',' after this., null, {string: ,}], ), ))
                    rewriter()
                    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(x, expression)
                                    listener: handleNoTypeArguments(-)
                                    parseArgumentsOpt(x)
                                      listener: handleNoArguments(-)
                                    listener: handleSend(x, -)
                            listener: beginBinaryExpression(-)
                            parsePrecedenceExpression(-, 14, true)
                              parseUnaryExpression(-, true)
                                parsePrimary(-, expression)
                                  parseLiteralInt(-)
                                    listener: handleLiteralInt(1)
                            listener: endBinaryExpression(-)
                            listener: beginBinaryExpression(>)
                            parsePrecedenceExpression(>, 9, true)
                              parseUnaryExpression(>, true)
                                parsePrimary(>, expression)
                                  parseLiteralInt(>)
                                    listener: handleLiteralInt(0)
                            listener: endBinaryExpression(>)
                        listener: endAssert(assert, Assert.Initializer, (, null, ;)
                      listener: endInitializer(;)
                    listener: endInitializers(2, :, ;)
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: handleEmptyFunctionBody(;)
                listener: endClassConstructor(null, D, (, :, ;)
              listener: endMember()
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 1, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, null, Instance of 'DirectiveContext')
      parseClassOrNamedMixinApplication(null, null, null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(E, classOrMixinDeclaration)
        listener: handleNoTypeVariables(extends)
        listener: beginClassDeclaration(class, null, null, null, E)
        parseClass(E, class, class, E)
          parseClassHeaderOpt(E, class, class)
            parseClassExtendsOpt(E)
              parseClassExtendsSeenExtendsClause(extends, E)
                listener: handleIdentifier(A, typeReference)
                listener: handleNoTypeArguments({)
                listener: handleType(A, null)
                listener: handleClassExtends(extends, 1)
            parseClassWithClauseOpt(A)
              listener: handleClassNoWithClause()
            parseClassOrMixinOrEnumImplementsOpt(A)
              listener: handleImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(A, DeclarationKind.Class, E)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, final)
            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, E)
              parseMetadataStar({)
                listener: beginMetadataStar(final)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields({, null, null, null, null, null, null, final, final, Instance of 'SimpleType', y, DeclarationKind.Class, E, false)
                listener: beginFields(DeclarationKind.Class, null, null, null, null, null, null, final, {)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(y)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, fieldDeclaration, false)
                  listener: handleIdentifier(y, fieldDeclaration)
                parseFieldInitializerOpt(y, y, null, null, null, null, final, DeclarationKind.Class, E)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, null, null, null, null, null, final, 1, final, ;)
              listener: endMember()
            notEofOrValue(}, E)
            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, E)
              parseMetadataStar(;)
                listener: beginMetadataStar(E)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(()
              parseMethod(;, null, null, null, null, null, null, null, ;, Instance of 'NoType', null, E, DeclarationKind.Class, E, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, E)
                listener: handleNoType(;)
                ensureIdentifierPotentiallyRecovered(;, methodDeclaration, false)
                  listener: handleIdentifier(E, methodDeclaration)
                parseQualifiedRestOpt(E, methodDeclarationContinuation)
                parseMethodTypeVar(E)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(E, E, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(E, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(int)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleIdentifier(int, typeReference)
                        listener: handleNoTypeArguments(x)
                        listener: handleType(int, null)
                        ensureIdentifier(int, formalParameterDeclaration)
                          listener: handleIdentifier(x, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, x, 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(x, expression)
                                    listener: handleNoTypeArguments(>)
                                    parseArgumentsOpt(x)
                                      listener: handleNoArguments(>)
                                    listener: handleSend(x, >)
                            listener: beginBinaryExpression(>)
                            parsePrecedenceExpression(>, 9, true)
                              parseUnaryExpression(>, true)
                                parsePrimary(>, expression)
                                  parseLiteralInt(>)
                                    listener: handleLiteralInt(0)
                            listener: endBinaryExpression(>)
                        listener: endAssert(assert, Assert.Initializer, (, null, this)
                      listener: endInitializer(this)
                    reportRecoverableError(), Message[ExpectedAfterButGot, Expected ',' after this., null, {string: ,}])
                      listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ',' after this., null, {string: ,}], ), ))
                    rewriter()
                    parseInitializer(,)
                      listener: beginInitializer(this)
                      parseInitializerExpressionRest(,)
                        parseExpression(,)
                          parsePrecedenceExpression(,, 1, true)
                            parseUnaryExpression(,, true)
                              parsePrimary(,, expression)
                                parseThisExpression(,, expression)
                                  listener: handleThisExpression(this, expression)
                            parsePrimary(., expressionContinuation)
                              parseSendOrFunctionLiteral(., expressionContinuation)
                                parseSend(., expressionContinuation)
                                  isNextIdentifier(.)
                                  ensureIdentifier(., expressionContinuation)
                                    listener: handleIdentifier(y, expressionContinuation)
                                  listener: handleNoTypeArguments(=)
                                  parseArgumentsOpt(y)
                                    listener: handleNoArguments(=)
                                  listener: handleSend(y, =)
                            listener: handleEndingBinaryExpression(.)
                            parsePrecedenceExpression(=, 1, true)
                              parseUnaryExpression(=, true)
                                parsePrimary(=, expression)
                                  parseSendOrFunctionLiteral(=, expression)
                                    parseSend(=, expression)
                                      isNextIdentifier(=)
                                      ensureIdentifier(=, expression)
                                        listener: handleIdentifier(x, expression)
                                      listener: handleNoTypeArguments(*)
                                      parseArgumentsOpt(x)
                                        listener: handleNoArguments(*)
                                      listener: handleSend(x, *)
                              listener: beginBinaryExpression(*)
                              parsePrecedenceExpression(*, 15, true)
                                parseUnaryExpression(*, true)
                                  parsePrimary(*, expression)
                                    parseLiteralInt(*)
                                      listener: handleLiteralInt(2)
                              listener: endBinaryExpression(*)
                            listener: handleAssignmentExpression(=)
                        listener: endInitializer(;)
                    listener: endInitializers(2, :, ;)
                parseAsyncModifierOpt(2)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(2, false, true)
                  listener: handleEmptyFunctionBody(;)
                listener: endClassConstructor(null, E, (, :, ;)
              listener: endMember()
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 2, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration()
  reportAllErrorTokens(class)
  listener: endCompilationUnit(7, )