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