clang/test/Sema/block-return.c

   1 // RUN: %clang_cc1 -Wno-int-to-pointer-cast -Wno-pointer-to-int-cast -pedantic -fsyntax-only %s -verify -fblocks
   2
   3 extern int printf(const char *, ...);
   4
   5 typedef void (^CL)(void);
   6
   7 CL foo(void) {
   8   short y;
   9   short (^add1)(void) = ^{ return y+1; }; // expected-error {{incompatible block pointer types initializing 'short (^)(void)' with an expression of type 'int (^)(void)'}}
  10
  11   CL X = ^{
  12     if (2)
  13       return;
  14     return 1;  // expected-error {{return type 'int' must match previous return type 'void' when block literal has unspecified explicit return type}}
  15   };
  16
  17   int (^Y) (void)  = ^{
  18     if (3)
  19       return 1;
  20     else
  21       return; // expected-error {{return type 'void' must match previous return type 'int' when block literal has unspecified explicit return type}}
  22   };
  23
  24   char *(^Z)(void) = ^{
  25     if (3)
  26       return "";
  27     else
  28       return (char*)0;
  29   };
  30
  31   double (^A)(void) = ^ { // expected-error {{incompatible block pointer types initializing 'double (^)(void)' with an expression of type 'float (^)(void)'}}
  32     if (1)
  33       return (float)1.0;
  34     else
  35       if (2)
  36         return (double)2.0; // expected-error {{return type 'double' must match previous return type 'float' when block literal has unspecified explicit return type}}
  37     return 1; // expected-error {{return type 'int' must match previous return type 'float' when block literal has unspecified explicit return type}}
  38   };
  39   char *(^B)(void) = ^{
  40     if (3)
  41       return "";
  42     else
  43       return 2; // expected-error {{return type 'int' must match previous return type 'char *' when block literal has unspecified explicit return type}}
  44   };
  45
  46   return ^{ return 1; }; // expected-error {{incompatible block pointer types returning 'int (^)(void)' from a function with result type 'CL' (aka 'void (^)(void)')}}
  47 }
  48
  49 typedef int (^CL2)(void);
  50
  51 CL2 foo2(void) {
  52   return ^{ return 1; };
  53 }
  54
  55 typedef unsigned int * uintptr_t;
  56 typedef char Boolean;
  57 typedef int CFBasicHash;
  58
  59 #define INVOKE_CALLBACK2(P, A, B) (P)(A, B)
  60
  61 typedef struct {
  62     Boolean (^isEqual)(const CFBasicHash *, uintptr_t stack_value_or_key1, uintptr_t stack_value_or_key2, Boolean is_key);
  63 } CFBasicHashCallbacks;
  64
  65 int foo3(void) {
  66     CFBasicHashCallbacks cb;
  67
  68     Boolean (*value_equal)(uintptr_t, uintptr_t) = 0;
  69
  70     cb.isEqual = ^(const CFBasicHash *table, uintptr_t stack_value_or_key1, uintptr_t stack_value_or_key2, Boolean is_key) {
  71       return (Boolean)(uintptr_t)INVOKE_CALLBACK2(value_equal, (uintptr_t)stack_value_or_key1, (uintptr_t)stack_value_or_key2);
  72     };
  73 }
  74
  75 static int funk(char *s) {
  76   if (^{} == ((void*)0))
  77     return 1;
  78   else
  79     return 0;
  80 }
  81 void next(void);
  82 void foo4(void) {
  83   int (^xx)(const char *s) = ^(char *s) { return 1; }; // expected-error {{incompatible block pointer types initializing 'int (^)(const char *)' with an expression of type 'int (^)(char *)'}}
  84   int (*yy)(const char *s) = funk; // expected-error {{incompatible function pointer types initializing 'int (*)(const char *)' with an expression of type 'int (char *)'}}
  85
  86   int (^nested)(char *s) = ^(char *str) { void (^nest)(void) = ^(void) { printf("%s\n", str); }; next(); return 1; };
  87 }
  88
  89 typedef void (^bptr)(void);
  90
  91 bptr foo5(int j) {
  92   __block int i;
  93   if (j)
  94     return ^{ ^{ i=0; }(); };  // expected-error {{returning block that lives on the local stack}}
  95   return ^{ i=0; };  // expected-error {{returning block that lives on the local stack}}
  96   return (^{ i=0; });  // expected-error {{returning block that lives on the local stack}}
  97   return (void*)(^{ i=0; });  // expected-error {{returning block that lives on the local stack}}
  98 }
  99
 100 int (*funcptr3[5])(long);
 101 int sz8 = sizeof(^int (*[5])(long) {return funcptr3;}); // expected-error {{block cannot return array type}} expected-error {{incompatible pointer to integer conversion}}
 102 int sz9 = sizeof(^int(*())()[3]{ }); // expected-error {{function cannot return array type}}
 103                                      // expected-warning@-1 {{a function declaration without a prototype is deprecated in all versions of C}}
 104
 105 void foo6(void) {
 106   int (^b)(int) __attribute__((noreturn));
 107   b = ^ (int i) __attribute__((noreturn)) { return 1; };  // expected-error {{block declared 'noreturn' should not return}}
 108   b(1);
 109   int (^c)(void) __attribute__((noreturn)) = ^ __attribute__((noreturn)) { return 100; }; // expected-error {{block declared 'noreturn' should not return}}
 110 }
 111
 112
 113 void foo7(void)
 114 {
 115  const int (^BB) (void) = ^{ const int i = 1; return i; }; // OK - initializing 'const int (^)(void)' with an expression of type 'int (^)(void)'
 116
 117  const int (^CC) (void)  = ^const int{ const int i = 1; return i; };
 118
 119
 120   int i;
 121   int (^FF) (void)  = ^{ return i; }; // OK
 122   int (^EE) (void)  = ^{ return i+1; }; // OK
 123
 124   __block int j;
 125   int (^JJ) (void)  = ^{ return j; }; // OK
 126   int (^KK) (void)  = ^{ return j+1; }; // OK
 127
 128   __block const int k;
 129   const int cint = 100;
 130
 131   int (^MM) (void)  = ^{ return k; };
 132   int (^NN) (void)  = ^{ return cint; };
 133 }
 134
 135 // rdar://11069896
 136 void (^blk)(void) = ^{
 137     return (void)0; // expected-warning {{void block literal should not return void expression}}
 138 };
 139
 140 // rdar://13463504
 141 enum Test8 { T8_a, T8_b, T8_c };
 142 void test8(void) {
 143   extern void test8_helper(int (^)(int));
 144   test8_helper(^(int flag) { if (flag) return T8_a; return T8_b; });
 145 }
 146 void test8b(void) {
 147   extern void test8_helper2(char (^)(int)); // expected-note {{here}}
 148   test8_helper2(^(int flag) { if (flag) return T8_a; return T8_b; }); // expected-error {{passing 'enum Test8 (^)(int)' to parameter of type 'char (^)(int)'}}
 149 }