243 lines · cpp
1// RUN: %clang_cc1 -fsyntax-only -verify %s2// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s3// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s4template<typename T, typename U = int> struct A; // expected-note {{template is declared here}} \5 // expected-note{{explicitly specialized}}6 7template<> struct A<double, double>; // expected-note{{forward declaration}}8 9template<> struct A<float, float> { // expected-note{{previous definition}}10 int x;11};12 13template<> struct A<float> { // expected-note{{previous definition}}14 int y;15};16 17int test_specs(A<float, float> *a1, A<float, int> *a2) {18 return a1->x + a2->y;19}20 21int test_incomplete_specs(A<double, double> *a1,22 A<double> *a2)23{24 (void)a1->x; // expected-error{{member access into incomplete type}}25 (void)a2->x; // expected-error{{implicit instantiation of undefined template 'A<double>'}}26}27 28typedef float FLOAT;29 30template<> struct A<float, FLOAT>;31 32template<> struct A<FLOAT, float> { }; // expected-error{{redefinition}}33 34template<> struct A<float, int> { }; // expected-error{{redefinition}}35 36template<typename T, typename U = int> struct X;37 38template <> struct X<int, int> { int foo(); }; // #139template <> struct X<float> { int bar(); }; // #240 41typedef int int_type;42void testme(X<int_type> *x1, X<float, int> *x2) {43 (void)x1->foo(); // okay: refers to #144 (void)x2->bar(); // okay: refers to #245}46 47// Make sure specializations are proper classes.48template<>49struct A<char> {50 A();51};52 53A<char>::A() { }54 55// Make sure we can see specializations defined before the primary template.56namespace N{57 template<typename T> struct A0;58}59 60namespace N {61 template<>62 struct A0<void> {63 typedef void* pointer;64 };65}66 67namespace N {68 template<typename T>69 struct A0 {70 void foo(A0<void>::pointer p = 0);71 };72}73 74// Diagnose specialization errors75struct A<double> { }; // expected-error{{template specialization requires 'template<>'}}76 77template<> struct ::A<double>; // expected-warning {{extra qualification on member}}78 79namespace N {80 template<typename T> struct B; // expected-note {{explicitly specialized}}81 82 template<> struct ::N::B<char>; // expected-warning {{extra qualification on member}}83 template<> struct ::N::B<short>; // expected-warning {{extra qualification on member}}84 template<> struct ::N::B<int>; // expected-warning {{extra qualification on member}}85 86 int f(int);87}88 89template<> struct N::B<int> { }; // okay90 91template<> struct N::B<float> { };92 93 94namespace M {95 template<> struct ::N::B<short> { }; // expected-error{{class template specialization of 'B' not in a namespace enclosing 'N'}}96 97 template<> struct ::A<long double>; // expected-error{{must occur at global scope}}98}99 100template<> struct N::B<char> {101 int testf(int x) { return f(x); }102};103 104// PR5264105template <typename T> class Foo;106Foo<int>* v;107Foo<int>& F() { return *v; }108template <typename T> class Foo {};109Foo<int> x;110 111 112// Template template parameters113template<template<class T> class Wibble>114class Wibble<int> { }; // expected-error{{cannot specialize a template template parameter}}115 116namespace rdar9676205 {117 template<typename T>118 struct X { // expected-note {{here}}119 template<typename U>120 struct X<U*> { // expected-error{{partial specialization of 'X' not in a namespace enclosing}}121 };122 };123 124}125 126namespace PR18009 {127 template <typename T> struct A {128 template <int N, int M> struct S;129 template <int N> struct S<N, sizeof(T)> {};130 };131 A<int>::S<8, sizeof(int)> a; // ok132 133 template <typename T> struct B {134 template <int N, int M> struct S;135 template <int N> struct S<N, sizeof(T) + N> {}; // ok (dr1315)136 };137 B<int>::S<8, sizeof(int) + 8> b;138 139 template <typename T> struct C {140 template <int N, int M> struct S;141 template <int N> struct S<N, N ? **(T(*)[N])0 : 0> {}; // ok142 };143 C<int> c;144 145 template<int A> struct outer {146 template<int B, int C> struct inner {};147 template<int C> struct inner<A * 2, C> {};148 };149}150 151namespace PR16519 {152 template<typename T, T...N> struct integer_sequence { typedef T value_type; };153#if __cplusplus <= 199711L154 // expected-warning@-2 {{variadic templates are a C++11 extension}}155#endif156 157 template<typename T> struct __make_integer_sequence;158 template<typename T, T N> using make_integer_sequence = typename __make_integer_sequence<T>::template make<N, N % 2>::type;159#if __cplusplus <= 199711L160 // expected-warning@-2 {{alias declarations are a C++11 extension}}161#endif162 163 template<typename T, typename T::value_type ...Extra> struct __make_integer_sequence_impl;164#if __cplusplus <= 199711L165 // expected-warning@-2 {{variadic templates are a C++11 extension}}166#endif167 168 // Note that the following seemingly-equivalent template parameter list is169 // not OK; it would result in a partial specialization that is not more170 // specialized than the primary template. (See NTTPTypeVsPartialOrder below.)171 //172 // template<typename T, T ...N, T ...Extra>173 template<typename T, T ...N, typename integer_sequence<T, N...>::value_type ...Extra>174#if __cplusplus <= 199711L175 // expected-warning@-2 2{{variadic templates are a C++11 extension}}176#endif177 struct __make_integer_sequence_impl<integer_sequence<T, N...>, Extra...> {178 typedef integer_sequence<T, N..., sizeof...(N) + N..., Extra...> type;179 };180 181 template<typename T> struct __make_integer_sequence {182 template<T N, T Parity, typename = void> struct make;183 template<typename Dummy> struct make<0, 0, Dummy> { typedef integer_sequence<T> type; };184 template<typename Dummy> struct make<1, 1, Dummy> { typedef integer_sequence<T, 0> type; };185 template<T N, typename Dummy> struct make<N, 0, Dummy> : __make_integer_sequence_impl<make_integer_sequence<T, N/2> > {};186 template<T N, typename Dummy> struct make<N, 1, Dummy> : __make_integer_sequence_impl<make_integer_sequence<T, N/2>, N - 1> {};187 };188 189 using X = make_integer_sequence<int, 5>;190#if __cplusplus <= 199711L191 // expected-warning@-2 {{alias declarations are a C++11 extension}}192#endif193 194 using X = integer_sequence<int, 0, 1, 2, 3, 4>;195#if __cplusplus <= 199711L196 // expected-warning@-2 {{alias declarations are a C++11 extension}}197#endif198}199 200namespace NTTPTypeVsPartialOrder {201 struct X { typedef int value_type; };202 template<typename T> struct Y { typedef T value_type; };203 204 template<typename T, typename T::value_type N> struct A;205 template<int N> struct A<X, N> {};206 template<typename T, T N> struct A<Y<T>, N> {};207 A<X, 0> ax;208 A<Y<int>, 0> ay;209 210 211 template<int, typename T, typename T::value_type> struct B;212 template<typename T, typename T::value_type N> struct B<0, T, N>;213 template<int N> struct B<0, X, N> {};214 template<typename T, T N> struct B<0, Y<T>, N> {};215 B<0, X, 0> bx;216 B<0, Y<int>, 0> by;217}218 219namespace DefaultArgVsPartialSpec {220 // Check that the diagnostic points at the partial specialization, not just at221 // the default argument.222 template<typename T, int N =223 sizeof(T) // ok (dr1315)224 > struct X {};225 template<typename T> struct X<T> {};226 227 template<typename T,228 T N = 0 // expected-note {{template parameter is declared here}}229 > struct S;230 template<typename T> struct S<T> {}; // expected-error {{non-type template argument specializes a template parameter with dependent type 'T'}}231}232 233namespace LateDefined {234 template <class> struct A;235 struct B {236 typedef A<B> X;237 };238 template <> struct A<B> {239 void f();240 };241 void A<B>::f() {}242}243