blob: e8e3e7dd5a088b391712ad98cf9ef6d7e08ee1ab [file] [log] [blame]
// RUN: %clang_cc1 -std=c++11 -verify %s
namespace UseBeforeDefinition {
struct A {
template<typename T> static constexpr T get() { return T(); }
// ok, not a constant expression.
int n = get<int>();
};
// ok, constant expression.
constexpr int j = A::get<int>();
template<typename T> constexpr int consume(T);
// ok, not a constant expression.
const int k = consume(0); // expected-note {{here}}
template<typename T> constexpr int consume(T) { return 0; }
// ok, constant expression.
constexpr int l = consume(0);
constexpr int m = k; // expected-error {{constant expression}} expected-note {{initializer of 'k'}}
}
namespace IntegralConst {
template<typename T> constexpr T f(T n) { return n; }
enum E {
v = f(0), w = f(1) // ok
};
static_assert(w == 1, "");
char arr[f('x')]; // ok
static_assert(sizeof(arr) == 'x', "");
}
namespace ConvertedConst {
template<typename T> constexpr T f(T n) { return n; }
int f() {
switch (f()) {
case f(4): return 0;
}
return 1;
}
}
namespace OverloadResolution {
template<typename T> constexpr T f(T t) { return t; }
template<int n> struct S { };
template<typename T> auto g(T t) -> S<f(sizeof(T))> &;
char &f(...);
template<typename T> auto h(T t[f(sizeof(T))]) -> decltype(&*t) {
return t;
}
S<4> &k = g(0);
int *p, *q = h(p);
}
namespace DataMember {
template<typename T> struct S { static const int k; };
const int n = S<int>::k; // expected-note {{here}}
template<typename T> const int S<T>::k = 0;
constexpr int m = S<int>::k; // ok
constexpr int o = n; // expected-error {{constant expression}} expected-note {{initializer of 'n'}}
}
namespace Reference {
const int k = 5;
template<typename T> struct S {
static volatile int &r;
};
template<typename T> volatile int &S<T>::r = const_cast<volatile int&>(k);
constexpr int n = const_cast<int&>(S<int>::r);
static_assert(n == 5, "");
}
namespace Unevaluated {
// We follow g++ in treating any reference to a constexpr function template
// specialization as requiring an instantiation, even if it occurs in an
// unevaluated context.
//
// We go slightly further than g++, and also trigger the implicit definition
// of a defaulted special member in the same circumstances. This seems scary,
// since a lot of classes have constexpr special members in C++11, but the
// only observable impact should be the implicit instantiation of constexpr
// special member templates (defaulted special members should only be
// generated if they are well-formed, and non-constexpr special members in a
// base or member cause the class's special member to not be constexpr).
//
// FIXME: None of this is required by the C++ standard. The rules in this
// area are poorly specified, so this is subject to change.
namespace NotConstexpr {
template<typename T> struct S {
S() : n(0) {}
S(const S&) : n(T::error) {}
int n;
};
struct U : S<int> {};
decltype(U(U())) u; // ok, don't instantiate S<int>::S() because it wasn't declared constexpr
}
namespace Constexpr {
template<typename T> struct S {
constexpr S() : n(0) {}
constexpr S(const S&) : n(T::error) {} // expected-error {{has no members}}
int n;
};
struct U : S<int> {}; // expected-note {{instantiation}}
decltype(U(U())) u; // expected-note {{here}}
}
namespace PR11851_Comment0 {
template<int x> constexpr int f() { return x; }
template<int i> void ovf(int (&x)[f<i>()]);
void f() { int x[10]; ovf<10>(x); }
}
namespace PR11851_Comment1 {
template<typename T>
constexpr bool Integral() {
return true;
}
template<typename T, bool Int = Integral<T>()>
struct safe_make_unsigned {
typedef T type;
};
template<typename T>
using Make_unsigned = typename safe_make_unsigned<T>::type;
template <typename T>
struct get_distance_type {
using type = int;
};
template<typename R>
auto size(R) -> Make_unsigned<typename get_distance_type<R>::type>;
auto check() -> decltype(size(0));
}
namespace PR11851_Comment6 {
template<int> struct foo {};
template<class> constexpr int bar() { return 0; }
template<class T> foo<bar<T>()> foobar();
auto foobar_ = foobar<int>();
}
namespace PR11851_Comment9 {
struct S1 {
constexpr S1() {}
constexpr operator int() const { return 0; }
};
int k1 = sizeof(short{S1(S1())});
struct S2 {
constexpr S2() {}
constexpr operator int() const { return 123456; }
};
int k2 = sizeof(short{S2(S2())}); // expected-error {{cannot be narrowed}} expected-note {{insert an explicit cast to silence this issue}}
}
namespace PR12288 {
template <typename> constexpr bool foo() { return true; }
template <bool> struct bar {};
template <typename T> bar<foo<T>()> baz() { return bar<foo<T>()>(); }
int main() { baz<int>(); }
}
namespace PR13423 {
template<bool, typename> struct enable_if {};
template<typename T> struct enable_if<true, T> { using type = T; };
template<typename T> struct F {
template<typename U>
static constexpr bool f() { return sizeof(T) < U::size; }
template<typename U>
static typename enable_if<f<U>(), void>::type g() {} // expected-note {{disabled by 'enable_if'}}
};
struct U { static constexpr int size = 2; };
void h() { F<char>::g<U>(); }
void i() { F<int>::g<U>(); } // expected-error {{no matching function}}
}
namespace PR14203 {
struct duration { constexpr duration() {} };
template <typename>
void sleep_for() {
constexpr duration max = duration();
}
}
}
namespace NoInstantiationWhenSelectingOverload {
// Check that we don't instantiate conversion functions when we're checking
// for the existence of an implicit conversion sequence, only when a function
// is actually chosen by overload resolution.
struct S {
template<typename T> constexpr S(T) : n(T::error) {} // expected-error {{no members}}
int n;
};
int f(S);
int f(int);
void g() { f(0); }
void h() { (void)sizeof(f(0)); }
void i() { (void)sizeof(f("oops")); } // expected-note {{instantiation of}}
}