// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11
// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 -fexperimental-new-constant-interpreter
namespace value_range_detail {
template<typename T>
class value_range_iter {
T t;
public:
value_range_iter(const T &t) : t(t) {}
T operator*() const { return t; }
bool operator!=(const value_range_iter &o) const { return t != o.t; }
value_range_iter &operator++() { ++t; return *this; }
};
template<typename T>
struct value_range {
value_range(const T &a, const T &b) : begin_(a), end_(b) {}
value_range_iter<T> begin_, end_;
};
template<typename T>
value_range_iter<T> begin(const value_range<T> &r) { return r.begin_; }
template<typename T>
value_range_iter<T> end(const value_range<T> &r) { return r.end_; }
struct end_t {};
template<typename T>
class value_range_step_iter {
T it, step;
public:
value_range_step_iter(const T &it, const T &step) : it(it), step(step) {}
T operator*() const { return it; }
bool operator!=(value_range_step_iter end) const { return it != end.it; }
value_range_step_iter &operator++() { it += step; return *this; }
};
template<typename T>
class value_range_step {
T it, step, end_;
public:
value_range_step(const T &it, const T &end, const T &step) :
it(it), end_(end), step(step) {}
typedef value_range_step_iter<T> iterator;
iterator begin() const { return iterator(it, step); }
iterator end() const { return iterator(end_, step); }
};
}
template<typename T>
value_range_detail::value_range<T> range(const T &a, const T &b) { return value_range_detail::value_range<T>(a, b); }
template<typename T>
value_range_detail::value_range_step<T> range(const T &a, const T &b, const T &step) { return value_range_detail::value_range_step<T>(a, b, step); }
namespace map_range {
template<typename T>
class vector {
T storage[100];
decltype(sizeof(char)) size;
public:
vector() : size() {}
void push_back(T t) { storage[size++] = t; }
T *begin() { return storage; }
T *end() { return storage + size; }
};
template<typename T> struct tuple_elem {
T t;
tuple_elem() {}
tuple_elem(T t) : t(t) {}
};
template<typename... A>
struct tuple : tuple_elem<A>... {
tuple() : tuple_elem<A>()... {}
tuple(A... a) : tuple_elem<A>(a)... {}
template<typename B> B &get() { return tuple_elem<B>::t; }
};
template<typename F, typename I>
class map_iter {
F f;
I i;
public:
map_iter(F f, I i) : f(f), i(i) {}
auto operator*() const -> decltype(f(*i)) { return f(*i); }
bool operator!=(const map_iter &o) const { return i != o.i; }
map_iter &operator++() { ++i; return *this; }
};
template<typename T>
struct iter_pair {
T begin_, end_;
iter_pair(T begin, T end) : begin_(begin), end_(end) {}
};
template<typename T> T begin(iter_pair<T> p) { return p.begin_; }
template<typename T> T end(iter_pair<T> p) { return p.end_; }
template<typename...> class mem_fun_impl;
template<typename R, typename T, typename... A>
class mem_fun_impl<R (T::*)(A...)> {
typedef R (T::*F)(A...);
F f;
public:
mem_fun_impl(F f) : f(f) {}
R operator()(T &t, A &&...a) const { return (t.*f)(static_cast<A&&>(a)...); }
};
template<typename F> mem_fun_impl<F> mem_fun(F f) { return mem_fun_impl<F>(f); }
template<typename F, typename T>
auto map(const F &f, T &t) -> iter_pair<map_iter<F, decltype(t.begin())>> {
typedef map_iter<F, decltype(t.begin())> iter;
return iter_pair<iter>(iter(f, t.begin()), iter(f, t.end()));
}
}
#define assert(b) if (!(b)) { return 1; }
int main() {
int total = 0;
for (auto n : range(1, 5)) {
total += n;
}
assert(total == 10);
for (auto n : range(10, 100, 10)) {
total += n;
}
assert(total == 460);
map_range::vector<char> chars;
chars.push_back('a');
chars.push_back('b');
chars.push_back('c');
for (char c : chars) {
++total;
}
assert(total == 463);
typedef map_range::tuple<int, double> T;
map_range::vector<T> pairs;
pairs.push_back(T(42, 12.9));
pairs.push_back(T(6, 4.2));
pairs.push_back(T(9, 1.1));
for (auto a : map(map_range::mem_fun(&T::get<int>), pairs)) {
total += a;
}
assert(total == 500);
}
// PR11793
namespace test2 {
class A {
int xs[10]; // expected-note {{implicitly declared private here}}
};
void test(A &a) {
for (int x : a.xs) { } // expected-error {{'xs' is a private member of 'test2::A'}}
}
}
namespace test3 {
// Make sure this doesn't crash
struct A {};
struct B { ~B(); operator bool(); };
struct C { B operator!=(const C&); C& operator++(); int operator*(); };
C begin(const A&);
C end(const A&);
template<typename T> void f() { for (auto a : A()) {} }
void g() { f<int>(); }
}
namespace test4 {
void f() {
int y;
// Make sure these don't crash. Better diagnostics would be nice.
for (: {1, 2, 3}) {} // expected-error {{expected expression}} expected-error {{expected ';'}}
for (1 : {1, 2, 3}) {} // expected-error {{must declare a variable}}
for (+x : {1, 2, 3}) {} // expected-error {{undeclared identifier}} expected-error {{expected ';'}}
for (+y : {1, 2, 3}) {} // expected-error {{must declare a variable}}
}
}
namespace test5 {
// Test error-recovery.
void f() {
for (auto x : undeclared_identifier) // expected-error {{undeclared identifier}}
for (auto y : x->foo)
y->bar();
for (auto x : 123) // expected-error {{no viable 'begin'}}
x->foo();
}
}
namespace test6 {
void foo(int arr[]) { // expected-note {{declared here}}
for (auto i : arr) { }
// expected-error@-1 {{cannot build range expression with array function parameter 'arr' since parameter with array type 'int[]' is treated as pointer type 'int *'}}
}
struct vector {
int *begin() { return 0; }
int *end() { return 0; }
};
void foo(vector arr[]) { // expected-note {{declared here}}
// Don't suggest to dereference arr.
for (auto i : arr) { }
// expected-error@-1 {{cannot build range expression with array function parameter 'arr' since parameter with array type 'vector[]' is treated as pointer type 'vector *'}}
}
}
namespace test7 {
void f() {
int arr[5], b;
for (a : arr) {} // expected-error {{requires type for loop variable}}
// FIXME: Give a different error in this case?
for (b : arr) {} // expected-error {{requires type for loop variable}}
for (arr : arr) {} // expected-error {{requires type for loop variable}}
for (c alignas(8) : arr) { // expected-error {{requires type for loop variable}}
static_assert(alignof(c) == 8, ""); // expected-warning {{extension}}
}
for (d alignas(1) : arr) {} // expected-error {{requested alignment is less than minimum}} expected-error {{requires type for loop variable}}
for (e [[deprecated]] : arr) { e = 0; } // expected-warning {{deprecated}} expected-note {{here}} expected-error {{requires type for loop variable}}
}
}
namespace pr18587 {
class Arg {};
struct Cont {
int *begin();
int *end();
};
void AddAllArgs(Cont &x) {
for (auto Arg: x) {
}
}
}
namespace PR32933 {
// https://bugs.llvm.org/show_bug.cgi?id=32933
void foo ()
{
int b = 1, a[b]; // expected-warning {{variable length arrays in C++ are a Clang extension}} \
expected-note {{read of non-const variable 'b' is not allowed in a constant expression}} \
expected-note {{declared here}}
a[0] = 0;
[&] { for (int c : a) 0; } (); // expected-warning {{expression result unused}}
}
int foo(int b) { // expected-note {{declared here}}
int varr[b][(b+=8)]; // expected-warning 2{{variable length arrays in C++ are a Clang extension}} \
expected-note {{function parameter 'b' with unknown value cannot be used in a constant expression}}
b = 15;
[&] {
int i = 0;
for (auto &c : varr)
{
c[0] = ++b;
}
[&] {
int i = 0;
for (auto &c : varr) {
int j = 0;
for(auto &c2 : c) {
++j;
}
++i;
}
}();
}();
return b;
}
}
Codebase Browser
llvm