1// RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
2// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
3// RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
4// RUN: %clang_cc1 -std=c++1z -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
5
6#if __cplusplus < 201103L
7// expected-no-diagnostics
8#endif
9
10namespace dr1550 { // dr1550: yes
11  int f(bool b, int n) {
12    return (b ? (throw 0) : n) + (b ? n : (throw 0));
13  }
14}
15
16namespace dr1560 { // dr1560: 3.5
17  void f(bool b, int n) {
18    (b ? throw 0 : n) = (b ? n : throw 0) = 0;
19  }
20  class X { X(const X&); };
21  const X &get();
22  const X &x = true ? get() : throw 0;
23}
24
25namespace dr1573 { // dr1573: 3.9
26#if __cplusplus >= 201103L
27  // ellipsis is inherited (p0136r1 supersedes this part).
28  struct A { A(); A(int, char, ...); };
29  struct B : A { using A::A; };
30  B b(1, 'x', 4.0, "hello"); // ok
31
32  // inherited constructor is effectively constexpr if the user-written constructor would be
33  struct C { C(); constexpr C(int) {} };
34  struct D : C { using C::C; };
35  constexpr D d = D(0); // ok
36  struct E : C { using C::C; A a; }; // expected-note {{non-literal type}}
37  constexpr E e = E(0); // expected-error {{non-literal type}}
38  // FIXME: This diagnostic is pretty bad; we should explain that the problem
39  // is that F::c would be initialized by a non-constexpr constructor.
40  struct F : C { using C::C; C c; }; // expected-note {{here}}
41  constexpr F f = F(0); // expected-error {{constant expression}} expected-note {{constructor inherited from base class 'C'}}
42
43  // inherited constructor is effectively deleted if the user-written constructor would be
44  struct G { G(int); };
45  struct H : G { using G::G; G g; }; // expected-note {{constructor inherited by 'H' is implicitly deleted because field 'g' has no default constructor}}
46  H h(0); // expected-error {{constructor inherited by 'H' from base class 'G' is implicitly deleted}}
47#endif
48}
49
50#if __cplusplus >= 201103L
51namespace std {
52  typedef decltype(sizeof(int)) size_t;
53
54  // libc++'s implementation
55  template <class _E>
56  class initializer_list
57  {
58    const _E* __begin_;
59    size_t    __size_;
60
61    initializer_list(const _E* __b, size_t __s)
62    : __begin_(__b), __size_(__s) {}
63
64  public:
65    typedef _E        value_type;
66    typedef const _E& reference;
67    typedef const _E& const_reference;
68    typedef size_t    size_type;
69
70    typedef const _E* iterator;
71    typedef const _E* const_iterator;
72
73    initializer_list() : __begin_(nullptr), __size_(0) {}
74
75    size_t    size()  const {return __size_;}
76    const _E* begin() const {return __begin_;}
77    const _E* end()   const {return __begin_ + __size_;}
78  };
79
80  template < class _T1, class _T2 > struct pair { _T2 second; };
81
82  template<typename T> struct basic_string {
83    basic_string(const T* x) {}
84    ~basic_string() {};
85  };
86  typedef basic_string<char> string;
87
88} // std
89
90namespace dr1579 { // dr1579: 3.9
91template<class T>
92struct GenericMoveOnly {
93  GenericMoveOnly();
94  template<class U> GenericMoveOnly(const GenericMoveOnly<U> &) = delete; // expected-note 5 {{marked deleted here}}
95  GenericMoveOnly(const int &) = delete; // expected-note 2 {{marked deleted here}}
96  template<class U> GenericMoveOnly(GenericMoveOnly<U> &&);
97  GenericMoveOnly(int &&);
98};
99
100GenericMoveOnly<float> DR1579_Eligible(GenericMoveOnly<char> CharMO) {
101  int i;
102  GenericMoveOnly<char> GMO;
103
104  if (0)
105    return i;
106  else if (0)
107    return GMO;
108  else if (0)
109    return ((GMO));
110  else
111    return CharMO;
112}
113
114GenericMoveOnly<char> GlobalMO;
115
116GenericMoveOnly<float> DR1579_Ineligible(int &AnInt,
117                                          GenericMoveOnly<char> &CharMO) {
118  static GenericMoveOnly<char> StaticMove;
119  extern GenericMoveOnly<char> ExternMove;
120
121  if (0)
122    return AnInt; // expected-error{{invokes a deleted function}}
123  else if (0)
124    return GlobalMO; // expected-error{{invokes a deleted function}}
125  else if (0)
126    return StaticMove; // expected-error{{invokes a deleted function}}
127  else if (0)
128    return ExternMove; // expected-error{{invokes a deleted function}}
129  else if (0)
130    return AnInt; // expected-error{{invokes a deleted function}}
131  else
132    return CharMO; // expected-error{{invokes a deleted function}}
133}
134
135auto DR1579_lambda_valid = [](GenericMoveOnly<float> mo) ->
136  GenericMoveOnly<char> {
137  return mo;
138};
139
140auto DR1579_lambda_invalid = []() -> GenericMoveOnly<char> {
141  static GenericMoveOnly<float> mo;
142  return mo; // expected-error{{invokes a deleted function}}
143};
144} // end namespace dr1579
145
146namespace dr1589 {   // dr1589: 3.7 c++11
147  // Ambiguous ranking of list-initialization sequences
148
149  void f0(long, int=0);                 // Would makes selection of #0 ambiguous
150  void f0(long);                        // #0
151  void f0(std::initializer_list<int>);  // #00
152  void g0() { f0({1L}); }               // chooses #00
153
154  void f1(int, int=0);                    // Would make selection of #1 ambiguous
155  void f1(int);                           // #1
156  void f1(std::initializer_list<long>);   // #2
157  void g1() { f1({42}); }                 // chooses #2
158
159  void f2(std::pair<const char*, const char*>, int = 0); // Would makes selection of #3 ambiguous
160  void f2(std::pair<const char*, const char*>); // #3
161  void f2(std::initializer_list<std::string>);  // #4
162  void g2() { f2({"foo","bar"}); }              // chooses #4
163
164  namespace with_error {
165    void f0(long);                        // #0    expected-note {{candidate function}}
166    void f0(std::initializer_list<int>);  // #00   expected-note {{candidate function}}
167    void f0(std::initializer_list<int>, int = 0);  // Makes selection of #00 ambiguous \
168    // expected-note {{candidate function}}
169    void g0() { f0({1L}); }                 // chooses #00    expected-error{{call to 'f0' is ambiguous}}
170
171    void f1(int);                           // #1   expected-note {{candidate function}}
172    void f1(std::initializer_list<long>);   // #2   expected-note {{candidate function}}
173    void f1(std::initializer_list<long>, int = 0);   // Makes selection of #00 ambiguous \
174    // expected-note {{candidate function}}
175    void g1() { f1({42}); }                 // chooses #2   expected-error{{call to 'f1' is ambiguous}}
176
177    void f2(std::pair<const char*, const char*>); // #3   TODO: expected- note {{candidate function}}
178    void f2(std::initializer_list<std::string>);  // #4   expected-note {{candidate function}}
179    void f2(std::initializer_list<std::string>, int = 0);   // Makes selection of #00 ambiguous \
180    // expected-note {{candidate function}}
181    void g2() { f2({"foo","bar"}); }        // chooses #4   expected-error{{call to 'f2' is ambiguous}}
182  }
183
184} // dr1589
185
186namespace dr1591 {  //dr1591. Deducing array bound and element type from initializer list
187  template<class T, int N> int h(T const(&)[N]);
188  int X = h({1,2,3});              // T deduced to int, N deduced to 3
189
190  template<class T> int j(T const(&)[3]);
191  int Y = j({42});                 // T deduced to int, array bound not considered
192
193  struct Aggr { int i; int j; };
194  template<int N> int k(Aggr const(&)[N]); //expected-note{{not viable}}
195  int Y0 = k({1,2,3});              //expected-error{{no matching function}}
196  int Z = k({{1},{2},{3}});        // OK, N deduced to 3
197
198  template<int M, int N> int m(int const(&)[M][N]);
199  int X0 = m({{1,2},{3,4}});        // M and N both deduced to 2
200
201  template<class T, int N> int n(T const(&)[N], T);
202  int X1 = n({{1},{2},{3}},Aggr()); // OK, T is Aggr, N is 3
203
204
205  namespace check_multi_dim_arrays {
206    template<class T, int N, int M, int O> int ***f(const T (&a)[N][M][O]); //expected-note{{deduced conflicting values}}
207    template<class T, int N, int M> int **f(const T (&a)[N][M]); //expected-note{{couldn't infer}}
208
209   template<class T, int N> int *f(const T (&a)[N]); //expected-note{{couldn't infer}}
210    int ***p3 = f({  {  {1,2}, {3, 4}  }, {  {5,6}, {7, 8}  }, {  {9,10}, {11, 12}  } });
211    int ***p33 = f({  {  {1,2}, {3, 4}  }, {  {5,6}, {7, 8}  }, {  {9,10}, {11, 12, 13}  } }); //expected-error{{no matching}}
212    int **p2 = f({  {1,2,3}, {3, 4, 5}  });
213    int **p22 = f({  {1,2}, {3, 4}  });
214    int *p1 = f({1, 2, 3});
215  }
216  namespace check_multi_dim_arrays_rref {
217    template<class T, int N, int M, int O> int ***f(T (&&a)[N][M][O]); //expected-note{{deduced conflicting values}}
218    template<class T, int N, int M> int **f(T (&&a)[N][M]); //expected-note{{couldn't infer}}
219
220    template<class T, int N> int *f(T (&&a)[N]); //expected-note{{couldn't infer}}
221    int ***p3 = f({  {  {1,2}, {3, 4}  }, {  {5,6}, {7, 8}  }, {  {9,10}, {11, 12}  } });
222    int ***p33 = f({  {  {1,2}, {3, 4}  }, {  {5,6}, {7, 8}  }, {  {9,10}, {11, 12, 13}  } }); //expected-error{{no matching}}
223    int **p2 = f({  {1,2,3}, {3, 4, 5}  });
224    int **p22 = f({  {1,2}, {3, 4}  });
225    int *p1 = f({1, 2, 3});
226  }
227
228  namespace check_arrays_of_init_list {
229    template<class T, int N> float *f(const std::initializer_list<T> (&)[N]);
230    template<class T, int N> double *f(const T(&)[N]);
231    double *p = f({1, 2, 3});
232    float *fp = f({{1}, {1, 2}, {1, 2, 3}});
233  }
234  namespace core_reflector_28543 {
235
236    template<class T, int N> int *f(T (&&)[N]);  // #1
237    template<class T> char *f(std::initializer_list<T> &&);  //#2
238    template<class T, int N, int M> int **f(T (&&)[N][M]); //#3 expected-note{{candidate}}
239    template<class T, int N> char **f(std::initializer_list<T> (&&)[N]); //#4 expected-note{{candidate}}
240
241    template<class T> short *f(T (&&)[2]);  //#5
242
243    template<class T> using Arr = T[];
244
245    char *pc = f({1, 2, 3}); // OK prefer #2 via 13.3.3.2 [over.ics.rank]
246    char *pc2 = f({1, 2}); // #2 also
247    int *pi = f(Arr<int>{1, 2, 3}); // OK prefer #1
248
249    void *pv1 = f({ {1, 2, 3}, {4, 5, 6} }); // expected-error{{ambiguous}} btw 3 & 4
250    char **pcc = f({ {1}, {2, 3} }); // OK #4
251
252    short *ps = f(Arr<int>{1, 2});  // OK #5
253  }
254} // dr1591
255
256#endif
257