Add support for method references as first predicate

When the first argument to Predicates.and() or Predicates.or() is a
method reference, wrap it with a cast to enable calling .and()/.or()
on it.

Example:
  Before: Predicates.and(Objects::nonNull, s -> s.length() > 5)
  After: ((Predicate<String>) Objects::nonNull).and(s -> s.length() > 5)

Changes:
- Detect J.MemberReference as first argument
- Extract parameterized type information
- Build cast template with proper type string
- Added test case for method reference scenario

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: timtebeek

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

@@ -25,6 +25,8 @@
 import org.openrewrite.java.search.UsesMethod;
 import org.openrewrite.java.tree.Expression;
 import org.openrewrite.java.tree.J;
+import org.openrewrite.java.tree.JavaType;
+import org.openrewrite.java.tree.TypeUtils;
 
 import java.util.List;
 import java.util.Set;
@@ -78,6 +80,20 @@ private J handlePredicatesMethod(J.MethodInvocation method, String operation) {
 
                 // Build the chain: first.operation(second).operation(third)...
                 Expression result = arguments.get(0);
+
+                // If the first argument is a method reference, wrap it with a cast
+                if (result instanceof J.MemberReference && result.getType() != null) {
+                    JavaType type = result.getType();
+                    String typeString = getTypeString(type);
+                    if (typeString != null) {
+                        result = JavaTemplate.builder("((" + typeString + ") #{any()})")
+                                .build()
+                                .apply(getCursor(),
+                                        method.getCoordinates().replace(),
+                                        result);
+                    }
+                }
+
                 for (int i = 1; i < arguments.size(); i++) {
                     result = JavaTemplate.builder("#{any(java.util.function.Predicate)}." + operation + "(#{any(java.util.function.Predicate)})")
                             .build()
@@ -89,6 +105,28 @@ private J handlePredicatesMethod(J.MethodInvocation method, String operation) {
 
                 return result;
             }
+
+            private String getTypeString(JavaType type) {
+                if (type instanceof JavaType.Parameterized) {
+                    JavaType.Parameterized parameterized = (JavaType.Parameterized) type;
+                    JavaType.FullyQualified fq = TypeUtils.asFullyQualified(parameterized.getType());
+                    if (fq != null && !parameterized.getTypeParameters().isEmpty()) {
+                        StringBuilder sb = new StringBuilder(fq.getClassName());
+                        sb.append("<");
+                        for (int i = 0; i < parameterized.getTypeParameters().size(); i++) {
+                            if (i > 0) sb.append(", ");
+                            JavaType param = parameterized.getTypeParameters().get(i);
+                            JavaType.FullyQualified paramFq = TypeUtils.asFullyQualified(param);
+                            if (paramFq != null) {
+                                sb.append(paramFq.getClassName());
+                            }
+                        }
+                        sb.append(">");
+                        return sb.toString();
+                    }
+                }
+                return null;
+            }
         });
     }
 }

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

@@ -119,6 +119,32 @@ class Test {
         );
     }
 
+    @Test
+    void replacePredicatesAndWithMethodReference() {
+        //language=java
+        rewriteRun(
+          java(
+            """
+              import com.google.common.base.Predicate;
+              import com.google.common.base.Predicates;
+              import java.util.Objects;
+
+              class Test {
+                  Predicate<String> combined = Predicates.and(Objects::nonNull, s -> s.length() > 5);
+              }
+              """,
+            """
+              import com.google.common.base.Predicate;
+              import java.util.Objects;
+
+              class Test {
+                  Predicate<String> combined = ((Predicate<String>) Objects::nonNull).and(s -> s.length() > 5);
+              }
+              """
+          )
+        );
+    }
+
     @Test
     void replacePredicatesAndNestedCalls() {
         //language=java