package clang.tidy.nullability

Get desktop application:
View/edit binary Protocol Buffers messages

An observation of nullability based on local analysis (e.g. a function body). Evidence from across different functions/TUs is combined to form conclusions.

Used in: SlotInference

• optional Symbol symbol = 1

• optional uint32 slot = 2

• optional Evidence.Kind kind = 3

• optional string location = 4

  Source location: file:line:col. Optional, for debugging only.

A pattern in the code that might help us determine nullability.

Used in: Evidence

• ANNOTATED_UNKNOWN = 0

  The declaration was annotated with _Null_unspecified or similar.

• ANNOTATED_NULLABLE = 1

  The declaration was annotated with _Nullable or similar.

• ANNOTATED_NONNULL = 2

  The declaration was annotated with _Nonnull or similar.

• UNCHECKED_DEREFERENCE = 3

  A pointer was dereferenced without being checked for null first.

• NULLABLE_ARGUMENT = 4

  A Nullable value was passed as an argument.

• NONNULL_ARGUMENT = 5

  A Nonnull value was passed as an argument.

• UNKNOWN_ARGUMENT = 6

  A value with Unknown nullability was passed as an argument.

• NULLABLE_RETURN = 7

  A Nullable value was returned.

• NONNULL_RETURN = 8

  A Nonnull value was returned.

• UNKNOWN_RETURN = 9

  A value with Unknown nullability was returned.

• ASSIGNED_TO_NONNULL = 10

  A value was assigned to a Nonnull declaration. e.g. evidence for `p` from `Nonnull<int*> q = p;`.

• ASSIGNED_TO_MUTABLE_NULLABLE = 11

  A value was assigned to a declaration that is a reference to a mutable nullable pointer, e.g. evidence for `p` from `Nullable<int*>& q = p;`.

• ABORT_IF_NULL = 12

  The program aborts if a value is null.

• ASSIGNED_FROM_NULLABLE = 13

  A nullable value was assigned. e.g. evidence for `p` from `int* p = nullptr;`.

• ARITHMETIC = 14

  A pointer was used with an arithmetic operator without being checked for null first.

• NULLPTR_DEFAULT_MEMBER_INITIALIZER = 15

  A non-static member variable has a default initializer that is a literal nullptr or is simply constructed from a literal nullptr. This is considered to be a weaker signal than other assignments to nullable, due to the common use of nullptr as a default value to avoid quieter uninitialized memory errors in favor of loud segfaults, so we differentiate the evidence. Default initializers that are nullable but not using literal nullptrs use the stronger evidence ASSIGNED_TO_NULLABLE, as they likely indicate more explicit Nullable intent.

• GCC_NONNULL_ATTRIBUTE = 16

  __attribute((nonnull[(optional_param_indices)])) was applied to a function or parameter declaration or __attribute((returns_nonnull)) was applied to a function declaration.

• NULLABLE_REFERENCE_RETURN = 17

  A Nullable value was returned as a reference.

• NONNULL_REFERENCE_RETURN = 18

  A Nonnull value was returned as a mutable reference.

• UNKNOWN_REFERENCE_RETURN = 19

  A value with Unknown nullability was returned as a reference.

• NULLABLE_REFERENCE_ARGUMENT = 20

  A Nullable value was passed as a reference argument.

• NONNULL_REFERENCE_ARGUMENT = 21

  A Nonnull value was passed as a mutable reference argument.

• UNKNOWN_REFERENCE_ARGUMENT = 22

  A value with Unknown nullability was passed as a reference argument.

• ASSIGNED_FROM_NONNULL = 23

  A nonnull value was assigned. e.g. evidence for `p` from `int a; int* p = &a;`.

• ASSIGNED_FROM_UNKNOWN = 24

  An unknown value was assigned. e.g. evidence for `p` from `int* p = getUnknownPtr();`.

• ASSIGNED_TO_NONNULL_REFERENCE = 26

  A value was bound to a reference to a nonnull pointer, regardless of whether the pointer can be mutated through the reference. If any Nonnull reference exists, the pointer must be declared Nonnull to prevent the pointer from being directly, or through a different reference, assigned to null and then accessed through the Nonnull reference unsafely. e.g. evidence for `p` from `Nonnull<int*> &q = p;`.

• NONNULL_REFERENCE_RETURN_AS_CONST = 27

  A reference to a nonnull value was returned as a reference to a const value. This is distinct from NONNULL_REFERENCE_RETURN because it does not require that the return type is Nonnull, the way returning a reference to a mutable nonnull value does.

• NONNULL_REFERENCE_ARGUMENT_AS_CONST = 28

  A reference to a nonnull value was passed as an argument to a const reference parameter. This is distinct from NONNULL_REFERENCE_ARGUMENT because it does not require that the argument type is Nonnull, the way passing a reference to a mutable nonnull value does.

• WELL_KNOWN_NONNULL = 29

  A decl that is defined by the standard or strong convention to be Nonnull.

• WELL_KNOWN_NULLABLE = 30

  A decl that is defined by the standard or strong convention to be Nullable.

• ARRAY_SUBSCRIPT = 31

  A pointer was used with an array subscript operator without being checked for null first.

Used in: SlotInference, SlotRange

• UNKNOWN = 0

• NONNULL = 1

• NULLABLE = 2

A half-open source range to be removed: [begin, end).

Used in: SlotRange

• optional uint64 begin = 1

• optional uint64 end = 2

A "slot" identifies a position in a symbol's type that may have nullability. We use uint32 rather than the Slot type to represent slot numbers in protos. (A symbol may have any number of slots, and proto2 enums are closed). The Slot enum only defines well-known slot values for functions. Fields and global variables use Slot numbers aligned with the indices of their nullability vectors.

• SLOT_RETURN_TYPE = 0

  The slot number for a function's return type.

• SLOT_PARAM = 1

  The slot number for a function's first parameter. The second param is SLOT_PARAM + 1, etc.

A conclusion about nullability based on global analysis (e.g. all TUs).

• optional Nullability nullability = 1

• optional bool conflict = 2

  Indicates that not we could not reconcile all evidence into a conclusion. e.g. a decl that was both unconditionally dereferenced and assigned null.

• repeated Evidence sample_evidence = 3

  Examples of evidence that contributed. Optional, for debugging only.

• optional bool trivial = 4

  Indicates that this inference does not represent new information beyond what is explicitly written in the source code, and so does not need to be separately propagated from one round of inference into the next. e.g. an inference gathered from ANNOTATED_NONNULL Evidence.

Summary of an incomplete set of Evidence for a slot. Once all evidence has been incorporated, can be finalized into SlotInference. This type should be treated as opaque, and its serialization is not stable.

• map<uint32, uint32> kind_count = 1

• map<uint32, SlotPartial.SampleLocations> kind_samples = 2

Used in: SlotPartial

• repeated string location = 1

  A bounded number of locations are stored.

Nullability information for a pointer-type source range. Does not include the full source range for the type, as that isn't needed for adding/removing nullability annotations.

• optional string path = 1

  Path of the file containing this range.

• optional Nullability pragma_nullability = 2

  The nullability default set by the pragma affecting `path`, if one exists.

• optional uint64 qualifier_annotation_insertion_offset = 3

  The offset at which a qualifier-position annotation should be inserted. For a named pointer type not ending with `*`, including smart pointers and aliases to raw pointers, this precedes the type but follows any cv-qualifiers. For other pointers, this follows the `*` but precedes any cv-qualifiers. This field uniquely identifies a pointer-type slot range within a file, as no two pointer ranges can be annotated with a qualifier-positioned annotation in the same location.

• optional Nullability existing_annotation = 4

• repeated RemovalRange existing_annotation_removal_range = 5

  The source ranges of existing annotations to be removed if modifying the annotation for this range.

A symbol whose nullability should potentially be inferred.

Used in: Evidence

• optional string usr = 1

  Clang "Unified Symbol Resolution" identifier for the symbol.