1 // RUN: %clang_cc1 -fsyntax-only -verify %s 2 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s 3 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s 4 5 template<template<typename T> class X> struct A; // expected-note 2{{previous template template parameter is here}} 6 7 template<template<typename T, int I> class X> struct B; // expected-note{{previous template template parameter is here}} 8 9 template<template<int I> class X> struct C; // expected-note 2{{previous non-type template parameter with type 'int' is here}} 10 11 template<class> struct X; // expected-note{{too few template parameters in template template argument}} 12 template<int N> struct Y; // expected-note{{template parameter has a different kind in template argument}} 13 template<long N> struct Ylong; // expected-note{{template non-type parameter has a different type 'long' in template argument}} 14 template<const int &N> struct Yref; // expected-note{{template non-type parameter has a different type 'const int &' in template argument}} 15 16 namespace N { 17 template<class> struct Z; 18 } 19 template<class, class> struct TooMany; // expected-note{{too many template parameters in template template argument}} 20 21 22 A<X> *a1; 23 A<N::Z> *a2; 24 A< ::N::Z> *a3; 25 26 A<Y> *a4; // expected-error{{template template argument has different template parameters than its corresponding template template parameter}} 27 A<TooMany> *a5; // expected-error{{template template argument has different template parameters than its corresponding template template parameter}} 28 B<X> *a6; // expected-error{{template template argument has different template parameters than its corresponding template template parameter}} 29 C<Y> *a7; 30 C<Ylong> *a8; // expected-error{{template template argument has different template parameters than its corresponding template template parameter}} 31 C<Yref> *a9; // expected-error{{template template argument has different template parameters than its corresponding template template parameter}} 32 33 template<typename T> void f(int); 34 35 A<f> *a9; // expected-error{{must be a class template}} 36 37 // Evil digraph '<:' is parsed as '[', expect error. 38 A<::N::Z> *a10; 39 #if __cplusplus <= 199711L 40 // expected-error@-2 {{found '<::' after a template name which forms the digraph '<:' (aka '[') and a ':', did you mean '< ::'?}} 41 #endif 42 43 // Do not do a digraph correction here. 44 A<: :N::Z> *a11; // expected-error{{expected expression}} \ 45 expected-error{{C++ requires a type specifier for all declarations}} 46 47 // PR7807 48 namespace N { 49 template <typename, typename = int> 50 struct X 51 { }; 52 53 template <typename ,int> 54 struct Y 55 { X<int> const_ref(); }; 56 57 template <template<typename,int> class TT, typename T, int N> 58 int operator<<(int, TT<T, N> a) { // expected-note{{candidate template ignored}} 59 0 << a.const_ref(); // expected-error{{invalid operands to binary expression ('int' and 'X<int>')}} 60 } 61 62 void f0( Y<int,1> y){ 1 << y; } // expected-note{{in instantiation of function template specialization 'N::operator<<<Y, int, 1>' requested here}} 63 } 64 65 // PR12179 66 template <typename Primitive, template <Primitive...> class F> 67 #if __cplusplus <= 199711L 68 // expected-warning@-2 {{variadic templates are a C++11 extension}} 69 #endif 70 71 struct unbox_args { 72 typedef typename Primitive::template call<F> x; 73 }; 74 75 template <template <typename> class... Templates> 76 #if __cplusplus <= 199711L 77 // expected-warning@-2 {{variadic templates are a C++11 extension}} 78 #endif 79 80 struct template_tuple { 81 #if __cplusplus >= 201103L 82 static constexpr int N = sizeof...(Templates); 83 #endif 84 }; 85 template <typename T> 86 struct identity {}; 87 template <template <typename> class... Templates> 88 #if __cplusplus <= 199711L 89 // expected-warning@-2 {{variadic templates are a C++11 extension}} 90 #endif 91 92 template_tuple<Templates...> f7() {} 93 94 #if __cplusplus >= 201103L 95 struct S : public template_tuple<identity, identity> { 96 static_assert(N == 2, "Number of template arguments incorrect"); 97 }; 98 #endif 99 100 void foo() { 101 f7<identity>(); 102 } 103 104 namespace CheckDependentNonTypeParamTypes { 105 template<template<typename T, typename U, T v> class X> struct A { 106 void f() { 107 X<int, void*, 3> x; // expected-error {{does not refer to any declaration}} 108 } 109 void g() { 110 X<int, long, 3> x; 111 } 112 void h() { 113 // FIXME: If we accept A<B> at all, it's not obvious what should happen 114 // here. While parsing the template, we form 115 // X<unsigned char, int, (unsigned char)1234> 116 // but in the final instantiation do we get 117 // B<unsigned char, int, (int)1234> 118 // or 119 // B<unsigned char, int, (int)(unsigned char)1234> 120 // ? 121 X<unsigned char, int, 1234> x; 122 int check[x.value == 1234 ? 1 : -1]; 123 } 124 }; 125 126 template<typename T, typename U, U v> struct B { // expected-note {{parameter}} 127 static const U value = v; 128 }; 129 130 // FIXME: This should probably be rejected, but the rules are at best unclear. 131 A<B> ab; 132 133 void use() { 134 ab.f(); // expected-note {{instantiation of}} 135 ab.g(); 136 ab.h(); 137 } 138 } 139 140 namespace PR32185 { 141 template<template<typename T, T> class U> struct A {}; 142 template<template<typename T, T> class U> struct B : A<U> {}; 143 } 144 145 namespace PR10147 { 146 template<typename T> struct A {}; 147 template<typename T = int> struct A; 148 template<template<typename...> class A> void f(A<int>*) { A<> a; } // expected-warning 0-1{{extension}} 149 void g() { f((A<>*)0); } 150 } 151