1ef7554efd
conversions are only applied to operands of class type, and the second standard conversion sequence is not applied. When diagnosing an invalid builtin binary operator, talk about the original types rather than the converted types. If these differ by a user-defined conversion, tell the user what happened. llvm-svn: 335781
484 lines
19 KiB
C++
484 lines
19 KiB
C++
// RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
|
|
// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
|
|
// RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
|
|
// RUN: %clang_cc1 -std=c++1z -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
|
|
|
|
namespace dr1512 { // dr1512: 4
|
|
void f(char *p) {
|
|
if (p > 0) {} // expected-error {{ordered comparison between pointer and zero}}
|
|
#if __cplusplus >= 201103L
|
|
if (p > nullptr) {} // expected-error {{invalid operands}}
|
|
#endif
|
|
}
|
|
bool g(int **x, const int **y) {
|
|
return x < y;
|
|
}
|
|
|
|
template<typename T> T val();
|
|
|
|
template<typename A, typename B, typename C> void composite_pointer_type_is_base() {
|
|
typedef __typeof(true ? val<A>() : val<B>()) type;
|
|
typedef C type;
|
|
|
|
typedef __typeof(val<A>() == val<B>()) cmp;
|
|
typedef __typeof(val<A>() != val<B>()) cmp;
|
|
typedef bool cmp;
|
|
}
|
|
|
|
template<typename A, typename B, typename C> void composite_pointer_type_is_ord() {
|
|
composite_pointer_type_is_base<A, B, C>();
|
|
|
|
typedef __typeof(val<A>() < val<B>()) cmp;
|
|
typedef __typeof(val<A>() <= val<B>()) cmp;
|
|
typedef __typeof(val<A>() > val<B>()) cmp;
|
|
typedef __typeof(val<A>() >= val<B>()) cmp;
|
|
typedef bool cmp;
|
|
}
|
|
|
|
template <typename A, typename B, typename C>
|
|
void composite_pointer_type_is_unord(int = 0) {
|
|
composite_pointer_type_is_base<A, B, C>();
|
|
}
|
|
template <typename A, typename B, typename C>
|
|
void composite_pointer_type_is_unord(__typeof(val<A>() < val<B>()) * = 0);
|
|
template <typename A, typename B, typename C>
|
|
void composite_pointer_type_is_unord(__typeof(val<A>() <= val<B>()) * = 0);
|
|
template <typename A, typename B, typename C>
|
|
void composite_pointer_type_is_unord(__typeof(val<A>() > val<B>()) * = 0);
|
|
template <typename A, typename B, typename C>
|
|
void composite_pointer_type_is_unord(__typeof(val<A>() >= val<B>()) * = 0);
|
|
|
|
// A call to this is ambiguous if a composite pointer type exists.
|
|
template<typename A, typename B>
|
|
void no_composite_pointer_type(__typeof((true ? val<A>() : val<B>()), void()) * = 0);
|
|
template<typename A, typename B> void no_composite_pointer_type(int = 0);
|
|
|
|
struct A {};
|
|
struct B : A {};
|
|
struct C {};
|
|
|
|
void test() {
|
|
#if __cplusplus >= 201103L
|
|
using nullptr_t = decltype(nullptr);
|
|
composite_pointer_type_is_unord<nullptr_t, nullptr_t, nullptr_t>();
|
|
no_composite_pointer_type<nullptr_t, int>();
|
|
|
|
composite_pointer_type_is_unord<nullptr_t, const char**, const char**>();
|
|
composite_pointer_type_is_unord<const char**, nullptr_t, const char**>();
|
|
#endif
|
|
|
|
composite_pointer_type_is_ord<const int *, volatile void *, const volatile void*>();
|
|
composite_pointer_type_is_ord<const void *, volatile int *, const volatile void*>();
|
|
|
|
composite_pointer_type_is_ord<const A*, volatile B*, const volatile A*>();
|
|
composite_pointer_type_is_ord<const B*, volatile A*, const volatile A*>();
|
|
|
|
composite_pointer_type_is_unord<const int *A::*, volatile int *B::*, const volatile int *const B::*>();
|
|
composite_pointer_type_is_unord<const int *B::*, volatile int *A::*, const volatile int *const B::*>();
|
|
no_composite_pointer_type<int (A::*)(), int (C::*)()>();
|
|
no_composite_pointer_type<const int (A::*)(), volatile int (C::*)()>();
|
|
|
|
#if __cplusplus > 201402
|
|
composite_pointer_type_is_ord<int (*)() noexcept, int (*)(), int (*)()>();
|
|
composite_pointer_type_is_ord<int (*)(), int (*)() noexcept, int (*)()>();
|
|
composite_pointer_type_is_unord<int (A::*)() noexcept, int (A::*)(), int (A::*)()>();
|
|
composite_pointer_type_is_unord<int (A::*)(), int (A::*)() noexcept, int (A::*)()>();
|
|
// FIXME: This looks like a standard defect; these should probably all have type 'int (B::*)()'.
|
|
composite_pointer_type_is_unord<int (B::*)(), int (A::*)() noexcept, int (B::*)()>();
|
|
composite_pointer_type_is_unord<int (A::*)() noexcept, int (B::*)(), int (B::*)()>();
|
|
composite_pointer_type_is_unord<int (B::*)() noexcept, int (A::*)(), int (B::*)()>();
|
|
composite_pointer_type_is_unord<int (A::*)(), int (B::*)() noexcept, int (B::*)()>();
|
|
|
|
// FIXME: It would be reasonable to permit these, with a common type of 'int (*const *)()'.
|
|
no_composite_pointer_type<int (**)() noexcept, int (**)()>();
|
|
no_composite_pointer_type<int (**)(), int (**)() noexcept>();
|
|
|
|
// FIXME: It would be reasonable to permit these, with a common type of 'int (A::*)()'.
|
|
no_composite_pointer_type<int (A::*)() const, int (A::*)()>();
|
|
no_composite_pointer_type<int (A::*)(), int (A::*)() const>();
|
|
|
|
// FIXME: It would be reasonable to permit these, with a common type of
|
|
// 'int (A::*)() &' and 'int (A::*)() &&', respectively.
|
|
no_composite_pointer_type<int (A::*)() &, int (A::*)()>();
|
|
no_composite_pointer_type<int (A::*)(), int (A::*)() &>();
|
|
no_composite_pointer_type<int (A::*)() &&, int (A::*)()>();
|
|
no_composite_pointer_type<int (A::*)(), int (A::*)() &&>();
|
|
|
|
no_composite_pointer_type<int (A::*)() &&, int (A::*)() &>();
|
|
no_composite_pointer_type<int (A::*)() &, int (A::*)() &&>();
|
|
|
|
no_composite_pointer_type<int (C::*)(), int (A::*)() noexcept>();
|
|
no_composite_pointer_type<int (A::*)() noexcept, int (C::*)()>();
|
|
#endif
|
|
}
|
|
|
|
#if __cplusplus >= 201103L
|
|
template<typename T> struct Wrap { operator T(); }; // expected-note 4{{converted to type 'nullptr_t'}} expected-note 4{{converted to type 'int *'}}
|
|
void test_overload() {
|
|
using nullptr_t = decltype(nullptr);
|
|
void(Wrap<nullptr_t>() == Wrap<nullptr_t>());
|
|
void(Wrap<nullptr_t>() != Wrap<nullptr_t>());
|
|
void(Wrap<nullptr_t>() < Wrap<nullptr_t>()); // expected-error {{invalid operands}}
|
|
void(Wrap<nullptr_t>() > Wrap<nullptr_t>()); // expected-error {{invalid operands}}
|
|
void(Wrap<nullptr_t>() <= Wrap<nullptr_t>()); // expected-error {{invalid operands}}
|
|
void(Wrap<nullptr_t>() >= Wrap<nullptr_t>()); // expected-error {{invalid operands}}
|
|
|
|
// Under dr1213, this is ill-formed: we select the builtin operator<(int*, int*)
|
|
// but then only convert as far as 'nullptr_t', which we then can't convert to 'int*'.
|
|
void(Wrap<nullptr_t>() == Wrap<int*>());
|
|
void(Wrap<nullptr_t>() != Wrap<int*>());
|
|
void(Wrap<nullptr_t>() < Wrap<int*>()); // expected-error {{invalid operands to binary expression ('Wrap<nullptr_t>' and 'Wrap<int *>')}}
|
|
void(Wrap<nullptr_t>() > Wrap<int*>()); // expected-error {{invalid operands}}
|
|
void(Wrap<nullptr_t>() <= Wrap<int*>()); // expected-error {{invalid operands}}
|
|
void(Wrap<nullptr_t>() >= Wrap<int*>()); // expected-error {{invalid operands}}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
namespace dr1518 { // dr1518: 4
|
|
#if __cplusplus >= 201103L
|
|
struct Z0 { // expected-note 0+ {{candidate}}
|
|
explicit Z0() = default; // expected-note 0+ {{here}}
|
|
};
|
|
struct Z { // expected-note 0+ {{candidate}}
|
|
explicit Z(); // expected-note 0+ {{here}}
|
|
explicit Z(int);
|
|
explicit Z(int, int); // expected-note 0+ {{here}}
|
|
};
|
|
template <class T> int Eat(T); // expected-note 0+ {{candidate}}
|
|
Z0 a;
|
|
Z0 b{};
|
|
Z0 c = {}; // expected-error {{explicit in copy-initialization}}
|
|
int i = Eat<Z0>({}); // expected-error {{no matching function for call to 'Eat'}}
|
|
|
|
Z c2 = {}; // expected-error {{explicit in copy-initialization}}
|
|
int i2 = Eat<Z>({}); // expected-error {{no matching function for call to 'Eat'}}
|
|
Z a1 = 1; // expected-error {{no viable conversion}}
|
|
Z a3 = Z(1);
|
|
Z a2(1);
|
|
Z *p = new Z(1);
|
|
Z a4 = (Z)1;
|
|
Z a5 = static_cast<Z>(1);
|
|
Z a6 = {4, 3}; // expected-error {{explicit in copy-initialization}}
|
|
|
|
struct UserProvidedBaseCtor { // expected-note 0+ {{candidate}}
|
|
UserProvidedBaseCtor() {}
|
|
};
|
|
struct DoesntInheritCtor : UserProvidedBaseCtor { // expected-note 0+ {{candidate}}
|
|
int x;
|
|
};
|
|
DoesntInheritCtor I{{}, 42};
|
|
#if __cplusplus <= 201402L
|
|
// expected-error@-2 {{no matching constructor}}
|
|
#endif
|
|
|
|
struct BaseCtor { BaseCtor() = default; }; // expected-note 0+ {{candidate}}
|
|
struct InheritsCtor : BaseCtor { // expected-note 1+ {{candidate}}
|
|
using BaseCtor::BaseCtor; // expected-note 2 {{inherited here}}
|
|
int x;
|
|
};
|
|
InheritsCtor II = {{}, 42}; // expected-error {{no matching constructor}}
|
|
|
|
namespace std_example {
|
|
struct A {
|
|
explicit A() = default; // expected-note 2{{declared here}}
|
|
};
|
|
|
|
struct B : A {
|
|
explicit B() = default; // expected-note 2{{declared here}}
|
|
};
|
|
|
|
struct C {
|
|
explicit C(); // expected-note 2{{declared here}}
|
|
};
|
|
|
|
struct D : A {
|
|
C c;
|
|
explicit D() = default; // expected-note 2{{declared here}}
|
|
};
|
|
|
|
template <typename T> void f() {
|
|
T t; // ok
|
|
T u{}; // ok
|
|
T v = {}; // expected-error 4{{explicit}}
|
|
}
|
|
template <typename T> void g() {
|
|
void x(T t); // expected-note 4{{parameter}}
|
|
x({}); // expected-error 4{{explicit}}
|
|
}
|
|
|
|
void test() {
|
|
f<A>(); // expected-note {{instantiation of}}
|
|
f<B>(); // expected-note {{instantiation of}}
|
|
f<C>(); // expected-note {{instantiation of}}
|
|
f<D>(); // expected-note {{instantiation of}}
|
|
g<A>(); // expected-note {{instantiation of}}
|
|
g<B>(); // expected-note {{instantiation of}}
|
|
g<C>(); // expected-note {{instantiation of}}
|
|
g<D>(); // expected-note {{instantiation of}}
|
|
}
|
|
}
|
|
#endif // __cplusplus >= 201103L
|
|
}
|
|
|
|
namespace dr1550 { // dr1550: yes
|
|
int f(bool b, int n) {
|
|
return (b ? (throw 0) : n) + (b ? n : (throw 0));
|
|
}
|
|
}
|
|
|
|
namespace dr1560 { // dr1560: 3.5
|
|
void f(bool b, int n) {
|
|
(b ? throw 0 : n) = (b ? n : throw 0) = 0;
|
|
}
|
|
class X { X(const X&); };
|
|
const X &get();
|
|
const X &x = true ? get() : throw 0;
|
|
}
|
|
|
|
namespace dr1573 { // dr1573: 3.9
|
|
#if __cplusplus >= 201103L
|
|
// ellipsis is inherited (p0136r1 supersedes this part).
|
|
struct A { A(); A(int, char, ...); };
|
|
struct B : A { using A::A; };
|
|
B b(1, 'x', 4.0, "hello"); // ok
|
|
|
|
// inherited constructor is effectively constexpr if the user-written constructor would be
|
|
struct C { C(); constexpr C(int) {} };
|
|
struct D : C { using C::C; };
|
|
constexpr D d = D(0); // ok
|
|
struct E : C { using C::C; A a; }; // expected-note {{non-literal type}}
|
|
constexpr E e = E(0); // expected-error {{non-literal type}}
|
|
// FIXME: This diagnostic is pretty bad; we should explain that the problem
|
|
// is that F::c would be initialized by a non-constexpr constructor.
|
|
struct F : C { using C::C; C c; }; // expected-note {{here}}
|
|
constexpr F f = F(0); // expected-error {{constant expression}} expected-note {{constructor inherited from base class 'C'}}
|
|
|
|
// inherited constructor is effectively deleted if the user-written constructor would be
|
|
struct G { G(int); };
|
|
struct H : G { using G::G; G g; }; // expected-note {{constructor inherited by 'H' is implicitly deleted because field 'g' has no default constructor}}
|
|
H h(0); // expected-error {{constructor inherited by 'H' from base class 'G' is implicitly deleted}}
|
|
#endif
|
|
}
|
|
|
|
#if __cplusplus >= 201103L
|
|
namespace std {
|
|
typedef decltype(sizeof(int)) size_t;
|
|
|
|
// libc++'s implementation
|
|
template <class _E>
|
|
class initializer_list
|
|
{
|
|
const _E* __begin_;
|
|
size_t __size_;
|
|
|
|
initializer_list(const _E* __b, size_t __s)
|
|
: __begin_(__b), __size_(__s) {}
|
|
|
|
public:
|
|
typedef _E value_type;
|
|
typedef const _E& reference;
|
|
typedef const _E& const_reference;
|
|
typedef size_t size_type;
|
|
|
|
typedef const _E* iterator;
|
|
typedef const _E* const_iterator;
|
|
|
|
initializer_list() : __begin_(nullptr), __size_(0) {}
|
|
|
|
size_t size() const {return __size_;}
|
|
const _E* begin() const {return __begin_;}
|
|
const _E* end() const {return __begin_ + __size_;}
|
|
};
|
|
|
|
template < class _T1, class _T2 > struct pair { _T2 second; };
|
|
|
|
template<typename T> struct basic_string {
|
|
basic_string(const T* x) {}
|
|
~basic_string() {};
|
|
};
|
|
typedef basic_string<char> string;
|
|
|
|
} // std
|
|
|
|
namespace dr1579 { // dr1579: 3.9
|
|
template<class T>
|
|
struct GenericMoveOnly {
|
|
GenericMoveOnly();
|
|
template<class U> GenericMoveOnly(const GenericMoveOnly<U> &) = delete; // expected-note 5 {{marked deleted here}}
|
|
GenericMoveOnly(const int &) = delete; // expected-note 2 {{marked deleted here}}
|
|
template<class U> GenericMoveOnly(GenericMoveOnly<U> &&);
|
|
GenericMoveOnly(int &&);
|
|
};
|
|
|
|
GenericMoveOnly<float> DR1579_Eligible(GenericMoveOnly<char> CharMO) {
|
|
int i;
|
|
GenericMoveOnly<char> GMO;
|
|
|
|
if (0)
|
|
return i;
|
|
else if (0)
|
|
return GMO;
|
|
else if (0)
|
|
return ((GMO));
|
|
else
|
|
return CharMO;
|
|
}
|
|
|
|
GenericMoveOnly<char> GlobalMO;
|
|
|
|
GenericMoveOnly<float> DR1579_Ineligible(int &AnInt,
|
|
GenericMoveOnly<char> &CharMO) {
|
|
static GenericMoveOnly<char> StaticMove;
|
|
extern GenericMoveOnly<char> ExternMove;
|
|
|
|
if (0)
|
|
return AnInt; // expected-error{{invokes a deleted function}}
|
|
else if (0)
|
|
return GlobalMO; // expected-error{{invokes a deleted function}}
|
|
else if (0)
|
|
return StaticMove; // expected-error{{invokes a deleted function}}
|
|
else if (0)
|
|
return ExternMove; // expected-error{{invokes a deleted function}}
|
|
else if (0)
|
|
return AnInt; // expected-error{{invokes a deleted function}}
|
|
else
|
|
return CharMO; // expected-error{{invokes a deleted function}}
|
|
}
|
|
|
|
auto DR1579_lambda_valid = [](GenericMoveOnly<float> mo) ->
|
|
GenericMoveOnly<char> {
|
|
return mo;
|
|
};
|
|
|
|
auto DR1579_lambda_invalid = []() -> GenericMoveOnly<char> {
|
|
static GenericMoveOnly<float> mo;
|
|
return mo; // expected-error{{invokes a deleted function}}
|
|
};
|
|
} // end namespace dr1579
|
|
|
|
namespace dr1584 {
|
|
// Deducing function types from cv-qualified types
|
|
template<typename T> void f(const T *); // expected-note {{candidate template ignored}}
|
|
template<typename T> void g(T *, const T * = 0);
|
|
template<typename T> void h(T *) { T::error; } // expected-error {{no members}}
|
|
template<typename T> void h(const T *);
|
|
void i() {
|
|
f(&i); // expected-error {{no matching function}}
|
|
g(&i);
|
|
h(&i); // expected-note {{here}}
|
|
}
|
|
}
|
|
|
|
namespace dr1589 { // dr1589: 3.7 c++11
|
|
// Ambiguous ranking of list-initialization sequences
|
|
|
|
void f0(long, int=0); // Would makes selection of #0 ambiguous
|
|
void f0(long); // #0
|
|
void f0(std::initializer_list<int>); // #00
|
|
void g0() { f0({1L}); } // chooses #00
|
|
|
|
void f1(int, int=0); // Would make selection of #1 ambiguous
|
|
void f1(int); // #1
|
|
void f1(std::initializer_list<long>); // #2
|
|
void g1() { f1({42}); } // chooses #2
|
|
|
|
void f2(std::pair<const char*, const char*>, int = 0); // Would makes selection of #3 ambiguous
|
|
void f2(std::pair<const char*, const char*>); // #3
|
|
void f2(std::initializer_list<std::string>); // #4
|
|
void g2() { f2({"foo","bar"}); } // chooses #4
|
|
|
|
namespace with_error {
|
|
void f0(long); // #0 expected-note {{candidate function}}
|
|
void f0(std::initializer_list<int>); // #00 expected-note {{candidate function}}
|
|
void f0(std::initializer_list<int>, int = 0); // Makes selection of #00 ambiguous \
|
|
// expected-note {{candidate function}}
|
|
void g0() { f0({1L}); } // chooses #00 expected-error{{call to 'f0' is ambiguous}}
|
|
|
|
void f1(int); // #1 expected-note {{candidate function}}
|
|
void f1(std::initializer_list<long>); // #2 expected-note {{candidate function}}
|
|
void f1(std::initializer_list<long>, int = 0); // Makes selection of #00 ambiguous \
|
|
// expected-note {{candidate function}}
|
|
void g1() { f1({42}); } // chooses #2 expected-error{{call to 'f1' is ambiguous}}
|
|
|
|
void f2(std::pair<const char*, const char*>); // #3 TODO: expected- note {{candidate function}}
|
|
void f2(std::initializer_list<std::string>); // #4 expected-note {{candidate function}}
|
|
void f2(std::initializer_list<std::string>, int = 0); // Makes selection of #00 ambiguous \
|
|
// expected-note {{candidate function}}
|
|
void g2() { f2({"foo","bar"}); } // chooses #4 expected-error{{call to 'f2' is ambiguous}}
|
|
}
|
|
|
|
} // dr1589
|
|
|
|
namespace dr1591 { //dr1591. Deducing array bound and element type from initializer list
|
|
template<class T, int N> int h(T const(&)[N]);
|
|
int X = h({1,2,3}); // T deduced to int, N deduced to 3
|
|
|
|
template<class T> int j(T const(&)[3]);
|
|
int Y = j({42}); // T deduced to int, array bound not considered
|
|
|
|
struct Aggr { int i; int j; };
|
|
template<int N> int k(Aggr const(&)[N]); //expected-note{{not viable}}
|
|
int Y0 = k({1,2,3}); //expected-error{{no matching function}}
|
|
int Z = k({{1},{2},{3}}); // OK, N deduced to 3
|
|
|
|
template<int M, int N> int m(int const(&)[M][N]);
|
|
int X0 = m({{1,2},{3,4}}); // M and N both deduced to 2
|
|
|
|
template<class T, int N> int n(T const(&)[N], T);
|
|
int X1 = n({{1},{2},{3}},Aggr()); // OK, T is Aggr, N is 3
|
|
|
|
|
|
namespace check_multi_dim_arrays {
|
|
template<class T, int N, int M, int O> int ***f(const T (&a)[N][M][O]); //expected-note{{deduced conflicting values}}
|
|
template<class T, int N, int M> int **f(const T (&a)[N][M]); //expected-note{{couldn't infer}}
|
|
|
|
template<class T, int N> int *f(const T (&a)[N]); //expected-note{{couldn't infer}}
|
|
int ***p3 = f({ { {1,2}, {3, 4} }, { {5,6}, {7, 8} }, { {9,10}, {11, 12} } });
|
|
int ***p33 = f({ { {1,2}, {3, 4} }, { {5,6}, {7, 8} }, { {9,10}, {11, 12, 13} } }); //expected-error{{no matching}}
|
|
int **p2 = f({ {1,2,3}, {3, 4, 5} });
|
|
int **p22 = f({ {1,2}, {3, 4} });
|
|
int *p1 = f({1, 2, 3});
|
|
}
|
|
namespace check_multi_dim_arrays_rref {
|
|
template<class T, int N, int M, int O> int ***f(T (&&a)[N][M][O]); //expected-note{{deduced conflicting values}}
|
|
template<class T, int N, int M> int **f(T (&&a)[N][M]); //expected-note{{couldn't infer}}
|
|
|
|
template<class T, int N> int *f(T (&&a)[N]); //expected-note{{couldn't infer}}
|
|
int ***p3 = f({ { {1,2}, {3, 4} }, { {5,6}, {7, 8} }, { {9,10}, {11, 12} } });
|
|
int ***p33 = f({ { {1,2}, {3, 4} }, { {5,6}, {7, 8} }, { {9,10}, {11, 12, 13} } }); //expected-error{{no matching}}
|
|
int **p2 = f({ {1,2,3}, {3, 4, 5} });
|
|
int **p22 = f({ {1,2}, {3, 4} });
|
|
int *p1 = f({1, 2, 3});
|
|
}
|
|
|
|
namespace check_arrays_of_init_list {
|
|
template<class T, int N> float *f(const std::initializer_list<T> (&)[N]);
|
|
template<class T, int N> double *f(const T(&)[N]);
|
|
double *p = f({1, 2, 3});
|
|
float *fp = f({{1}, {1, 2}, {1, 2, 3}});
|
|
}
|
|
namespace core_reflector_28543 {
|
|
|
|
template<class T, int N> int *f(T (&&)[N]); // #1
|
|
template<class T> char *f(std::initializer_list<T> &&); //#2
|
|
template<class T, int N, int M> int **f(T (&&)[N][M]); //#3 expected-note{{candidate}}
|
|
template<class T, int N> char **f(std::initializer_list<T> (&&)[N]); //#4 expected-note{{candidate}}
|
|
|
|
template<class T> short *f(T (&&)[2]); //#5
|
|
|
|
template<class T> using Arr = T[];
|
|
|
|
char *pc = f({1, 2, 3}); // OK prefer #2 via 13.3.3.2 [over.ics.rank]
|
|
char *pc2 = f({1, 2}); // #2 also
|
|
int *pi = f(Arr<int>{1, 2, 3}); // OK prefer #1
|
|
|
|
void *pv1 = f({ {1, 2, 3}, {4, 5, 6} }); // expected-error{{ambiguous}} btw 3 & 4
|
|
char **pcc = f({ {1}, {2, 3} }); // OK #4
|
|
|
|
short *ps = f(Arr<int>{1, 2}); // OK #5
|
|
}
|
|
} // dr1591
|
|
|
|
#endif
|