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(}, foo)
          parseStatement({)
            parseStatementX({)
              parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
                looksLikeLocalFunction(foo)
                parseExpressionStatement({)
                  parseExpression({)
                    parsePrecedenceExpression({, 1, true)
                      parseUnaryExpression({, true)
                        parsePrimary({, expression)
                          parseSendOrFunctionLiteral({, expression)
                            looksLikeFunctionBody(;)
                            parseSend({, expression)
                              ensureIdentifier({, expression)
                                listener: handleIdentifier(foo, expression)
                              listener: handleNoTypeArguments(()
                              parseArgumentsOpt(foo)
                                parseArguments(foo)
                                  parseArgumentsRest(()
                                    listener: beginArguments(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          parsePrimary((, expression)
                                            parseParenthesizedExpressionOrFunctionLiteral(()
                                              listener: handleNoTypeVariables(()
                                              parseFunctionExpression(()
                                                listener: beginFunctionExpression(()
                                                parseFormalParametersRequiredOpt((, MemberKind.Local)
                                                  parseFormalParametersRest((, MemberKind.Local)
                                                    listener: beginFormalParameters((, MemberKind.Local)
                                                    listener: endFormalParameters(0, (, ), MemberKind.Local)
                                                parseAsyncOptBody(), true, false)
                                                  parseAsyncModifierOpt())
                                                    listener: handleAsyncModifier(null, null)
                                                    inPlainSync()
                                                  parseFunctionBody(), true, false)
                                                    listener: beginBlockFunctionBody({)
                                                    notEofOrValue(}, bar)
                                                    parseStatement({)
                                                      parseStatementX({)
                                                        parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
                                                          looksLikeLocalFunction(bar)
                                                          parseExpressionStatement({)
                                                            parseExpression({)
                                                              parsePrecedenceExpression({, 1, true)
                                                                parseUnaryExpression({, true)
                                                                  parsePrimary({, expression)
                                                                    parseSendOrFunctionLiteral({, expression)
                                                                      looksLikeFunctionBody())
                                                                      parseSend({, expression)
                                                                        ensureIdentifier({, expression)
                                                                          listener: handleIdentifier(bar, expression)
                                                                        listener: handleNoTypeArguments(()
                                                                        parseArgumentsOpt(bar)
                                                                          parseArguments(bar)
                                                                            parseArgumentsRest(()
                                                                              listener: beginArguments(()
                                                                              listener: endArguments(0, (, ))
                                                                        listener: handleSend(bar, ))
                                                            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)
                                                                        ensureIdentifier(;, expression)
                                                                          reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                                                            listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., null, {token: )}], ), ))
                                                                          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, {token: ;}])
                                                      listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {token: ;}], ), ))
                                                    notEofOrValue(}, ;)
                                                    parseStatement())
                                                      parseStatementX())
                                                        parseEmptyStatement())
                                                          listener: handleEmptyStatement(;)
                                                    notEofOrValue(}, })
                                                    listener: endBlockFunctionBody(3, {, })
                                                listener: endFunctionExpression((, ))
                                    listener: endArguments(1, (, ))
                              listener: handleSend(foo, ;)
                  ensureSemicolon())
                  listener: handleExpressionStatement(;)
          notEofOrValue(}, })
          listener: endBlockFunctionBody(1, {, })
        listener: endTopLevelMethod(void, null, })
  listener: endTopLevelDeclaration()
  reportAllErrorTokens(void)
  listener: endCompilationUnit(1, )