blob: b4ea2c23b3ccd8a0bdebc987870bd21c36b636f4 [file] [log] [blame]
// Header for PCH test cxx-templates.cpp
template <typename T1, typename T2>
struct S;
template <typename T1, typename T2>
struct S {
S() { }
static void templ();
};
template <typename T>
struct S<int, T> {
static void partial();
};
template <>
struct S<int, float> {
static void explicit_special();
};
template <int x>
int tmpl_f2() { return x; }
template <typename T, int y>
T templ_f(T x) {
int z = templ_f<int, 5>(3);
z = tmpl_f2<y+2>();
T data[y];
return x+y;
}
void govl(int);
void govl(char);
template <typename T>
struct Unresolv {
void f() {
govl(T());
}
};
template <typename T>
struct Dep {
typedef typename T::type Ty;
void f() {
Ty x = Ty();
T::my_f();
int y = T::template my_templf<int>(0);
ovl(y);
}
void ovl(int);
void ovl(float);
};
template<typename T, typename A1>
inline T make_a(const A1& a1) {
T::depend_declref();
return T(a1);
}
template <class T> class UseBase {
void foo();
typedef int bar;
};
template <class T> class UseA : public UseBase<T> {
using UseBase<T>::foo;
using typename UseBase<T>::bar;
};
template <class T> class Sub : public UseBase<int> { };
template <class _Ret, class _Tp>
class mem_fun_t
{
public:
explicit
mem_fun_t(_Ret (_Tp::*__pf)())
{}
private:
_Ret (_Tp::*_M_f)();
};
template<unsigned N>
bool isInt(int x);
template<> bool isInt<8>(int x) {
try { ++x; } catch(...) { --x; }
return true;
}
template<typename _CharT>
int __copy_streambufs_eof(_CharT);
class basic_streambuf
{
void m() { }
friend int __copy_streambufs_eof<>(int);
};
// PR 7660
template<typename T> struct S_PR7660 { void g(void (*)(T)); };
template<> void S_PR7660<int>::g(void(*)(int)) {}
// PR 7670
template<typename> class C_PR7670;
template<> class C_PR7670<int>;
template<> class C_PR7670<int>;
template <bool B>
struct S2 {
static bool V;
};
extern template class S2<true>;
template <typename T>
struct S3 {
void m();
};
template <typename T>
inline void S3<T>::m() { }
template <typename T>
struct S4 {
void m() { }
};
extern template struct S4<int>;
void S4ImplicitInst() {
S4<int> s;
s.m();
}
struct S5 {
S5(int x);
};
struct TS5 {
S5 s;
template <typename T>
TS5(T y) : s(y) {}
};
// PR 8134
template<class T> void f_PR8134(T);
template<class T> void f_PR8134(T);
void g_PR8134() { f_PR8134(0); f_PR8134('x'); }
// rdar8580149
template <typename T>
struct S6;
template <typename T, unsigned N>
struct S6<const T [N]>
{
private:
typedef const T t1[N];
public:
typedef t1& t2;
};
template<typename T>
struct S7;
template<unsigned N>
struct S7<int[N]> : S6<const int[N]> { };
// Zero-length template argument lists
namespace ZeroLengthExplicitTemplateArgs {
template<typename T> void h();
struct Y {
template<typename T> void f();
};
template<typename T>
void f(T *ptr) {
T::template g<>(17);
ptr->template g2<>(17);
h<T>();
h<int>();
Y y;
y.f<int>();
}
struct X {
template<typename T> static void g(T);
template<typename T> void g2(T);
};
}
namespace NonTypeTemplateParmContext {
template<typename T, int inlineCapacity = 0> class Vector { };
struct String {
template<int inlineCapacity>
static String adopt(Vector<char, inlineCapacity>&);
};
template<int inlineCapacity>
inline bool equalIgnoringNullity(const Vector<char, inlineCapacity>& a, const String& b) { return false; }
}
// <rdar://problem/11112464>
template< typename > class Foo;
template< typename T >
class Foo : protected T
{
public:
Foo& operator=( const Foo& other );
};
template<typename...A> struct NestedExpansion {
template<typename...B> auto f(A...a, B...b) -> decltype(g(a + b...));
};
template struct NestedExpansion<char, char, char>;
namespace rdar13135282 {
template < typename _Alloc >
void foo(_Alloc = _Alloc());
template < bool > class __pool;
template < template < bool > class _PoolTp >
struct __common_pool {
typedef _PoolTp < 0 > pool_type;
};
template < template < bool > class _PoolTp >
struct __common_pool_base : __common_pool < _PoolTp > {};
template < template < bool > class _PoolTp >
struct A : __common_pool_base < _PoolTp > {};
template < typename _Poolp = A < __pool > >
struct __mt_alloc {
typedef typename _Poolp::pool_type __pool_type;
__mt_alloc() {
foo<__mt_alloc<> >();
}
};
}
namespace PR13020 {
template<typename T>
void f() {
enum E {
enumerator
};
T t = enumerator;
}
template void f<int>();
}
template<typename T> void doNotDeserialize() {}
template<typename T> struct ContainsDoNotDeserialize {
static int doNotDeserialize;
};
template<typename T> struct ContainsDoNotDeserialize2 {
static void doNotDeserialize();
};
template<typename T> int ContainsDoNotDeserialize<T>::doNotDeserialize = 0;
template<typename T> void ContainsDoNotDeserialize2<T>::doNotDeserialize() {}
template<typename T> void DependentSpecializedFunc(T x) { x.foo(); }
template<typename T> class DependentSpecializedFuncClass {
void foo() {}
friend void DependentSpecializedFunc<>(DependentSpecializedFuncClass);
};
namespace cyclic_module_load {
// Reduced from a libc++ modules crasher.
namespace std {
template<class> class mask_array;
template<class> class valarray {
public:
valarray(const valarray &v);
};
class gslice {
valarray<int> x;
valarray<int> stride() const { return x; }
};
template<class> class mask_array {
template<class> friend class valarray;
};
}
}
namespace local_extern {
template<typename T> int f() {
extern int arr[3];
{
extern T arr;
return sizeof(arr);
}
}
template<typename T> int g() {
extern int arr[3];
extern T arr;
return sizeof(arr);
}
}
namespace rdar15468709a {
template<typename> struct decay {};
template<typename FooParamTy> auto foo(FooParamTy fooParam) -> decltype(fooParam);
template<typename BarParamTy> auto bar(BarParamTy barParam) -> decay<decltype(barParam)>;
struct B {};
void crash() {
B some;
bar(some);
}
}
namespace rdar15468709b {
template<typename> struct decay {};
template<typename... Foos> int returnsInt(Foos... foos);
template<typename... FooParamTy> auto foo(FooParamTy... fooParam) -> decltype(returnsInt(fooParam...));
template<typename... BarParamTy> auto bar(BarParamTy... barParam) -> decay<decltype(returnsInt(barParam...))>;
struct B {};
void crash() {
B some;
bar(some);
}
}
namespace rdar15468709c {
template<typename> struct decay {};
template<class... Foos> int returnsInt(Foos... foos);
template<typename FooParamTy> void foo(FooParamTy fooParam) { decltype(fooParam) a; }
template<typename BarParamTy> auto bar(BarParamTy barParam) -> decay<decltype(barParam)>;
struct B {};
void crash() {
B some;
bar(some);
}
}
namespace MemberSpecializationLocation {
template<typename T> struct A { static int n; };
}
// https://bugs.llvm.org/show_bug.cgi?id=34728
namespace PR34728 {
// case 1: defaulted `NonTypeTemplateParmDecl`, non-defaulted 2nd tpl param
template <int foo = 10, class T>
int func1(T const &);
template <int foo, class T>
int func1(T const &) {
return foo;
}
// case 2: defaulted `TemplateTypeParmDecl`, non-defaulted 2nd tpl param
template <class A = int, class B>
A func2(B const &);
template <class A, class B>
A func2(B const &) {
return A(20.0f);
}
// case 3: defaulted `TemplateTemplateParmDecl`, non-defaulted 2nd tpl param
template <class T>
struct Container { T const &item; };
template <template <class> class C = Container, class D>
C<D> func3(D const &);
template <template <class> class C, class D>
C<D> func3(D const &d) {
return Container<D>{d};
}
} // end namespace PR34728
namespace ClassScopeExplicitSpecializations {
template<int> struct A {
template<int> constexpr int f() const { return 1; }
template<> constexpr int f<0>() const { return 2; }
};
template<> template<int> constexpr int A<0>::f() const { return 3; }
template<> template<> constexpr int A<0>::f<0>() const { return 4; }
template<> template<> constexpr int A<0>::f<1>() const { return 5; }
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winstantiation-after-specialization"
template int A<2>::f<0>() const;
#pragma clang diagnostic pop
template int A<2>::f<1>() const;
extern template int A<3>::f<0>() const;
extern template int A<3>::f<1>() const;
template<int> struct B {
template<typename> static const int v = 1;
template<typename T> static const int v<T*> = 2;
template<> static const int v<int> = 3;
template<typename> static constexpr int w = 1;
template<typename T> static constexpr int w<T*> = 2;
template<> static constexpr int w<int> = 3;
};
template<> template<typename> constexpr int B<0>::v = 4;
template<> template<typename T> constexpr int B<0>::v<T*> = 5;
template<> template<typename T> constexpr int B<0>::v<T&> = 6;
// This is ill-formed: the initializer of v<int> is instantiated with the
// class.
//template<> template<> constexpr int B<0>::v<int> = 7;
template<> template<> constexpr int B<0>::v<float> = 8;
template<> template<typename> constexpr int B<0>::w = 4;
template<> template<typename T> constexpr int B<0>::w<T*> = 5;
template<> template<typename T> constexpr int B<0>::w<T&> = 6;
template<> template<> constexpr int B<0>::w<int> = 7;
template<> template<> constexpr int B<0>::w<float> = 8;
}
namespace DependentMemberExpr {
struct Base {
constexpr int setstate() { return 0; }
};
template<typename T> struct A : Base {
constexpr int f() { return Base::setstate(); }
};
}
namespace DependentTemplateName {
template <template <class> class Template>
struct TakesClassTemplate {};
template <class T>
TakesClassTemplate<T::template Member> getWithIdentifier();
}