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
