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 '_Nonnull' conflicts with existing specifier '_Nullable'}} 24 typedef int * _Null_unspecified _Nonnull conflicting_2; // expected-error{{nullability specifier '_Null_unspecified' conflicts with existing specifier '_Nonnull'}} 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() { 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() { 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 129 accepts_nonnull_1(ptr); // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nonnull'}} 130 } 131
