test/CXX/drs/dr13xx.cpp

   1 // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
   2 // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
   3 // RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
   4 // RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
   5
   6 __extension__ typedef __SIZE_TYPE__ size_t;
   7
   8 namespace std {
   9   template<typename T> struct initializer_list {
  10     const T *ptr;
  11     size_t n;
  12     initializer_list(const T*, size_t);
  13   };
  14 }
  15
  16 namespace dr1310 { // dr1310: 5
  17   struct S {} * sp = new S::S; // expected-error {{qualified reference to 'S' is a constructor name}}
  18   void f() {
  19     S::S(a); // expected-error {{qualified reference to 'S' is a constructor name}}
  20   }
  21   struct T { int n; typedef int U; typedef T V; };
  22   int k = T().T::T::n;
  23   T::V v;
  24
  25   struct U { int U; };
  26   int u = U().U::U;
  27   struct U::U w;
  28
  29   struct V : T::T {
  30     // FIXME: This is technically ill-formed, but we consider that to be a defect.
  31     V() : T::T() {}
  32   };
  33   template<typename T> struct VT : T::T {
  34     VT() : T::T() {}
  35   };
  36   template struct VT<T>;
  37
  38   template<template<typename> class> class TT {};
  39   template<typename> class TTy {};
  40
  41   template<typename T> struct WBase {};
  42   template<typename T> struct W : WBase<T> { typedef int X; int n; };
  43
  44   void w_test() {
  45     W<int>::W w1a; // expected-error {{qualified reference to 'W' is a constructor name}}
  46     W<int>::W::X w1ax;
  47     W<int>::W<int> w1b; // expected-error {{qualified reference to 'W' is a constructor name}}
  48     W<int>::W<int>::X w1bx;
  49     typename W<int>::W w2a; // expected-error {{qualified reference to 'W' is a constructor name}} expected-error 0-1{{outside of a template}}
  50     typename W<int>::W::X w2ax; // expected-error 0-1{{outside of a template}}
  51     typename W<int>::W<int> w2b; // expected-error {{qualified reference to 'W' is a constructor name}} expected-error 0-1{{outside of a template}}
  52     typename W<int>::W<int>::X w2bx; // expected-error 0-1{{outside of a template}}
  53     W<int>::template W<int> w3; // expected-error {{qualified reference to 'W' is a constructor name}} expected-error 0-1{{outside of a template}}
  54     W<int>::template W<int>::X w3x; // expected-error 0-1{{outside of a template}}
  55     typename W<int>::template W<int> w4; // expected-error {{qualified reference to 'W' is a constructor name}} expected-error 0-2{{outside of a template}}
  56     typename W<int>::template W<int>::X w4x; // expected-error 0-2{{outside of a template}}
  57
  58     TT<W<int>::W> tt1; // expected-error {{qualified reference to 'W' is a constructor name}}
  59     TTy<W<int>::W> tt1a; // expected-error {{qualified reference to 'W' is a constructor name}}
  60     TT<W<int>::template W> tt2; // expected-error {{qualified reference to 'W' is a constructor name}} expected-error 0-1{{outside of a template}}
  61     TT<W<int>::WBase> tt3;
  62     TTy<W<int>::WBase> tt3a;
  63     TT<W<int>::template WBase> tt4; // expected-error 0-1{{outside of a template}}
  64
  65     W<int> w;
  66     (void)w.W::W::n;
  67     (void)w.W<int>::W::n;
  68     (void)w.W<int>::W<int>::n;
  69     (void)w.W<int>::template W<int>::n; // expected-error 0-1{{outside of a template}}
  70   }
  71
  72   template<typename W>
  73   void wt_test() {
  74     typename W::W w2a; // expected-error {{qualified reference to 'W' is a constructor name}}
  75     typename W::template W<int> w4; // expected-error {{qualified reference to 'W' is a constructor name}}
  76     TTy<typename W::W> tt2; // expected-error {{qualified reference to 'W' is a constructor name}}
  77     TT<W::template W> tt3; // expected-error {{qualified reference to 'W' is a constructor name}}
  78   }
  79   template<typename W>
  80   void wt_test_good() {
  81     typename W::W::X w2ax;
  82     typename W::template W<int>::X w4x;
  83     TTy<typename W::WBase> tt4;
  84     TT<W::template WBase> tt5;
  85
  86     W w;
  87     (void)w.W::W::n;
  88     (void)w.W::template W<int>::n;
  89     (void)w.template W<int>::W::n;
  90     (void)w.template W<int>::template W<int>::n;
  91   }
  92   template void wt_test<W<int> >(); // expected-note {{instantiation of}}
  93   template void wt_test_good<W<int> >();
  94 }
  95
  96 namespace dr1315 { // dr1315: partial
  97   template <int I, int J> struct A {};
  98   template <int I> // expected-note {{non-deducible template parameter 'I'}}
  99     struct A<I + 5, I * 2> {}; // expected-error {{contains a template parameter that cannot be deduced}}
 100   template <int I> struct A<I, I> {};
 101
 102   template <int I, int J, int K> struct B;
 103   template <int I, int K> struct B<I, I * 2, K> {}; // expected-note {{matches}}
 104   B<1, 2, 3> b1;
 105
 106   // Multiple declarations with the same dependent expression are equivalent
 107   // for partial ordering purposes.
 108   template <int I> struct B<I, I * 2, 2> { typedef int type; };
 109   B<1, 2, 2>::type b2;
 110
 111   // Multiple declarations with differing dependent expressions are unordered.
 112   template <int I, int K> struct B<I, I + 1, K> {}; // expected-note {{matches}}
 113   B<1, 2, 4> b3; // expected-error {{ambiguous}}
 114
 115   // FIXME: Under dr1315, this is perhaps valid, but that is not clear: this
 116   // fails the "more specialized than the primary template" test because the
 117   // dependent type of T::value is not the same as 'int'.
 118   // A core issue will be opened to decide what is supposed to happen here.
 119   template <typename T, int I> struct C;
 120   template <typename T> struct C<T, T::value>;
 121   // expected-error@-1 {{type of specialized non-type template argument depends on a template parameter of the partial specialization}}
 122 }
 123
 124 namespace dr1330 { // dr1330: 4 c++11
 125   // exception-specifications are parsed in a context where the class is complete.
 126   struct A {
 127     void f() throw(T) {} // expected-error 0-1{{C++17}} expected-note 0-1{{noexcept}}
 128     struct T {};
 129
 130 #if __cplusplus >= 201103L
 131     void g() noexcept(&a == b) {}
 132     static int a;
 133     static constexpr int *b = &a;
 134 #endif
 135   };
 136
 137   void (A::*af1)() throw(A::T) = &A::f; // expected-error 0-1{{C++17}} expected-note 0-1{{noexcept}}
 138   void (A::*af2)() throw() = &A::f; // expected-error-re {{{{not superset|different exception spec}}}}
 139
 140 #if __cplusplus >= 201103L
 141   static_assert(noexcept(A().g()), "");
 142 #endif
 143
 144   // Likewise, they're instantiated separately from an enclosing class template.
 145   template<typename U>
 146   struct B {
 147     void f() throw(T, typename U::type) {} // expected-error 0-1{{C++17}} expected-note 0-1{{noexcept}}
 148     struct T {};
 149
 150 #if __cplusplus >= 201103L
 151     void g() noexcept(&a == b && U::value) {}
 152     static int a;
 153     static constexpr int *b = &a;
 154 #endif
 155   };
 156
 157   B<int> bi; // ok
 158
 159   struct P {
 160     typedef int type;
 161     static const int value = true;
 162   };
 163
 164   void (B<P>::*bpf1)() throw(B<P>::T, int) = &B<P>::f; // expected-error 0-1{{C++17}} expected-note 0-1{{noexcept}}
 165 #if __cplusplus < 201103L
 166   // expected-error@-2 {{not superset}}
 167   // FIXME: We only delay instantiation in C++11 onwards. In C++98, something
 168   // weird happens: instantiation of B<P> fails because it references T before
 169   // it's instantiated, but the diagnostic is suppressed in
 170   // Sema::FindInstantiatedDecl because we've already hit an error. This is
 171   // obviously a bad way to react to this situation; we should still producing
 172   // the "T has not yet been instantiated" error here, rather than giving
 173   // confusing errors later on.
 174 #endif
 175   void (B<P>::*bpf2)() throw(int) = &B<P>::f; // expected-error 0-1{{C++17}} expected-note 0-1{{noexcept}}
 176 #if __cplusplus <= 201402L
 177   // expected-error@-2 {{not superset}}
 178 #else
 179   // expected-warning@-4 {{not superset}}
 180 #endif
 181   void (B<P>::*bpf3)() = &B<P>::f;
 182   void (B<P>::*bpf4)() throw() = &B<P>::f;
 183 #if __cplusplus <= 201402L
 184   // expected-error@-2 {{not superset}}
 185 #else
 186   // expected-error@-4 {{different exception specifications}}
 187 #endif
 188
 189 #if __cplusplus >= 201103L
 190   static_assert(noexcept(B<P>().g()), "");
 191   struct Q { static const int value = false; };
 192   static_assert(!noexcept(B<Q>().g()), "");
 193 #endif
 194
 195   template<typename T> int f() throw(typename T::error) { return 0; } // expected-error 1-4{{prior to '::'}} expected-note 0-1{{prior to '::'}} expected-note 0-1{{requested here}}
 196 #if __cplusplus > 201402L
 197     // expected-error@-2 0-1{{C++17}} expected-note@-2 0-1{{noexcept}}
 198 #endif
 199   // An exception-specification is needed even if the function is only used in
 200   // an unevaluated operand.
 201   int f1 = sizeof(f<int>()); // expected-note {{instantiation of}}
 202 #if __cplusplus >= 201103L
 203   decltype(f<char>()) f2; // expected-note {{instantiation of}}
 204   bool f3 = noexcept(f<float>()); // expected-note {{instantiation of}}
 205 #endif
 206   // In C++17 onwards, substituting explicit template arguments into the
 207   // function type substitutes into the exception specification (because it's
 208   // part of the type). In earlier languages, we don't notice there's a problem
 209   // until we've already started to instantiate.
 210   template int f<short>();
 211 #if __cplusplus >= 201703L
 212   // expected-error@-2 {{does not refer to a function template}}
 213 #else
 214   // expected-note@-4 {{instantiation of}}
 215 #endif
 216
 217   template<typename T> struct C {
 218     C() throw(typename T::type); // expected-error 1-2{{prior to '::'}}
 219 #if __cplusplus > 201402L
 220     // expected-error@-2 0-1{{C++17}} expected-note@-2 0-1{{noexcept}}
 221 #endif
 222   };
 223   struct D : C<void> {}; // ok
 224 #if __cplusplus < 201103L
 225   // expected-note@-2 {{instantiation of}}
 226 #endif
 227   void f(D &d) { d = d; } // ok
 228
 229   struct E : C<int> {}; // expected-note {{in instantiation of}}
 230 #if __cplusplus >= 201103L
 231   E e; // expected-note {{needed here}}
 232 #endif
 233 }
 234
 235 namespace dr1346 { // dr1346: 3.5
 236   auto a(1); // expected-error 0-1{{extension}}
 237   auto b(1, 2); // expected-error {{multiple expressions}} expected-error 0-1{{extension}}
 238 #if __cplusplus >= 201103L
 239   auto c({}); // expected-error {{parenthesized initializer list}}
 240   auto d({1}); // expected-error {{parenthesized initializer list}}
 241   auto e({1, 2}); // expected-error {{parenthesized initializer list}}
 242 #endif
 243   template<typename...Ts> void f(Ts ...ts) { // expected-error 0-1{{extension}}
 244     auto x(ts...); // expected-error {{empty}} expected-error 0-1{{extension}}
 245   }
 246   template void f(); // expected-note {{instantiation}}
 247
 248 #if __cplusplus >= 201103L
 249   void init_capture() {
 250     [a(1)] {} (); // expected-error 0-1{{extension}}
 251     [b(1, 2)] {} (); // expected-error {{multiple expressions}} expected-error 0-1{{extension}}
 252 #if __cplusplus >= 201103L
 253     [c({})] {} (); // expected-error {{parenthesized initializer list}} expected-error 0-1{{extension}}
 254     [d({1})] {} (); // expected-error {{parenthesized initializer list}} expected-error 0-1{{extension}}
 255     [e({1, 2})] {} (); // expected-error {{parenthesized initializer list}} expected-error 0-1{{extension}}
 256 #endif
 257   }
 258 #endif
 259 }
 260
 261 namespace dr1347 { // dr1347: yes
 262   auto x = 5, *y = &x; // expected-error 0-1{{extension}}
 263   auto z = y, *q = y; // expected-error {{'auto' deduced as 'int *' in declaration of 'z' and deduced as 'int' in declaration of 'q'}} expected-error 0-1{{extension}}
 264 #if __cplusplus >= 201103L
 265   auto a = 5, b = {1, 2}; // expected-error {{'auto' deduced as 'int' in declaration of 'a' and deduced as 'std::initializer_list<int>' in declaration of 'b'}}
 266   auto (*fp)(int) -> int, i = 0; // expected-error {{declaration with trailing return type must be the only declaration in its group}}
 267 #endif
 268 }
 269
 270 namespace dr1359 { // dr1359: 3.5
 271 #if __cplusplus >= 201103L
 272   union A { constexpr A() = default; };
 273   union B { constexpr B() = default; int a; }; // expected-error {{not constexpr}} expected-note 2{{candidate}}
 274   union C { constexpr C() = default; int a, b; }; // expected-error {{not constexpr}} expected-note 2{{candidate}}
 275   struct X { constexpr X() = default; union {}; };
 276   struct Y { constexpr Y() = default; union { int a; }; }; // expected-error {{not constexpr}} expected-note 2{{candidate}}
 277
 278   constexpr A a = A();
 279   constexpr B b = B(); // expected-error {{no matching}}
 280   constexpr C c = C(); // expected-error {{no matching}}
 281   constexpr X x = X();
 282   constexpr Y y = Y(); // expected-error {{no matching}}
 283 #endif
 284 }
 285
 286 namespace dr1388 { // dr1388: 4
 287   template<typename A, typename ...T> void f(T..., A); // expected-note 1+{{candidate}} expected-error 0-1{{C++11}}
 288   template<typename ...T> void g(T..., int); // expected-note 1+{{candidate}} expected-error 0-1{{C++11}}
 289   template<typename ...T, typename A> void h(T..., A); // expected-note 1+{{candidate}} expected-error 0-1{{C++11}}
 290
 291   void test_f() {
 292     f(0); // ok, trailing parameter pack deduced to empty
 293     f(0, 0); // expected-error {{no matching}}
 294     f<int>(0);
 295     f<int>(0, 0); // expected-error {{no matching}}
 296     f<int, int>(0, 0);
 297     f<int, int, int>(0, 0); // expected-error {{no matching}}
 298
 299     g(0);
 300     g(0, 0); // expected-error {{no matching}}
 301     g<>(0);
 302     g<int>(0); // expected-error {{no matching}}
 303     g<int>(0, 0);
 304
 305     h(0);
 306     h(0, 0); // expected-error {{no matching}}
 307     h<int>(0, 0);
 308     h<int, int>(0, 0); // expected-error {{no matching}}
 309   }
 310
 311   // A non-trailing parameter pack is still a non-deduced context, even though
 312   // we know exactly how many arguments correspond to it.
 313   template<typename T, typename U> struct pair {};
 314   template<typename ...T> struct tuple { typedef char type; }; // expected-error 0-2{{C++11}}
 315   template<typename ...T, typename ...U> void f_pair_1(pair<T, U>..., int); // expected-error 0-2{{C++11}} expected-note {{different lengths (2 vs. 0)}}
 316   template<typename ...T, typename U> void f_pair_2(pair<T, char>..., U); // expected-error 0-2{{C++11}}
 317   template<typename ...T, typename ...U> void f_pair_3(pair<T, U>..., tuple<U...>); // expected-error 0-2{{C++11}} expected-note {{different lengths (2 vs. 1)}}
 318   template<typename ...T> void f_pair_4(pair<T, char>..., T...); // expected-error 0-2{{C++11}} expected-note {{<int, long> vs. <int, long, const char *>}}
 319   void g(pair<int, char> a, pair<long, char> b, tuple<char, char> c) {
 320     f_pair_1<int, long>(a, b, 0); // expected-error {{no match}}
 321     f_pair_2<int, long>(a, b, 0);
 322     f_pair_3<int, long>(a, b, c);
 323     f_pair_3<int, long>(a, b, tuple<char>()); // expected-error {{no match}}
 324     f_pair_4<int, long>(a, b, 0, 0L);
 325     f_pair_4<int, long>(a, b, 0, 0L, "foo"); // expected-error {{no match}}
 326   }
 327 }
 328
 329 namespace dr1391 { // dr1391: partial
 330   struct A {}; struct B : A {};
 331   template<typename T> struct C { C(int); typename T::error error; }; // expected-error 2{{'::'}}
 332   template<typename T> struct D {};
 333
 334   // No deduction is performed for parameters with no deducible template-parameters, therefore types do not need to match.
 335   template<typename T> void a(T, int T::*);
 336   void test_a(int A::*p) { a(A(), p); } // ok, type of second parameter does not need to match
 337
 338   namespace dr_example_1 {
 339     template<typename T, typename U> void f(C<T>);
 340     template<typename T> void f(D<T>);
 341
 342     void g(D<int> d) {
 343       f(d); // ok, first 'f' eliminated by deduction failure
 344       f<int>(d); // ok, first 'f' eliminated because 'U' cannot be deduced
 345     }
 346   }
 347
 348   namespace dr_example_2 {
 349     template<typename T> typename C<T>::error f(int, T);
 350     template<typename T> T f(T, T);
 351
 352     void g(A a) {
 353       f(a, a); // ok, no conversion from A to int for first parameter of first candidate
 354     }
 355   }
 356
 357   namespace std_example {
 358     template<typename T> struct Z {
 359       typedef typename T::x xx;
 360     };
 361     template<typename T> typename Z<T>::xx f(void *, T);
 362     template<typename T> void f(int, T);
 363     struct A {} a;
 364     void g() { f(1, a); }
 365   }
 366
 367   template<typename T> void b(C<int> ci, T *p);
 368   void b(...);
 369   void test_b() {
 370     b(0, 0); // ok, deduction fails prior to forming a conversion sequence and instantiating C<int>
 371     // FIXME: The "while substituting" note should point at the overload candidate.
 372     b<int>(0, 0); // expected-note {{instantiation of}} expected-note {{while substituting}}
 373   }
 374
 375   template<typename T> struct Id { typedef T type; };
 376   template<typename T> void c(T, typename Id<C<T> >::type);
 377   void test_c() {
 378     // Implicit conversion sequences for dependent types are checked later.
 379     c(0.0, 0); // expected-note {{instantiation of}}
 380   }
 381
 382   namespace partial_ordering {
 383     // FIXME: Second template should be considered more specialized because non-dependent parameter is ignored.
 384     template<typename T> int a(T, short) = delete; // expected-error 0-1{{extension}} expected-note {{candidate}}
 385     template<typename T> int a(T*, char); // expected-note {{candidate}}
 386     int test_a = a((int*)0, 0); // FIXME: expected-error {{ambiguous}}
 387
 388     // FIXME: Second template should be considered more specialized:
 389     // deducing #1 from #2 ignores the second P/A pair, so deduction succeeds,
 390     // deducing #2 from #1 fails to deduce T, so deduction fails.
 391     template<typename T> int b(T, int) = delete; // expected-error 0-1{{extension}} expected-note {{candidate}}
 392     template<typename T, typename U> int b(T*, U); // expected-note {{candidate}}
 393     int test_b = b((int*)0, 0); // FIXME: expected-error {{ambiguous}}
 394
 395     // Unintended consequences: because partial ordering does not consider
 396     // explicit template arguments, and deduction from a non-dependent type
 397     // vacuously succeeds, a non-dependent template is less specialized than
 398     // anything else!
 399     // According to DR1391, this is ambiguous!
 400     template<typename T> int c(int);
 401     template<typename T> int c(T);
 402     int test_c1 = c(0); // ok
 403     int test_c2 = c<int>(0); // FIXME: apparently ambiguous
 404   }
 405 }
 406
 407 namespace dr1399 { // dr1399: dup 1388
 408   template<typename ...T> void f(T..., int, T...) {} // expected-note {{candidate}} expected-error 0-1{{C++11}}
 409   void g() {
 410     f(0);
 411     f<int>(0, 0, 0);
 412     f(0, 0, 0); // expected-error {{no match}}
 413   }
 414 }