clang/test/SemaCXX/cxx11-inheriting-ctors.cpp

   1 // RUN: %clang_cc1 -std=c++11 %s -verify
   2
   3 namespace PR15757 {
   4   struct S {
   5   };
   6
   7   template<typename X, typename Y> struct T {
   8     template<typename A> T(X x, A &&a) {}
   9
  10     template<typename A> explicit T(A &&a)
  11         noexcept(noexcept(T(X(), static_cast<A &&>(a))))
  12       : T(X(), static_cast<A &&>(a)) {}
  13   };
  14
  15   template<typename X, typename Y> struct U : T<X, Y> {
  16     using T<X, Y>::T;
  17   };
  18
  19   U<S, char> foo(char ch) { return U<S, char>(ch); }
  20
  21   int main() {
  22     U<S, int> a(42);
  23     U<S, char> b('4');
  24     return 0;
  25   }
  26 }
  27
  28 namespace WrongIdent {
  29   struct A {};
  30   struct B : A {};
  31   struct C : B {
  32     using B::A;
  33   };
  34 }
  35
  36 namespace DefaultCtorConflict {
  37   struct A { A(int = 0); };
  38   struct B : A {
  39     using A::A;
  40   } b; // ok, not ambiguous, inherited constructor suppresses implicit default constructor
  41   struct C {
  42     B b;
  43   } c;
  44 }
  45
  46 namespace InvalidConstruction {
  47   struct A { A(int); };
  48   struct B { B() = delete; };
  49   struct C : A, B { using A::A; };
  50   // Initialization here is performed as if by a defaulted default constructor,
  51   // which would be ill-formed (in the immediate context) in this case because
  52   // it would be defined as deleted.
  53   template<typename T> void f(decltype(T(0))*);
  54   template<typename T> int &f(...);
  55   int &r = f<C>(0);
  56 }
  57
  58 namespace ExplicitConv {
  59   struct B {};
  60   struct D : B { // expected-note 3{{candidate}}
  61     using B::B;
  62   };
  63   struct X { explicit operator B(); } x;
  64   struct Y { explicit operator D(); } y;
  65
  66   D dx(x); // expected-error {{no matching constructor}}
  67   D dy(y);
  68 }
  69
  70 namespace NestedListInit {
  71   struct B { B(); } b; // expected-note 3{{candidate}}
  72   struct D : B { // expected-note 14{{not viable}}
  73     using B::B;
  74   };
  75   // This is a bit weird. We're allowed one pair of braces for overload
  76   // resolution, and one more pair of braces due to [over.ics.list]/2.
  77   B b1 = {b};
  78   B b2 = {{b}};
  79   B b3 = {{{b}}}; // expected-error {{no match}}
  80   // Per a proposed defect resolution, we don't get to call
  81   // D's version of B::B(const B&) here.
  82   D d0 = b; // expected-error {{no viable conversion}}
  83   D d1 = {b}; // expected-error {{no match}}
  84   D d2 = {{b}}; // expected-error {{no match}}
  85   D d3 = {{{b}}}; // expected-error {{no match}}
  86   D d4 = {{{{b}}}}; // expected-error {{no match}}
  87 }
  88
  89 namespace PR31606 {
  90   // PR31606: as part of a proposed defect resolution, do not consider
  91   // inherited constructors that would be copy constructors for any class
  92   // between the declaring class and the constructed class (inclusive).
  93   struct Base {};
  94
  95   struct A : Base {
  96     using Base::Base;
  97     bool operator==(A const &) const; // expected-note {{no known conversion from 'PR31606::B' to 'const PR31606::A' for 1st argument}}
  98   };
  99
 100   struct B : Base {
 101     using Base::Base;
 102   };
 103
 104   bool a = A{} == A{};
 105   // Note, we do *not* allow operator=='s argument to use the inherited A::A(Base&&) constructor to construct from B{}.
 106   bool b = A{} == B{}; // expected-error {{invalid operands}}
 107 }
 108
 109 namespace implicit_member_srcloc {
 110   template<class T>
 111   struct S3 {
 112   };
 113
 114   template<class T>
 115   struct S2 {
 116     S2(S3<T> &&);
 117   };
 118
 119   template<class T>
 120   struct S1 : S2<T> {
 121     using S2<T>::S2;
 122     S1();
 123   };
 124
 125   template<class T>
 126   struct S0 {
 127     S0();
 128     S0(S0&&) = default;
 129     S1<T> m1;
 130   };
 131
 132   void foo1() {
 133     S0<int> s0;
 134   }
 135 }
 136
 137 namespace PR47555 {
 138   struct A { constexpr A(int) {} };
 139   struct B : A { using A::A; };
 140   template<typename> void f() {
 141     constexpr B b = 0;
 142   };
 143   template void f<int>();
 144 }
 145
 146 namespace PR48545 {
 147   struct B {
 148       void f();
 149   private:
 150       B(int, int = 0);
 151   };
 152   struct D : B { using B::B; };
 153   void B::f() {
 154       D{0};
 155       D{0, 0};
 156       D(0);
 157       D(0, 0);
 158       D u = {0};
 159       D v = {0, 0};
 160       D w{0};
 161       D x{0, 0};
 162       D y(0);
 163       D z(0, 0);
 164   }
 165 }