Refactored autoFormat and added MethodInvocation argument wrapping

* Refactor the Wrap-/ChopIfTooLong to use MinimizationVisitor to correctly count Method chain / Declaration length

* Added more coverage to the MinimizationVisitor and fixed a bug in TryResource visitor not returning updated prefixes and markers

* Added more tests for all intelliJ Spaces settings style coverage

* Last fixes

* Implement MethodCall Argument wrapping

* Added tests for Method Invocation Wrapping

* Split up the PR as it gets too big to review.

* Refactor formatting to do a single edit to the tree's prefix/suffixes if needed.

This allows for ChopIfTooLong and WrapIfLong to expect that parent objects will be formatted correctly during calculation of the wrapping phase.

This also allows for formatting to remove additional enters which are introduced between items that should not have an enter in between.

While this is in line with how auto-code-formatters behave (ignore if comment is present eg.), the impact downstream might be big in a lot of unit tests as they expect a certain style.

* Remove files

* private again

* remove changes to SpacesStyle

* eof

* reset test

* remove unused method

* revert test changes

* eof

* review comments auto-bot

* Fix 3 out of 4 failing tests

* Rework Groovy visitor and Kotlin visitor to same concepts

* bot comments

* bot comments

* fix case label suffix from disappearing

* fix case label suffix from disappearing

* fix case label suffix from disappearing + improved test coverage for 2 missed cases

* Groovy specific SpacesVisitor

* Fixed failing tests

* Fixed failing tests

* bot

* tests

* altered expectation to match intelliJ

* Review comment

* Remove unused package declarations

* Remove more unused package declarations

* Review comment

* Add Nullable to reduce warning count

* Reduce impact downstream compilation

---------

Co-authored-by: Tim te Beek <tim@moderne.io>

Author: Jenson3210

rewrite-core/src/main/java/org/openrewrite/style/StyleHelper.java

@@ -17,18 +17,19 @@
 
 import org.jspecify.annotations.Nullable;
 import org.openrewrite.SourceFile;
+import org.openrewrite.Tree;
 import org.openrewrite.internal.StringUtils;
 import org.openrewrite.marker.Markers;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
+import java.util.*;
 import java.util.function.Supplier;
 
+import static java.util.Collections.emptySet;
+import static java.util.stream.Collectors.joining;
+
 public class StyleHelper {
 
     private static final Set<Class<?>> primitiveWrapperClasses = new HashSet<>();
@@ -57,9 +58,9 @@ private static boolean isEnum(Object value) {
     /**
      * Copies all non-null properties from right into left, recursively. Assumes use of @With from project lombok.
      *
-     * @param left left object, target of merged properties
+     * @param left  left object, target of merged properties
      * @param right right object, source of merged properties
-     * @param <T> Type of left and right
+     * @param <T>   Type of left and right
      * @return left object with merged properties from right
      */
     public static <T> T merge(T left, T right) {
@@ -119,6 +120,14 @@ public static <T extends SourceFile> T addStyleMarker(T t, List<NamedStyles> sty
         return t;
     }
 
+    public static <S extends Style> S getStyle(Class<S> styleClass, List<NamedStyles> styles, Supplier<S> defaultStyle) {
+        S style = NamedStyles.merge(styleClass, styles);
+        if (style != null) {
+            return StyleHelper.merge(defaultStyle.get(), style);
+        }
+        return defaultStyle.get();
+    }
+
     public static <S extends Style, T extends SourceFile> @Nullable S getStyle(Class<S> styleClass, List<NamedStyles> styles, T sourceFile) {
         S projectStyle = Style.from(styleClass, sourceFile);
         S style = NamedStyles.merge(styleClass, styles);
@@ -139,4 +148,21 @@ public static <S extends Style, T extends SourceFile> S getStyle(Class<S> styleC
         }
         return projectStyle;
     }
+
+    public static <S extends Style> @Nullable S getStyle(Class<S> styleClass, List<NamedStyles> styles) {
+        S style = NamedStyles.merge(styleClass, styles);
+        if (style != null) {
+            return (S) style.applyDefaults();
+        }
+        return null;
+    }
+
+    public static NamedStyles fromStyles(Style... styles) {
+        return new NamedStyles(Tree.randomId(),
+                "MergedStyles",
+                "Merged styles",
+                "Merged styles from " + Arrays.stream(styles).map(Object::getClass).map(Class::getSimpleName).collect(joining(", ")),
+                emptySet(),
+                Arrays.asList(styles));
+    }
 }

rewrite-groovy/src/main/java/org/openrewrite/groovy/format/AutoFormatVisitor.java

@@ -20,15 +20,8 @@
 import org.openrewrite.Tree;
 import org.openrewrite.groovy.GroovyIsoVisitor;
 import org.openrewrite.java.format.*;
-import org.openrewrite.java.style.*;
 import org.openrewrite.java.tree.J;
 import org.openrewrite.java.tree.JavaSourceFile;
-import org.openrewrite.style.GeneralFormatStyle;
-import org.openrewrite.style.Style;
-
-import java.util.Optional;
-
-import static org.openrewrite.java.format.AutodetectGeneralFormatStyle.autodetectGeneralFormatStyle;
 
 public class AutoFormatVisitor<P> extends GroovyIsoVisitor<P> {
     @Nullable
@@ -49,39 +42,20 @@ public J visit(@Nullable Tree tree, P p, Cursor cursor) {
                 (JavaSourceFile) tree :
                 cursor.firstEnclosingOrThrow(JavaSourceFile.class);
 
-        J t = new NormalizeFormatVisitor<>(stopAfter).visit(tree, p, cursor.fork());
-
-        t = new BlankLinesVisitor<>(Style.from(BlankLinesStyle.class, cu, IntelliJ::blankLines), stopAfter)
-                .visit(t, p, cursor.fork());
-
-        WrappingAndBracesStyle wrappingAndBracesStyle = Style.from(WrappingAndBracesStyle.class, cu, IntelliJ::wrappingAndBraces);
-        TabsAndIndentsStyle tabsAndIndentsStyle = Style.from(TabsAndIndentsStyle.class, cu, IntelliJ::tabsAndIndents);
-        SpacesStyle spacesStyle = Style.from(SpacesStyle.class, cu, IntelliJ::spaces);
-
-        t = new WrappingAndBracesVisitor<>(spacesStyle, wrappingAndBracesStyle, stopAfter)
-                .visit(t, p, cursor.fork());
-
-        t = new SpacesVisitor<>(
-                spacesStyle,
-                Style.from(EmptyForInitializerPadStyle.class, cu),
-                Style.from(EmptyForIteratorPadStyle.class, cu),
-                stopAfter
-        ).visit(t, p, cursor.fork());
-
-        t = new NormalizeTabsOrSpacesVisitor<>(tabsAndIndentsStyle, stopAfter)
-                .visit(t, p, cursor.fork());
-
-        t = new TabsAndIndentsVisitor<>(tabsAndIndentsStyle, spacesStyle, wrappingAndBracesStyle, stopAfter)
-                .visit(t, p, cursor.fork());
-
-        t = new NormalizeLineBreaksVisitor<>(Optional.ofNullable(Style.from(GeneralFormatStyle.class, cu))
-                .orElse(autodetectGeneralFormatStyle(cu)), stopAfter)
-                .visit(t, p, cursor.fork());
+        tree = new OmitParenthesesForLastArgumentLambdaVisitor<>(stopAfter).visitNonNull(tree, p, cursor.fork());
 
+        // Format the tree in multiple passes to visitors that "enlarge" the space (Eg. first spaces, then wrapping, then indents...)
+        J t = new NormalizeFormatVisitor<>(stopAfter).visit(tree, p, cursor.fork());
+        t = new BlankLinesVisitor<>(cu, stopAfter).visit(t, p, cursor.fork());
+        t = new SpacesVisitor<>(cu, false, stopAfter).visit(t, p, cursor.fork());
+        t = new WrappingAndBracesVisitor<>(cu, stopAfter).visit(t, p, cursor.fork());
+        t = new NormalizeTabsOrSpacesVisitor<>(cu, stopAfter).visit(t, p, cursor.fork());
+        t = new TabsAndIndentsVisitor<>(cu, stopAfter).visit(t, p, cursor.fork());
+        t = new NormalizeLineBreaksVisitor<>(cu, stopAfter).visit(t, p, cursor.fork());
         t = new RemoveTrailingWhitespaceVisitor<>(stopAfter).visit(t, p, cursor.fork());
+        t = new MinimumViableSpacingVisitor<>(stopAfter).visitNonNull(t, p, cursor.fork());
 
-        t = new OmitParenthesesForLastArgumentLambdaVisitor<>(stopAfter).visitNonNull(t, p, cursor.fork());
-
-        return new MinimumViableSpacingVisitor<>(stopAfter).visitNonNull(t, p, cursor.fork());
+        // With the updated tree, overwrite the original space with the newly computed space
+        return new MergeSpacesVisitor().visit(tree, t);
     }
 }