Revert "Refactored autoFormat and added MethodInvocation argument wrapping" (#6329)

This reverts commit 8bf9f21.

Author: Jenson3210

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

@@ -17,19 +17,18 @@
 
 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.*;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
 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<>();
@@ -58,9 +57,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) {
@@ -120,14 +119,6 @@ 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);
@@ -148,21 +139,4 @@ 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,8 +20,15 @@
 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
@@ -42,20 +49,39 @@ public J visit(@Nullable Tree tree, P p, Cursor cursor) {
                 (JavaSourceFile) tree :
                 cursor.firstEnclosingOrThrow(JavaSourceFile.class);
 
-        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 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());
+
         t = new RemoveTrailingWhitespaceVisitor<>(stopAfter).visit(t, p, cursor.fork());
-        t = 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);
+        t = new OmitParenthesesForLastArgumentLambdaVisitor<>(stopAfter).visitNonNull(t, p, cursor.fork());
+
+        return new MinimumViableSpacingVisitor<>(stopAfter).visitNonNull(t, p, cursor.fork());
     }
 }