Rewrite ConvertJulEntering

- Strip final from local variables
- Pass `UsesMethod` directly into Preconditions
- Create a MethodMatcher field used twice
- Inline `EnteringMethodVisitor`
- Match on `entering(String, String, ..)`
- Drop `@JsonPOJOBuilder`

Author: timtebeek

src/main/java/org/openrewrite/java/logging/log4j/ConvertJulEntering.java

@@ -15,38 +15,36 @@
  */
 package org.openrewrite.java.logging.log4j;
 
-import static java.util.Objects.requireNonNull;
-import static org.openrewrite.Tree.randomId;
-
-import com.fasterxml.jackson.databind.annotation.JsonPOJOBuilder;
-import java.util.ArrayList;
-import java.util.List;
 import lombok.EqualsAndHashCode;
 import lombok.Value;
-import org.openrewrite.*;
-import org.openrewrite.internal.lang.Nullable;
+import org.openrewrite.ExecutionContext;
+import org.openrewrite.Preconditions;
+import org.openrewrite.Recipe;
+import org.openrewrite.TreeVisitor;
 import org.openrewrite.java.JavaIsoVisitor;
-import org.openrewrite.java.JavaVisitor;
 import org.openrewrite.java.MethodMatcher;
 import org.openrewrite.java.search.UsesMethod;
-import org.openrewrite.java.tree.*;
-import org.openrewrite.java.tree.J.Identifier;
+import org.openrewrite.java.tree.Expression;
+import org.openrewrite.java.tree.J;
+import org.openrewrite.java.tree.JavaType;
 import org.openrewrite.java.tree.JavaType.Method;
 import org.openrewrite.java.tree.JavaType.Primitive;
+import org.openrewrite.java.tree.Space;
 import org.openrewrite.marker.Markers;
 
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.openrewrite.Tree.randomId;
+
 /**
  * This recipe rewrites JUL's {@link java.util.logging.Logger#entering} method.
  */
 @Value
 @EqualsAndHashCode(callSuper = true)
 public class ConvertJulEntering extends Recipe {
 
-    private static final String METHOD_PATTERN = "java.util.logging.Logger entering(..)";
-
-    @JsonPOJOBuilder(withPrefix = "")
-    public static class Builder {
-    }
+    private static final MethodMatcher METHOD_MATCHER = new MethodMatcher("java.util.logging.Logger entering(String, String, ..)", false);
 
     @Override
     public String getDisplayName() {
@@ -60,60 +58,39 @@ public String getDescription() {
 
     @Override
     public TreeVisitor<?, ExecutionContext> getVisitor() {
-        return Preconditions.check(new JavaVisitor<ExecutionContext>() {
-            @Override
-            public J visit(@Nullable Tree tree, ExecutionContext ctx) {
-                if (tree instanceof JavaSourceFile) {
-                    JavaSourceFile cu = (JavaSourceFile) requireNonNull(tree);
-                    return new UsesMethod<>(METHOD_PATTERN).visitNonNull(cu, ctx);
-                }
-                return super.visit(tree, ctx);
-            }
-        }, new EnteringMethodVisitor(new MethodMatcher(METHOD_PATTERN, false)));
-    }
-
-    private class EnteringMethodVisitor extends JavaIsoVisitor<ExecutionContext> {
-        private final MethodMatcher methodMatcher;
-
-        private EnteringMethodVisitor(MethodMatcher methodMatcher) {
-            this.methodMatcher = methodMatcher;
-        }
+        return Preconditions.check(new UsesMethod<>(METHOD_MATCHER), new JavaIsoVisitor<ExecutionContext>() {
+                    @Override
+                    public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) {
+                        J.MethodInvocation m = super.visitMethodInvocation(method, ctx);
+                        if (METHOD_MATCHER.matches(m)) {
+                            List<Expression> originalArgs = m.getArguments();
+                            int originalArgCount = originalArgs.size();
+                            if (3 < originalArgCount) {
+                                return m;
+                            }
+                            List<Expression> modifiedArgs = new ArrayList<>();
+                            List<JavaType> modifiedTypes = new ArrayList<>();
+                            modifiedArgs.add(buildNullString());
+                            modifiedTypes.add(Primitive.String);
+                            if (originalArgCount > 2) {
+                                JavaType varargType = JavaType.buildType("java.lang.Object[]");
+                                modifiedArgs.add(originalArgs.get(2));
+                                modifiedTypes.add(varargType);
+                            }
+                            Method mt = m.getMethodType().withParameterTypes(modifiedTypes);
+                            JavaType.FullyQualified dt = mt.getDeclaringType().withFullyQualifiedName("org.apache.logging.log4j.Logger");
+                            return m.withMethodType(mt)
+                                    .withName(m.getName().withSimpleName("traceEntry"))
+                                    .withArguments(modifiedArgs)
+                                    .withDeclaringType(dt);
+                        }
+                        return m;
+                    }
 
-        @Override
-        public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) {
-            return (J.MethodInvocation) visitMethodCall(super.visitMethodInvocation(method, ctx));
-        }
-
-        private J.MethodInvocation visitMethodCall(J.MethodInvocation m) {
-            if (methodMatcher.matches(m) && m.getMethodType() != null) {
-                final List<Expression> originalArgs = m.getArguments();
-                final int originalArgCount = originalArgs.size();
-                if (originalArgCount < 2 || 3 < originalArgCount) {
-                    throw new IllegalArgumentException("Unsupported Logger#entering method: " + m.getMethodType());
-                }
-                final List<Expression> modifiedArgs = new ArrayList<>();
-                final List<JavaType> modifiedTypes = new ArrayList<>();
-                final J.Literal nullString = buildNullString();
-                modifiedArgs.add(nullString);
-                modifiedTypes.add(Primitive.String);
-                if (originalArgCount > 2) {
-                    final JavaType varargType = JavaType.buildType("java.lang.Object[]");
-                    modifiedArgs.add(originalArgs.get(2));
-                    modifiedTypes.add(varargType);
+                    private J.Literal buildNullString() {
+                        return new J.Literal(randomId(), Space.EMPTY, Markers.EMPTY, null, "null", null, JavaType.Primitive.String);
+                    }
                 }
-                final Identifier traceEntry = m.getName().withSimpleName("traceEntry");
-                final Method mt = m.getMethodType().withParameterTypes(modifiedTypes);
-                return m.withMethodType(mt)
-                        .withName(traceEntry)
-                        .withArguments(modifiedArgs)
-                        .withDeclaringType(mt.getDeclaringType()
-                                .withFullyQualifiedName("org.apache.logging.log4j.Logger"));
-            }
-            return m;
-        }
-    }
-
-    private static J.Literal buildNullString() {
-        return new J.Literal(randomId(), Space.EMPTY, Markers.EMPTY, null, "null", null, JavaType.Primitive.String);
+        );
     }
 }