diff options
-rw-r--r-- | test/SemaCXX/generalized-initializers.cpp | 127 |
1 files changed, 127 insertions, 0 deletions
diff --git a/test/SemaCXX/generalized-initializers.cpp b/test/SemaCXX/generalized-initializers.cpp new file mode 100644 index 0000000000..4d8f177851 --- /dev/null +++ b/test/SemaCXX/generalized-initializers.cpp @@ -0,0 +1,127 @@ +// RUN: %clang_cc1 -std=c++0x -fsyntax-only -verify %s +// XFAIL: * + +template <typename T, typename U> +struct same_type { static const bool value = false; }; +template <typename T> +struct same_type<T, T> { static const bool value = true; }; + +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_;} + }; +} + +namespace integral { + + void initialization() { + { const int a{}; static_assert(a == 0, ""); } + { const int a = {}; static_assert(a == 0, ""); } + { const int a{1}; static_assert(a == 1, ""); } + { const int a = {1}; static_assert(a == 1, ""); } + { const int a{1, 2}; } // expected-error {{ too many initializers}} + { const int a = {1, 2}; } // expected-error {{ too many initializers}} + { const short a = {100000}; } // expected-error {{narrowing conversion}} + } + + int function_call() { + void takes_int(int); + takes_int({1}); + + int ar[10]; + (void) ar[{1}]; // expected-error {{initializer list is illegal with the built-in index operator}} + + return {1}; + } + + void inline_init() { + (void) int{1}; + (void) new int{1}; + } + + void initializer_list() { + auto l = {1, 2, 3, 4}; + static_assert(same_type<decltype(l), std::initializer_list<int>>::value, ""); + + for (int i : {1, 2, 3, 4}) {} + } + + struct A { + int i; + A() : i{1} {} + }; + +} + +namespace objects { + + struct A { + A(); + A(int, double); + A(int, int); + A(std::initializer_list<int>); + + int operator[](A); + }; + + void initialization() { + // FIXME: how to ensure correct overloads are called? + { A a{}; } + { A a = {}; } + { A a{1, 1.0}; } + { A a = {1, 1.0}; } + { A a{1, 2, 3, 4, 5, 6, 7, 8}; } + { A a = {1, 2, 3, 4, 5, 6, 7, 8}; } + { A a{1, 2, 3, 4, 5, 6, 7, 8}; } + { A a{1, 2}; } + } + + A function_call() { + void takes_A(A); + takes_a({1, 1.0}); + + A a; + a[{1, 1.0}]; + + return {1, 1.0}; + } + + void inline_init() { + (void) A{1, 1.0}; + (void) new A{1, 1.0}; + } + + struct B { + B(A, int, A); + }; + + void nested_init() { + B b{{1, 1.0}, 2, {3, 4, 5, 6, 7}}; + } +} |