clang/test/Sema/block-misc.c

   1 // RUN: %clang_cc1 -fsyntax-only -Wno-strict-prototypes -verify %s -fblocks
   2 void donotwarn(void);
   3
   4 int (^IFP) ();
   5 int (^II) (int);
   6 int test1(void) {
   7   int (^PFR) (int) = 0; // OK
   8   PFR = II;             // OK
   9
  10   if (PFR == II)        // OK
  11     donotwarn();
  12
  13   if (PFR == IFP)       // OK
  14     donotwarn();
  15
  16   if (PFR == (int (^) (int))IFP) // OK
  17     donotwarn();
  18
  19   if (PFR == 0)         // OK
  20     donotwarn();
  21
  22   if (PFR)              // OK
  23     donotwarn();
  24
  25   if (!PFR)             // OK
  26     donotwarn();
  27
  28   return PFR != IFP;    // OK
  29 }
  30
  31 int test2(double (^S)()) {
  32   double (^I)(int)  = (void*) S;
  33   (void*)I = (void *)S; // expected-error {{assignment to cast is illegal, lvalue casts are not supported}}
  34
  35   void *pv = I;
  36
  37   pv = S;
  38
  39   I(1);
  40
  41   return (void*)I == (void *)S;
  42 }
  43
  44 int^ x; // expected-error {{block pointer to non-function type is invalid}}
  45 int^^ x1; // expected-error {{block pointer to non-function type is invalid}} expected-error {{block pointer to non-function type is invalid}}
  46
  47 void test3(void) {
  48   char *^ y; // expected-error {{block pointer to non-function type is invalid}}
  49 }
  50
  51
  52
  53 enum {NSBIRLazilyAllocated = 0};
  54
  55 int test4(int argc) {  // rdar://6251437
  56   ^{
  57     switch (argc) {
  58       case NSBIRLazilyAllocated:  // is an integer constant expression.
  59       default:
  60         break;
  61     }
  62   }();
  63   return 0;
  64 }
  65
  66
  67 void bar(void*);
  68 // rdar://6257721 - reference to static/global is byref by default.
  69 static int test5g;
  70 void test5() {
  71   bar(^{ test5g = 1; });
  72 }
  73
  74 // rdar://6405429 - __func__ in a block refers to the containing function name.
  75 const char*test6(void) {
  76   return ^{
  77     return __func__;
  78   } ();
  79 }
  80
  81 // radr://6732116 - block comparisons
  82 void (^test7a)();
  83 int test7(void (^p)()) {
  84   return test7a == p;
  85 }
  86
  87
  88 void test8(void) {
  89 somelabel:
  90   ^{ goto somelabel; }();   // expected-error {{use of undeclared label 'somelabel'}}
  91 }
  92
  93 void test9(void) {
  94   goto somelabel;       // expected-error {{use of undeclared label 'somelabel'}}
  95   ^{ somelabel: ; }();
  96 }
  97
  98 void test10(int i) {
  99   switch (i) {
 100   case 41: ;
 101   ^{ case 42: ; }();     // expected-error {{'case' statement not in switch statement}}
 102   }
 103 }
 104
 105 void test11(int i) {
 106   switch (i) {
 107   case 41: ;
 108     ^{ break; }();     // expected-error {{'break' statement not in loop or switch statement}}
 109   }
 110
 111   for (; i < 100; ++i)
 112     ^{ break; }();     // expected-error {{'break' statement not in loop or switch statement}}
 113 }
 114
 115 void (^test12f)(void);
 116 void test12() {
 117   test12f = ^test12f;  // expected-error {{type name requires a specifier or qualifier}} expected-error {{expected expression}}
 118 }
 119
 120 // rdar://6808730
 121 void *test13 = ^{
 122   int X = 32;
 123
 124   void *P = ^{
 125     return X+4;  // References outer block's "X", so outer block is constant.
 126   };
 127 };
 128
 129 void test14(void) {
 130   int X = 32;
 131   static void *P = ^{  // expected-error {{initializer element is not a compile-time constant}}
 132
 133     void *Q = ^{
 134       // References test14's "X": outer block is non-constant.
 135       return X+4;
 136     };
 137   };
 138 }
 139
 140 enum { LESS };
 141
 142 void foo(long (^comp)()) { // expected-note{{passing argument to parameter 'comp' here}}
 143 }
 144
 145 void (^test15f)(void);
 146 void test15(void) {
 147   foo(^{ return LESS; }); // expected-error {{incompatible block pointer types passing 'int (^)(void)' to parameter of type 'long (^)()'}}
 148 }
 149
 150 __block int test16i;  // expected-error {{__block attribute not allowed, only allowed on local variables}}
 151
 152 void test16(__block int i) { // expected-error {{__block attribute not allowed, only allowed on local variables}}
 153   int size = 5;
 154   extern __block double extern_var; // expected-error {{__block attribute not allowed, only allowed on local variables}}
 155   static __block char * pch; // expected-error {{__block attribute not allowed, only allowed on local variables}}
 156   __block int a[size]; // expected-error {{__block attribute not allowed on declaration with a variably modified type}}
 157   __block int (*ap)[size]; // expected-error {{__block attribute not allowed on declaration with a variably modified type}}
 158 }
 159
 160 void f();
 161
 162 void test17(void) {
 163   void (^bp)(int);
 164   void (*rp)(int);
 165   void (^bp1)();
 166   void *vp = bp;
 167
 168   f(1 ? bp : vp);
 169   f(1 ? vp : bp);
 170   f(1 ? bp : bp1);
 171   (void)(bp > rp); // expected-error {{invalid operands}}
 172   (void)(bp > 0); // expected-error {{invalid operands}}
 173   (void)(bp > bp); // expected-error {{invalid operands}}
 174   (void)(bp > vp); // expected-error {{invalid operands}}
 175   f(1 ? bp : rp); // expected-error {{incompatible operand types ('void (^)(int)' and 'void (*)(int)')}}
 176   (void)(bp == 1); // expected-error {{invalid operands to binary expression}}
 177   (void)(bp == 0);
 178   (void)(1 == bp); // expected-error {{invalid operands to binary expression}}
 179   (void)(0 == bp);
 180   (void)(bp < 1); // expected-error {{invalid operands to binary expression}}
 181   (void)(bp < 0); // expected-error {{invalid operands to binary expression}}
 182   (void)(1 < bp); // expected-error {{invalid operands to binary expression}}
 183   (void)(0 < bp); // expected-error {{invalid operands to binary expression}}
 184 }
 185
 186 void test18(void) {
 187   void (^const  blockA)(void) = ^{ };  // expected-note {{variable 'blockA' declared const here}}
 188   blockA = ^{ }; // expected-error {{cannot assign to variable 'blockA' with const-qualified type 'void (^const)(void)}}
 189 }
 190
 191 // rdar://7072507
 192 int test19(void) {
 193   goto L0;       // expected-error {{cannot jump}}
 194
 195   __block int x; // expected-note {{jump bypasses setup of __block variable}}
 196 L0:
 197   x = 0;
 198   ^(){ ++x; }();
 199   return x;
 200 }
 201
 202 // radr://7438948
 203 void test20(void) {
 204   int n = 7;
 205   int vla[n]; // expected-note {{declared here}}
 206   int (*vm)[n] = 0; // expected-note {{declared here}}
 207   vla[1] = 4341;
 208   ^{
 209     (void)vla[1];  // expected-error {{cannot refer to declaration with a variably modified type inside block}}
 210     (void)(vm+1);  // expected-error {{cannot refer to declaration with a variably modified type inside block}}
 211   }();
 212 }
 213
 214 // radr://7438948
 215 void test21(void) {
 216   int a[7]; // expected-note {{declared here}}
 217   __block int b[10]; // expected-note {{declared here}}
 218   a[1] = 1;
 219   ^{
 220     (void)a[1]; // expected-error {{cannot refer to declaration with an array type inside block}}
 221     (void)b[1]; // expected-error {{cannot refer to declaration with an array type inside block}}
 222   }();
 223 }
 224
 225 // rdar ://8218839
 226 const char * (^func)(void) = ^{ return __func__; };
 227 const char * (^function)(void) = ^{ return __FUNCTION__; };
 228 const char * (^pretty)(void) = ^{ return __PRETTY_FUNCTION__; };