parseUnit(UnmatchedToken(())
  skipErrorTokens(UnmatchedToken(())
  listener: beginCompilationUnit(class)
  syntheticPreviousToken(class)
  parseTopLevelDeclarationImpl(UnmatchedToken((), Instance of 'DirectiveContext')
    parseMetadataStar(UnmatchedToken(())
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(UnmatchedToken((), class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(UnmatchedToken((), class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(Foo, classOrMixinDeclaration)
        listener: beginTypeVariables(<)
        listener: beginMetadataStar(T)
        listener: endMetadataStar(0)
        listener: handleIdentifier(T, typeVariableDeclaration)
        listener: beginTypeVariable(T)
        listener: handleTypeVariablesDefined(T, 1)
        listener: handleNoType(T)
        listener: endTypeVariable(>, 0, null, null)
        listener: endTypeVariables(<, >)
        listener: beginClassDeclaration(class, null, Foo)
        parseClass(>, class, class, Foo)
          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, Foo)
            listener: beginClassOrMixinBody(DeclarationKind.Class, {)
            notEofOrValue(}, foo)
            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, Foo)
              parseMetadataStar({)
                listener: beginMetadataStar(foo)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(()
              parseMethod({, null, null, null, null, null, null, {, Instance of 'NoType', null, foo, DeclarationKind.Class, Foo, false)
                listener: beginMethod(null, null, null, null, null, foo)
                listener: handleNoType({)
                ensureIdentifierPotentiallyRecovered({, methodDeclaration, false)
                  listener: handleIdentifier(foo, methodDeclaration)
                parseQualifiedRestOpt(foo, methodDeclarationContinuation)
                parseMethodTypeVar(foo)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(foo, foo, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(foo, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(Object)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(Object, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleIdentifier(Object, typeReference)
                        listener: handleNoTypeArguments(?)
                        listener: handleType(Object, ?)
                        ensureIdentifier(?, formalParameterDeclaration)
                          listener: handleIdentifier(key, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, key, 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: beginBlockFunctionBody({)
                  notEofOrValue(}, if)
                  parseStatement({)
                    parseStatementX({)
                      parseIfStatement({)
                        listener: beginIfStatement(if)
                        ensureParenthesizedCondition(if)
                          parseExpressionInParenthesisRest(()
                            parseExpression(()
                              parsePrecedenceExpression((, 1, true)
                                parseUnaryExpression((, true)
                                  parsePrimary((, expression)
                                    parseSendOrFunctionLiteral((, expression)
                                      parseSend((, expression)
                                        isNextIdentifier(()
                                        ensureIdentifier((, expression)
                                          listener: handleIdentifier(key, expression)
                                        listener: handleNoTypeArguments(is)
                                        parseArgumentsOpt(key)
                                          listener: handleNoArguments(is)
                                        listener: handleSend(key, is)
                                parseIsOperatorRest(key)
                                  listener: beginIsOperatorType(is)
                                  computeTypeAfterIsOrAs(!)
                                  listener: handleIdentifier(T, typeReference)
                                  listener: handleNoTypeArguments(or)
                                  listener: handleType(T, null)
                                  listener: endIsOperatorType(is)
                                  listener: handleIsOperator(is, !)
                                  skipChainedAsIsOperators(T)
                                rewriter()
                                parsePrecedenceExpression(||, 6, true)
                                  parseUnaryExpression(||, true)
                                    parsePrimary(||, expression)
                                      parseSend(||, expression)
                                        isNextIdentifier(||)
                                        ensureIdentifier(||, expression)
                                          reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                          rewriter()
                                        parseArgumentsOpt()
                            ensureCloseParen(T, ()
                              rewriter()
                          listener: handleParenthesizedCondition(()
                        listener: beginThenStatement(or)
                        parseStatement())
                          parseStatementX())
                            parseExpressionStatementOrDeclarationAfterModifiers(), ), null, null, null, false)
                              looksLikeLocalFunction(or)
                              parseExpressionStatement())
                                parseExpression())
                                  parsePrecedenceExpression(), 1, true)
                                    parseUnaryExpression(), true)
                                      parsePrimary(), expression)
                                        parseSendOrFunctionLiteral(), expression)
                                          parseSend(), expression)
                                            isNextIdentifier())
                                            ensureIdentifier(), expression)
                                              listener: handleIdentifier(or, expression)
                                            listener: handleNoTypeArguments(})
                                            parseArgumentsOpt(or)
                                              listener: handleNoArguments(})
                                            listener: handleSend(or, })
                                ensureSemicolon(or)
                                  reportRecoverableError(or, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], or, or)
                                  rewriter()
                                listener: handleExpressionStatement(;)
                        listener: endThenStatement(;)
                        listener: endIfStatement(if, null)
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(1, {, })
                listener: endClassMethod(null, foo, (, null, })
              listener: endMember()
            notEofOrValue(}, })
            listener: endClassOrMixinBody(DeclarationKind.Class, 1, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration()
  reportAllErrorTokens(UnmatchedToken(())
    listener: handleErrorToken(UnmatchedToken(())
    listener: handleRecoverableError(Message[UnmatchedToken, Can't find ')' to match '('., null, {string: ), lexeme: (}], UnmatchedToken((), UnmatchedToken(())
  listener: endCompilationUnit(1, )