Reports the code that always produces the same result, throws an exception, or potentially violates nullability contracts.
Examples:
if (array.length < index) {
System.out.println(array[index]);
} // Array index is always out of bounds
if (str == null) System.out.println("str is null");
System.out.println(str.trim());
// the last statement may throw an NPE
@NotNull
Integer square(@Nullable Integer input) {
// the method contract is violated
return input == null ? null : input * input;
}
The inspection behavior may be controlled by a number of annotations, such as
nullability annotations,
@Contract
annotation,
@Range
annotation and so on.
Configure the inspection:
- Use the Suggest @Nullable annotation for methods/fields/parameters where nullable values are used option to warn when a
nullable value is passed as an argument to a method with a non-annotated parameter,
stored into non-annotated field, or returned from a non-annotated method. In this case, the inspection will suggest propagating
the
@Nullable
annotation. You can also configure nullability annotations using the Configure Annotations button.
- Use the Treat non-annotated members and parameters as @Nullable option to assume that non-annotated members can be null,
so they must not be used in non-null context.
- Use the Report not-null required parameter with null-literal argument usages option to report method parameters that cannot be
null (e.g. immediately dereferenced in the method body), but there are call sites where a
null
literal is passed.
- Use the Report nullable methods that always return a non-null value option to report methods that are annotated as
@Nullable
, but always return non-null value. In this case, it's suggested that you change the annotation to @NotNull
.
- Use the Don't report assertions with condition statically proven to be always true option to avoid reporting assertions that were
statically proven to be always true. This also includes conditions like
if (alwaysFalseCondition) throw new IllegalArgumentException();
.
- Use the Ignore assert statements option to control how the inspection treats
assert
statements. By default, the option
is disabled, which means that the assertions are assumed to be executed (-ea mode). If the option is enabled, the assertions will be completely ignored
(-da mode).
- Use the Warn when reading a value guaranteed to be constant option to add warnings on reading variables that contain some constant values,
for example:
true
, false
, or null
.
- Use the Report problems that happen only on some code paths option to control whether to report problems that may happen only
on some code path. If this option is disabled, warnings like exception is possible will not be reported. The inspection will report
only warnings like exception will definitely occur. This mode may greatly reduce the number of false-positives, especially if the code
is not consistently annotated with nullability and contract annotations. That is why it can be useful for finding the most
important problems in legacy code bases.