gcc/testsuite/g++.dg/torture/pr57235.C

   1 // { dg-do compile }
   2
   3 namespace std
   4 {
   5   template < class _Elem > struct char_traits
   6   {
   7   };
   8   struct _Container_base
   9   {
  10   };
  11     template < class _Ty > struct _Allocator_base
  12   {
  13   };
  14     template < class _Ty > class allocator:public _Allocator_base < _Ty >
  15   {
  16   };
  17   class _String_base:public _Container_base
  18   {
  19   };
  20 template < class _Ty, class _Alloc > class _String_val:public _String_base
  21   {
  22   };
  23 template < class _Elem, class _Traits, class _Ax > class basic_string:public _String_val < _Elem,
  24     _Ax
  25     >
  26   {
  27   public:typedef basic_string < _Elem, _Traits, _Ax > _Myt;
  28     typedef _String_val < _Elem, _Ax > _Mybase;
  29     basic_string (const _Elem * _Ptr):_Mybase ()
  30     {
  31     }
  32   };
  33   typedef basic_string < char, char_traits < char >,
  34     allocator < char > >string;
  35 }
  36
  37
  38 namespace google
  39 {
  40   namespace protobuf
  41   {
  42     namespace internal
  43     {
  44       template < class C > class scoped_ptr
  45       {
  46       public:typedef C element_type;
  47       explicit scoped_ptr (C * p = __null):ptr_ (p)
  48         {
  49         }
  50          ~scoped_ptr ()
  51         {
  52           delete ptr_;
  53         }
  54         C *get () const
  55         {
  56           return ptr_;
  57         }
  58       private:  C * ptr_;
  59       };
  60     }
  61     using internal::scoped_ptr;
  62     enum LogLevel
  63     {
  64       LOGLEVEL_INFO, LOGLEVEL_WARNING, LOGLEVEL_ERROR, LOGLEVEL_FATAL,
  65         LOGLEVEL_DFATAL = LOGLEVEL_ERROR
  66     };
  67     namespace internal
  68     {
  69       class LogMessage
  70       {
  71       public:LogMessage (LogLevel level, const char *filename,
  72                     int line);
  73          ~LogMessage ();
  74           LogMessage & operator<< (const std::string & value);
  75       };
  76       class LogFinisher
  77       {
  78       public:void operator= (LogMessage & other);
  79       };
  80     }
  81     using namespace std;
  82     class Descriptor
  83     {
  84     };
  85     class FieldDescriptor
  86     {
  87     public:
  88       const Descriptor *message_type () const;
  89       string DebugString () const;
  90     };
  91     class MessageLite
  92     {
  93     };
  94     class Message:public MessageLite
  95     {
  96     public:inline Message ()
  97       {
  98       }
  99       virtual ~ Message ();
 100       virtual Message *New () const = 0;
 101     };
 102     class MessageFactory
 103     {
 104     };
 105     class UnknownFieldSet
 106     {
 107     };
 108     class DynamicMessageFactory:public MessageFactory
 109     {
 110     public:DynamicMessageFactory ();
 111       const Message *GetPrototype (const Descriptor * type);
 112     };
 113     namespace io
 114     {
 115       class ErrorCollector
 116       {
 117       public:inline ErrorCollector ()
 118         {
 119         }
 120         virtual ~ ErrorCollector ();
 121       };
 122     }
 123     class DescriptorBuilder
 124     {
 125       class OptionInterpreter
 126       {
 127         bool SetAggregateOption (const FieldDescriptor * option_field,
 128                                  UnknownFieldSet * unknown_fields);
 129         DynamicMessageFactory dynamic_factory_;
 130       };
 131     };
 132     namespace
 133     {
 134       class AggregateErrorCollector:public io::ErrorCollector
 135       {
 136       };
 137     }
 138     bool DescriptorBuilder::OptionInterpreter::
 139       SetAggregateOption (const FieldDescriptor * option_field,
 140                           UnknownFieldSet * unknown_fields)
 141     {
 142       const Descriptor *type = option_field->message_type ();
 143       scoped_ptr < Message >
 144         dynamic (dynamic_factory_.GetPrototype (type)->New ());
 145       !(!(dynamic.get () !=
 146           __null)) ? (void) 0 : ::google::protobuf::internal::
 147         LogFinisher () =::google::protobuf::internal::LogMessage (::google::
 148                                                                   protobuf::
 149                                                                   LOGLEVEL_FATAL,
 150                                                                   "descriptor.cc",
 151                                                                   4396) <<
 152         option_field->DebugString ();
 153       AggregateErrorCollector collector;
 154     }
 155   }
 156 }