parseUnit(UnmatchedToken(())
  skipErrorTokens(UnmatchedToken(())
  listener: beginCompilationUnit(f)
  syntheticPreviousToken(f)
  parseTopLevelDeclarationImpl(UnmatchedToken({), Instance of 'DirectiveContext')
    parseMetadataStar(UnmatchedToken({))
      listener: beginMetadataStar(f)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(UnmatchedToken({))
      listener: beginTopLevelMember(f)
      isReservedKeyword(()
      parseTopLevelMethod(UnmatchedToken({), null, UnmatchedToken({), Instance of 'NoType', null, f, false)
        listener: beginTopLevelMethod(UnmatchedToken({), null)
        listener: handleNoType(UnmatchedToken({))
        ensureIdentifierPotentiallyRecovered(UnmatchedToken({), topLevelFunctionDeclaration, false)
          listener: handleIdentifier(f, topLevelFunctionDeclaration)
        parseMethodTypeVar(f)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(f, f, false, MemberKind.TopLevelMethod)
          parseFormalParameters(f, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              listener: endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, m)
          parseStatement({)
            parseStatementX({)
              parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
                looksLikeLocalFunction(m)
                parseExpressionStatement({)
                  parseExpression({)
                    parsePrecedenceExpression({, 1, true)
                      parseUnaryExpression({, true)
                        parsePrimary({, expression)
                          parseSendOrFunctionLiteral({, expression)
                            looksLikeFunctionBody(})
                            parseSend({, expression)
                              ensureIdentifier({, expression)
                                listener: handleIdentifier(m, expression)
                              listener: handleNoTypeArguments(()
                              parseArgumentsOpt(m)
                                parseArguments(m)
                                  parseArgumentsRest(()
                                    listener: beginArguments(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          parsePrimary((, expression)
                                            parseSendOrFunctionLiteral((, expression)
                                              parseSend((, expression)
                                                ensureIdentifier((, expression)
                                                  listener: handleIdentifier(T, expression)
                                                listener: handleNoTypeArguments(<)
                                                parseArgumentsOpt(T)
                                                  listener: handleNoArguments(<)
                                                listener: handleSend(T, <)
                                        listener: beginBinaryExpression(<)
                                        parsePrecedenceExpression(<, 9, true)
                                          parseUnaryExpression(<, true)
                                            parsePrimary(<, expression)
                                              parseSendOrFunctionLiteral(<, expression)
                                                looksLikeFunctionBody(>)
                                                parseSend(<, expression)
                                                  ensureIdentifier(<, expression)
                                                    listener: handleIdentifier(R, expression)
                                                  listener: handleNoTypeArguments(()
                                                  parseArgumentsOpt(R)
                                                    parseArguments(R)
                                                      parseArgumentsRest(()
                                                        listener: beginArguments(()
                                                        parseExpression(()
                                                          parsePrecedenceExpression((, 1, true)
                                                            parseUnaryExpression((, true)
                                                              parsePrimary((, expression)
                                                                parseLiteralListSetMapOrFunction((, null)
                                                                  listener: beginTypeArguments(<)
                                                                  listener: handleIdentifier(Z, typeReference)
                                                                  listener: handleNoTypeArguments())
                                                                  listener: handleType(Z, null)
                                                                  listener: endTypeArguments(1, <, >)
                                                                  reportRecoverableError(), Message[ExpectedButGot, Expected '[' before this., null, {string: [}])
                                                                    listener: handleRecoverableError(Message[ExpectedButGot, Expected '[' before this., null, {string: [}], , )
                                                                    listener: // WARNING: Reporting at eof for .
                                                                  rewriter()
                                                                  parseLiteralListSuffix(>, null)
                                                                    rewriteSquareBrackets(>)
                                                                      link([, ])
                                                                      rewriter()
                                                                    listener: handleLiteralList(0, [, null, ])
                                                        listener: endArguments(1, (, ))
                                                  listener: handleSend(R, })
                                        listener: endBinaryExpression(<)
                                    ensureCloseParen(), ()
                                      rewriter()
                                    listener: endArguments(1, (, ))
                              listener: handleSend(m, })
                  ensureSemicolon())
                    reportRecoverableError([, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                      listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], , )
                      listener: // WARNING: Reporting at eof for .
                    rewriter()
                  listener: handleExpressionStatement(;)
          notEofOrValue(}, })
          listener: endBlockFunctionBody(1, {, })
        listener: endTopLevelMethod(f, null, })
  listener: endTopLevelDeclaration()
  reportAllErrorTokens(UnmatchedToken(())
    listener: handleErrorToken(UnmatchedToken(())
    listener: handleRecoverableError(Message[UnmatchedToken, Can't find ')' to match '('., null, {string: ), lexeme: (}], UnmatchedToken((), UnmatchedToken(())
    listener: handleErrorToken(UnmatchedToken(<))
    listener: handleRecoverableError(Message[UnmatchedToken, Can't find '>' to match '<'., null, {string: >, lexeme: <}], UnmatchedToken(<), UnmatchedToken(<))
    listener: handleErrorToken(UnmatchedToken(())
    listener: handleRecoverableError(Message[UnmatchedToken, Can't find ')' to match '('., null, {string: ), lexeme: (}], UnmatchedToken((), UnmatchedToken(())
    listener: handleErrorToken(UnmatchedToken({))
    listener: handleRecoverableError(Message[UnmatchedToken, Can't find '}' to match '{'., null, {string: }, lexeme: {}], UnmatchedToken({), UnmatchedToken({))
  listener: endCompilationUnit(1, )