mirror of
https://github.com/Gericom/teak-llvm.git
synced 2025-06-26 14:58:59 -04:00
dc5ce72afa
Recommit of r335084 after revert in r335516. ... instead of prepending it at the beginning (the original behavior since implemented in r122535 2010-12-23). This builds up an AttributeList in the the order in which the attributes appear in the source. The reverse order caused nodes for attributes in the AST (e.g. LoopHint) to be in the reverse order, and therefore printed in the wrong order in -ast-dump. Some TODO comments mention this. The order was explicitly reversed for enable_if attribute overload resolution and name mangling, which is not necessary anymore with this patch. The change unfortunately has some secondary effect, especially on diagnostic output. In the simplest cases, the CHECK lines or expected diagnostic were changed to the the new output. If the kind of error/warning changed, the attributes' order was changed instead. This unfortunately causes some 'previous occurrence here' hints to be textually after the main marker. This typically happens when attributes are merged, but are incompatible to each other. Interchanging the role of the the main and note SourceLocation will also cause the case where two different declaration's attributes (in contrast to multiple attributes of the same declaration) are merged to be reverse. There is no easy fix because sometimes previous attributes are merged into a new declaration's attribute list, sometimes new attributes are added to a previous declaration's attribute list. Since 'previous occurrence here' pointing to locations after the main marker is not rare, I left the markers as-is; it is only relevant when the attributes are declared in the same declaration anyway. Differential Revision: https://reviews.llvm.org/D48100 llvm-svn: 338800
250 lines
13 KiB
C
250 lines
13 KiB
C
// RUN: %clang_cc1 -fsyntax-only -fblocks -Wnullable-to-nonnull-conversion -Wno-nullability-declspec %s -verify
|
|
|
|
#if __has_feature(nullability)
|
|
#else
|
|
# error nullability feature should be defined
|
|
#endif
|
|
|
|
typedef int * int_ptr;
|
|
|
|
// Parse nullability type specifiers.
|
|
// This note requires C11.
|
|
#if __STDC_VERSION__ > 199901L
|
|
// expected-note@+2{{'_Nonnull' specified here}}
|
|
#endif
|
|
typedef int * _Nonnull nonnull_int_ptr;
|
|
typedef int * _Nullable nullable_int_ptr;
|
|
typedef int * _Null_unspecified null_unspecified_int_ptr;
|
|
|
|
// Redundant nullability type specifiers.
|
|
typedef int * _Nonnull _Nonnull redundant_1; // expected-warning{{duplicate nullability specifier '_Nonnull'}}
|
|
|
|
// Conflicting nullability type specifiers.
|
|
typedef int * _Nonnull _Nullable conflicting_1; // expected-error{{nullability specifier '_Nullable' conflicts with existing specifier '_Nonnull'}}
|
|
typedef int * _Null_unspecified _Nonnull conflicting_2; // expected-error{{nullability specifier '_Nonnull' conflicts with existing specifier '_Null_unspecified'}}
|
|
|
|
// Redundant nullability specifiers via a typedef are okay.
|
|
typedef nonnull_int_ptr _Nonnull redundant_okay_1;
|
|
|
|
// Conflicting nullability specifiers via a typedef are not.
|
|
// Some of these errors require C11.
|
|
#if __STDC_VERSION__ > 199901L
|
|
typedef nonnull_int_ptr _Nullable conflicting_2; // expected-error{{nullability specifier '_Nullable' conflicts with existing specifier '_Nonnull'}}
|
|
#endif
|
|
typedef nonnull_int_ptr nonnull_int_ptr_typedef;
|
|
#if __STDC_VERSION__ > 199901L
|
|
typedef nonnull_int_ptr_typedef _Nullable conflicting_2; // expected-error{{nullability specifier '_Nullable' conflicts with existing specifier '_Nonnull'}}
|
|
#endif
|
|
typedef nonnull_int_ptr_typedef nonnull_int_ptr_typedef_typedef;
|
|
typedef nonnull_int_ptr_typedef_typedef _Null_unspecified conflicting_3; // expected-error{{nullability specifier '_Null_unspecified' conflicts with existing specifier '_Nonnull'}}
|
|
|
|
// Nullability applies to all pointer types.
|
|
typedef int (* _Nonnull function_pointer_type_1)(int, int);
|
|
typedef int (^ _Nonnull block_type_1)(int, int);
|
|
|
|
// Nullability must be on a pointer type.
|
|
typedef int _Nonnull int_type_1; // expected-error{{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'int'}}
|
|
|
|
// Nullability can move out to a pointer/block pointer declarator
|
|
// (with a suppressed warning).
|
|
typedef _Nonnull int * nonnull_int_ptr_2;
|
|
typedef int _Nullable * nullable_int_ptr_2;
|
|
typedef _Nonnull int (* function_pointer_type_2)(int, int);
|
|
typedef _Nonnull int (^ block_type_2)(int, int);
|
|
typedef _Nonnull int * * _Nullable nonnull_int_ptr_ptr_1;
|
|
typedef _Nonnull int *(^ block_type_3)(int, int);
|
|
typedef _Nonnull int *(* function_pointer_type_3)(int, int);
|
|
typedef _Nonnull int_ptr (^ block_type_4)(int, int);
|
|
typedef _Nonnull int_ptr (* function_pointer_type_4)(int, int);
|
|
typedef void (* function_pointer_type_5)(int_ptr _Nonnull);
|
|
|
|
void acceptFunctionPtr(_Nonnull int *(*)(void));
|
|
void acceptBlockPtr(_Nonnull int *(^)(void));
|
|
|
|
void testBlockFunctionPtrNullability() {
|
|
float *fp;
|
|
fp = (function_pointer_type_3)0; // expected-warning{{from 'function_pointer_type_3' (aka 'int * _Nonnull (*)(int, int)')}}
|
|
fp = (block_type_3)0; // expected-error{{from incompatible type 'block_type_3' (aka 'int * _Nonnull (^)(int, int)')}}
|
|
fp = (function_pointer_type_4)0; // expected-warning{{from 'function_pointer_type_4' (aka 'int * _Nonnull (*)(int, int)')}}
|
|
fp = (function_pointer_type_5)0; // expected-warning{{from 'function_pointer_type_5' (aka 'void (*)(int * _Nonnull)')}}
|
|
fp = (block_type_4)0; // expected-error{{from incompatible type 'block_type_4' (aka 'int_ptr _Nonnull (^)(int, int)')}}
|
|
|
|
acceptFunctionPtr(0); // no-warning
|
|
acceptBlockPtr(0); // no-warning
|
|
}
|
|
|
|
// Moving nullability where it creates a conflict.
|
|
typedef _Nonnull int * _Nullable * conflict_int_ptr_ptr_2; // expected-error{{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'int'}}
|
|
|
|
// Nullability is not part of the canonical type.
|
|
typedef int * _Nonnull ambiguous_int_ptr;
|
|
// Redefining a typedef is a C11 feature.
|
|
#if __STDC_VERSION__ > 199901L
|
|
typedef int * ambiguous_int_ptr;
|
|
typedef int * _Nullable ambiguous_int_ptr;
|
|
#endif
|
|
|
|
// Printing of nullability.
|
|
float f;
|
|
int * _Nonnull ip_1 = &f; // expected-warning{{incompatible pointer types initializing 'int * _Nonnull' with an expression of type 'float *'}}
|
|
|
|
// Check printing of nullability specifiers.
|
|
void printing_nullability(void) {
|
|
int * _Nonnull iptr;
|
|
float *fptr = iptr; // expected-warning{{incompatible pointer types initializing 'float *' with an expression of type 'int * _Nonnull'}}
|
|
|
|
int * * _Nonnull iptrptr;
|
|
float **fptrptr = iptrptr; // expected-warning{{incompatible pointer types initializing 'float **' with an expression of type 'int ** _Nonnull'}}
|
|
|
|
int * _Nullable * _Nonnull iptrptr2;
|
|
float * *fptrptr2 = iptrptr2; // expected-warning{{incompatible pointer types initializing 'float **' with an expression of type 'int * _Nullable * _Nonnull'}}
|
|
}
|
|
|
|
// Check passing null to a _Nonnull argument.
|
|
void accepts_nonnull_1(_Nonnull int *ptr);
|
|
void (*accepts_nonnull_2)(_Nonnull int *ptr);
|
|
void (^accepts_nonnull_3)(_Nonnull int *ptr);
|
|
|
|
void test_accepts_nonnull_null_pointer_literal() {
|
|
accepts_nonnull_1(0); // expected-warning{{null passed to a callee that requires a non-null argument}}
|
|
accepts_nonnull_2(0); // expected-warning{{null passed to a callee that requires a non-null argument}}
|
|
accepts_nonnull_3(0); // expected-warning{{null passed to a callee that requires a non-null argument}}
|
|
}
|
|
|
|
// Check returning nil from a _Nonnull-returning function.
|
|
_Nonnull int *returns_int_ptr(int x) {
|
|
if (x) {
|
|
return 0; // expected-warning{{null returned from function that requires a non-null return value}}
|
|
}
|
|
|
|
return (_Nonnull int *)0;
|
|
}
|
|
|
|
// Check nullable-to-nonnull conversions.
|
|
void nullable_to_nonnull(_Nullable int *ptr) {
|
|
int *a = ptr; // okay
|
|
_Nonnull int *b = ptr; // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nonnull'}}
|
|
b = ptr; // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nonnull'}}
|
|
|
|
accepts_nonnull_1(ptr); // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nonnull'}}
|
|
}
|
|
|
|
// Check nullability of conditional expressions.
|
|
void conditional_expr(int c) {
|
|
int * _Nonnull p;
|
|
int * _Nonnull nonnullP;
|
|
int * _Nullable nullableP;
|
|
int * _Null_unspecified unspecifiedP;
|
|
int *noneP;
|
|
|
|
p = c ? nonnullP : nonnullP;
|
|
p = c ? nonnullP : nullableP; // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nonnull'}}
|
|
p = c ? nonnullP : unspecifiedP;
|
|
p = c ? nonnullP : noneP;
|
|
p = c ? nullableP : nonnullP; // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nonnull'}}
|
|
p = c ? nullableP : nullableP; // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nonnull'}}
|
|
p = c ? nullableP : unspecifiedP; // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nonnull'}}
|
|
p = c ? nullableP : noneP; // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nonnull'}}
|
|
p = c ? unspecifiedP : nonnullP;
|
|
p = c ? unspecifiedP : nullableP; // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nonnull'}}
|
|
p = c ? unspecifiedP : unspecifiedP;
|
|
p = c ? unspecifiedP : noneP;
|
|
p = c ? noneP : nonnullP;
|
|
p = c ? noneP : nullableP; // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nonnull'}}
|
|
p = c ? noneP : unspecifiedP;
|
|
p = c ? noneP : noneP;
|
|
|
|
// Check that we don't remove all sugar when creating a new QualType for the
|
|
// conditional expression.
|
|
typedef int *IntP;
|
|
typedef IntP _Nonnull NonnullIntP0;
|
|
typedef NonnullIntP0 _Nonnull NonnullIntP1;
|
|
typedef IntP _Nullable NullableIntP0;
|
|
typedef NullableIntP0 _Nullable NullableIntP1;
|
|
NonnullIntP1 nonnullP2;
|
|
NullableIntP1 nullableP2;
|
|
|
|
p = c ? nonnullP2 : nonnullP2;
|
|
p = c ? nonnullP2 : nullableP2; // expected-warning{{implicit conversion from nullable pointer 'IntP _Nullable' (aka 'int *') to non-nullable pointer type 'int * _Nonnull'}}
|
|
p = c ? nullableP2 : nonnullP2; // expected-warning{{implicit conversion from nullable pointer 'NullableIntP1' (aka 'int *') to non-nullable pointer type 'int * _Nonnull'}}
|
|
p = c ? nullableP2 : nullableP2; // expected-warning{{implicit conversion from nullable pointer 'NullableIntP1' (aka 'int *') to non-nullable pointer type 'int * _Nonnull'}}
|
|
}
|
|
|
|
// Check nullability of binary conditional expressions.
|
|
void binary_conditional_expr() {
|
|
int * _Nonnull p;
|
|
int * _Nonnull nonnullP;
|
|
int * _Nullable nullableP;
|
|
int * _Null_unspecified unspecifiedP;
|
|
int *noneP;
|
|
|
|
p = nonnullP ?: nonnullP;
|
|
p = nonnullP ?: nullableP;
|
|
p = nonnullP ?: unspecifiedP;
|
|
p = nonnullP ?: noneP;
|
|
p = nullableP ?: nonnullP;
|
|
p = nullableP ?: nullableP; // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nonnull'}}
|
|
p = nullableP ?: unspecifiedP;
|
|
p = nullableP ?: noneP;
|
|
p = unspecifiedP ?: nonnullP;
|
|
p = unspecifiedP ?: nullableP; // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nonnull'}}
|
|
p = unspecifiedP ?: unspecifiedP;
|
|
p = unspecifiedP ?: noneP;
|
|
p = noneP ?: nonnullP;
|
|
p = noneP ?: nullableP; // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nonnull'}}
|
|
p = noneP ?: unspecifiedP;
|
|
p = noneP ?: noneP;
|
|
}
|
|
|
|
extern int GLOBAL_LENGTH;
|
|
|
|
// Nullability can appear on arrays when the arrays are in parameter lists.
|
|
void arrays(int ints[_Nonnull],
|
|
void *ptrs[_Nullable],
|
|
void **nestedPtrs[_Nullable],
|
|
void * _Null_unspecified * _Nonnull nestedPtrs2[_Nullable],
|
|
int fixedSize[_Nonnull 2],
|
|
int staticSize[_Nonnull static 2],
|
|
int staticSize2[static _Nonnull 2],
|
|
int starSize[_Nonnull *],
|
|
int vla[_Nonnull GLOBAL_LENGTH],
|
|
void ** _Nullable reference);
|
|
void testDecayedType() {
|
|
int produceAnErrorMessage = arrays; // expected-warning {{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)'}}
|
|
}
|
|
|
|
int notInFunction[_Nullable 3]; // expected-error {{nullability specifier '_Nullable' cannot be applied to non-pointer type 'int [3]'}}
|
|
|
|
void nestedArrays(int x[5][_Nonnull 1]) {} // expected-error {{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'int [1]'}}
|
|
void nestedArrays2(int x[5][_Nonnull 1][2]) {} // expected-error {{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'int [1][2]'}}
|
|
void nestedArraysOK(int x[_Nonnull 5][1]) {} // ok
|
|
|
|
void nullabilityOnBase(_Nonnull int x[1], // expected-error {{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'int'}}
|
|
int _Nonnull y[1]); // expected-error {{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'int'}}
|
|
|
|
typedef int INTS[4];
|
|
typedef int BAD_INTS[_Nonnull 4]; // expected-error {{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'int [4]'}}
|
|
|
|
void typedefTest(INTS _Nonnull x,
|
|
_Nonnull INTS xx,
|
|
INTS _Nonnull y[2], // expected-error {{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'INTS' (aka 'int [4]')}}
|
|
INTS z[_Nonnull 2]);
|
|
|
|
INTS _Nonnull x; // expected-error {{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'INTS' (aka 'int [4]')}}
|
|
_Nonnull INTS x; // expected-error {{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'INTS' (aka 'int [4]')}}
|
|
|
|
void arraysInBlocks() {
|
|
typedef int INTS[4];
|
|
void (^simple)(int [_Nonnull 2]) = ^(int x[_Nonnull 2]) {};
|
|
simple(0); // expected-warning {{null passed to a callee that requires a non-null argument}}
|
|
void (^nested)(void *_Nullable x[_Nonnull 2]) = ^(void *_Nullable x[_Nonnull 2]) {};
|
|
nested(0); // expected-warning {{null passed to a callee that requires a non-null argument}}
|
|
void (^nestedBad)(int x[2][_Nonnull 2]) = // expected-error {{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'int [2]'}}
|
|
^(int x[2][_Nonnull 2]) {}; // expected-error {{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'int [2]'}}
|
|
|
|
void (^withTypedef)(INTS _Nonnull) = ^(INTS _Nonnull x) {};
|
|
withTypedef(0); // expected-warning {{null passed to a callee that requires a non-null argument}}
|
|
void (^withTypedefBad)(INTS _Nonnull [2]) = // expected-error {{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'INTS' (aka 'int [4]')}}
|
|
^(INTS _Nonnull x[2]) {}; // expected-error {{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'INTS' (aka 'int [4]')}}
|
|
}
|