FutureReturnValueIgnored: check the return type before searching super methods For every call whose return value is unused, MATCHER checked for @CanIgnoreReturnValue on the method, searched all supertypes for overridden methods annotated with @CanIgnoreReturnValue, and ran the IGNORED_METHODS matchers before checking whether the method returns a Future at all. Most methods don't, so checking the return type first avoids computing the supertype closure and scanning member scopes for nearly all calls. The matcher is a conjunction of predicates that don't depend on each other and have no side effects other than completing symbols, so reordering them doesn't change its result. getSymbol() having returned a MethodSymbol is the only precondition the return type check needs, and it already handles void, type variables and error types on its own. (On an incomplete classpath, non-Future calls no longer complete the supertypes of the method's owner, while calls exempted by the earlier predicates now walk the supertypes of their return type, which checkLostType() already does for the result type of method invocations.) PiperOrigin-RevId: 1018394858
Error Prone is a static analysis tool for Java that catches common programming mistakes at compile-time.
public class ShortSet { public static void main (String[] args) { Set<Short> s = new HashSet<>(); for (short i = 0; i < 100; i++) { s.add(i); s.remove(i - 1); } System.out.println(s.size()); } }
error: [CollectionIncompatibleType] Argument 'i - 1' should not be passed to this method;
its type int is not compatible with its collection's type argument Short
s.remove(i - 1);
^
(see https://errorprone.info/bugpattern/CollectionIncompatibleType)
1 error
Our documentation is at errorprone.info.
Error Prone works with Bazel, Maven, Ant, and Gradle. See our installation instructions for details.
Developing and building Error Prone is documented on the wiki.