parseUnit(foo)
  skipErrorTokens(foo)
  listener: beginCompilationUnit(foo)
  syntheticPreviousToken(foo)
  parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext')
    parseMetadataStar()
      listener: beginMetadataStar(foo)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl()
      listener: beginTopLevelMember(foo)
      isReservedKeyword(!)
      parseTopLevelMethod(, null, , Instance of 'NoType', null, foo, false)
        listener: beginTopLevelMethod(, null)
        listener: handleNoType()
        ensureIdentifierPotentiallyRecovered(, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(foo, topLevelFunctionDeclaration)
        parseMethodTypeVar(foo)
          reportRecoverableErrorWithToken(!, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token '!'., null, {token: !}], !, !)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(!, foo, false, MemberKind.TopLevelMethod)
          parseFormalParameters(!, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              listener: endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          parseExpressionFunctionBody(=>, false)
            parseExpression(=>)
              parsePrecedenceExpression(=>, 1, true)
                parseUnaryExpression(=>, true)
                  parsePrimary(=>, expression)
                    parseLiteralInt(=>)
                      listener: handleLiteralInt(42)
            ensureSemicolon(42)
            listener: handleExpressionFunctionBody(=>, ;)
            inGenerator()
        listener: endTopLevelMethod(foo, null, ;)
  listener: endTopLevelDeclaration(bar)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(bar)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(;)
      listener: beginTopLevelMember(bar)
      isReservedKeyword(!)
      parseTopLevelMethod(;, null, ;, Instance of 'NoType', null, bar, false)
        listener: beginTopLevelMethod(;, null)
        listener: handleNoType(;)
        ensureIdentifierPotentiallyRecovered(;, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(bar, topLevelFunctionDeclaration)
        parseMethodTypeVar(bar)
          reportRecoverableErrorWithToken(!, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token '!'., null, {token: !}], !, !)
          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(<, >)
        parseGetterOrFormalParameters(>, bar, false, MemberKind.TopLevelMethod)
          parseFormalParameters(>, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              listener: endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          parseExpressionFunctionBody(=>, false)
            parseExpression(=>)
              parsePrecedenceExpression(=>, 1, true)
                parseUnaryExpression(=>, true)
                  parsePrimary(=>, expression)
                    parseLiteralInt(=>)
                      listener: handleLiteralInt(42)
            ensureSemicolon(42)
            listener: handleExpressionFunctionBody(=>, ;)
            inGenerator()
        listener: endTopLevelMethod(bar, null, ;)
  listener: endTopLevelDeclaration()
  reportAllErrorTokens(foo)
  listener: endCompilationUnit(2, )
