From 222e2a7620e6520ffaf4fc4e69d79c18da31542e Mon Sep 17 00:00:00 2001 From: "Zancanaro; Carlo" Date: Mon, 24 Sep 2012 09:58:17 +1000 Subject: Add the clang library to the repo (with some of my changes, too). --- .../cxx0x-initializer-stdinitializerlist.cpp | 177 +++++++++++++++++++++ 1 file changed, 177 insertions(+) create mode 100644 clang/test/SemaCXX/cxx0x-initializer-stdinitializerlist.cpp (limited to 'clang/test/SemaCXX/cxx0x-initializer-stdinitializerlist.cpp') diff --git a/clang/test/SemaCXX/cxx0x-initializer-stdinitializerlist.cpp b/clang/test/SemaCXX/cxx0x-initializer-stdinitializerlist.cpp new file mode 100644 index 0000000..7384309 --- /dev/null +++ b/clang/test/SemaCXX/cxx0x-initializer-stdinitializerlist.cpp @@ -0,0 +1,177 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s + +// This must obviously come before the definition of std::initializer_list. +void missing_initializerlist() { + auto l = {1, 2, 3, 4}; // expected-error {{std::initializer_list was not found}} +} + +namespace std { + typedef decltype(sizeof(int)) size_t; + + // libc++'s implementation + template + 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 +struct same_type { static const bool value = false; }; +template +struct same_type { static const bool value = true; }; + +struct one { char c[1]; }; +struct two { char c[2]; }; + +struct A { + int a, b; +}; + +struct B { + B(); + B(int, int); +}; + +void simple_list() { + std::initializer_list il = { 1, 2, 3 }; + std::initializer_list dl = { 1.0, 2.0, 3 }; + std::initializer_list al = { {1, 2}, {2, 3}, {3, 4} }; + std::initializer_list bl = { {1, 2}, {2, 3}, {} }; +} + +void function_call() { + void f(std::initializer_list); + f({1, 2, 3}); + + void g(std::initializer_list); + g({ {1, 2}, {2, 3}, {} }); +} + +struct C { + C(int); +}; + +struct D { + D(); + operator int(); + operator C(); +}; + +void overloaded_call() { + one overloaded(std::initializer_list); + two overloaded(std::initializer_list); + + static_assert(sizeof(overloaded({1, 2, 3})) == sizeof(one), "bad overload"); + static_assert(sizeof(overloaded({ {1, 2}, {2, 3}, {} })) == sizeof(two), "bad overload"); + + void ambiguous(std::initializer_list); // expected-note {{candidate}} + void ambiguous(std::initializer_list); // expected-note {{candidate}} + ambiguous({ {1, 2}, {2, 3}, {3, 4} }); // expected-error {{ambiguous}} + + one ov2(std::initializer_list); // expected-note {{candidate}} + two ov2(std::initializer_list); // expected-note {{candidate}} + // Worst sequence to int is identity, whereas to C it's user-defined. + static_assert(sizeof(ov2({1, 2, 3})) == sizeof(one), "bad overload"); + // But here, user-defined is worst in both cases. + ov2({1, 2, D()}); // expected-error {{ambiguous}} +} + +template +T deduce(std::initializer_list); // expected-note {{conflicting types for parameter 'T' ('int' vs. 'double')}} +template +T deduce_ref(const std::initializer_list&); // expected-note {{conflicting types for parameter 'T' ('int' vs. 'double')}} + +void argument_deduction() { + static_assert(same_type::value, "bad deduction"); + static_assert(same_type::value, "bad deduction"); + + deduce({1, 2.0}); // expected-error {{no matching function}} + + static_assert(same_type::value, "bad deduction"); + static_assert(same_type::value, "bad deduction"); + + deduce_ref({1, 2.0}); // expected-error {{no matching function}} +} + +void auto_deduction() { + auto l = {1, 2, 3, 4}; + static_assert(same_type>::value, ""); + auto bl = {1, 2.0}; // expected-error {{cannot deduce}} + + for (int i : {1, 2, 3, 4}) {} +} + +void dangle() { + new auto{1, 2, 3}; // expected-error {{cannot use list-initialization}} + new std::initializer_list{1, 2, 3}; // expected-warning {{at the end of the full-expression}} +} + +struct haslist1 { + std::initializer_list il = {1, 2, 3}; // expected-warning{{at the end of the constructor}} + std::initializer_list jl{1, 2, 3}; // expected-warning{{at the end of the constructor}} + haslist1(); +}; + +haslist1::haslist1() +: il{1, 2, 3} // expected-warning{{at the end of the constructor}} +{} + +namespace PR12119 { + // Deduction with nested initializer lists. + template void f(std::initializer_list); + template void g(std::initializer_list>); + + void foo() { + f({0, {1}}); + g({{0, 1}, {2, 3}}); + std::initializer_list il = {1, 2}; + g({il, {2, 3}}); + } +} + +namespace Decay { + template + void f(std::initializer_list) { + T x = 1; // expected-error{{cannot initialize a variable of type 'const char *' with an rvalue of type 'int'}} + } + + void g() { + f({"A", "BB", "CCC"}); // expected-note{{in instantiation of function template specialization 'Decay::f' requested here}} + + auto x = { "A", "BB", "CCC" }; + std::initializer_list *il = &x; + + for( auto s : {"A", "BB", "CCC", "DDD"}) { } + } +} + +namespace PR12436 { + struct X { + template + X(std::initializer_list, T); + }; + + X x({}, 17); +} -- cgit v1.2.3