DataFlowIssue

Reports code constructs that always violate nullability contracts, may throw exceptions, or are just redundant, based on data flow analysis.

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 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 Reports patterns that may throw MatchException option to report patterns that may throw MatchException at runtime due to null values in deconstruction patterns.
• 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.

Before IntelliJ IDEA 2022.3, this inspection was part of the "Constant Conditions & Exceptions" inspection. Now, it is split into two inspections: "Constant Values" and "Nullability and data flow problems".