| // 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 |