1 // RUN: %clang_cc1 -fsyntax-only -fblocks -Wnullable-to-nonnull-conversion -Wno-nullability-declspec %s -verify 2 3 #if __has_feature(nullability) 4 #else 5 # error nullability feature should be defined 6 #endif 7 8 typedef int * int_ptr; 9 10 // Parse nullability type specifiers. 11 // This note requires C11. 12 #if __STDC_VERSION__ > 199901L 13 // expected-note@+2{{'_Nonnull' specified here}} 14 #endif 15 typedef int * _Nonnull nonnull_int_ptr; 16 typedef int * _Nullable nullable_int_ptr; 17 typedef int * _Null_unspecified null_unspecified_int_ptr; 18 19 // Redundant nullability type specifiers. 20 typedef int * _Nonnull _Nonnull redundant_1; // expected-warning{{duplicate nullability specifier '_Nonnull'}} 21 22 // Conflicting nullability type specifiers. 23 typedef int * _Nonnull _Nullable conflicting_1; // expected-error{{nullability specifier '_Nullable' conflicts with existing specifier '_Nonnull'}} 24 typedef int * _Null_unspecified _Nonnull conflicting_2; // expected-error{{nullability specifier '_Nonnull' conflicts with existing specifier '_Null_unspecified'}} 25 26 // Redundant nullability specifiers via a typedef are okay. 27 typedef nonnull_int_ptr _Nonnull redundant_okay_1; 28 29 // Conflicting nullability specifiers via a typedef are not. 30 // Some of these errors require C11. 31 #if __STDC_VERSION__ > 199901L 32 typedef nonnull_int_ptr _Nullable conflicting_2; // expected-error{{nullability specifier '_Nullable' conflicts with existing specifier '_Nonnull'}} 33 #endif 34 typedef nonnull_int_ptr nonnull_int_ptr_typedef; 35 #if __STDC_VERSION__ > 199901L 36 typedef nonnull_int_ptr_typedef _Nullable conflicting_2; // expected-error{{nullability specifier '_Nullable' conflicts with existing specifier '_Nonnull'}} 37 #endif 38 typedef nonnull_int_ptr_typedef nonnull_int_ptr_typedef_typedef; 39 typedef nonnull_int_ptr_typedef_typedef _Null_unspecified conflicting_3; // expected-error{{nullability specifier '_Null_unspecified' conflicts with existing specifier '_Nonnull'}} 40 41 // Nullability applies to all pointer types. 42 typedef int (* _Nonnull function_pointer_type_1)(int, int); 43 typedef int (^ _Nonnull block_type_1)(int, int); 44 45 // Nullability must be on a pointer type. 46 typedef int _Nonnull int_type_1; // expected-error{{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'int'}} 47 48 // Nullability can move out to a pointer/block pointer declarator 49 // (with a suppressed warning). 50 typedef _Nonnull int * nonnull_int_ptr_2; 51 typedef int _Nullable * nullable_int_ptr_2; 52 typedef _Nonnull int (* function_pointer_type_2)(int, int); 53 typedef _Nonnull int (^ block_type_2)(int, int); 54 typedef _Nonnull int * * _Nullable nonnull_int_ptr_ptr_1; 55 typedef _Nonnull int *(^ block_type_3)(int, int); 56 typedef _Nonnull int *(* function_pointer_type_3)(int, int); 57 typedef _Nonnull int_ptr (^ block_type_4)(int, int); 58 typedef _Nonnull int_ptr (* function_pointer_type_4)(int, int); 59 typedef void (* function_pointer_type_5)(int_ptr _Nonnull); 60 61 void acceptFunctionPtr(_Nonnull int *(*)(void)); 62 void acceptBlockPtr(_Nonnull int *(^)(void)); 63 64 void testBlockFunctionPtrNullability(void) { 65 float *fp; 66 fp = (function_pointer_type_3)0; // expected-warning{{from 'function_pointer_type_3' (aka 'int * _Nonnull (*)(int, int)')}} 67 fp = (block_type_3)0; // expected-error{{from incompatible type 'block_type_3' (aka 'int * _Nonnull (^)(int, int)')}} 68 fp = (function_pointer_type_4)0; // expected-warning{{from 'function_pointer_type_4' (aka 'int * _Nonnull (*)(int, int)')}} 69 fp = (function_pointer_type_5)0; // expected-warning{{from 'function_pointer_type_5' (aka 'void (*)(int * _Nonnull)')}} 70 fp = (block_type_4)0; // expected-error{{from incompatible type 'block_type_4' (aka 'int_ptr _Nonnull (^)(int, int)')}} 71 72 acceptFunctionPtr(0); // no-warning 73 acceptBlockPtr(0); // no-warning 74 } 75 76 // Moving nullability where it creates a conflict. 77 typedef _Nonnull int * _Nullable * conflict_int_ptr_ptr_2; // expected-error{{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'int'}} 78 79 // Nullability is not part of the canonical type. 80 typedef int * _Nonnull ambiguous_int_ptr; 81 // Redefining a typedef is a C11 feature. 82 #if __STDC_VERSION__ > 199901L 83 typedef int * ambiguous_int_ptr; 84 typedef int * _Nullable ambiguous_int_ptr; 85 #endif 86 87 // Printing of nullability. 88 float f; 89 int * _Nonnull ip_1 = &f; // expected-warning{{incompatible pointer types initializing 'int * _Nonnull' with an expression of type 'float *'}} 90 91 // Check printing of nullability specifiers. 92 void printing_nullability(void) { 93 int * _Nonnull iptr; 94 float *fptr = iptr; // expected-warning{{incompatible pointer types initializing 'float *' with an expression of type 'int * _Nonnull'}} 95 96 int * * _Nonnull iptrptr; 97 float **fptrptr = iptrptr; // expected-warning{{incompatible pointer types initializing 'float **' with an expression of type 'int ** _Nonnull'}} 98 99 int * _Nullable * _Nonnull iptrptr2; 100 float * *fptrptr2 = iptrptr2; // expected-warning{{incompatible pointer types initializing 'float **' with an expression of type 'int * _Nullable * _Nonnull'}} 101 } 102 103 // Check passing null to a _Nonnull argument. 104 void accepts_nonnull_1(_Nonnull int *ptr); 105 void (*accepts_nonnull_2)(_Nonnull int *ptr); 106 void (^accepts_nonnull_3)(_Nonnull int *ptr); 107 108 void test_accepts_nonnull_null_pointer_literal(void) { 109 accepts_nonnull_1(0); // expected-warning{{null passed to a callee that requires a non-null argument}} 110 accepts_nonnull_2(0); // expected-warning{{null passed to a callee that requires a non-null argument}} 111 accepts_nonnull_3(0); // expected-warning{{null passed to a callee that requires a non-null argument}} 112 } 113 114 // Check returning nil from a _Nonnull-returning function. 115 _Nonnull int *returns_int_ptr(int x) { 116 if (x) { 117 return 0; // expected-warning{{null returned from function that requires a non-null return value}} 118 } 119 120 return (_Nonnull int *)0; 121 } 122 123 // Check nullable-to-nonnull conversions. 124 void nullable_to_nonnull(_Nullable int *ptr) { 125 int *a = ptr; // okay 126 _Nonnull int *b = ptr; // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nonnull'}} 127 b = ptr; // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nonnull'}} 128 __auto_type _Nonnull c = ptr; // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nullable _Nonnull'}} 129 130 accepts_nonnull_1(ptr); // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nonnull'}} 131 } 132 133 // Check nullability of conditional expressions. 134 void conditional_expr(int c) { 135 int * _Nonnull p; 136 int * _Nonnull nonnullP; 137 int * _Nullable nullableP; 138 int * _Null_unspecified unspecifiedP; 139 int *noneP; 140 141 p = c ? nonnullP : nonnullP; 142 p = c ? nonnullP : nullableP; // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nonnull'}} 143 p = c ? nonnullP : unspecifiedP; 144 p = c ? nonnullP : noneP; 145 p = c ? nullableP : nonnullP; // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nonnull'}} 146 p = c ? nullableP : nullableP; // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nonnull'}} 147 p = c ? nullableP : unspecifiedP; // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nonnull'}} 148 p = c ? nullableP : noneP; // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nonnull'}} 149 p = c ? unspecifiedP : nonnullP; 150 p = c ? unspecifiedP : nullableP; // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nonnull'}} 151 p = c ? unspecifiedP : unspecifiedP; 152 p = c ? unspecifiedP : noneP; 153 p = c ? noneP : nonnullP; 154 p = c ? noneP : nullableP; // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nonnull'}} 155 p = c ? noneP : unspecifiedP; 156 p = c ? noneP : noneP; 157 158 // Check that we don't remove all sugar when creating a new QualType for the 159 // conditional expression. 160 typedef int *IntP; 161 typedef IntP _Nonnull NonnullIntP0; 162 typedef NonnullIntP0 _Nonnull NonnullIntP1; 163 typedef IntP _Nullable NullableIntP0; 164 typedef NullableIntP0 _Nullable NullableIntP1; 165 NonnullIntP1 nonnullP2; 166 NullableIntP1 nullableP2; 167 168 p = c ? nonnullP2 : nonnullP2; 169 p = c ? nonnullP2 : nullableP2; // expected-warning{{implicit conversion from nullable pointer 'IntP _Nullable' (aka 'int *') to non-nullable pointer type 'int * _Nonnull'}} 170 p = c ? nullableP2 : nonnullP2; // expected-warning{{implicit conversion from nullable pointer 'IntP _Nullable' (aka 'int *') to non-nullable pointer type 'int * _Nonnull'}} 171 p = c ? nullableP2 : nullableP2; // expected-warning{{implicit conversion from nullable pointer 'NullableIntP1' (aka 'int *') to non-nullable pointer type 'int * _Nonnull'}} 172 } 173 174 // Check nullability of binary conditional expressions. 175 void binary_conditional_expr(void) { 176 int * _Nonnull p; 177 int * _Nonnull nonnullP; 178 int * _Nullable nullableP; 179 int * _Null_unspecified unspecifiedP; 180 int *noneP; 181 182 p = nonnullP ?: nonnullP; 183 p = nonnullP ?: nullableP; 184 p = nonnullP ?: unspecifiedP; 185 p = nonnullP ?: noneP; 186 p = nullableP ?: nonnullP; 187 p = nullableP ?: nullableP; // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nonnull'}} 188 p = nullableP ?: unspecifiedP; 189 p = nullableP ?: noneP; 190 p = unspecifiedP ?: nonnullP; 191 p = unspecifiedP ?: nullableP; // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nonnull'}} 192 p = unspecifiedP ?: unspecifiedP; 193 p = unspecifiedP ?: noneP; 194 p = noneP ?: nonnullP; 195 p = noneP ?: nullableP; // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nonnull'}} 196 p = noneP ?: unspecifiedP; 197 p = noneP ?: noneP; 198 } 199 200 extern int GLOBAL_LENGTH; 201 202 // Nullability can appear on arrays when the arrays are in parameter lists. 203 void arrays(int ints[_Nonnull], 204 void *ptrs[_Nullable], 205 void **nestedPtrs[_Nullable], 206 void * _Null_unspecified * _Nonnull nestedPtrs2[_Nullable], 207 int fixedSize[_Nonnull 2], 208 int staticSize[_Nonnull static 2], 209 int staticSize2[static _Nonnull 2], 210 int starSize[_Nonnull *], 211 int vla[_Nonnull GLOBAL_LENGTH], 212 void ** _Nullable reference); 213 void testDecayedType(void) { 214 int produceAnErrorMessage = arrays; // expected-error {{incompatible pointer to integer conversion initializing 'int' with an expression of type 'void (int * _Nonnull, void ** _Nullable, void *** _Nullable, void * _Null_unspecified * _Nonnull * _Nullable, int * _Nonnull, int * _Nonnull, int * _Nonnull, int * _Nonnull, int * _Nonnull, void ** _Nullable)'}} 215 } 216 217 int notInFunction[_Nullable 3]; // expected-error {{nullability specifier '_Nullable' cannot be applied to non-pointer type 'int[3]'}} 218 219 void nestedArrays(int x[5][_Nonnull 1]) {} // expected-error {{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'int[1]'}} 220 void nestedArrays2(int x[5][_Nonnull 1][2]) {} // expected-error {{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'int[1][2]'}} 221 void nestedArraysOK(int x[_Nonnull 5][1]) {} // ok 222 223 void nullabilityOnBase(_Nonnull int x[1], // expected-error {{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'int'}} 224 int _Nonnull y[1]); // expected-error {{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'int'}} 225 226 typedef int INTS[4]; 227 typedef int BAD_INTS[_Nonnull 4]; // expected-error {{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'int[4]'}} 228 229 void typedefTest(INTS _Nonnull x, 230 _Nonnull INTS xx, 231 INTS _Nonnull y[2], // expected-error {{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'INTS' (aka 'int[4]')}} 232 INTS z[_Nonnull 2]); 233 234 INTS _Nonnull x; // expected-error {{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'INTS' (aka 'int[4]')}} 235 _Nonnull INTS x; // expected-error {{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'INTS' (aka 'int[4]')}} 236 237 void arraysInBlocks(void) { 238 typedef int INTS[4]; 239 void (^simple)(int [_Nonnull 2]) = ^(int x[_Nonnull 2]) {}; 240 simple(0); // expected-warning {{null passed to a callee that requires a non-null argument}} 241 void (^nested)(void *_Nullable x[_Nonnull 2]) = ^(void *_Nullable x[_Nonnull 2]) {}; 242 nested(0); // expected-warning {{null passed to a callee that requires a non-null argument}} 243 void (^nestedBad)(int x[2][_Nonnull 2]) = // expected-error {{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'int[2]'}} 244 ^(int x[2][_Nonnull 2]) {}; // expected-error {{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'int[2]'}} 245 246 void (^withTypedef)(INTS _Nonnull) = ^(INTS _Nonnull x) {}; 247 withTypedef(0); // expected-warning {{null passed to a callee that requires a non-null argument}} 248 void (^withTypedefBad)(INTS _Nonnull [2]) = // expected-error {{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'INTS' (aka 'int[4]')}} 249 ^(INTS _Nonnull x[2]) {}; // expected-error {{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'INTS' (aka 'int[4]')}} 250 } 251