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 {}; // expected-note 2{{candidate}}
  60   struct D : B { // expected-note 3{{candidate}}
  61     using B::B; // expected-note 2{{inherited}}
  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 5{{candidate}}
  72   struct D : B { // expected-note 3{{candidate}}
  73     using B::B; // expected-note 2{{inherited}}
  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   // This is the same, but we get one call to D's version of B::B(const B&)
  81   // before the two permitted calls to D::D(D&&).
  82   D d1 = {b};
  83   D d2 = {{b}};
  84   D d3 = {{{b}}};
  85   D d4 = {{{{b}}}}; // expected-error {{no match}}
  86 }