clang/test/SemaObjCXX/arc-templates.mm

   1 // RUN: %clang_cc1 -fobjc-runtime-has-weak -fsyntax-only -fobjc-arc -verify -fblocks -std=c++11 %s
   2
   3 #define CONSUMED __attribute__((ns_consumed))
   4 #define PRODUCED __attribute__((ns_returns_retained))
   5
   6 @interface A
   7 @end
   8
   9 @class NSString;
  10
  11 template<typename T, typename U>
  12 struct is_same {
  13   static const bool value = false;
  14 };
  15
  16 template<typename T>
  17 struct is_same<T, T> {
  18   static const bool value = true;
  19 };
  20
  21 // Instantiation for reference/pointer types that will get lifetime
  22 // adjustments.
  23 template<typename T>
  24 struct X0 {
  25   typedef T* pointer; // okay: ends up being strong.
  26   typedef T& reference; // okay: ends up being strong
  27 };
  28
  29 void test_X0() {
  30   X0<id> x0id;
  31   X0<A*> x0a;
  32   X0<__strong A*> x0sa;
  33
  34   id __strong *ptr;
  35   id __strong val;
  36   X0<__strong id>::pointer &ptr_ref = ptr;
  37   X0<__strong id>::reference ref = val;
  38 }
  39
  40 int check_infer_strong[is_same<id, __strong id>::value? 1 : -1];
  41
  42 // Check template argument deduction (e.g., for specialization) using
  43 // lifetime qualifiers.
  44 template<typename T>
  45 struct is_pointer_strong {
  46   static const bool value = false;
  47 };
  48
  49 template<typename T>
  50 struct is_pointer_strong<__strong T*> {
  51   static const bool value = true;
  52 };
  53
  54 int check_ptr_strong1[is_pointer_strong<__strong id*>::value? 1 : -1];
  55 int check_ptr_strong2[is_pointer_strong<__weak id*>::value? -1 : 1];
  56 int check_ptr_strong3[is_pointer_strong<__autoreleasing id*>::value? -1 : 1];
  57 int check_ptr_strong4[is_pointer_strong<__unsafe_unretained id*>::value? -1 : 1];
  58 int check_ptr_strong5[is_pointer_strong<id>::value? -1 : 1];
  59
  60 // Check substitution into lifetime-qualified dependent types.
  61 template<typename T>
  62 struct make_strong_pointer {
  63   typedef __strong T *type;
  64 };
  65
  66 template<typename T>
  67 struct make_strong_pointer<__weak T> {
  68   typedef __strong T *type;
  69 };
  70
  71 template<typename T>
  72 struct make_strong_pointer<__autoreleasing T> {
  73   typedef __strong T *type;
  74 };
  75
  76 template<typename T>
  77 struct make_strong_pointer<__unsafe_unretained T> {
  78   typedef __strong T *type;
  79 };
  80
  81 // Adding qualifiers
  82 int check_make_strong1[is_same<make_strong_pointer<id>::type, __strong id *>::value ? 1 : -1];
  83 int check_make_strong2[is_same<make_strong_pointer<A*>::type, A* __strong *>::value ? 1 : -1];
  84
  85 // Adding redundant qualifiers
  86 int check_make_strong3[is_same<make_strong_pointer<__strong id>::type, __strong id *>::value ? 1 : -1];
  87 int check_make_strong4[is_same<make_strong_pointer<__strong A*>::type, A* __strong *>::value ? 1 : -1];
  88
  89 // Adding nonsensical qualifiers.
  90 int check_make_strong5[is_same<make_strong_pointer<int>::type, int *>::value ? 1 : -1];
  91 int check_make_strong6[is_same<make_strong_pointer<__weak id>::type, __strong id *>::value ? 1 : -1];
  92
  93 template<typename T>
  94 struct make_weak {
  95   typedef __weak T type;
  96 };
  97
  98 int check_make_weak0[is_same<make_weak<id>::type, __weak id>::value? 1 : -1];
  99 int check_make_weak1[is_same<make_weak<__strong id>::type, __weak id>::value? 1 : -1];
 100 int check_make_weak2[is_same<make_weak<__autoreleasing id>::type, __weak id>::value? 1 : -1];
 101
 102 template<typename T>
 103 struct make_weak_fail {
 104   typedef T T_type;
 105   typedef __weak T_type type; // expected-error{{the type 'T_type' (aka '__weak id') is already explicitly ownership-qualified}} \
 106   // expected-error{{the type 'T_type' (aka '__strong id') is already explicitly ownership-qualified}}
 107 };
 108
 109 int check_make_weak_fail0[is_same<make_weak_fail<__weak id>::type, __weak id>::value? 1 : -1]; // expected-note{{in instantiation of template class 'make_weak_fail<__weak id>' requested here}}
 110
 111 int check_make_weak_fail1[is_same<make_weak_fail<id>::type, __weak id>::value? -1 : 1]; // expected-note{{in instantiation of template class 'make_weak_fail<id>' requested here}}
 112
 113 // Check template argument deduction from function templates.
 114 template<typename T> struct identity { };
 115
 116 template<typename T> identity<T> accept_strong_ptr(__strong T*);
 117 template<typename T> identity<T> accept_strong_ref(__strong T&);
 118
 119 template<typename T> identity<T> accept_any_ptr(T*);
 120 template<typename T> identity<T> accept_any_ref(T&);
 121
 122 void test_func_deduction_id() {
 123   __strong id *sip;
 124   __weak id *wip;
 125   __autoreleasing id *aip;
 126   __unsafe_unretained id *uip;
 127
 128   identity<id> res1 = accept_strong_ptr(sip);
 129   identity<__strong id> res2 = accept_any_ptr(sip);
 130
 131   __strong id si;
 132   __weak id wi;
 133   __autoreleasing id ai;
 134   __unsafe_unretained id ui;
 135   identity<id> res3 = accept_strong_ref(si);
 136   identity<__strong id> res4 = accept_any_ref(si);
 137   identity<__weak id> res5 = accept_any_ref(wi);
 138   identity<__autoreleasing id> res6 = accept_any_ref(ai);
 139   identity<__unsafe_unretained id> res7 = accept_any_ref(ui);
 140 }
 141
 142 void test_func_deduction_A() {
 143   __strong A * *sip;
 144   __weak A * *wip;
 145   __autoreleasing A * *aip;
 146   __unsafe_unretained A * *uip;
 147
 148   identity<A *> res1 = accept_strong_ptr(sip);
 149   identity<__strong A *> res2 = accept_any_ptr(sip);
 150
 151   __strong A * si;
 152   __weak A * wi;
 153   __autoreleasing A * ai;
 154   __unsafe_unretained A * ui;
 155   identity<A *> res3 = accept_strong_ref(si);
 156   identity<__strong A *> res4 = accept_any_ref(si);
 157   identity<__weak A *> res5 = accept_any_ref(wi);
 158   identity<__autoreleasing A *> res6 = accept_any_ref(ai);
 159   identity<__unsafe_unretained A *> res7 = accept_any_ref(ui);
 160 }
 161
 162 // Test partial ordering (qualified vs. non-qualified).
 163 template<typename T>
 164 struct classify_pointer_pointer {
 165   static const unsigned value = 0;
 166 };
 167
 168 template<typename T>
 169 struct classify_pointer_pointer<T*> {
 170   static const unsigned value = 1;
 171 };
 172
 173 template<typename T>
 174 struct classify_pointer_pointer<__strong T*> {
 175   static const unsigned value = 2;
 176 };
 177
 178 template<typename T>
 179 struct classify_pointer_pointer<__weak T*> {
 180   static const unsigned value = 3;
 181 };
 182
 183 template<typename T>
 184 struct classify_pointer_pointer<T&> {
 185   static const unsigned value = 4;
 186 };
 187
 188 template<typename T>
 189 struct classify_pointer_pointer<__strong T&> {
 190   static const unsigned value = 5;
 191 };
 192
 193 template<typename T>
 194 struct classify_pointer_pointer<__weak T&> {
 195   static const unsigned value = 6;
 196 };
 197
 198 int classify_ptr1[classify_pointer_pointer<int>::value == 0? 1 : -1];
 199 int classify_ptr2[classify_pointer_pointer<int *>::value == 1? 1 : -1];
 200 int classify_ptr3[classify_pointer_pointer<id __strong *>::value == 2? 1 : -1];
 201 int classify_ptr4[classify_pointer_pointer<id __weak *>::value == 3? 1 : -1];
 202 int classify_ptr5[classify_pointer_pointer<int&>::value == 4? 1 : -1];
 203 int classify_ptr6[classify_pointer_pointer<id __strong&>::value == 5? 1 : -1];
 204 int classify_ptr7[classify_pointer_pointer<id __weak&>::value == 6? 1 : -1];
 205 int classify_ptr8[classify_pointer_pointer<id __autoreleasing&>::value == 4? 1 : -1];
 206 int classify_ptr9[classify_pointer_pointer<id __unsafe_unretained&>::value == 4? 1 : -1];
 207 int classify_ptr10[classify_pointer_pointer<id __autoreleasing *>::value == 1? 1 : -1];
 208 int classify_ptr11[classify_pointer_pointer<id __unsafe_unretained *>::value == 1? 1 : -1];
 209 int classify_ptr12[classify_pointer_pointer<int *>::value == 1? 1 : -1];
 210 int classify_ptr13[classify_pointer_pointer<A * __strong *>::value == 2? 1 : -1];
 211 int classify_ptr14[classify_pointer_pointer<A * __weak *>::value == 3? 1 : -1];
 212 int classify_ptr15[classify_pointer_pointer<int&>::value == 4? 1 : -1];
 213 int classify_ptr16[classify_pointer_pointer<A * __strong&>::value == 5? 1 : -1];
 214 int classify_ptr17[classify_pointer_pointer<A * __weak&>::value == 6? 1 : -1];
 215 int classify_ptr18[classify_pointer_pointer<A * __autoreleasing&>::value == 4? 1 : -1];
 216 int classify_ptr19[classify_pointer_pointer<A * __unsafe_unretained&>::value == 4? 1 : -1];
 217 int classify_ptr20[classify_pointer_pointer<A * __autoreleasing *>::value == 1? 1 : -1];
 218 int classify_ptr21[classify_pointer_pointer<A * __unsafe_unretained *>::value == 1? 1 : -1];
 219
 220 template<typename T> int& qual_vs_unqual_ptr(__strong T*);
 221 template<typename T> double& qual_vs_unqual_ptr(__weak T*);
 222 template<typename T> float& qual_vs_unqual_ptr(T*);
 223 template<typename T> int& qual_vs_unqual_ref(__strong T&);
 224 template<typename T> double& qual_vs_unqual_ref(__weak T&);
 225 template<typename T> float& qual_vs_unqual_ref(T&);
 226
 227 void test_qual_vs_unqual_id() {
 228   __strong id *sip;
 229   __weak id *wip;
 230   __autoreleasing id *aip;
 231   __unsafe_unretained id *uip;
 232
 233   int &ir1 = qual_vs_unqual_ptr(sip);
 234   double &dr1 = qual_vs_unqual_ptr(wip);
 235   float &fr1 = qual_vs_unqual_ptr(aip);
 236   float &fr2 = qual_vs_unqual_ptr(uip);
 237
 238   int &ir2 = qual_vs_unqual_ref(*sip);
 239   double &dr2 = qual_vs_unqual_ref(*wip);
 240   float &fr3 = qual_vs_unqual_ref(*aip);
 241   float &fr4 = qual_vs_unqual_ref(*uip);
 242 }
 243
 244 void test_qual_vs_unqual_a() {
 245   __strong A * *sap;
 246   __weak A * *wap;
 247   __autoreleasing A * *aap;
 248   __unsafe_unretained A * *uap;
 249
 250   int &ir1 = qual_vs_unqual_ptr(sap);
 251   double &dr1 = qual_vs_unqual_ptr(wap);
 252   float &fr1 = qual_vs_unqual_ptr(aap);
 253   float &fr2 = qual_vs_unqual_ptr(uap);
 254
 255   int &ir2 = qual_vs_unqual_ref(*sap);
 256   double &dr2 = qual_vs_unqual_ref(*wap);
 257   float &fr3 = qual_vs_unqual_ref(*aap);
 258   float &fr4 = qual_vs_unqual_ref(*uap);
 259 }
 260
 261 namespace rdar9828157 {
 262   // Template argument deduction involving lifetime qualifiers and
 263   // non-lifetime types.
 264   class A { };
 265
 266   template<typename T> float& f(T&);
 267   template<typename T> int& f(__strong T&);
 268   template<typename T> double& f(__weak T&);
 269
 270   void test_f(A* ap) {
 271     float &fr = (f)(ap);
 272   }
 273 }
 274
 275 namespace rdar10862386 {
 276   // More deduction with lifetime qualifiers.
 277   template <typename T>
 278   int testing(const T &) {
 279       return 1;
 280   }
 281
 282   void test() {
 283      testing(1);
 284       testing("hi");
 285       testing<NSString *>(@"hi");
 286       testing(@"hi");
 287  }
 288 }
 289
 290 namespace rdar12367446 {
 291   template <class T> class A;
 292   template <class R> class A<R()> {};
 293
 294   void test() {
 295     A<id()> value;
 296   }
 297 }
 298
 299 namespace rdar14467941 {
 300   template<typename T> int &takePtr(const T &);
 301   template<typename T> float &takePtr(T * const &);
 302
 303   void testTakePtr(A *a) {
 304     float &fr1 = takePtr(a);
 305     float &fr2 = takePtr<A>(a);
 306   }
 307 }
 308
 309 namespace rdar15713945 {
 310   template <class T> int &f(__strong T &);
 311   template <class T> float &f(__weak T &);
 312   template <class T> double &f(__unsafe_unretained T &);
 313   template <class T> char &f(T &);
 314
 315   void foo() {
 316     __strong NSString * const strong = 0;
 317     int &ir = (f)(strong);
 318     __weak NSString * const weak = 0;
 319     float &fr = (f)(weak);
 320     __unsafe_unretained NSString * const unsafe = 0;
 321     double &dr = (f)(unsafe);
 322   }
 323 }
 324
 325 namespace consumed {
 326   void take_yes_no(void (&)(id CONSUMED, id)); // expected-note 2 {{candidate function not viable}}
 327   void take_no_yes(void (&)(id, CONSUMED id)); // expected-note 2 {{candidate function not viable}}
 328   void take_yes_yes(void (&)(CONSUMED id, CONSUMED id)); // expected-note 2 {{candidate function not viable}}
 329
 330   template <class... As> void consumes_first(id CONSUMED, As...);
 331   void test1() {
 332     take_yes_no(consumes_first<id>);
 333     take_no_yes(consumes_first<id>); // expected-error {{no matching function}}
 334     take_yes_yes(consumes_first<id>); // expected-error {{no matching function}}
 335   }
 336
 337   template <class... As> void consumes_rest(id, CONSUMED As...);
 338   void test2() {
 339     take_yes_no(consumes_rest<id>); // expected-error {{no matching function}}
 340     take_no_yes(consumes_rest<id>);
 341     take_yes_yes(consumes_rest<id>); // expected-error {{no matching function}}
 342   }
 343
 344   template <class T, class U> void consumes_two(CONSUMED T, CONSUMED U);
 345   void test3() {
 346     take_yes_no(consumes_two); // expected-error {{no matching function}}
 347     take_no_yes(consumes_two); // expected-error {{no matching function}}
 348     take_yes_yes(consumes_two);
 349   }
 350 }
 351
 352 namespace consumed_nested {
 353   void take_yes_no(void (&)(id CONSUMED, id)); // expected-note 4 {{candidate function not viable}}
 354   void take_no_yes(void (&)(id, CONSUMED id)); // expected-note 4 {{candidate function not viable}}
 355   void take_yes_yes(void (&)(CONSUMED id, CONSUMED id)); // expected-note 4 {{candidate function not viable}}
 356
 357   template <unsigned N> struct consumes_first {
 358     template <class... As> static void fn(id CONSUMED, As...);
 359   };
 360   void test1() {
 361     take_yes_no(consumes_first<1>::fn<id>);
 362     take_no_yes(consumes_first<2>::fn<id>); // expected-error {{no matching function}}
 363     take_yes_yes(consumes_first<3>::fn<id>); // expected-error {{no matching function}}
 364     take_yes_no(consumes_first<4>::fn);
 365     take_no_yes(consumes_first<5>::fn); // expected-error {{no matching function}}
 366     take_yes_yes(consumes_first<6>::fn); // expected-error {{no matching function}}
 367   }
 368
 369   template <unsigned N> struct consumes_rest {
 370     template <class... As> static void fn(id, CONSUMED As...);
 371   };
 372   void test2() {
 373     take_yes_no(consumes_rest<1>::fn<id>); // expected-error {{no matching function}}
 374     take_no_yes(consumes_rest<2>::fn<id>);
 375     take_yes_yes(consumes_rest<3>::fn<id>); // expected-error {{no matching function}}
 376     take_yes_no(consumes_rest<4>::fn<id>); // expected-error {{no matching function}}
 377     take_no_yes(consumes_rest<5>::fn<id>);
 378     take_yes_yes(consumes_rest<6>::fn<id>); // expected-error {{no matching function}}
 379   }
 380
 381   template <unsigned N> struct consumes_two {
 382     template <class T, class U> static void fn(CONSUMED T, CONSUMED U);
 383   };
 384   void test3() {
 385     take_yes_no(consumes_two<1>::fn<id, id>); // expected-error {{no matching function}}
 386     take_no_yes(consumes_two<2>::fn<id, id>); // expected-error {{no matching function}}
 387     take_yes_yes(consumes_two<3>::fn<id, id>);
 388     take_yes_no(consumes_two<1>::fn); // expected-error {{no matching function}}
 389     take_no_yes(consumes_two<2>::fn); // expected-error {{no matching function}}
 390     take_yes_yes(consumes_two<3>::fn);
 391   }
 392 }
 393
 394 namespace produced {
 395   void take_yes(PRODUCED id (&)()); // expected-note 2 {{candidate function not viable}}
 396   void take_no(id (&)()); // expected-note 2 {{candidate function not viable}}
 397
 398   template <class T> T non_produces1();
 399   template <class T> T non_produces2();
 400   template <class T> T non_produces3();
 401   template <class T> T non_produces4();
 402   void test1() {
 403     take_yes(non_produces1<id>); // expected-error {{no matching function}}
 404     take_yes(non_produces2); // expected-error {{no matching function}}
 405     take_no(non_produces3<id>);
 406     take_no(non_produces4);
 407   }
 408
 409   template <class T> PRODUCED T produces1();
 410   template <class T> PRODUCED T produces2();
 411   template <class T> PRODUCED T produces3();
 412   template <class T> PRODUCED T produces4();
 413   void test2() {
 414     take_yes(produces1<id>);
 415     take_yes(produces2);
 416     take_no(produces3<id>); // expected-error {{no matching function}}
 417     take_no(produces4); // expected-error {{no matching function}}
 418   }
 419 }
 420
 421 namespace produced_nested {
 422   void take_yes(PRODUCED id (&)()); // expected-note 2 {{candidate function not viable}}
 423   void take_no(id (&)()); // expected-note 2 {{candidate function not viable}}
 424
 425   template <unsigned N> struct non_produces {
 426     template <class T> static T fn();
 427   };
 428   void test1() {
 429     take_yes(non_produces<1>::fn<id>); // expected-error {{no matching function}}
 430     take_yes(non_produces<2>::fn); // expected-error {{no matching function}}
 431     take_no(non_produces<3>::fn<id>);
 432     take_no(non_produces<4>::fn);
 433   }
 434
 435   template <unsigned N> struct produces {
 436     template <class T> static PRODUCED T fn();
 437   };
 438   void test2() {
 439     take_yes(produces<1>::fn<id>);
 440     take_yes(produces<2>::fn);
 441     take_no(produces<3>::fn<id>); // expected-error {{no matching function}}
 442     take_no(produces<4>::fn); // expected-error {{no matching function}}
 443   }
 444 }
 445
 446 namespace instantiate_consumed {
 447   template <class T> void take(CONSUMED T t) {} // expected-note {{candidate template ignored: substitution failure [with T = int]: ns_consumed attribute only applies to Objective-C object parameters}}
 448   void test() {
 449     take((id) 0);
 450     take((int) 0); // expected-error {{no matching function for call to 'take'}}
 451   }
 452 }