clang/test/CXX/temp/temp.decls/temp.variadic/sizeofpack.cpp

   1 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
   2 // RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify %s
   3 // expected-no-diagnostics
   4
   5 namespace pr12262 {
   6
   7 template<typename T, typename... Ts>
   8 void abc1(int (*xxx)[sizeof ... (Ts) + 1]);
   9
  10 void qq1 () {
  11   abc1<int>(0);
  12   abc1<int,double>(0);
  13 }
  14
  15
  16 template <unsigned N> class array {};
  17
  18
  19 template<typename T, typename... Types>
  20 array<sizeof...(Types)> make_array1(Types&&... args);
  21
  22 void qq2 () {
  23   array<1> arr = make_array1<int>(1);
  24   array<3> arr2 = make_array1<int>(1,array<5>(),0.1);
  25 }
  26
  27
  28 template<typename T, typename... Types>
  29 int make_array(array<sizeof...(Types)>&, Types... args);
  30
  31 void qq3 () {
  32   array<1> a1;
  33   int aa1 = make_array<int>(a1,1);
  34   array<2> a2;
  35   int aa2 = make_array<int>(a2, 0L, "abc");
  36 }
  37
  38
  39 template<typename ... Ts>
  40 struct AAA {
  41   template<typename T, typename... Types>
  42   static array<sizeof...(Types)> make_array(Types ... args);
  43 };
  44
  45 void qq4 () {
  46   array<2> arr2 = AAA<int, int>::make_array<int>(1,2);
  47 }
  48
  49 }
  50
  51
  52 namespace pr12439 {
  53
  54 template<class... Members>
  55 struct X {
  56   template<int Idx>
  57   using get_t = decltype(sizeof...(Members));
  58
  59   template<int i>
  60   get_t<i> get();
  61 };
  62
  63 template<class... Members>
  64 template<int i>
  65 typename X<Members...>::template get_t<i> X<Members...>::get()
  66 {
  67   return 0;
  68 }
  69
  70 }
  71
  72
  73 namespace pr13272 {
  74
  75 template<bool B, class T = void>
  76 struct enable_if { };
  77
  78 template<class T> struct enable_if<true, T> {
  79   typedef T type;
  80 };
  81
  82 class Exception {};
  83
  84 template<class Ex, typename... Args>
  85 void cxx_throw(typename enable_if<(sizeof...(Args) > 0), const char *>::type fmt, Args&&... args) {
  86   return;
  87 }
  88
  89 void test() {
  90   cxx_throw<Exception>("Youpi",1);
  91 }
  92
  93 }
  94
  95
  96 namespace pr13817 {
  97
  98 template <unsigned>
  99 struct zod;
 100
 101 template <>
 102 struct zod<1> {};
 103
 104 template <typename T, typename ... Ts>
 105 zod<sizeof...(Ts)> make_zod(Ts ...) {
 106   return zod<sizeof...(Ts)>();
 107 }
 108
 109 int main(int argc, char *argv[])
 110 {
 111   make_zod<int>(1);
 112   return 0;
 113 }
 114
 115 }
 116
 117
 118 namespace pr14273 {
 119
 120 template<typename T, int i>
 121 struct myType
 122 { };
 123
 124 template<typename T, typename... Args>
 125 struct Counter
 126 {
 127   static const int count = 1 + Counter<Args...>::count;
 128 };
 129
 130 template<typename T>
 131 struct Counter<T>
 132 {
 133   static const int count = 1;
 134 };
 135
 136 template<typename Arg, typename... Args>
 137 myType<Arg, sizeof...(Args)>* make_array_with_type(const Args&... args)
 138 {
 139   return 0;
 140 }
 141
 142 void func(void)
 143 {
 144   make_array_with_type<char>(1,2,3);
 145 }
 146
 147 }
 148
 149
 150 namespace pr15112
 151 {
 152   template<bool, typename _Tp = void>
 153     struct enable_if
 154     { };
 155   template<typename _Tp>
 156     struct enable_if<true,_Tp>
 157     { typedef _Tp type; };
 158
 159   typedef __typeof__(sizeof(int)) size_t;
 160
 161   template <size_t n, typename T, typename... Args>
 162   struct is_array_of { static const bool value = true; };
 163
 164   struct cpu { using value_type = void; };
 165
 166   template <size_t Order, typename T>
 167   struct coords_alias { typedef T type; };
 168
 169   template <size_t Order, typename MemoryTag>
 170   using coords = typename coords_alias<Order, MemoryTag>::type;
 171
 172   template <typename MemTag, typename... Args>
 173   typename enable_if<is_array_of<sizeof...(Args), size_t, Args...>::value,
 174                      coords<sizeof...(Args), MemTag>>::type
 175     mkcoords(Args... args);
 176
 177   auto c1 = mkcoords<cpu>(0ul, 0ul, 0ul);
 178 }
 179
 180
 181 namespace pr12699 {
 182
 183 template<bool B>
 184 struct bool_constant
 185 {
 186   static const bool value = B;
 187 };
 188
 189 template<typename... A>
 190 struct F
 191 {
 192   template<typename... B>
 193     using SameSize = bool_constant<sizeof...(A) == sizeof...(B)>;
 194
 195   template<typename... B, typename = SameSize<B...>>
 196   F(B...) { }
 197 };
 198
 199 void func()
 200 {
 201   F<int> f1(3);
 202 }
 203
 204 }
 205
 206 #if __cplusplus >= 202002L
 207 namespace GH81436 {
 208
 209 template <class E> struct Bar;
 210
 211 template <class E>
 212 Bar(E) -> Bar<E>;
 213
 214 template <int> struct Foo {};
 215
 216 // Bar<Ts> doesn't have to be of a complete type.
 217 template <class... Ts>
 218 auto func() requires requires(Bar<Ts> ...init_lists) {
 219   sizeof...(init_lists) > 0;
 220 } {}
 221
 222 void f() { func<int>(); }
 223
 224 } // namespace GH81436
 225 #endif