Always add explicit type to the Predicate.isEqual method (#927)

* 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).

* Add the recipe NoGuavaMapsNewLinkedHashMap to `no-guava.yml`

It seems that the recipe NoGuavaMapsNewLinkedHashMap has never been
added in `no-guava.yml`.

* Don't use try/catch to handle null type

---------

Co-authored-by: Tim te Beek <tim@moderne.io>

Author: lredor

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

@@ -27,6 +27,7 @@
 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,24 +61,26 @@ 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();
-                                J.MethodInvocation genericMethod = JavaTemplate.builder("Predicate.<" + typeString + ">isEqual(#{any(java.lang.Object)})")
+                            JavaType argumentType = method.getArguments().get(0).getType();
+                            if (argumentType == null) {
+                                // 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));
-                                doAfterVisit(ShortenFullyQualifiedTypeReferences.modifyOnly(genericMethod));
-                                return genericMethod;
                             }
-                            // Fallback is not type is found.
-                            return JavaTemplate.builder("Predicate.isEqual(#{any(java.lang.Object)})")
+
+                            String typeString = Objects.requireNonNull(argumentType).toString();
+                            J.MethodInvocation genericMethod = JavaTemplate.builder("Predicate.<" + typeString + ">isEqual(#{any(java.lang.Object)})")
                                     .imports("java.util.function.Predicate")
                                     .build()
                                     .apply(getCursor(),
                                             method.getCoordinates().replace(),
                                             method.getArguments().get(0));
+                            doAfterVisit(ShortenFullyQualifiedTypeReferences.modifyOnly(genericMethod));
+                            return genericMethod;
                         }
                         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());
+                  }
+              }
+              """
+          )
+        );
+    }
 }