clang/test/SemaTemplate/temp_arg_template.cpp

   1 // RUN: %clang_cc1 -fsyntax-only -verify=expected,precxx17 %std_cxx98-14 %s
   2 // RUN: %clang_cc1 -fsyntax-only -verify=expected,cxx17 -std=c++17 %s
   3
   4 template<template<typename T> class X> struct A; // expected-note 2{{previous template template parameter is here}}
   5
   6 template<template<typename T, int I> class X> struct B; // expected-note{{previous template template parameter is here}}
   7
   8 template<template<int I> class X> struct C;  // expected-note 2{{previous non-type template parameter with type 'int' is here}}
   9
  10 template<class> struct X; // expected-note{{too few template parameters in template template argument}}
  11 template<int N> struct Y; // expected-note{{template parameter has a different kind in template argument}}
  12 template<long N> struct Ylong; // expected-note{{template non-type parameter has a different type 'long' in template argument}}
  13 template<const int &N> struct Yref; // expected-note{{template non-type parameter has a different type 'const int &' in template argument}}
  14
  15 namespace N {
  16   template<class> struct Z;
  17 }
  18 template<class, class> struct TooMany; // expected-note{{too many template parameters in template template argument}}
  19
  20
  21 A<X> *a1;
  22 A<N::Z> *a2;
  23 A< ::N::Z> *a3;
  24
  25 A<Y> *a4; // expected-error{{template template argument has different template parameters than its corresponding template template parameter}}
  26 A<TooMany> *a5; // expected-error{{template template argument has different template parameters than its corresponding template template parameter}}
  27 B<X> *a6; // expected-error{{template template argument has different template parameters than its corresponding template template parameter}}
  28 C<Y> *a7;
  29 C<Ylong> *a8; // expected-error{{template template argument has different template parameters than its corresponding template template parameter}}
  30 C<Yref> *a9; // expected-error{{template template argument has different template parameters than its corresponding template template parameter}}
  31
  32 template<typename T> void f(int);
  33
  34 A<f> *a9; // expected-error{{must be a class template}}
  35
  36 // Evil digraph '<:' is parsed as '[', expect error.
  37 A<::N::Z> *a10;
  38 #if __cplusplus <= 199711L
  39 // expected-error@-2 {{found '<::' after a template name which forms the digraph '<:' (aka '[') and a ':', did you mean '< ::'?}}
  40 #endif
  41
  42 // Do not do a digraph correction here.
  43 A<: :N::Z> *a11;  // expected-error{{expected expression}} \
  44                      precxx17-error{{a type specifier is required for all declarations}} \
  45                      cxx17-error{{expected unqualified-id}}
  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<<<N::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; // precxx17-error {{does not refer to any declaration}} \
 108                              cxx17-error {{value of type 'int' is not implicitly convertible to 'void *'}}
 109     }
 110     void g() {
 111       X<int, long, 3> x;
 112     }
 113     void h() {
 114       // FIXME: If we accept A<B> at all, it's not obvious what should happen
 115       // here. While parsing the template, we form
 116       //   X<unsigned char, int, (unsigned char)1234>
 117       // but in the final instantiation do we get
 118       //   B<unsigned char, int, (int)1234>
 119       // or
 120       //   B<unsigned char, int, (int)(unsigned char)1234>
 121       // ?
 122       X<unsigned char, int, 1234> x;
 123       int check[x.value == 1234 ? 1 : -1];
 124     }
 125   };
 126
 127   template<typename T, typename U, U v> struct B { // precxx17-note {{parameter}}
 128     static const U value = v;
 129   };
 130
 131   // FIXME: This should probably be rejected, but the rules are at best unclear.
 132   A<B> ab;
 133
 134   void use() {
 135     ab.f(); // expected-note {{instantiation of}}
 136     ab.g();
 137     ab.h();
 138   }
 139 }
 140
 141 namespace PR32185 {
 142   template<template<typename T, T> class U> struct A {};
 143   template<template<typename T, T> class U> struct B : A<U> {};
 144 }
 145
 146 namespace PR10147 {
 147   template<typename T> struct A {};
 148   template<typename T = int> struct A;
 149   template<template<typename...> class A> void f(A<int>*) { A<> a; } // expected-warning 0-1{{extension}}
 150   void g() { f((A<>*)0); }
 151 }