1  typedef unsigned long uintptr_t;
       2  namespace v8 {
       3  class Extension;
       4  namespace internal {
       5  class A {
       6  public:
       7    A(int) {};
       8  };
       9  class B {
      10  public:
      11    B(int) {};
      12  };
      13  class Scanner;
      14  class FuncNameInferrer;
      15  template <typename Traits> class ParserBase : Traits {
      16    class FunctionState;
      17    bool parenthesized_function_;
      18    typename Traits::Type::Scope *scope_;
      19    FunctionState *function_state_;
      20    v8::Extension *extension_;
      21    FuncNameInferrer *fni_;
      22    Scanner *scanner_;
      23    uintptr_t stack_limit_;
      24    bool stack_overflow_;
      25    bool allow_lazy_;
      26    bool allow_natives_syntax_;
      27    bool allow_generators_;
      28    bool allow_for_of_;
      29    typename Traits::Type::Zone *zone_;
      30  };
      31  class PreParserScope;
      32  class F;
      33  class PreParserTraits {
      34  public:
      35    struct Type {
      36      typedef PreParserScope Scope;
      37      typedef void Zone;
      38    };
      39  
      40  private:
      41    F *pre_parser_;
      42  };
      43  class F : ParserBase<PreParserTraits> {};
      44  class C {
      45  public:
      46    struct Type {
      47      typedef v8::internal::FuncNameInferrer Scope;
      48      typedef int Zone;
      49    };
      50  };
      51  class G : ParserBase<C> {
      52  public:
      53    static int m_fn1();
      54    static int test();
      55    F reusable_preparser_;
      56  };
      57  class D {
      58  public:
      59    D(int a) : function_(0), context_(0), nested_scope_chain_(0) { G::test(); }
      60    B function_;
      61    B context_;
      62    A nested_scope_chain_;
      63  };
      64  }
      65  }
      66  
      67  
      68