Home | History | Annotate | Download | only in SemaCXX 
      1 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s -pedantic-errors
      2 
      3 struct one { char c[1]; };
      4 struct two { char c[2]; };
      5 
      6 namespace std {
      7   typedef decltype(sizeof(int)) size_t;
      8 
      9   // libc++'s implementation
     10   template <class _E>
     11   class initializer_list
     12   {
     13     const _E* __begin_;
     14     size_t    __size_;
     15 
     16     initializer_list(const _E* __b, size_t __s)
     17       : __begin_(__b),
     18         __size_(__s)
     19     {}
     20 
     21   public:
     22     typedef _E        value_type;
     23     typedef const _E& reference;
     24     typedef const _E& const_reference;
     25     typedef size_t    size_type;
     26 
     27     typedef const _E* iterator;
     28     typedef const _E* const_iterator;
     29 
     30     initializer_list() : __begin_(nullptr), __size_(0) {}
     31 
     32     size_t    size()  const {return __size_;}
     33     const _E* begin() const {return __begin_;}
     34     const _E* end()   const {return __begin_ + __size_;}
     35   };
     36 }
     37 
     38 namespace integral {
     39 
     40   void initialization() {
     41     { const int a{}; static_assert(a == 0, ""); }
     42     { const int a = {}; static_assert(a == 0, ""); }
     43     { const int a{1}; static_assert(a == 1, ""); }
     44     { const int a = {1}; static_assert(a == 1, ""); }
     45     { const int a{1, 2}; } // expected-error {{excess elements}}
     46     { const int a = {1, 2}; } // expected-error {{excess elements}}
     47     // FIXME: Redundant warnings.
     48     { const short a{100000}; } // expected-error {{cannot be narrowed}} expected-note {{insert an explicit cast}} expected-warning {{changes value}}
     49     { const short a = {100000}; } // expected-error {{cannot be narrowed}} expected-note {{insert an explicit cast}} expected-warning {{changes value}}
     50     { if (const int a{1}) static_assert(a == 1, ""); }
     51     { if (const int a = {1}) static_assert(a == 1, ""); }
     52   }
     53 
     54   int direct_usage() {
     55     int ar[10];
     56     (void) ar[{1}]; // expected-error {{array subscript is not an integer}}
     57 
     58     return {1}; // expected-warning {{braces around scalar init}}
     59   }
     60 
     61   void inline_init() {
     62     auto v = int{1};
     63     (void) new int{1};
     64   }
     65 
     66   struct A {
     67     int i;
     68     A() : i{1} {}
     69   };
     70 
     71   void function_call() {
     72     void takes_int(int);
     73     takes_int({1}); // expected-warning {{braces around scalar init}}
     74   }
     75 
     76   void overloaded_call() {
     77     one overloaded(int);
     78     two overloaded(double);
     79 
     80     static_assert(sizeof(overloaded({0})) == sizeof(one), "bad overload"); // expected-warning {{braces around scalar init}}
     81     static_assert(sizeof(overloaded({0.0})) == sizeof(two), "bad overload"); // expected-warning {{braces around scalar init}}
     82 
     83     void ambiguous(int, double); // expected-note {{candidate}}
     84     void ambiguous(double, int); // expected-note {{candidate}}
     85     ambiguous({0}, {0}); // expected-error {{ambiguous}}
     86 
     87     void emptylist(int);
     88     void emptylist(int, int, int);
     89     emptylist({});
     90     emptylist({}, {}, {});
     91   }
     92 
     93   void edge_cases() {
     94     // FIXME: very poor error message
     95     int a({0}); // expected-error {{cannot initialize}}
     96     (void) int({0}); // expected-error {{functional-style cast}}
     97     new int({0});  // expected-error {{cannot initialize}}
     98   }
     99 
    100   void default_argument(int i = {}) {
    101   }
    102   struct DefaultArgument {
    103     void default_argument(int i = {}) {
    104     }
    105   };
    106 }
    107 
    108 namespace PR12118 {
    109   void test() {
    110     one f(std::initializer_list<int>);
    111     two f(int);
    112 
    113     // to initializer_list is preferred
    114     static_assert(sizeof(f({0})) == sizeof(one), "bad overload");
    115   }
    116 }
    117