forked from OSchip/llvm-project
128 lines
2.6 KiB
C++
128 lines
2.6 KiB
C++
// 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}};
|
|
}
|
|
}
|