Add parentheses in CompareEnumsWithEqualityOperator as needed (#658)

* Add parentheses in `CompareEnumsWithEqualityOperator` as needed

- Fixes #657

* Add test for #3

* Reduce code down to bare minimum to pass tests

Author: timtebeek

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

@@ -58,14 +58,25 @@ public J visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx)
                 if (enumEquals.matches(m) && m.getSelect() != null) {
                     Cursor parent = getCursor().dropParentUntil(is -> is instanceof J.Unary || is instanceof J.Block || is instanceof J.Binary || is instanceof J.Ternary || is instanceof J.Lambda);
                     boolean isNot = parent.getValue() instanceof J.Unary && ((J.Unary) parent.getValue()).getOperator() == J.Unary.Type.Not;
+                    boolean needsParentheses = false;
                     if (isNot) {
                         parent.putMessage("REMOVE_UNARY_NOT", parent.getValue());
+                    } else if (parent.getValue() instanceof J.Binary) {
+                        // Check if the method invocation is part of a binary expression with equality/inequality operators
+                        // In such cases, we need parentheses to avoid chained equality operators
+                        J.Binary binary = parent.getValue();
+                        J.Binary.Type op = binary.getOperator();
+                        // Only add parentheses when the parent binary uses equality/inequality operators
+                        needsParentheses = op == J.Binary.Type.Equal || op == J.Binary.Type.NotEqual;
                     }
+
                     String code = "#{any()} " + (isNot ? "!=" : "==") + " #{any()}";
-                    return autoFormat(JavaTemplate
-                            .builder(code)
-                            .build()
-                            .apply(updateCursor(m), m.getCoordinates().replace(), m.getSelect(), m.getArguments().get(0)), ctx);
+                    return JavaTemplate.apply(
+                            needsParentheses ? "(" + code + ")" : code,
+                            updateCursor(m),
+                            m.getCoordinates().replace(),
+                            m.getSelect(),
+                            m.getArguments().get(0));
                 }
                 return m;
             }

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

@@ -400,4 +400,65 @@ void method(A value1, A value2, A value3, A value4) {
           )
         );
     }
+
+    @Issue("https://github.com/openrewrite/rewrite-static-analysis/issues/657")
+    @Test
+    void parenthesesRequiredInBinaryExpression() {
+        rewriteRun(
+          //language=java
+          java(
+            """
+              import java.time.DayOfWeek;
+              class Test {
+                  void method() {
+                      boolean foo = true == DayOfWeek.MONDAY.equals(DayOfWeek.TUESDAY);
+                  }
+              }
+              """,
+            """
+              import java.time.DayOfWeek;
+              class Test {
+                  void method() {
+                      boolean foo = true == (DayOfWeek.MONDAY == DayOfWeek.TUESDAY);
+                  }
+              }
+              """
+          )
+        );
+    }
+
+    @Issue("https://github.com/openrewrite/rewrite-static-analysis/issues/3")
+    @Test
+    void negatedEnumComparisonInComplexBooleanExpression() {
+        rewriteRun(
+          enumA,
+          //language=java
+          java(
+            """
+              import a.A;
+              class Test {
+                  boolean hasField(String field) {
+                      return true;
+                  }
+                  void method(A field, Object entry) {
+                      if ((!A.FOO.equals(field) && !A.BAR.equals(field)) || !hasField("test")) {
+                      }
+                  }
+              }
+              """,
+            """
+              import a.A;
+              class Test {
+                  boolean hasField(String field) {
+                      return true;
+                  }
+                  void method(A field, Object entry) {
+                      if ((A.FOO != field && A.BAR != field) || !hasField("test")) {
+                      }
+                  }
+              }
+              """
+          )
+        );
+    }
 }