Superclass modifying recipes

README.md

@@ -1,4 +1,5 @@
-<p align="center">
+                                                                                                    <p align="center">
+
   <a href="https://docs.openrewrite.org">
     <picture>
       <source media="(prefers-color-scheme: dark)" srcset="https://github.com/openrewrite/rewrite/raw/main/doc/logo-oss-dark.svg">
@@ -23,10 +24,13 @@
 
 ### What is this?
 
-This project implements a [Rewrite module](https://github.com/openrewrite/rewrite) that applies best practices and migrations for those projects using the [Dropwizard framework](https://dropwizard.io/).
+This project implements a [Rewrite module](https://github.com/openrewrite/rewrite) that applies best practices and
+migrations for those projects using the [Dropwizard framework](https://dropwizard.io/).
 
 Browse [a selection of recipes available through this module in the recipe catalog](https://docs.openrewrite.org/recipes/java/dropwizard).
 
 ## Contributing
 
-We appreciate all types of contributions. See the [contributing guide](https://github.com/openrewrite/.github/blob/main/CONTRIBUTING.md) for detailed instructions on how to get started.
+We appreciate all types of contributions. See
+the [contributing guide](https://github.com/openrewrite/.github/blob/main/CONTRIBUTING.md) for detailed instructions on
+how to get started.

build.gradle.kts

@@ -26,9 +26,11 @@ dependencies {
     testImplementation("org.openrewrite:rewrite-test")
 
     testRuntimeOnly("io.dropwizard.metrics:metrics-annotation:4.1.+")
+    testRuntimeOnly("io.dropwizard.metrics:metrics-healthchecks:4.1.+")
     testRuntimeOnly("org.springframework.boot:spring-boot-starter-actuator:2.5.+")
     testRuntimeOnly("javax.persistence:javax.persistence-api:2.2")
     testRuntimeOnly("org.projectlombok:lombok:1.18.+")
+    testRuntimeOnly("net.sourceforge.argparse4j:argparse4j:0.9.0")
 }
 
 recipeDependencies {

src/main/java/org/openrewrite/java/dropwizard/method/ChangeSuperType.java

@@ -0,0 +1,164 @@
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.openrewrite.java.dropwizard.method;
+
+
+import lombok.EqualsAndHashCode;
+import lombok.Value;
+import org.openrewrite.ExecutionContext;
+import org.openrewrite.Option;
+import org.openrewrite.Recipe;
+import org.openrewrite.TreeVisitor;
+import org.openrewrite.java.JavaIsoVisitor;
+import org.openrewrite.java.JavaParser;
+import org.openrewrite.java.JavaTemplate;
+import org.openrewrite.java.service.ImportService;
+import org.openrewrite.java.tree.Expression;
+import org.openrewrite.java.tree.J;
+import org.openrewrite.java.tree.JavaType;
+import org.openrewrite.java.tree.TypeTree;
+
+import static java.lang.Boolean.TRUE;
+import static org.openrewrite.java.tree.TypeUtils.asFullyQualified;
+import static org.openrewrite.java.tree.TypeUtils.isOfClassType;
+
+@Value
+@EqualsAndHashCode(callSuper = false)
+public class ChangeSuperType extends Recipe {
+
+    @Option(displayName = "Target class",
+            description = "The fully qualified name of the class whose superclass should be changed.",
+            example = "com.myorg.MyClass")
+    String targetClass;
+
+    @Option(displayName = "New superclass",
+            description = "The fully qualified name of the new superclass to extend or interface to implement.",
+            example = "com.myorg.NewSuperclass")
+    String newSuperclass;
+
+    @Option(displayName = "Keep type parameters",
+            description = "Whether to keep existing type parameters on the target class declaration.",
+            required = false)
+    Boolean keepTypeParameters;
+
+    @Option(displayName = "Convert to interface",
+            description = "If the new supertype is an interface, setting this to true converts 'extends' to 'implements'.",
+            required = false)
+    Boolean convertToInterface;
+
+    @Option(displayName = "Remove unnecessary overrides",
+            description = "Remove method Override annotations that override methods from the *old* superclass but are no longer necessary with the new superclass.",
+            required = false)
+    Boolean removeUnnecessaryOverrides;
+
+    @Override
+    public String getDisplayName() {
+        return "Change superclass";
+    }
+
+    @Override
+    public String getDescription() {
+        return "Changes the superclass of a specified class to a new superclass.";
+    }
+
+    @Override
+    public TreeVisitor<?, ExecutionContext> getVisitor() {
+        return new JavaIsoVisitor<ExecutionContext>() {
+            @Override
+            public J.ClassDeclaration visitClassDeclaration(
+                    J.ClassDeclaration classDecl, ExecutionContext ctx) {
+                J.ClassDeclaration cd = super.visitClassDeclaration(classDecl, ctx);
+
+                if (cd.getExtends() == null || !isOfClassType(cd.getExtends().getType(), targetClass)) {
+                    return cd;
+                }
+
+                String typeParams = getTypeParams(cd.getExtends());
+
+                maybeAddImport(newSuperclass);
+                maybeRemoveImport(targetClass);
+
+                JavaTemplate extendsTemplate =
+                        JavaTemplate.builder("#{}" + typeParams)
+                                .javaParser(JavaParser.fromJavaVersion().classpath(JavaParser.runtimeClasspath()))
+                                .imports(newSuperclass)
+                                .contextSensitive()
+                                .build();
+
+                JavaType.FullyQualified newSuperType;
+
+                if (TRUE.equals(convertToInterface)) {
+                    cd =
+                            extendsTemplate.apply(
+                                    updateCursor(cd), cd.getCoordinates().addImplementsClause(), newSuperclass);
+                    cd = cd.withExtends(null);
+                    TypeTree lastInterface = cd.getImplements().get(cd.getImplements().size() - 1);
+                    newSuperType = asFullyQualified(lastInterface.getType());
+                } else {
+                    cd =
+                            extendsTemplate.apply(
+                                    updateCursor(cd), cd.getCoordinates().replaceExtendsClause(), newSuperclass);
+                    newSuperType = asFullyQualified(cd.getExtends().getType());
+                }
+
+                // If changing to a class that was not compiled initially (eg. from a new library)
+                if (newSuperType == null) {
+                    newSuperType = asFullyQualified(JavaType.buildType(newSuperclass));
+                }
+
+                cd = cd.withType(((JavaType.Class) cd.getType()).withSupertype(newSuperType));
+
+                doAfterVisit(new UpdateMethodTypesVisitor(cd.getType()));
+
+                if (TRUE.equals(removeUnnecessaryOverrides)) {
+                    doAfterVisit(new RemoveUnnecessaryOverride.RemoveUnnecessaryOverrideVisitor());
+                }
+
+                doAfterVisit(new RemoveUnnecessarySuperCalls.RemoveUnnecessarySuperCallsVisitor());
+                doAfterVisit(service(ImportService.class).shortenFullyQualifiedTypeReferencesIn(cd));
+
+                return cd;
+            }
+
+            private String getTypeParams(TypeTree extendsType) {
+                StringBuilder typeParams = new StringBuilder();
+
+                if (TRUE.equals(keepTypeParameters) && extendsType instanceof J.ParameterizedType) {
+                    J.ParameterizedType parameterizedType = (J.ParameterizedType) extendsType;
+
+                    boolean hasParameters = false;
+                    typeParams.append('<');
+
+                    for (Expression typeParameter : parameterizedType.getTypeParameters()) {
+                        if (hasParameters) {
+                            typeParams.append(", ");
+                        }
+                        typeParams.append(typeParameter.toString());
+                        hasParameters = true;
+                    }
+
+                    if (hasParameters) {
+                        typeParams.append('>');
+                    } else {
+                        typeParams.setLength(0);
+                    }
+                }
+
+                return typeParams.toString();
+            }
+        };
+    }
+}

src/main/java/org/openrewrite/java/dropwizard/method/RemoveSuperTypeByType.java

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.openrewrite.java.dropwizard.method;
+
+import lombok.EqualsAndHashCode;
+import lombok.Value;
+import org.jspecify.annotations.Nullable;
+import org.openrewrite.*;
+import org.openrewrite.internal.ListUtils;
+import org.openrewrite.java.JavaIsoVisitor;
+import org.openrewrite.java.search.UsesType;
+import org.openrewrite.java.tree.J;
+import org.openrewrite.java.tree.JavaType;
+
+import static org.openrewrite.java.tree.TypeUtils.isOfClassType;
+
+@Value
+@EqualsAndHashCode(callSuper = false)
+public class RemoveSuperTypeByType extends Recipe {
+
+    @Option(displayName = "Fully qualified name of the superclass to remove",
+            description = "Supertypes that match this name are to be removed",
+            example = "io.dropwizard.Configuration")
+    String typeToRemove;
+
+    @Override
+    public String getDisplayName() {
+        return "Remove supertype by fully qualified name matches";
+    }
+
+    @Override
+    public String getDescription() {
+        return "Removes a specified type from class extends or implements clauses.";
+    }
+
+    @Override
+    public TreeVisitor<?, ExecutionContext> getVisitor() {
+        return Preconditions.check(
+                new UsesType<>(typeToRemove, false),
+                new JavaIsoVisitor<ExecutionContext>() {
+                    @Override
+                    public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, ExecutionContext ctx) {
+                        J.ClassDeclaration cd = super.visitClassDeclaration(classDecl, ctx);
+
+                        if (cd.getExtends() != null && shouldRemoveType(cd.getExtends().getType())) {
+                            cd = cd.withExtends(null);
+                        }
+                        if (cd.getImplements() != null) {
+                            cd = cd.withImplements(ListUtils.filter(cd.getImplements(), impl -> !shouldRemoveType(impl.getType())));
+                        }
+                        if (cd != classDecl) {
+                            JavaType.ShallowClass type = (JavaType.ShallowClass) JavaType.buildType("java.lang.Object");
+                            doAfterVisit(new UpdateMethodTypesVisitor(type));
+                            doAfterVisit(new RemoveUnnecessarySuperCalls.RemoveUnnecessarySuperCallsVisitor());
+                        }
+
+                        return cd;
+                    }
+
+                    private boolean shouldRemoveType(@Nullable JavaType type) {
+                        return isOfClassType(type, typeToRemove);
+                    }
+                }
+        );
+    }
+}

src/main/java/org/openrewrite/java/dropwizard/method/RemoveUnnecessaryOverride.java

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.openrewrite.java.dropwizard.method;
+
+import lombok.EqualsAndHashCode;
+import lombok.Value;
+import org.jspecify.annotations.Nullable;
+import org.openrewrite.*;
+import org.openrewrite.java.AnnotationMatcher;
+import org.openrewrite.java.JavaIsoVisitor;
+import org.openrewrite.java.service.AnnotationService;
+import org.openrewrite.java.tree.J;
+import org.openrewrite.java.tree.TypeUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Value
+@EqualsAndHashCode(callSuper = false)
+public class RemoveUnnecessaryOverride extends Recipe {
+
+    @Option(
+            displayName = "Ignore methods in anonymous classes",
+            description = "When enabled, ignore @Override annotations on methods in anonymous classes.",
+            required = false)
+    @Nullable
+    Boolean ignoreAnonymousClassMethods;
+
+    @Override
+    public String getDisplayName() {
+        return "Remove unnecessary `@Override` annotations";
+    }
+
+    @Override
+    public String getDescription() {
+        return "Removes `@Override` annotations from methods that don't actually override or implement any method. " +
+                "This helps maintain clean code by removing incorrect annotations that could be misleading.";
+    }
+
+    @Override
+    public TreeVisitor<?, ExecutionContext> getVisitor() {
+        return new RemoveUnnecessaryOverrideVisitor(ignoreAnonymousClassMethods);
+    }
+
+    public static class RemoveUnnecessaryOverrideVisitor extends JavaIsoVisitor<ExecutionContext> {
+        private final AnnotationMatcher OVERRIDE_ANNOTATION =
+                new AnnotationMatcher("@java.lang.Override");
+        private final Boolean ignoreAnonymousClassMethods;
+
+        public RemoveUnnecessaryOverrideVisitor(Boolean ignoreAnonymousClassMethods) {
+            this.ignoreAnonymousClassMethods = ignoreAnonymousClassMethods;
+        }
+
+        public RemoveUnnecessaryOverrideVisitor() {
+            this(false);
+        }
+
+        private Cursor getCursorToParentScope(Cursor cursor) {
+            return cursor.dropParentUntil(
+                    is -> is instanceof J.NewClass || is instanceof J.ClassDeclaration);
+        }
+
+        @Override
+        public J.MethodDeclaration visitMethodDeclaration(
+                J.MethodDeclaration method, ExecutionContext ctx) {
+            J.MethodDeclaration m = super.visitMethodDeclaration(method, ctx);
+
+            if (!m.isConstructor() &&
+                    service(AnnotationService.class).matches(getCursor(), OVERRIDE_ANNOTATION) &&
+                    !TypeUtils.isOverride(m.getMethodType()) &&
+                    !(Boolean.TRUE.equals(ignoreAnonymousClassMethods) &&
+                    getCursorToParentScope(getCursor()).getValue() instanceof J.NewClass)) {
+
+                // Find and remove the @Override annotation
+                List<J.Annotation> annotations = new ArrayList<>(m.getLeadingAnnotations());
+                annotations.removeIf(OVERRIDE_ANNOTATION::matches);
+
+                return maybeAutoFormat(method, m.withLeadingAnnotations(annotations), ctx);
+            }
+
+            return m;
+        }
+    }
+}