Minimize duplicate logic & traversal in NestedEnumsAreNotStatic

Closes #802

Author: timtebeek

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

@@ -22,13 +22,13 @@
 import org.openrewrite.internal.ListUtils;
 import org.openrewrite.java.JavaIsoVisitor;
 import org.openrewrite.java.tree.J;
-import org.openrewrite.marker.SearchResult;
 import org.openrewrite.staticanalysis.csharp.CSharpFileChecker;
 
 import java.time.Duration;
 import java.util.Set;
 
 import static java.util.Collections.singleton;
+import static org.openrewrite.java.tree.J.Modifier.Type.Static;
 
 public class NestedEnumsAreNotStatic extends Recipe {
     @Override
@@ -53,34 +53,27 @@ public Duration getEstimatedEffortPerOccurrence() {
 
     @Override
     public TreeVisitor<?, ExecutionContext> getVisitor() {
-        TreeVisitor<?, ExecutionContext> preconditions = Preconditions.and(new HasNestedEnum(), Preconditions.not(new CSharpFileChecker<>()));
-        return Preconditions.check(preconditions, new JavaIsoVisitor<ExecutionContext>() {
+        return Preconditions.check(Preconditions.not(new CSharpFileChecker<>()), new JavaIsoVisitor<ExecutionContext>() {
             @Override
             public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, ExecutionContext ctx) {
                 J.ClassDeclaration cd = super.visitClassDeclaration(classDecl, ctx);
-                if (cd.getKind() == J.ClassDeclaration.Kind.Type.Enum && cd.getType() != null && cd.getType().getOwningClass() != null) {
-                    if (J.Modifier.hasModifier(cd.getModifiers(), J.Modifier.Type.Static)) {
-                        cd = maybeAutoFormat(cd,
-                                cd.withModifiers(ListUtils.map(cd.getModifiers(), mod ->
-                                        mod.getType() == J.Modifier.Type.Static ? null : mod)),
-                                cd.getName(),
-                                ctx,
-                                getCursor().getParent());
-                    }
+                if (shouldRemoveStaticModifierFromClass(cd)) {
+                    return maybeAutoFormat(
+                            cd,
+                            cd.withModifiers(ListUtils.filter(cd.getModifiers(), mod -> mod.getType() != Static)),
+                            cd.getName(),
+                            ctx,
+                            getCursor().getParent());
                 }
                 return cd;
             }
-        });
-    }
 
-    private static class HasNestedEnum extends JavaIsoVisitor<ExecutionContext> {
-        @Override
-        public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, ExecutionContext ctx) {
-            J.ClassDeclaration cd = super.visitClassDeclaration(classDecl, ctx);
-            if (cd.getKind() == J.ClassDeclaration.Kind.Type.Enum && cd.getType() != null && cd.getType().getOwningClass() != null) {
-                cd = SearchResult.found(cd);
+            private boolean shouldRemoveStaticModifierFromClass(J.ClassDeclaration cd) {
+                return cd.getKind() == J.ClassDeclaration.Kind.Type.Enum &&
+                        cd.getType() != null &&
+                        cd.getType().getOwningClass() != null &&
+                        J.Modifier.hasModifier(cd.getModifiers(), Static);
             }
-            return cd;
-        }
+        });
     }
 }

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

@@ -125,4 +125,27 @@ public enum testEnum {
           )
         );
     }
+
+    @Test
+    void emptyInnerEnum() {
+        rewriteRun(
+          //language=java
+          java(
+            """
+              class Outer {
+                  static enum Inner {
+                      A, B, C
+                  }
+              }
+              """,
+            """
+              class Outer {
+                  enum Inner {
+                      A, B, C
+                  }
+              }
+              """
+          )
+        );
+    }
 }