parseUnit(void)
  skipErrorTokens(void)
  listener: beginCompilationUnit(void)
  syntheticPreviousToken(void)
  parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext')
    parseMetadataStar()
      listener: beginMetadataStar(void)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl()
      listener: beginTopLevelMember(void)
      parseTopLevelMethod(, null, , Instance of 'VoidType', null, foo, false)
        listener: beginTopLevelMethod(, null)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(foo, topLevelFunctionDeclaration)
        parseMethodTypeVar(foo)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(foo, foo, false, MemberKind.TopLevelMethod)
          parseFormalParameters(foo, 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(}, {)
          parseStatement({)
            parseStatementX({)
              parseBlock({, BlockKind(statement))
                ensureBlock({, null, null)
                listener: beginBlock({, BlockKind(statement))
                notEofOrValue(}, foo)
                parseStatement({)
                  parseStatementX({)
                    parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
                      looksLikeLocalFunction(foo)
                      parseExpressionStatement({)
                        parseExpression({)
                          parsePrecedenceExpression({, 1, true)
                            parseUnaryExpression({, true)
                              parsePrimary({, expression)
                                parseSendOrFunctionLiteral({, expression)
                                  looksLikeFunctionBody())
                                  parseSend({, expression)
                                    isNextIdentifier({)
                                    ensureIdentifier({, expression)
                                      listener: handleIdentifier(foo, expression)
                                    listener: handleNoTypeArguments(()
                                    parseArgumentsOpt(foo)
                                      parseArguments(foo)
                                        parseArgumentsRest(()
                                          listener: beginArguments(()
                                          listener: endArguments(0, (, ))
                                    listener: handleSend(foo, ))
                        ensureSemicolon())
                          reportRecoverableError(), Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                            listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], ), ))
                          rewriter()
                        listener: handleExpressionStatement(;)
                notEofOrValue(}, ))
                parseStatement(;)
                  parseStatementX(;)
                    parseExpressionStatementOrDeclaration(;, false)
                      parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                        looksLikeLocalFunction())
                        parseExpressionStatement(;)
                          parseExpression(;)
                            parsePrecedenceExpression(;, 1, true)
                              parseUnaryExpression(;, true)
                                parsePrimary(;, expression)
                                  parseSend(;, expression)
                                    isNextIdentifier(;)
                                    ensureIdentifier(;, expression)
                                      reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
                                      rewriter()
                                      listener: handleIdentifier(, expression)
                                    listener: handleNoTypeArguments())
                                    parseArgumentsOpt()
                                      listener: handleNoArguments())
                                    listener: handleSend(, ))
                          ensureSemicolon()
                            reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                              listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], ), ))
                            rewriter()
                          listener: handleExpressionStatement(;)
                reportRecoverableError(), Message[UnexpectedToken, Unexpected token ')'., null, {lexeme: )}])
                  listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token ')'., null, {lexeme: )}], ), ))
                notEofOrValue(}, ;)
                parseStatement())
                  parseStatementX())
                    parseEmptyStatement())
                      listener: handleEmptyStatement(;)
                notEofOrValue(}, })
                listener: endBlock(3, {, }, BlockKind(statement))
          notEofOrValue(}, })
          listener: endBlockFunctionBody(1, {, })
        listener: endTopLevelMethod(void, null, })
  listener: endTopLevelDeclaration()
  reportAllErrorTokens(void)
  listener: endCompilationUnit(1, )