cxx0x-initializer-scalars.cpp revision 2422e82b54aa115bba23da3a44998477720ef6a4 
1// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
2
3struct one { char c[1]; };
4struct two { char c[2]; };
5
6namespace 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
38namespace 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 {{inserting an explicit cast}} expected-warning {{changes value}}
49    { const short a = {100000}; } // expected-error {{cannot be narrowed}} expected-note {{inserting 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};
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});
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");
81    static_assert(sizeof(overloaded({0.0})) == sizeof(two), "bad overload");
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
101namespace PR12118 {
102  void test() {
103    one f(std::initializer_list<int>);
104    two f(int);
105
106    // to initializer_list is preferred
107    static_assert(sizeof(f({0})) == sizeof(one), "bad overload");
108  }
109}
110