Clang Project

clang_source_code/test/SemaCXX/cxx0x-initializer-scalars.cpp
1// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s -pedantic-errors
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 {{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    int a({0}); // expected-error {{cannot initialize non-class type 'int' with a parenthesized initializer list}}
95    (void) int({0}); // expected-error {{cannot initialize non-class type 'int' with a parenthesized initializer list}}
96    new int({0});  // expected-error {{cannot initialize non-class type 'int' with a parenthesized initializer list}}
97
98    int *b({0});  // expected-error {{cannot initialize non-class type 'int *' with a parenthesized initializer list}}
99    typedef int *intptr;
100    int *c = intptr({0});  // expected-error {{cannot initialize non-class type 'intptr' (aka 'int *') with a parenthesized initializer list}}
101  }
102
103  template<typename T> void dependent_edge_cases() {
104    T a({0});
105    (void) T({0});
106    new T({0});
107
108    T *b({0});
109    typedef T *tptr;
110    T *c = tptr({0});
111  }
112
113  void default_argument(int i = {}) {
114  }
115  struct DefaultArgument {
116    void default_argument(int i = {}) {
117    }
118  };
119}
120
121namespace PR12118 {
122  void test() {
123    one f(std::initializer_list<int>); 
124    two f(int); 
125
126    // to initializer_list is preferred
127    static_assert(sizeof(f({0})) == sizeof(one), "bad overload");
128  }
129}
130
131namespace excess_braces_sfinae {
132  using valid = int&;
133  using invalid = float&;
134
135  template<typename T> valid braces1(decltype(T{0})*);
136  template<typename T> invalid braces1(...);
137
138  template<typename T> valid braces2(decltype(T{{0}})*);
139  template<typename T> invalid braces2(...);
140
141  template<typename T> valid braces3(decltype(T{{{0}}})*);
142  template<typename T> invalid braces3(...);
143
144  valid a = braces1<int>(0);
145  invalid b = braces2<int>(0);
146  invalid c = braces3<int>(0);
147
148  struct X { int n; };
149  valid d = braces1<X>(0);
150  valid e = braces2<X>(0);
151  invalid f = braces3<X>(0);
152}
153
CodeThinker, Enjoy your reading code