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
testBlockFunctionPtrNullability()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.
printing_nullability(void)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
test_accepts_nonnull_null_pointer_literal()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.
returns_int_ptr(int x)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.
nullable_to_nonnull(_Nullable int * ptr)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