Reordering Annotations (#544)

* Reordering annotations (aphabetically only for now) on method declarations.

* Apply suggestions from code review

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

* Suggested formatting changes

* Do not make order configurable; show test failures

* Keep prefix per annotation position

* Update examples.yml

* Sort annotations as a first show or results

* Reorder class annotations as well

* Also reorder field annotations

* Only reorder if there's more than one annotation

---------

Co-authored-by: Tim te Beek <[email protected]>
Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: Laurens Westerlaken <[email protected]>

Author: 4 people

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

@@ -50,8 +50,8 @@ public Duration getEstimatedEffortPerOccurrence() {
         return Duration.ofMinutes(1);
     }
 
-    @Override
     @NonNull
+    @Override
     public TreeVisitor<?, ExecutionContext> getVisitor() {
         return Preconditions.check(
                 Preconditions.and(

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

@@ -51,8 +51,8 @@ public Duration getEstimatedEffortPerOccurrence() {
     public TreeVisitor<?, ExecutionContext> getVisitor() {
         return new JavaVisitor<ExecutionContext>() {
 
-            @SuppressWarnings("ConstantConditions")
             @Override
+            @SuppressWarnings("ConstantConditions")
             public J visitUnary(J.Unary unary, ExecutionContext ctx) {
                 if (unary.getOperator() == J.Unary.Type.Not && unary.getExpression() instanceof J.Parentheses) {
                     J.Parentheses<?> expr = (J.Parentheses<?>) unary.getExpression();

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

@@ -715,8 +715,8 @@ public J.CompilationUnit visitCompilationUnit(J.CompilationUnit cu, J j) {
                 return cu;
             }
 
-            @SuppressWarnings("unchecked")
             @Override
+            @SuppressWarnings("unchecked")
             public <T extends J> J.ControlParentheses<T> visitControlParentheses(J.ControlParentheses<T> controlParens, J j) {
                 if (isEqual.get()) {
                     if (!(j instanceof J.ControlParentheses)) {
@@ -1426,8 +1426,8 @@ public J.ParameterizedType visitParameterizedType(J.ParameterizedType type, J j)
                 return type;
             }
 
-            @SuppressWarnings("unchecked")
             @Override
+            @SuppressWarnings("unchecked")
             public <T extends J> J.Parentheses<T> visitParentheses(J.Parentheses<T> parens, J j) {
                 if (isEqual.get()) {
                     if (!(j instanceof J.Parentheses)) {

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

@@ -64,8 +64,8 @@ public HideUtilityClassConstructorVisitor(HideUtilityClassConstructorStyle style
         this.utilityClassMatcher = new UtilityClassMatcher(style.getIgnoreIfAnnotatedBy());
     }
 
-    @SuppressWarnings("ConstantConditions")
     @Override
+    @SuppressWarnings("ConstantConditions")
     public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, P p) {
         J.ClassDeclaration c = super.visitClassDeclaration(classDecl, p);
         if (!EXCLUDE_CLASS_TYPES.contains(c.getKind()) && !c.hasModifier(J.Modifier.Type.Abstract) && utilityClassMatcher.isRefactorableUtilityClass(getCursor())) {

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

@@ -451,8 +451,8 @@ public J visitTypeCast(J.TypeCast typeCast, Integer executionContext) {
             return typeCast;
         }
 
-        @SuppressWarnings("NullableProblems")
         @Override
+        @SuppressWarnings("NullableProblems")
         public @Nullable J visitVariableDeclarations(J.VariableDeclarations multiVariable, Integer integer) {
             multiVariable = (J.VariableDeclarations) super.visitVariableDeclarations(multiVariable, integer);
             return replacements.processVariableDeclarations(multiVariable);

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

@@ -53,8 +53,8 @@ public Duration getEstimatedEffortPerOccurrence() {
         return Duration.ofMinutes(1);
     }
 
-    @SuppressWarnings("ConstantConditions")
     @Override
+    @SuppressWarnings("ConstantConditions")
     public TreeVisitor<?, ExecutionContext> getVisitor() {
         return new JavaIsoVisitor<ExecutionContext>() {
 

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

@@ -68,8 +68,8 @@ public RemoveUnusedLocalVariables(
         this.withSideEffects = withSideEffects;
     }
 
-    @InlineMe(replacement = "new RemoveUnusedLocalVariables(ignoreVariablesNamed, null, withSideEffects)")
     @Deprecated
+    @InlineMe(replacement = "new RemoveUnusedLocalVariables(ignoreVariablesNamed, null, withSideEffects)")
     public RemoveUnusedLocalVariables(
             String @Nullable [] ignoreVariablesNamed,
             @Nullable Boolean withSideEffects) {

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

@@ -96,8 +96,8 @@ public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, Ex
                 return super.visitClassDeclaration(classDecl, ctx);
             }
 
-            @SuppressWarnings("all")
             @Override
+            @SuppressWarnings("all")
             public J.VariableDeclarations.NamedVariable visitVariable(J.VariableDeclarations.NamedVariable variable, ExecutionContext ctx) {
                 Cursor parentScope = getCursorToParentScope(getCursor());
 

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

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (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://docs.moderne.io/licensing/moderne-source-available-license
+ * <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.staticanalysis;
+
+import lombok.EqualsAndHashCode;
+import lombok.Value;
+import org.openrewrite.ExecutionContext;
+import org.openrewrite.Recipe;
+import org.openrewrite.internal.ListUtils;
+import org.openrewrite.java.JavaIsoVisitor;
+import org.openrewrite.java.tree.J;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+
+@Value
+@EqualsAndHashCode(callSuper = false)
+public class ReorderAnnotations extends Recipe {
+
+    @Override
+    public String getDisplayName() {
+        return "Reorder annotations alphabetically";
+    }
+
+    @Override
+    public String getDescription() {
+        return "Consistently order annotations by comparing their simple name.";
+    }
+
+    private static final Comparator<J.Annotation> comparator = Comparator.comparing(J.Annotation::getSimpleName);
+
+    @Override
+    public JavaIsoVisitor<ExecutionContext> getVisitor() {
+        return new JavaIsoVisitor<ExecutionContext>() {
+            @Override
+            public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, ExecutionContext ctx) {
+                J.ClassDeclaration d = super.visitClassDeclaration(classDecl, ctx);
+                if (1 < d.getLeadingAnnotations().size()) {
+                    List<J.Annotation> sortedAnnotations = new ArrayList<>(d.getLeadingAnnotations());
+                    sortedAnnotations.sort(comparator);
+                    if (!sortedAnnotations.equals(d.getLeadingAnnotations())) {
+                        return d.withLeadingAnnotations(ListUtils.map(sortedAnnotations,
+                                (i, a) -> a.withPrefix(d.getLeadingAnnotations().get(i).getPrefix())));
+                    }
+                }
+                return d;
+            }
+
+            @Override
+            public J.VariableDeclarations visitVariableDeclarations(J.VariableDeclarations multiVariable, ExecutionContext ctx) {
+                J.VariableDeclarations d = super.visitVariableDeclarations(multiVariable, ctx);
+                if (1 < d.getLeadingAnnotations().size()) {
+                    List<J.Annotation> sortedAnnotations = new ArrayList<>(d.getLeadingAnnotations());
+                    sortedAnnotations.sort(comparator);
+                    if (!sortedAnnotations.equals(d.getLeadingAnnotations())) {
+                        return d.withLeadingAnnotations(ListUtils.map(sortedAnnotations,
+                                (i, a) -> a.withPrefix(d.getLeadingAnnotations().get(i).getPrefix())));
+                    }
+                }
+                return d;
+            }
+
+            @Override
+            public J.MethodDeclaration visitMethodDeclaration(J.MethodDeclaration method, ExecutionContext ctx) {
+                J.MethodDeclaration d = super.visitMethodDeclaration(method, ctx);
+                if (1 < d.getLeadingAnnotations().size()) {
+                    List<J.Annotation> sortedAnnotations = new ArrayList<>(d.getLeadingAnnotations());
+                    sortedAnnotations.sort(comparator);
+                    if (!sortedAnnotations.equals(d.getLeadingAnnotations())) {
+                        return d.withLeadingAnnotations(ListUtils.map(sortedAnnotations,
+                                (i, a) -> a.withPrefix(d.getLeadingAnnotations().get(i).getPrefix())));
+                    }
+                }
+                return d;
+            }
+        };
+    }
+}

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

@@ -86,8 +86,8 @@ public TreeVisitor<?, ExecutionContext> getVisitor() {
                 return super.visit(tree, ctx);
             }
 
-            @SuppressWarnings("UnusedAssignment")
             @Override
+            @SuppressWarnings("UnusedAssignment")
             public J visitClassDeclaration(J.ClassDeclaration classDecl, ExecutionContext ctx) {
                 if (classDecl.getType() == null) {
                     return classDecl;