test/SemaTemplate/constructor-template.cpp

   1 // RUN: %clang_cc1 -fsyntax-only -verify %s
   2 struct X0 { // expected-note{{candidate}}
   3   X0(int); // expected-note{{candidate}}
   4   template<typename T> X0(T); // expected-note {{candidate}}
   5   template<typename T, typename U> X0(T*, U*); // expected-note {{candidate}}
   6
   7   // PR4761
   8   template<typename T> X0() : f0(T::foo) {} // expected-note {{candidate}}
   9   int f0;
  10 };
  11
  12 void accept_X0(X0);
  13
  14 void test_X0(int i, float f) {
  15   X0 x0a(i);
  16   X0 x0b(f);
  17   X0 x0c = i;
  18   X0 x0d = f;
  19   accept_X0(i);
  20   accept_X0(&i);
  21   accept_X0(f);
  22   accept_X0(&f);
  23   X0 x0e(&i, &f);
  24   X0 x0f(&f, &i);
  25
  26   X0 x0g(f, &i); // expected-error{{no matching constructor}}
  27 }
  28
  29 template<typename T>
  30 struct X1 {
  31   X1(const X1&);
  32   template<typename U> X1(const X1<U>&);
  33 };
  34
  35 template<typename T>
  36 struct Outer {
  37   typedef X1<T> A;
  38
  39   A alloc;
  40
  41   explicit Outer(const A& a) : alloc(a) { }
  42 };
  43
  44 void test_X1(X1<int> xi) {
  45   Outer<int> oi(xi);
  46   Outer<float> of(xi);
  47 }
  48
  49 // PR4655
  50 template<class C> struct A {};
  51 template <> struct A<int>{A(const A<int>&);};
  52 struct B { A<int> x; B(B& a) : x(a.x) {} };
  53
  54 struct X2 {
  55   X2(); // expected-note{{candidate constructor}}
  56   X2(X2&);      // expected-note {{candidate constructor}}
  57   template<typename T> X2(T);
  58 };
  59
  60 X2 test(bool Cond, X2 x2) {
  61   if (Cond)
  62     return x2; // okay, uses copy constructor
  63
  64   return X2(); // expected-error{{no matching constructor}}
  65 }
  66
  67 struct X3 {
  68   template<typename T> X3(T);
  69 };
  70
  71 template<> X3::X3(X3); // expected-error{{must pass its first argument by reference}}
  72
  73 struct X4 {
  74   X4();
  75   ~X4();
  76   X4(X4&);
  77   template<typename T> X4(const T&, int = 17);
  78 };
  79
  80 X4 test_X4(bool Cond, X4 x4) {
  81   X4 a(x4, 17); // okay, constructor template
  82   X4 b(x4); // okay, copy constructor
  83   return X4();
  84 }
  85
  86 // Instantiation of a non-dependent use of a constructor
  87 struct DefaultCtorHasDefaultArg {
  88   explicit DefaultCtorHasDefaultArg(int i = 17);
  89 };
  90
  91 template<typename T>
  92 void default_ctor_inst() {
  93   DefaultCtorHasDefaultArg def;
  94 }
  95
  96 template void default_ctor_inst<int>();
  97
  98 template<typename T>
  99 struct X5 {
 100   X5();
 101   X5(const T &);
 102 };
 103
 104 struct X6 {
 105   template<typename T> X6(T);
 106 };
 107
 108 void test_X5_X6() {
 109   X5<X6> tf;
 110   X5<X6> tf2(tf);
 111 }
 112
 113 namespace PR8182 {
 114   struct foo {
 115     foo();
 116     template<class T> foo(T&);
 117
 118   private:
 119     foo(const foo&);
 120   };
 121
 122   void test_foo() {
 123     foo f1;
 124     foo f2(f1);
 125     foo f3 = f1;
 126   }
 127
 128 }