Fix PMD rule LiteralsFirstInComparisons for compareTo* and contentEquals

src/main/java/org/openrewrite/staticanalysis/EqualsAvoidsNull.java

@@ -15,6 +15,7 @@
  */
 package org.openrewrite.staticanalysis;
 
+import org.apache.commons.lang3.ObjectUtils;
 import org.jspecify.annotations.Nullable;
 import org.openrewrite.*;
 import org.openrewrite.java.JavaIsoVisitor;
@@ -54,24 +55,23 @@ public Duration getEstimatedEffortPerOccurrence() {
 
     @Override
     public TreeVisitor<?, ExecutionContext> getVisitor() {
-        JavaIsoVisitor<ExecutionContext> replacementVisitor = new JavaIsoVisitor<ExecutionContext>() {
-            @Override
-            public J visit(@Nullable Tree tree, ExecutionContext ctx) {
-                if (tree instanceof JavaSourceFile) {
-                    JavaSourceFile cu = (JavaSourceFile) requireNonNull(tree);
-                    EqualsAvoidsNullStyle style = cu.getStyle(EqualsAvoidsNullStyle.class);
-                    if (style == null) {
-                        style = Checkstyle.equalsAvoidsNull();
+        return Preconditions.check(
+//                new UsesMethod<>("java.lang.String *quals*(..)"),
+                new UsesMethod<>("java.lang.String *(..)"),
+                new JavaIsoVisitor<ExecutionContext>() {
+                    @Override
+                    public J visit(@Nullable Tree tree, ExecutionContext ctx) {
+                        if (tree instanceof JavaSourceFile) {
+                            JavaSourceFile cu = (JavaSourceFile) requireNonNull(tree);
+                            return new EqualsAvoidsNullVisitor<>(
+                                    ObjectUtils.defaultIfNull(cu.getStyle(EqualsAvoidsNullStyle.class),
+                                            Checkstyle.equalsAvoidsNull()))
+                                    .visitNonNull(cu, ctx);
+                        }
+                        //noinspection DataFlowIssue
+                        return (J) tree;
                     }
-                    return new EqualsAvoidsNullVisitor<>(style).visitNonNull(cu, ctx);
                 }
-                //noinspection DataFlowIssue
-                return (J) tree;
-            }
-        };
-        return Preconditions.check(
-                new UsesMethod<>("java.lang.String *quals*(..)"),
-                replacementVisitor
         );
     }
 }

src/main/java/org/openrewrite/staticanalysis/EqualsAvoidsNullVisitor.java

@@ -49,15 +49,18 @@ public class EqualsAvoidsNullVisitor<P> extends JavaVisitor<P> {
     private static final String JAVA_LANG_STRING = "java.lang.String ";
     private static final MethodMatcher EQUALS = new MethodMatcher(JAVA_LANG_STRING + "equals(java.lang.Object)");
     private static final MethodMatcher EQUALS_IGNORE_CASE = new MethodMatcher(JAVA_LANG_STRING + "equalsIgnoreCase(java.lang.String)");
+    private static final MethodMatcher COMPARE_TO = new MethodMatcher(JAVA_LANG_STRING + "compareTo(java.lang.String)");
+    private static final MethodMatcher COMPARE_TO_IGNORE_CASE = new MethodMatcher(JAVA_LANG_STRING + "compareToIgnoreCase(java.lang.String)");
     private static final MethodMatcher CONTENT_EQUALS = new MethodMatcher(JAVA_LANG_STRING + "contentEquals(java.lang.CharSequence)");
 
     EqualsAvoidsNullStyle style;
 
     @Override
     public J visitMethodInvocation(J.MethodInvocation method, P p) {
         J.MethodInvocation m = (J.MethodInvocation) super.visitMethodInvocation(method, p);
+        boolean stringComparisonMethod = isStringComparisonMethod(m);
         if (m.getSelect() != null && !(m.getSelect() instanceof J.Literal) &&
-                isStringComparisonMethod(m) && hasCompatibleArgument(m)) {
+                stringComparisonMethod && hasCompatibleArgument(m)) {
 
             maybeHandleParentBinary(m);
 
@@ -90,7 +93,9 @@ private boolean hasCompatibleArgument(J.MethodInvocation m) {
     private boolean isStringComparisonMethod(J.MethodInvocation methodInvocation) {
         return EQUALS.matches(methodInvocation) ||
                 (!style.getIgnoreEqualsIgnoreCase() && EQUALS_IGNORE_CASE.matches(methodInvocation)) ||
-                CONTENT_EQUALS.matches(methodInvocation);
+                CONTENT_EQUALS.matches(methodInvocation) ||
+                COMPARE_TO.matches(methodInvocation) ||
+                COMPARE_TO_IGNORE_CASE.matches(methodInvocation);
     }
 
     private void maybeHandleParentBinary(J.MethodInvocation m) {

src/test/java/org/openrewrite/staticanalysis/EqualsAvoidsNullTest.java

@@ -64,6 +64,58 @@ public class A {
         );
     }
 
+    @DocumentExample
+    @Test
+    void invertConditional_compareTo() {
+        rewriteRun(
+          //language=java
+          java(
+            """
+              public class A {
+                  {
+                      String s = null;
+                      if(s.compareTo("test")) {}
+                  }
+              }
+              """,
+            """
+              public class A {
+                  {
+                      String s = null;
+                      if("test".compareTo(s)) {}
+                  }
+              }
+              """
+          )
+        );
+    }
+
+    @DocumentExample
+    @Test
+    void invertConditional_compareToIgnoreCase() {
+        rewriteRun(
+          //language=java
+          java(
+            """
+              public class A {
+                  {
+                      String s = null;
+                      if(s.compareToIgnoreCase("test")) {}
+                  }
+              }
+              """,
+            """
+              public class A {
+                  {
+                      String s = null;
+                      if("test".compareToIgnoreCase(s)) {}
+                  }
+              }
+              """
+          )
+        );
+    }
+
     @Test
     void removeUnnecessaryNullCheck() {
         rewriteRun(
@@ -447,6 +499,15 @@ public class A {
                       System.out.println(s.compareToIgnoreCase("test"));
                   }
               }
+              """,
+            """
+              public class A {
+                  {
+                      String s = null;
+                      System.out.println("test".compareTo(s));
+                      System.out.println("test".compareToIgnoreCase(s));
+                  }
+              }
               """
           )
         );