| // RUN: %clang_cc1 -verify -std=c++1z %s |
| |
| namespace Explicit { |
| // Each notional constructor is explicit if the function or function template |
| // was generated from a constructor or deduction-guide that was declared explicit. |
| template<typename T> struct A { |
| A(T); |
| A(T*); |
| A(...); |
| }; |
| template<typename T> A(T) -> A<T>; |
| template<typename T> explicit A(T*) -> A<T**>; // expected-note {{explicit}} |
| |
| int *p; |
| A a(p); |
| A b = p; |
| A c{p}; |
| A d = {p}; // expected-error {{selected an explicit deduction guide}} |
| |
| using X = A<int**>; |
| using Y = A<int>; // uses the implicit guide, being more specialized than the eligible user-defined deduction guides. |
| |
| using X = decltype(a); |
| using Y = decltype(b); |
| using X = decltype(c); |
| } |
| |
| |
| namespace std { |
| template<typename T> struct initializer_list { |
| const T *ptr; |
| __SIZE_TYPE__ size; |
| initializer_list(); |
| }; |
| } |
| |
| namespace p0702r1 { |
| template<typename T> struct X { // expected-note {{candidate}} |
| X(std::initializer_list<T>); // expected-note {{candidate}} |
| }; |
| |
| X xi = {0}; |
| X xxi = {xi}; |
| extern X<int> xi; |
| // Prior to P0702R1, this is X<X<int>>. |
| extern X<int> xxi; |
| |
| struct Y : X<int> {}; |
| Y y {{0}}; |
| X xy {y}; |
| extern X<int> xy; |
| |
| struct Z : X<int>, X<float> {}; |
| Z z = {{0}, {0.0f}}; |
| // This is not X<Z> even though that would work. Instead, it's ambiguous |
| // between X<int> and X<float>. |
| X xz = {z}; // expected-error {{no viable constructor or deduction guide}} |
| } |
| namespace pr34970 { |
| //https://bugs.llvm.org/show_bug.cgi?id=34970 |
| |
| template <typename X, typename Y> struct IsSame { |
| static constexpr bool value = false; |
| }; |
| |
| template <typename Z> struct IsSame<Z, Z> { |
| static constexpr bool value = true; |
| }; |
| |
| template <typename T> struct Optional { |
| template <typename U> Optional(U&&) { } |
| }; |
| |
| template <typename A> Optional(A) -> Optional<A>; |
| |
| int main() { |
| Optional opt(1729); |
| Optional dupe(opt); |
| |
| static_assert(IsSame<decltype(opt), Optional<int>>::value); |
| static_assert(IsSame<decltype(dupe), Optional<int>>::value); |
| static_assert(!IsSame<decltype(dupe), Optional<Optional<int>>>::value); |
| return 0; |
| } |
| |
| |
| } |