forked from OSchip/llvm-project
98 lines
2.4 KiB
C++
98 lines
2.4 KiB
C++
// RUN: %clang_cc1 -std=c++20 -verify %s
|
|
// RUN: %clang_cc1 -std=c++17 -verify %s
|
|
|
|
namespace One {
|
|
char (&b(int(&&)[1]))[1]; // #1 expected-note{{too many initializers}}
|
|
char (&b(int(&&)[2]))[2]; // #2 expected-note{{too many initializers}}
|
|
|
|
void f() {
|
|
static_assert(sizeof(b({1})) == 1); // #1
|
|
static_assert(sizeof(b({1, 2})) == 2); // #2
|
|
|
|
b({1, 2, 3}); // expected-error{{no matching function}}
|
|
}
|
|
} // namespace One
|
|
|
|
namespace Two {
|
|
struct Bob {
|
|
Bob(int = 1);
|
|
};
|
|
|
|
char (&b(Bob(&&)[1]))[1]; // #1
|
|
char (&b(Bob(&&)[2]))[2]; // #2
|
|
|
|
void f() {
|
|
static_assert(sizeof(b({})) == 1); // #1
|
|
static_assert(sizeof(b({Bob()})) == 1); // #1
|
|
static_assert(sizeof(b({2, Bob()})) == 2); // #2
|
|
}
|
|
} // namespace Two
|
|
|
|
namespace Three {
|
|
struct Kevin {
|
|
Kevin(int);
|
|
};
|
|
|
|
char (&b(Kevin(&&)[2]))[2]; // #2 expected-note{{too few initializers}}
|
|
|
|
void f() {
|
|
b({2}); // #1 expected-error{{no matching function}}
|
|
}
|
|
} // namespace Three
|
|
|
|
namespace Four {
|
|
char (&b(int(&&)[1], float))[1]; // #1 expected-note{{candidate}}
|
|
char (&b(int(&&)[1], double))[2]; // #2 expected-note{{candidate}}
|
|
|
|
char (&c(float, int(&&)[1]))[1]; // #1 expected-note{{candidate}}
|
|
char (&c(double, int(&&)[1]))[2]; // #2 expected-note{{candidate}}
|
|
|
|
void f() {
|
|
b({1}, 0); // expected-error{{is ambiguous}}
|
|
c(0, {1}); // expected-error{{is ambiguous}}
|
|
}
|
|
} // namespace Four
|
|
|
|
typedef decltype(sizeof(char)) size_t;
|
|
namespace std {
|
|
// sufficient initializer list
|
|
template <class _E>
|
|
class initializer_list {
|
|
const _E *__begin_;
|
|
size_t __size_;
|
|
|
|
constexpr 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;
|
|
|
|
constexpr initializer_list() : __begin_(nullptr), __size_(0) {}
|
|
|
|
constexpr size_t size() const { return __size_; }
|
|
constexpr const _E *begin() const { return __begin_; }
|
|
constexpr const _E *end() const { return __begin_ + __size_; }
|
|
};
|
|
} // namespace std
|
|
|
|
namespace Five {
|
|
struct ugly {
|
|
ugly(char *);
|
|
ugly(int);
|
|
};
|
|
char (&f(std::initializer_list<char *>))[1]; // #1
|
|
char (&f(std::initializer_list<ugly>))[2]; // #2
|
|
void g() {
|
|
// Pick #2 as #1 not viable (3->char * fails).
|
|
static_assert(sizeof(f({"hello", 3})) == 2); // expected-warning{{not allow}}
|
|
}
|
|
|
|
} // namespace Five
|