clang/test/SemaCXX/cxx1z-class-template-argument-deduction.cpp

   1 // RUN: %clang_cc1 -std=c++1z -verify %s -DERRORS -Wundefined-func-template
   2 // RUN: %clang_cc1 -std=c++1z -verify %s -UERRORS -Wundefined-func-template
   3
   4 // This test is split into two because we only produce "undefined internal"
   5 // warnings if we didn't produce any errors.
   6 #if ERRORS
   7
   8 namespace std {
   9   using size_t = decltype(sizeof(0));
  10   template<typename T> struct initializer_list {
  11     const T *p;
  12     size_t n;
  13     initializer_list();
  14   };
  15   // FIXME: This should probably not be necessary.
  16   template<typename T> initializer_list(initializer_list<T>) -> initializer_list<T>;
  17 }
  18
  19 template<typename T> constexpr bool has_type(...) { return false; }
  20 template<typename T> constexpr bool has_type(T&) { return true; }
  21
  22 std::initializer_list il = {1, 2, 3, 4, 5};
  23
  24 template<typename T> struct vector {
  25   template<typename Iter> vector(Iter, Iter);
  26   vector(std::initializer_list<T>);
  27 };
  28
  29 template<typename T> vector(std::initializer_list<T>) -> vector<T>;
  30 template<typename Iter> explicit vector(Iter, Iter) -> vector<typename Iter::value_type>;
  31 template<typename T> explicit vector(std::size_t, T) -> vector<T>;
  32
  33 vector v1 = {1, 2, 3, 4};
  34 static_assert(has_type<vector<int>>(v1));
  35
  36 struct iter { typedef char value_type; } it, end;
  37 vector v2(it, end);
  38 static_assert(has_type<vector<char>>(v2));
  39
  40 vector v3(5, 5);
  41 static_assert(has_type<vector<int>>(v3));
  42
  43 vector v4 = {it, end};
  44 static_assert(has_type<vector<iter>>(v4));
  45
  46 vector v5{it, end};
  47 static_assert(has_type<vector<iter>>(v5));
  48
  49 template<typename ...T> struct tuple { tuple(T...); };
  50 template<typename ...T> explicit tuple(T ...t) -> tuple<T...>; // expected-note {{declared}}
  51 // FIXME: Remove
  52 template<typename ...T> tuple(tuple<T...>) -> tuple<T...>;
  53
  54 const int n = 4;
  55 tuple ta = tuple{1, 'a', "foo", n};
  56 static_assert(has_type<tuple<int, char, const char*, int>>(ta));
  57
  58 tuple tb{ta};
  59 static_assert(has_type<tuple<int, char, const char*, int>>(tb));
  60
  61 // FIXME: This should be tuple<tuple<...>>; when the above guide is removed.
  62 tuple tc = {ta};
  63 static_assert(has_type<tuple<int, char, const char*, int>>(tc));
  64
  65 tuple td = {1, 2, 3}; // expected-error {{selected an explicit deduction guide}}
  66 static_assert(has_type<tuple<int, char, const char*, int>>(td));
  67
  68 // FIXME: This is a GCC extension for now; if CWG don't allow this, at least
  69 // add a warning for it.
  70 namespace new_expr {
  71   tuple<int> *p = new tuple{0};
  72   tuple<float, float> *q = new tuple(1.0f, 2.0f);
  73 }
  74
  75 namespace ambiguity {
  76   template<typename T> struct A {};
  77   A(unsigned short) -> A<int>; // expected-note {{candidate}}
  78   A(short) -> A<int>; // expected-note {{candidate}}
  79   A a = 0; // expected-error {{ambiguous deduction for template arguments of 'A'}}
  80
  81   template<typename T> struct B {};
  82   template<typename T> B(T(&)(int)) -> B<int>; // expected-note {{candidate function [with T = int]}}
  83   template<typename T> B(int(&)(T)) -> B<int>; // expected-note {{candidate function [with T = int]}}
  84   int f(int);
  85   B b = f; // expected-error {{ambiguous deduction for template arguments of 'B'}}
  86 }
  87
  88 // FIXME: Revisit this once CWG decides if attributes, and [[deprecated]] in
  89 // particular, should be permitted here.
  90 namespace deprecated {
  91   template<typename T> struct A { A(int); };
  92   [[deprecated]] A(int) -> A<void>; // expected-note {{marked deprecated here}}
  93   A a = 0; // expected-warning {{'<deduction guide for A>' is deprecated}}
  94 }
  95
  96 namespace dependent {
  97   template<template<typename...> typename A> decltype(auto) a = A{1, 2, 3};
  98   static_assert(has_type<vector<int>>(a<vector>));
  99   static_assert(has_type<tuple<int, int, int>>(a<tuple>));
 100
 101   struct B {
 102     template<typename T> struct X { X(T); };
 103     X(int) -> X<int>;
 104     template<typename T> using Y = X<T>; // expected-note {{template}}
 105   };
 106   template<typename T> void f() {
 107     typename T::X tx = 0;
 108     typename T::Y ty = 0; // expected-error {{alias template 'Y' requires template arguments; argument deduction only allowed for class templates}}
 109   }
 110   template void f<B>(); // expected-note {{in instantiation of}}
 111
 112   template<typename T> struct C { C(T); };
 113   template<typename T> C(T) -> C<T>;
 114   template<typename T> void g(T a) {
 115     C b = 0;
 116     C c = a;
 117     using U = decltype(b); // expected-note {{previous}}
 118     using U = decltype(c); // expected-error {{different types ('C<const char *>' vs 'C<int>')}}
 119   }
 120   void h() {
 121     g(0);
 122     g("foo"); // expected-note {{instantiation of}}
 123   }
 124 }
 125
 126 namespace look_into_current_instantiation {
 127   template<typename U> struct Q {};
 128   template<typename T> struct A {
 129     using U = T;
 130     template<typename> using V = Q<A<T>::U>;
 131     template<typename W = int> A(V<W>);
 132   };
 133   A a = Q<float>(); // ok, can look through class-scope typedefs and alias
 134                     // templates, and members of the current instantiation
 135   A<float> &r = a;
 136
 137   template<typename T> struct B { // expected-note {{could not match 'B<T>' against 'int'}}
 138     struct X {
 139       typedef T type;
 140     };
 141     B(typename X::type); // expected-note {{couldn't infer template argument 'T'}}
 142   };
 143   B b = 0; // expected-error {{no viable}}
 144
 145   // We should have a substitution failure in the immediate context of
 146   // deduction when using the C(T, U) constructor (probably; core wording
 147   // unclear).
 148   template<typename T> struct C {
 149     using U = typename T::type;
 150     C(T, U);
 151   };
 152
 153   struct R { R(int); typedef R type; };
 154   C(...) -> C<R>;
 155
 156   C c = {1, 2};
 157 }
 158
 159 namespace nondeducible {
 160   template<typename A, typename B> struct X {};
 161
 162   template<typename A> // expected-note {{non-deducible template parameter 'A'}}
 163   X() -> X<A, int>; // expected-error {{deduction guide template contains a template parameter that cannot be deduced}}
 164
 165   template<typename A> // expected-note {{non-deducible template parameter 'A'}}
 166   X(typename X<A, int>::type) -> X<A, int>; // expected-error {{deduction guide template contains a template parameter that cannot be deduced}}
 167
 168   template<typename A = int,
 169            typename B> // expected-note {{non-deducible template parameter 'B'}}
 170   X(int) -> X<A, B>; // expected-error {{deduction guide template contains a template parameter that cannot be deduced}}
 171
 172   template<typename A = int,
 173            typename ...B>
 174   X(float) -> X<A, B...>; // ok
 175
 176   template <typename> struct UnnamedTemplateParam {};
 177   template <typename>                                  // expected-note {{non-deducible template parameter (anonymous)}}
 178   UnnamedTemplateParam() -> UnnamedTemplateParam<int>; // expected-error {{deduction guide template contains a template parameter that cannot be deduced}}
 179 }
 180
 181 namespace default_args_from_ctor {
 182   template <class A> struct S { S(A = 0) {} };
 183   S s(0);
 184
 185   template <class A> struct T { template<typename B> T(A = 0, B = 0) {} };
 186   T t(0, 0);
 187 }
 188
 189 namespace transform_params {
 190   template<typename T, T N, template<T (*v)[N]> typename U, T (*X)[N]>
 191   struct A {
 192     template<typename V, V M, V (*Y)[M], template<V (*v)[M]> typename W>
 193     A(U<X>, W<Y>);
 194
 195     static constexpr T v = N;
 196   };
 197
 198   int n[12];
 199   template<int (*)[12]> struct Q {};
 200   Q<&n> qn;
 201   A a(qn, qn);
 202   static_assert(a.v == 12);
 203
 204   template<typename ...T> struct B {
 205     template<T ...V> B(const T (&...p)[V]) {
 206       constexpr int Vs[] = {V...};
 207       static_assert(Vs[0] == 3 && Vs[1] == 4 && Vs[2] == 4);
 208     }
 209     static constexpr int (*p)(T...) = (int(*)(int, char, char))nullptr;
 210   };
 211   B b({1, 2, 3}, "foo", {'x', 'y', 'z', 'w'}); // ok
 212
 213   template<typename ...T> struct C {
 214     template<T ...V, template<T...> typename X>
 215       C(X<V...>);
 216   };
 217   template<int...> struct Y {};
 218   C c(Y<0, 1, 2>{});
 219
 220   template<typename ...T> struct D {
 221     template<T ...V> D(Y<V...>);
 222   };
 223   D d(Y<0, 1, 2>{});
 224 }
 225
 226 namespace variadic {
 227   int arr3[3], arr4[4];
 228
 229   // PR32673
 230   template<typename T> struct A {
 231     template<typename ...U> A(T, U...);
 232   };
 233   A a(1, 2, 3);
 234
 235   template<typename T> struct B {
 236     template<int ...N> B(T, int (&...r)[N]);
 237   };
 238   B b(1, arr3, arr4);
 239
 240   template<typename T> struct C {
 241     template<template<typename> typename ...U> C(T, U<int>...);
 242   };
 243   C c(1, a, b);
 244
 245   template<typename ...U> struct X {
 246     template<typename T> X(T, U...);
 247   };
 248   X x(1, 2, 3);
 249
 250   template<int ...N> struct Y {
 251     template<typename T> Y(T, int (&...r)[N]);
 252   };
 253   Y y(1, arr3, arr4);
 254
 255   template<template<typename> typename ...U> struct Z {
 256     template<typename T> Z(T, U<int>...);
 257   };
 258   Z z(1, a, b);
 259 }
 260
 261 namespace tuple_tests {
 262   // The converting n-ary constructor appears viable, deducing T as an empty
 263   // pack (until we check its SFINAE constraints).
 264   namespace libcxx_1 {
 265     template<class ...T> struct tuple {
 266       template<class ...Args> struct X { static const bool value = false; };
 267       template<class ...U, bool Y = X<U...>::value> tuple(U &&...u);
 268     };
 269     tuple a = {1, 2, 3};
 270   }
 271
 272   // Don't get caught by surprise when X<...> doesn't even exist in the
 273   // selected specialization!
 274   namespace libcxx_2 {
 275     template<class ...T> struct tuple {
 276       template<class ...Args> struct X { static const bool value = false; };
 277       // Substitution into X<U...>::value succeeds but produces the
 278       // value-dependent expression
 279       //   tuple<T...>::X<>::value
 280       // FIXME: Is that the right behavior?
 281       template<class ...U, bool Y = X<U...>::value> tuple(U &&...u);
 282     };
 283     template <> class tuple<> {};
 284     tuple a = {1, 2, 3}; // expected-error {{excess elements in struct initializer}}
 285   }
 286
 287   namespace libcxx_3 {
 288     template<typename ...T> struct scoped_lock {
 289       scoped_lock(T...);
 290     };
 291     template<> struct scoped_lock<> {};
 292     scoped_lock l = {};
 293   }
 294 }
 295
 296 namespace dependent {
 297   template<typename T> struct X { // expected-note 3{{here}}
 298     X(T);
 299   };
 300   template<typename T> int Var(T t) {
 301     X x(t);
 302     return X(x) + 1; // expected-error {{invalid operands}}
 303   }
 304   template<typename T> int Cast(T t) {
 305     return X(X(t)) + 1; // expected-error {{invalid operands}}
 306   }
 307   template<typename T> int Cast2(T t) {
 308     return (X)(X)t + 1; // expected-error {{deduction not allowed}}
 309   }
 310   template<typename T> int Cast3(T t) {
 311     return X{X{t}} + 1; // expected-error {{invalid operands}}
 312   }
 313   template<typename T> int Cast4(T t) {
 314     return (X){(X){t}} + 1; // expected-error 2{{deduction not allowed}}
 315   }
 316   template<typename T> int New(T t) {
 317     return X(new X(t)) + 1; // expected-error {{invalid operands}}
 318   };
 319   template<typename T> int *New2(T t) {
 320     return new X(X(t)) * 2; // expected-error {{invalid operands}}
 321   };
 322   template int Var(float); // expected-note {{instantiation of}}
 323   template int Cast(float); // expected-note {{instantiation of}}
 324   template int Cast3(float); // expected-note {{instantiation of}}
 325   template int New(float); // expected-note {{instantiation of}}
 326   template int *New2(float); // expected-note {{instantiation of}}
 327   template<typename T> int operator+(X<T>, int);
 328   template int Var(int);
 329   template int Cast(int);
 330   template int New(int);
 331
 332   template<template<typename> typename Y> void test() {
 333     Y(0);
 334     new Y(0);
 335     Y y(0);
 336   }
 337   template void test<X>();
 338 }
 339
 340 namespace injected_class_name {
 341   template<typename T = void> struct A {
 342     A();
 343     template<typename U> A(A<U>);
 344   };
 345   A<int> a;
 346   A b = a;
 347   using T = decltype(a);
 348   using T = decltype(b);
 349 }
 350
 351 namespace member_guides {
 352   // PR34520
 353   template<class>
 354   struct Foo {
 355     template <class T> struct Bar {
 356       Bar(...) {}
 357     };
 358     Bar(int) -> Bar<int>;
 359   };
 360   Foo<int>::Bar b = 0;
 361
 362   struct A {
 363     template<typename T> struct Public; // expected-note {{declared public}}
 364     Public(float) -> Public<float>;
 365   protected: // expected-note {{declared protected by intervening access specifier}}
 366     template<typename T> struct Protected; // expected-note 2{{declared protected}}
 367     Protected(float) -> Protected<float>;
 368     Public(int) -> Public<int>; // expected-error {{different access}}
 369   private: // expected-note {{declared private by intervening access specifier}}
 370     template<typename T> struct Private; // expected-note {{declared private}}
 371     Protected(int) -> Protected<int>; // expected-error {{different access}}
 372   public: // expected-note 2{{declared public by intervening access specifier}}
 373     template<typename T> Public(T) -> Public<T>;
 374     template<typename T> Protected(T) -> Protected<T>; // expected-error {{different access}}
 375     template<typename T> Private(T) -> Private<T>; // expected-error {{different access}}
 376   };
 377 }
 378
 379 namespace rdar41903969 {
 380 template <class T> struct A {};
 381 template <class T> struct B;
 382 template <class T> struct C {
 383   C(A<T>&);
 384   C(B<T>&);
 385 };
 386
 387 void foo(A<int> &a, B<int> &b) {
 388   (void)C{b};
 389   (void)C{a};
 390 }
 391
 392 template<typename T> struct X {
 393   X(std::initializer_list<T>) = delete;
 394   X(const X&);
 395 };
 396
 397 template <class T> struct D : X<T> {};
 398
 399 void bar(D<int>& d) {
 400   (void)X{d};
 401 }
 402 }
 403
 404 namespace rdar41330135 {
 405 template <int> struct A {};
 406 template <class T>
 407 struct S {
 408   template <class U>
 409   S(T a, U t, A<sizeof(t)>);
 410 };
 411 template <class T> struct D {
 412   D(T t, A<sizeof(t)>);
 413 };
 414 int f() {
 415   S s(0, 0, A<sizeof(int)>());
 416   D d(0, A<sizeof(int)>());
 417 }
 418
 419 namespace test_dupls {
 420 template<unsigned long> struct X {};
 421 template<typename T> struct A {
 422   A(T t, X<sizeof(t)>);
 423 };
 424 A a(0, {});
 425 template<typename U> struct B {
 426   B(U u, X<sizeof(u)>);
 427 };
 428 B b(0, {});
 429 }
 430
 431 }
 432
 433 namespace no_crash_on_default_arg {
 434 class A {
 435   template <typename T> class B {
 436     B(int c = 1);
 437   };
 438   // This used to crash due to unparsed default arg above. The diagnostic could
 439   // be improved, but the point of this test is to simply check we do not crash.
 440   B(); // expected-error {{deduction guide declaration without trailing return type}}
 441 };
 442 } // namespace no_crash_on_default_arg
 443
 444 #pragma clang diagnostic push
 445 #pragma clang diagnostic warning "-Wctad-maybe-unsupported"
 446 namespace test_implicit_ctad_warning {
 447
 448 template <class T>
 449 struct Tag {};
 450
 451 template <class T>
 452 struct NoExplicit { // expected-note {{add a deduction guide to suppress this warning}}
 453   NoExplicit(T) {}
 454   NoExplicit(T, int) {}
 455 };
 456
 457 // expected-warning@+1 {{'NoExplicit' may not intend to support class template argument deduction}}
 458 NoExplicit ne(42);
 459
 460 template <class U>
 461 struct HasExplicit {
 462   HasExplicit(U) {}
 463   HasExplicit(U, int) {}
 464 };
 465 template <class U> HasExplicit(U, int) -> HasExplicit<Tag<U>>;
 466
 467 HasExplicit he(42);
 468
 469 // Motivating examples from (taken from Stephan Lavavej's 2018 Cppcon talk)
 470 template <class T, class U>
 471 struct AmateurPair { // expected-note {{add a deduction guide to suppress this warning}}
 472   T first;
 473   U second;
 474   explicit AmateurPair(const T &t, const U &u) {}
 475 };
 476 // expected-warning@+1 {{'AmateurPair' may not intend to support class template argument deduction}}
 477 AmateurPair p1(42, "hello world"); // deduces to Pair<int, char[12]>
 478
 479 template <class T, class U>
 480 struct AmateurPair2 { // expected-note {{add a deduction guide to suppress this warning}}
 481   T first;
 482   U second;
 483   explicit AmateurPair2(T t, U u) {}
 484 };
 485 // expected-warning@+1 {{'AmateurPair2' may not intend to support class template argument deduction}}
 486 AmateurPair2 p2(42, "hello world"); // deduces to Pair2<int, const char*>
 487
 488 template <class T, class U>
 489 struct ProPair {
 490   T first; U second;
 491     explicit ProPair(T const& t, U  const& u)  {}
 492 };
 493 template<class T1, class T2>
 494 ProPair(T1, T2) -> ProPair<T1, T2>;
 495 ProPair p3(42, "hello world"); // deduces to ProPair<int, const char*>
 496 static_assert(__is_same(decltype(p3), ProPair<int, const char*>));
 497
 498 // Test that user-defined explicit guides suppress the warning even if they
 499 // aren't used as candidates.
 500 template <class T>
 501 struct TestExplicitCtor {
 502   TestExplicitCtor(T) {}
 503 };
 504 template <class T>
 505 explicit TestExplicitCtor(TestExplicitCtor<T> const&) -> TestExplicitCtor<void>;
 506 TestExplicitCtor<int> ce1{42};
 507 TestExplicitCtor ce2 = ce1;
 508 static_assert(__is_same(decltype(ce2), TestExplicitCtor<int>), "");
 509
 510 struct allow_ctad_t {
 511   allow_ctad_t() = delete;
 512 };
 513
 514 template <class T>
 515 struct TestSuppression {
 516   TestSuppression(T) {}
 517 };
 518 TestSuppression(allow_ctad_t)->TestSuppression<void>;
 519 TestSuppression ta("abc");
 520 static_assert(__is_same(decltype(ta), TestSuppression<const char *>), "");
 521 }
 522 #pragma clang diagnostic pop
 523
 524 namespace PR41549 {
 525
 526 template <class H, class P> struct umm;
 527
 528 template <class H = int, class P = int>
 529 struct umm {
 530   umm(H h = 0, P p = 0);
 531 };
 532
 533 template <class H, class P> struct umm;
 534
 535 umm m(1);
 536
 537 }
 538
 539 namespace PR45124 {
 540   class a { int d; };
 541   class b : a {};
 542
 543   struct x { ~x(); };
 544   template<typename> class y { y(x = x()); };
 545   template<typename z> y(z)->y<z>;
 546
 547   // Not a constant initializer, but trivial default initialization. We won't
 548   // detect this as trivial default initialization if synthesizing the implicit
 549   // deduction guide 'template<typename T> y(x = x()) -> Y<T>;' leaves behind a
 550   // pending cleanup.
 551   __thread b g;
 552 }
 553
 554 namespace PR47175 {
 555   template<typename T> struct A { A(T); T x; };
 556   template<typename T> int &&n = A(T()).x;
 557   int m = n<int>;
 558 }
 559
 560 // Ensure we don't crash when CTAD fails.
 561 template <typename T1, typename T2>
 562 struct Foo {   // expected-note{{candidate function template not viable}}
 563   Foo(T1, T2); // expected-note{{candidate function template not viable}}
 564 };
 565
 566 template <typename... Args>
 567 void insert(Args &&...args);
 568
 569 void foo() {
 570   insert(Foo(2, 2, 2)); // expected-error{{no viable constructor or deduction guide}}
 571 }
 572
 573 namespace PR52139 {
 574   struct Abstract {
 575     template <class... Ts>
 576     struct overloaded : Ts... {
 577       using Ts::operator()...;
 578     };
 579     template <class... Ts>
 580     overloaded(Ts...) -> overloaded<Ts...>;
 581
 582   private:
 583     virtual void f() = 0;
 584   };
 585 }
 586
 587 namespace function_prototypes {
 588   template<class T> using fptr1 = void (*) (T);
 589   template<class T> using fptr2 = fptr1<fptr1<T>>;
 590
 591   template<class T> void foo0(fptr1<T>) {
 592     static_assert(__is_same(T, const char*));
 593   }
 594   void bar0(const char *const volatile __restrict);
 595   void t0() { foo0(&bar0); }
 596
 597   template<class T> void foo1(fptr1<const T *>) {
 598      static_assert(__is_same(T, char));
 599   }
 600   void bar1(const char * __restrict);
 601   void t1() { foo1(&bar1); }
 602
 603   template<class T> void foo2(fptr2<const T *>) {
 604     static_assert(__is_same(T, char));
 605   }
 606   void bar2(fptr1<const char * __restrict>);
 607   void t2() { foo2(&bar2); }
 608
 609   template<class T> void foo3(fptr1<const T *>) {}
 610   void bar3(char * __restrict);
 611   void t3() { foo3(&bar3); }
 612   // expected-error@-1 {{no matching function for call to 'foo3'}}
 613   // expected-note@-4  {{candidate template ignored: cannot deduce a type for 'T' that would make 'const T' equal 'char'}}
 614
 615   template<class T> void foo4(fptr2<const T *>) {}
 616   void bar4(fptr1<char * __restrict>);
 617   void t4() { foo4(&bar4); }
 618   // expected-error@-1 {{no matching function for call to 'foo4'}}
 619   // expected-note@-4  {{candidate template ignored: cannot deduce a type for 'T' that would make 'const T' equal 'char'}}
 620
 621   template<typename T> void foo5(T(T)) {}
 622   const int bar5(int);
 623   void t5() { foo5(bar5); }
 624   // expected-error@-1 {{no matching function for call to 'foo5'}}
 625   // expected-note@-4  {{candidate template ignored: deduced conflicting types for parameter 'T' ('const int' vs. 'int')}}
 626
 627   struct Foo6 {};
 628   template<typename T> void foo6(void(*)(struct Foo6, T)) {}
 629   void bar6(Foo6, int);
 630   void t6() { foo6(bar6); }
 631 }
 632 #else
 633
 634 // expected-no-diagnostics
 635 namespace undefined_warnings {
 636   // Make sure we don't get an "undefined but used internal symbol" warning for the deduction guide here.
 637   namespace {
 638     template <typename T>
 639     struct TemplDObj {
 640       explicit TemplDObj(T func) noexcept {}
 641     };
 642     auto test1 = TemplDObj(0);
 643
 644     TemplDObj(float) -> TemplDObj<double>;
 645     auto test2 = TemplDObj(.0f);
 646   }
 647 }
 648 #endif