Cast expression to @Nonnull to avoid warning in Eclipse?

I am experimenting with using javax.annotation.{Nonnull,Nullable} to see if it can enhance code quality in Eclipse. It seems to help in simple cases, but there are cases where it gets awkward, and I want to determine the best strategies for mitigating the problems.

I'm currently looking at a method that looks somewhat like this:

public @Nonnull List<Thing> produceSomeThings(Stuff stuff) {
    List<Thing> things = new ArrayList<>();
    if (stuff != null) {
        if (stuff.checkStuff())
            things.add(stuff.getThings());
        }
    }
    if (CollectionUtils.isNotEmpty(things)) {
        return things.stream() // this line
            .filter(Util.filter(thing -> thing.isBad())
            .collect(Collectors.toList());
    }
    return things;
}

In Eclipse, this presents a warning on "this line", saying this:

Null type safety: The expression of type 'List<Thing>' needs unchecked conversion to conform to '@NonNull List<Thing>'

I noticed the following Eclipse bug report: https://bugs.eclipse.org/bugs/show_bug.cgi?id=501464 .

This appears to have been fixed, and the fix was available many versions ago. However, I'm unable to figure out any way to cast this so that it even works, much less doesn't look nasty.

I also tried changing that line to simply assign to "things", but that just moves what line the warning appears at.

What are reasonable options here?

Update:

Examining some of the options that @howlger provides, I did the following:

• Modified the libraries/java/java/util/streams/Collectors.eea file, adding the one "1" character suggested
• Implemented the intermediate "toList" functor as suggested

From what I can see, these changes didn't make any difference. The error message is technically different, but I think it's the same problem. Adding the "SuppressWarnings" annotation had no effect at all.

The new code (a little closer to the actual real code) is this:

Collector<Thing, ?, @NonNull List<Thing>> toList = Collectors.toList();
return orderThing.stream()
		.filter(CartUtil.distinctByKey(individualThing -> individualThing.get_ThingId()))
		.collect(toList);

The "toList" expression has this warning:

> Null type safety (type annotations): The expression of type 'Collector<@NonNull Thing,capture#of ?,@NonNull List<@NonNull Thing>>' needs unchecked conversion to conform to '@NonNull Collector<? super @NonNull Thing,capture#of ?,@NonNull List<@NonNull Thing>>'

Here, not the modified things list, but a new object intance of type List<Thing>, that was computed based on things is returned. Whether this computed list is guaranteed to be non-null, depends on what collect(...) returns, which depends on the implementation of Collector. Since the API does not guarantee it and it is not trivial to deduce from the code, the warning is displayed.

Rewrite your code as follows:

@SuppressWarnings("null")
Collector<Thing, ?, @NonNull List<Thing>> toList = Collectors.toList();
return things.stream()
             .filter(Util.filter(thing -> thing.isBad()))
             .collect(toList);

Alternatively, external null annotations should also work if they cover everything used.