Always "cast" the Predicate.isEqual method

In some cases, the type can be inferred, but not always.
To follow the “Do no harm” principle, it’s safer to always "cast" the
`Predicate.isEqual` method explicitly.
Before this commit, certain cases resulted in compilation errors (see
the new test inlinedPredicatesEqualToWithStandardType, which reveals
this problem).

Author: lredor

src/main/java/org/openrewrite/java/migrate/guava/NoGuavaPredicatesEqualTo.java

@@ -25,8 +25,8 @@
 import org.openrewrite.java.ShortenFullyQualifiedTypeReferences;
 import org.openrewrite.java.search.UsesMethod;
 import org.openrewrite.java.tree.J;
-import org.openrewrite.java.tree.JavaType;
 
+import java.util.Objects;
 import java.util.Set;
 
 import static java.util.Collections.singleton;
@@ -60,8 +60,8 @@ public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, Execu
                             maybeRemoveImport("com.google.common.base.Predicates");
                             maybeAddImport("java.util.function.Predicate");
 
-                            if (method.getMethodType().getParameterTypes().get(0) instanceof JavaType.Parameterized) {
-                                String typeString = method.getArguments().get(0).getType().toString();
+                            try {
+                                String typeString = Objects.requireNonNull(method.getArguments().get(0).getType()).toString();
                                 J.MethodInvocation genericMethod = JavaTemplate.builder("Predicate.<" + typeString + ">isEqual(#{any(java.lang.Object)})")
                                         .imports("java.util.function.Predicate")
                                         .build()
@@ -70,14 +70,15 @@ public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, Execu
                                                 method.getArguments().get(0));
                                 doAfterVisit(ShortenFullyQualifiedTypeReferences.modifyOnly(genericMethod));
                                 return genericMethod;
+                            } catch (NullPointerException e) {
+                                // Fallback if no type is found.
+                                return JavaTemplate.builder("Predicate.isEqual(#{any(java.lang.Object)})")
+                                        .imports("java.util.function.Predicate")
+                                        .build()
+                                        .apply(getCursor(),
+                                                method.getCoordinates().replace(),
+                                                method.getArguments().get(0));
                             }
-                            // Fallback is not type is found.
-                            return JavaTemplate.builder("Predicate.isEqual(#{any(java.lang.Object)})")
-                                    .imports("java.util.function.Predicate")
-                                    .build()
-                                    .apply(getCursor(),
-                                            method.getCoordinates().replace(),
-                                            method.getArguments().get(0));
                         }
                         return super.visitMethodInvocation(method, ctx);
                     }

src/test/java/org/openrewrite/java/migrate/guava/NoGuavaPredicatesEqualToTest.java

@@ -54,7 +54,7 @@ public static Predicate<String> isHelloPredicate() {
 
               class A {
                   public static Predicate<String> isHelloPredicate() {
-                      return Predicate.isEqual("hello");
+                      return Predicate.<String>isEqual("hello");
                   }
               }
               """
@@ -64,7 +64,7 @@ public static Predicate<String> isHelloPredicate() {
 
     @Issue("https://github.com/openrewrite/rewrite-migrate-java/issues/903")
     @Test
-    void inlinedPredicatesEqualToToPredicateIsEqual() {
+    void inlinedPredicatesEqualToWithParameterizedType() {
         rewriteRun(
           //language=java
           java(
@@ -93,4 +93,40 @@ public static void test(Collection<String> aCollection, Predicate<Collection<Str
           )
         );
     }
+
+    @Test
+    void inlinedPredicatesEqualToWithStandardType() {
+        rewriteRun(
+          //language=java
+          java(
+            """
+              import com.google.common.base.Predicates;
+              import com.google.common.base.Predicate;
+
+              class Test {
+                  static Predicate<String> getMaxLengthPredicate() {
+                          return s -> s.length() < 10;
+                  }
+
+                  public static void test() {
+                      Predicate<String> combined = Predicates.and(Predicates.equalTo("MyTest"), getMaxLengthPredicate());
+                  }
+              }
+              """,
+            """
+              import java.util.function.Predicate;
+
+              class Test {
+                  static Predicate<String> getMaxLengthPredicate() {
+                          return s -> s.length() < 10;
+                  }
+
+                  public static void test() {
+                      Predicate<String> combined = Predicate.<String>isEqual("MyTest").and(getMaxLengthPredicate());
+                  }
+              }
+              """
+          )
+        );
+    }
 }