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> struct A {}; // expected-note {{previous}}
106   template<typename T, typename U, U v> struct B {}; // expected-note {{different type}}
107   A<B> ab; // expected-error {{different template parameters}}
108 }
109