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 {
TPR15757::T8     template<typename A> T(X x, A &&a) {}
9 
TPR15757::T10     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 
foo(char ch)19   U<S, char> foo(char ch) { return U<S, char>(ch); }
20 
main()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 
foo1()132   void foo1() {
133     S0<int> s0;
134   }
135 }
136 
137 namespace PR47555 {
APR47555::A138   struct A { constexpr A(int) {} };
139   struct B : A { using A::A; };
f()140   template<typename> void f() {
141     constexpr B b = 0;
142   };
143   template void f<int>();
144 }
145