Introduce IsInstanceLambdaUsage check

error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/IsInstanceUsage.java

@@ -0,0 +1,51 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
+import static com.google.errorprone.BugPattern.StandardTags.STYLE;
+import static com.sun.source.tree.Tree.Kind.INSTANCE_OF;
+import static com.sun.source.tree.Tree.Kind.LAMBDA_EXPRESSION;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
+
+import com.google.auto.service.AutoService;
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.bugpatterns.BugChecker.LambdaExpressionTreeMatcher;
+import com.google.errorprone.fixes.SuggestedFix;
+import com.google.errorprone.matchers.Description;
+import com.sun.source.tree.InstanceOfTree;
+import com.sun.source.tree.LambdaExpressionTree;
+
+/** A {@link BugChecker} that aligns usages of T.class::isInstance. */
+@AutoService(BugChecker.class)
+@BugPattern(
+    summary = "Use Class::isInstance where possible",
+    link = BUG_PATTERNS_BASE_URL + "IsInstanceUsage",
+    linkType = CUSTOM,
+    severity = SUGGESTION,
+    tags = STYLE)
+public final class IsInstanceUsage extends BugChecker implements LambdaExpressionTreeMatcher {
+  private static final long serialVersionUID = 1L;
+
+  /** Instantiates a new {@link IsInstanceUsage} instance. */
+  public IsInstanceUsage() {}
+
+  @Override
+  public Description matchLambdaExpression(LambdaExpressionTree tree, VisitorState state) {
+    if (LAMBDA_EXPRESSION == tree.getKind() && INSTANCE_OF == tree.getBody().getKind()) {
+      return constructDescription(
+          tree, constructFix(tree, ((InstanceOfTree) tree.getBody()).getType()));
+    }
+    return Description.NO_MATCH;
+  }
+
+  private Description constructDescription(
+      LambdaExpressionTree tree, SuggestedFix.Builder fixBuilder) {
+    return describeMatch(tree, fixBuilder.build());
+  }
+
+  private static SuggestedFix.Builder constructFix(LambdaExpressionTree tree, Object target) {
+    return SuggestedFix.builder().replace(tree, target + ".class::isInstance");
+  }
+}

error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/MethodReferenceUsage.java

@@ -106,6 +106,7 @@ private static Optional<SuggestedFix.Builder> constructMethodRef(
   }
 
   // XXX: Replace nested `Optional` usage.
+  // XXX: Cover for deeper method invocation like `T.class.isInstance(i)`.
   @SuppressWarnings("NestedOptionals")
   private static Optional<SuggestedFix.Builder> constructMethodRef(
       LambdaExpressionTree lambdaExpr, MethodInvocationTree subTree) {

error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/IsInstanceUsageTest.java

@@ -0,0 +1,58 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import com.google.errorprone.BugCheckerRefactoringTestHelper;
+import com.google.errorprone.CompilationTestHelper;
+import org.junit.jupiter.api.Test;
+
+final class IsInstanceUsageTest {
+  private final CompilationTestHelper compilationTestHelper =
+      CompilationTestHelper.newInstance(IsInstanceUsage.class, getClass());
+  private final BugCheckerRefactoringTestHelper refactoringTestHelper =
+      BugCheckerRefactoringTestHelper.newInstance(IsInstanceUsage.class, getClass());
+
+  @Test
+  void identification() {
+    compilationTestHelper
+        .addSourceLines(
+            "A.java",
+            "import reactor.core.publisher.Flux;",
+            "",
+            "class A {",
+            "  void m() {",
+            "    // BUG: Diagnostic contains:",
+            "    Flux.just(1).filter(i -> i instanceof Integer);",
+            "    // BUG: Diagnostic contains:",
+            "    Flux.just(1).onErrorResume(t -> t instanceof Exception, t -> Flux.empty());",
+            "",
+            "    Flux.just(1).filter(Integer.class::isInstance);",
+            "    Flux.just(1).onErrorResume(Exception.class, t -> Flux.empty());",
+            "    Flux.just(1).onErrorResume(Exception.class::isInstance, t -> Flux.empty());",
+            "  }",
+            "}")
+        .doTest();
+  }
+
+  @Test
+  void replacement() {
+    refactoringTestHelper
+        .addInputLines(
+            "A.java",
+            "import reactor.core.publisher.Flux;",
+            "",
+            "class A {",
+            "  void m() {",
+            "    Flux.just(1).filter(i -> i instanceof Integer);",
+            "  }",
+            "}")
+        .addOutputLines(
+            "A.java",
+            "import reactor.core.publisher.Flux;",
+            "",
+            "class A {",
+            "  void m() {",
+            "    Flux.just(1).filter(Integer.class::isInstance);",
+            "  }",
+            "}")
+        .doTest(BugCheckerRefactoringTestHelper.TestMode.TEXT_MATCH);
+  }
+}