@openrewrite/rewrite 8.69.0 → 8.69.1

package/src/javascript/{format.ts → format/format.ts}

@@ -13,19 +13,23 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {JS} from "./tree";
-import {JavaScriptVisitor} from "./visitor";
-import {Comment, J, lastWhitespace, replaceLastWhitespace, Statement} from "../java";
+import {JS} from "../tree";
+import {JavaScriptVisitor} from "../visitor";
+import {Comment, J, lastWhitespace, replaceLastWhitespace, Statement} from "../../java";
 import {Draft, produce} from "immer";
-import {Cursor, isScope, Tree} from "../tree";
-import {BlankLinesStyle, getStyle, SpacesStyle, StyleKind, TabsAndIndentsStyle, WrappingAndBracesStyle} from "./style";
-import {NamedStyles} from "../style";
-import {produceAsync} from "../visitor";
-import {findMarker} from "../markers";
-import {Generator} from "./markers";
+import {Cursor, isScope, Tree} from "../../tree";
+import {BlankLinesStyle, getStyle, SpacesStyle, StyleKind, TabsAndIndentsStyle, WrappingAndBracesStyle} from "../style";
+import {NamedStyles} from "../../style";
+import {produceAsync} from "../../visitor";
+import {Generator} from "../markers";
 import {TabsAndIndentsVisitor} from "./tabs-and-indents-visitor";
+import {NormalizeWhitespaceVisitor} from "./normalize-whitespace-visitor";
+import {MinimumViableSpacingVisitor} from "./minimum-viable-spacing-visitor";
+import {applyPrettierFormatting, getPrettierStyle} from "./prettier-format";
 
 export {TabsAndIndentsVisitor} from "./tabs-and-indents-visitor";
+export {NormalizeWhitespaceVisitor} from "./normalize-whitespace-visitor";
+export {MinimumViableSpacingVisitor} from "./minimum-viable-spacing-visitor";
 
 export const maybeAutoFormat = async <J2 extends J, P>(before: J2, after: J2, p: P, stopAfter?: J, parent?: Cursor): Promise<J2> => {
     if (before !== after) {
@@ -34,7 +38,13 @@ export const maybeAutoFormat = async <J2 extends J, P>(before: J2, after: J2, p:
     return after;
 }
 
-export const autoFormat = async <J2 extends J, P>(j: J2, p: P, stopAfter?: J, parent?: Cursor, styles?: NamedStyles[]): Promise<J2> =>
+export const autoFormat = async <J2 extends J, P>(
+    j: J2,
+    p: P,
+    stopAfter?: J,
+    parent?: Cursor,
+    styles?: NamedStyles<string>[]
+): Promise<J2> =>
     (await new AutoformatVisitor(stopAfter, styles).visit(j, p, parent) as J2);
 
 /**
@@ -44,16 +54,26 @@ export const autoFormat = async <J2 extends J, P>(j: J2, p: P, stopAfter?: J, pa
  * 1. Styles passed to the constructor
  * 2. Styles from source file markers (NamedStyles)
  * 3. IntelliJ defaults
+ *
+ * When a PrettierStyle is present (either in the styles array or as a marker on the source file),
+ * Prettier is used for formatting. Otherwise, built-in formatting visitors are used.
  */
 export class AutoformatVisitor<P> extends JavaScriptVisitor<P> {
-    private readonly styles?: NamedStyles[];
+    private readonly styles?: NamedStyles<string>[];
 
-    constructor(private stopAfter?: Tree, styles?: NamedStyles[]) {
+    constructor(private stopAfter?: Tree, styles?: NamedStyles<string>[]) {
         super();
         this.styles = styles;
     }
 
     async visit<R extends J>(tree: Tree, p: P, cursor?: Cursor): Promise<R | undefined> {
+        // Check for PrettierStyle in styles array or as marker on source file
+        // If found, delegate entirely to Prettier (skip other formatting visitors)
+        const prettierStyle = getPrettierStyle(tree, cursor, this.styles);
+        if (prettierStyle) {
+            return applyPrettierFormatting(tree as R, prettierStyle, p, cursor, this.stopAfter);
+        }
+
         const visitors = [
             new NormalizeWhitespaceVisitor(this.stopAfter),
             new MinimumViableSpacingVisitor(this.stopAfter),
@@ -75,29 +95,6 @@ export class AutoformatVisitor<P> extends JavaScriptVisitor<P> {
     }
 }
 
-export class NormalizeWhitespaceVisitor<P> extends JavaScriptVisitor<P> {
-    // called NormalizeFormat in Java
-    // Ensures that whitespace is on the outermost AST element possible
-
-    constructor(private stopAfter?: Tree) {
-        super();
-    }
-
-    override async visit<R extends J>(tree: Tree, p: P, parent?: Cursor): Promise<R | undefined> {
-        if (this.cursor?.getNearestMessage("stop") != null) {
-            return tree as R;
-        }
-        return super.visit(tree, p, parent);
-    }
-
-    override async postVisit(tree: J, p: P): Promise<J | undefined> {
-        if (this.stopAfter != null && isScope(this.stopAfter, tree)) {
-            this.cursor?.root.messages.set("stop", true);
-        }
-        return super.postVisit(tree, p);
-    }
-}
-
 export class SpacesVisitor<P> extends JavaScriptVisitor<P> {
     constructor(private style: SpacesStyle, private stopAfter?: Tree) {
         super();
@@ -580,6 +577,30 @@ export class SpacesVisitor<P> extends JavaScriptVisitor<P> {
         });
     }
 
+    protected async visitTypeParameter(typeParam: J.TypeParameter, p: P): Promise<J | undefined> {
+        const ret = await super.visitTypeParameter(typeParam, p) as J.TypeParameter;
+        return produce(ret, draft => {
+            if (draft.bounds && draft.bounds.elements.length >= 2) {
+                const constraintType = draft.bounds.elements[0];
+                const defaultType = draft.bounds.elements[1];
+                const hasConstraint = constraintType.element.kind !== J.Kind.Empty;
+                const hasDefault = defaultType.element.kind !== J.Kind.Empty;
+
+                if (hasConstraint) {
+                    // Space before '=' for default type (in the `after` of constraint type)
+                    if (hasDefault && !constraintType.after.whitespace.includes("\n")) {
+                        constraintType.after.whitespace = this.style.aroundOperators.assignment ? " " : "";
+                    }
+                } else if (hasDefault) {
+                    // No constraint, just default: space before '=' is in bounds.before
+                    if (!draft.bounds.before.whitespace.includes("\n")) {
+                        draft.bounds.before.whitespace = this.style.aroundOperators.assignment ? " " : "";
+                    }
+                }
+            }
+        });
+    }
+
     private async spaceAfterRightPadded<T extends J>(right: J.RightPadded<T>, spaceAfter: boolean): Promise<J.RightPadded<T>> {
         if (right.after.comments.length > 0) {
             // Perform the space rule for the suffix of the last comment only. Same as IntelliJ.
@@ -905,238 +926,6 @@ export class WrappingAndBracesVisitor<P> extends JavaScriptVisitor<P> {
     }
 }
 
-
-export class MinimumViableSpacingVisitor<P> extends JavaScriptVisitor<P> {
-    constructor(private stopAfter?: Tree) {
-        super();
-    }
-
-    override async visit<R extends J>(tree: Tree, p: P, parent?: Cursor): Promise<R | undefined> {
-        if (this.cursor?.getNearestMessage("stop") != null) {
-            return tree as R;
-        }
-        return super.visit(tree, p, parent);
-    }
-
-    override async postVisit(tree: J, p: P): Promise<J | undefined> {
-        if (this.stopAfter != null && isScope(this.stopAfter, tree)) {
-            this.cursor?.root.messages.set("stop", true);
-        }
-        return super.postVisit(tree, p);
-    }
-
-    protected async visitAwait(await_: JS.Await, p: P): Promise<J | undefined> {
-        const ret = await super.visitAwait(await_, p) as JS.Await;
-        return produce(ret, draft => {
-            this.ensureSpace(draft.expression.prefix)
-        });
-    }
-
-    protected async visitClassDeclaration(classDecl: J.ClassDeclaration, p: P): Promise<J | undefined> {
-        let c = await super.visitClassDeclaration(classDecl, p) as J.ClassDeclaration;
-        let first = c.leadingAnnotations.length === 0;
-
-        if (c.modifiers.length > 0) {
-            if (!first && c.modifiers[0].prefix.whitespace === "") {
-                c = produce(c, draft => {
-                    this.ensureSpace(draft.modifiers[0].prefix);
-                });
-            }
-            c = produce(c, draft => {
-                for (let i = 1; i < draft.modifiers.length; i++) {
-                    this.ensureSpace(draft.modifiers[i].prefix);
-                }
-            });
-            first = false;
-        }
-
-        if (c.classKind.prefix.whitespace === "" && !first) {
-            c = produce(c, draft => {
-                this.ensureSpace(draft.classKind.prefix);
-            });
-            first = false;
-        }
-
-        // anonymous classes have an empty name
-        if (c.name.simpleName !== "") {
-            c = produce(c, draft => {
-                this.ensureSpace(draft.name.prefix);
-            });
-        }
-
-        // Note: typeParameters should NOT have space before them - they immediately follow the class name
-        // e.g., "class DataTable<Row>" not "class DataTable <Row>"
-
-        if (c.extends && c.extends.before.whitespace === "") {
-            c = produce(c, draft => {
-                this.ensureSpace(draft.extends!.before);
-            });
-        }
-
-        if (c.implements && c.implements.before.whitespace === "") {
-            c = produce(c, draft => {
-                this.ensureSpace(draft.implements!.before);
-                if (draft.implements != undefined && draft.implements.elements.length > 0) {
-                    this.ensureSpace(draft.implements.elements[0].element.prefix);
-                }
-            });
-        }
-
-        c = produce(c, draft => {
-            draft.body.prefix.whitespace = "";
-        });
-
-        return c;
-    }
-
-    protected async visitMethodDeclaration(method: J.MethodDeclaration, p: P): Promise<J | undefined> {
-        let m = await super.visitMethodDeclaration(method, p) as J.MethodDeclaration;
-        let first = m.leadingAnnotations.length === 0;
-
-        if (m.modifiers.length > 0) {
-            if (!first && m.modifiers[0].prefix.whitespace === "") {
-                m = produce(m, draft => {
-                    this.ensureSpace(draft.modifiers[0].prefix);
-                });
-            }
-            m = produce(m, draft => {
-                for (let i = 1; i < draft.modifiers.length; i++) {
-                    this.ensureSpace(draft.modifiers[i].prefix);
-                }
-            });
-            first = false;
-        }
-
-        // FunctionDeclaration marker check must come AFTER modifiers processing
-        // to avoid adding unwanted space before the first modifier (e.g., 'async')
-        if (findMarker(method, JS.Markers.FunctionDeclaration)) {
-            first = false;
-        }
-
-        if (!first && m.name.prefix.whitespace === "") {
-            m = produce(m, draft => {
-                this.ensureSpace(draft.name.prefix);
-            });
-        }
-
-        if (m.throws && m.throws.before.whitespace === "") {
-            m = produce(m, draft => {
-                this.ensureSpace(draft.throws!.before);
-            });
-        }
-
-        return m;
-    }
-
-    protected async visitNamespaceDeclaration(namespaceDeclaration: JS.NamespaceDeclaration, p: P): Promise<J | undefined> {
-        const ret = await super.visitNamespaceDeclaration(namespaceDeclaration, p) as JS.NamespaceDeclaration;
-        return produce(ret, draft => {
-            if (draft.modifiers.length > 0) {
-                draft.keywordType.before.whitespace=" ";
-            }
-            this.ensureSpace(draft.name.element.prefix);
-        });
-    }
-
-    protected async visitNewClass(newClass: J.NewClass, p: P): Promise<J | undefined> {
-        const ret = await super.visitNewClass(newClass, p) as J.NewClass;
-        return produce(ret, draft => {
-            if (draft.class) {
-                if (draft.class.kind == J.Kind.Identifier) {
-                    this.ensureSpace((draft.class as Draft<J.Identifier>).prefix);
-                }
-            }
-        });
-    }
-
-    protected async visitReturn(returnNode: J.Return, p: P): Promise<J | undefined> {
-        const r = await super.visitReturn(returnNode, p) as J.Return;
-        if (r.expression && r.expression.prefix.whitespace === "" &&
-            !r.markers.markers.find(m => m.id === "org.openrewrite.java.marker.ImplicitReturn")) {
-            return produce(r, draft => {
-                this.ensureSpace(draft.expression!.prefix);
-            });
-        }
-        return r;
-    }
-
-    protected async visitThrow(thrown: J.Throw, p: P): Promise<J | undefined> {
-        const ret = await super.visitThrow(thrown, p) as J.Throw;
-        return ret && produce(ret, draft => {
-           this.ensureSpace(draft.exception.prefix);
-        });
-    }
-
-    protected async visitTypeDeclaration(typeDeclaration: JS.TypeDeclaration, p: P): Promise<J | undefined> {
-        const ret = await super.visitTypeDeclaration(typeDeclaration, p) as JS.TypeDeclaration;
-        return produce(ret, draft => {
-            if (draft.modifiers.length > 0) {
-                this.ensureSpace(draft.name.before);
-            }
-            this.ensureSpace(draft.name.element.prefix);
-        });
-    }
-
-    protected async visitTypeOf(typeOf: JS.TypeOf, p: P): Promise<J | undefined> {
-        const ret = await super.visitTypeOf(typeOf, p) as JS.TypeOf;
-        return produce(ret, draft => {
-            this.ensureSpace(draft.expression.prefix);
-        });
-    }
-
-    protected async visitTypeParameter(typeParam: J.TypeParameter, p: P): Promise<J | undefined> {
-        const ret = await super.visitTypeParameter(typeParam, p) as J.TypeParameter;
-        return produce(ret, draft => {
-            if (draft.bounds && draft.bounds.elements.length > 0) {
-                this.ensureSpace(draft.bounds.before);
-                this.ensureSpace(draft.bounds.elements[0].element.prefix);
-            }
-        });
-    }
-
-    protected async visitVariableDeclarations(v: J.VariableDeclarations, p: P): Promise<J | undefined> {
-        let ret = await super.visitVariableDeclarations(v, p) as J.VariableDeclarations;
-        let first = ret.leadingAnnotations.length === 0;
-
-        if (first && ret.modifiers.length > 0) {
-            ret = produce(ret, draft => {
-                for (let i = 1; i < draft.modifiers.length; i++) {
-                    this.ensureSpace(draft.modifiers[i].prefix);
-                }
-            });
-            first = false;
-        }
-
-        if (!first) {
-            ret = produce(ret, draft => {
-                this.ensureSpace(draft.variables[0].element.prefix);
-            });
-        }
-
-        return ret;
-    }
-
-
-    protected async visitCase(caseNode: J.Case, p: P): Promise<J | undefined> {
-        const c = await super.visitCase(caseNode, p) as J.Case;
-
-        if (c.guard && c.caseLabels.elements.length > 0 && c.caseLabels.elements[c.caseLabels.elements.length - 1].after.whitespace === "") {
-            return produce(c, draft => {
-                const last = draft.caseLabels.elements.length - 1;
-                draft.caseLabels.elements[last].after.whitespace = " ";
-            });
-        }
-
-        return c;
-    }
-
-    private ensureSpace(spaceDraft: Draft<J.Space>) {
-        if (spaceDraft.whitespace.length === 0 && spaceDraft.comments.length === 0) {
-            spaceDraft.whitespace = " ";
-        }
-    }
-}
-
 export class BlankLinesVisitor<P> extends JavaScriptVisitor<P> {
     constructor(private readonly style: BlankLinesStyle, private stopAfter?: Tree) {
         super();
@@ -1339,3 +1128,6 @@ export class BlankLinesVisitor<P> extends JavaScriptVisitor<P> {
         return super.postVisit(tree, p);
     }
 }
+
+// Re-export prettier formatting utilities
+export {prettierFormat} from "./prettier-format";

package/src/javascript/format/index.ts

@@ -0,0 +1,21 @@
+/*
+ * 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.
+ */
+
+// Main formatting entry point (includes AutoformatVisitor, autoFormat, maybeAutoFormat, and individual visitors)
+export * from "./format";
+
+// Prettier formatting (public API)
+export {prettierFormat} from "./prettier-format";

package/src/javascript/format/minimum-viable-spacing-visitor.ts

@@ -0,0 +1,256 @@
+/*
+ * 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.
+ */
+import {JavaScriptVisitor} from "../visitor";
+import {J} from "../../java";
+import {Cursor, isScope, Tree} from "../../tree";
+import {JS} from "../tree";
+import {Draft, produce} from "immer";
+import {findMarker} from "../../markers";
+
+/**
+ * Ensures minimum viable spacing between AST elements.
+ * Adds required spaces where they are missing (e.g., after keywords).
+ */
+export class MinimumViableSpacingVisitor<P> extends JavaScriptVisitor<P> {
+    constructor(private stopAfter?: Tree) {
+        super();
+    }
+
+    override async visit<R extends J>(tree: Tree, p: P, parent?: Cursor): Promise<R | undefined> {
+        if (this.cursor?.getNearestMessage("stop") != null) {
+            return tree as R;
+        }
+        return super.visit(tree, p, parent);
+    }
+
+    override async postVisit(tree: J, p: P): Promise<J | undefined> {
+        if (this.stopAfter != null && isScope(this.stopAfter, tree)) {
+            this.cursor?.root.messages.set("stop", true);
+        }
+        return super.postVisit(tree, p);
+    }
+
+    protected async visitAwait(await_: JS.Await, p: P): Promise<J | undefined> {
+        const ret = await super.visitAwait(await_, p) as JS.Await;
+        return produce(ret, draft => {
+            this.ensureSpace(draft.expression.prefix)
+        });
+    }
+
+    protected async visitClassDeclaration(classDecl: J.ClassDeclaration, p: P): Promise<J | undefined> {
+        let c = await super.visitClassDeclaration(classDecl, p) as J.ClassDeclaration;
+        let first = c.leadingAnnotations.length === 0;
+
+        if (c.modifiers.length > 0) {
+            if (!first && c.modifiers[0].prefix.whitespace === "") {
+                c = produce(c, draft => {
+                    this.ensureSpace(draft.modifiers[0].prefix);
+                });
+            }
+            c = produce(c, draft => {
+                for (let i = 1; i < draft.modifiers.length; i++) {
+                    this.ensureSpace(draft.modifiers[i].prefix);
+                }
+            });
+            first = false;
+        }
+
+        if (c.classKind.prefix.whitespace === "" && !first) {
+            c = produce(c, draft => {
+                this.ensureSpace(draft.classKind.prefix);
+            });
+            first = false;
+        }
+
+        // anonymous classes have an empty name
+        if (c.name.simpleName !== "") {
+            c = produce(c, draft => {
+                this.ensureSpace(draft.name.prefix);
+            });
+        }
+
+        // Note: typeParameters should NOT have space before them - they immediately follow the class name
+        // e.g., "class DataTable<Row>" not "class DataTable <Row>"
+
+        if (c.extends && c.extends.before.whitespace === "") {
+            c = produce(c, draft => {
+                this.ensureSpace(draft.extends!.before);
+            });
+        }
+
+        if (c.implements && c.implements.before.whitespace === "") {
+            c = produce(c, draft => {
+                this.ensureSpace(draft.implements!.before);
+                if (draft.implements != undefined && draft.implements.elements.length > 0) {
+                    this.ensureSpace(draft.implements.elements[0].element.prefix);
+                }
+            });
+        }
+
+        c = produce(c, draft => {
+            draft.body.prefix.whitespace = "";
+        });
+
+        return c;
+    }
+
+    protected async visitMethodDeclaration(method: J.MethodDeclaration, p: P): Promise<J | undefined> {
+        let m = await super.visitMethodDeclaration(method, p) as J.MethodDeclaration;
+        let first = m.leadingAnnotations.length === 0;
+
+        if (m.modifiers.length > 0) {
+            if (!first && m.modifiers[0].prefix.whitespace === "") {
+                m = produce(m, draft => {
+                    this.ensureSpace(draft.modifiers[0].prefix);
+                });
+            }
+            m = produce(m, draft => {
+                for (let i = 1; i < draft.modifiers.length; i++) {
+                    this.ensureSpace(draft.modifiers[i].prefix);
+                }
+            });
+            first = false;
+        }
+
+        // FunctionDeclaration marker check must come AFTER modifiers processing
+        // to avoid adding unwanted space before the first modifier (e.g., 'async')
+        if (findMarker(method, JS.Markers.FunctionDeclaration)) {
+            first = false;
+        }
+
+        if (!first && m.name.prefix.whitespace === "") {
+            m = produce(m, draft => {
+                this.ensureSpace(draft.name.prefix);
+            });
+        }
+
+        if (m.throws && m.throws.before.whitespace === "") {
+            m = produce(m, draft => {
+                this.ensureSpace(draft.throws!.before);
+            });
+        }
+
+        return m;
+    }
+
+    protected async visitNamespaceDeclaration(namespaceDeclaration: JS.NamespaceDeclaration, p: P): Promise<J | undefined> {
+        const ret = await super.visitNamespaceDeclaration(namespaceDeclaration, p) as JS.NamespaceDeclaration;
+        return produce(ret, draft => {
+            if (draft.modifiers.length > 0) {
+                draft.keywordType.before.whitespace=" ";
+            }
+            this.ensureSpace(draft.name.element.prefix);
+        });
+    }
+
+    protected async visitNewClass(newClass: J.NewClass, p: P): Promise<J | undefined> {
+        const ret = await super.visitNewClass(newClass, p) as J.NewClass;
+        return produce(ret, draft => {
+            if (draft.class) {
+                if (draft.class.kind == J.Kind.Identifier) {
+                    this.ensureSpace((draft.class as Draft<J.Identifier>).prefix);
+                }
+            }
+        });
+    }
+
+    protected async visitReturn(returnNode: J.Return, p: P): Promise<J | undefined> {
+        const r = await super.visitReturn(returnNode, p) as J.Return;
+        if (r.expression && r.expression.prefix.whitespace === "" &&
+            !r.markers.markers.find(m => m.id === "org.openrewrite.java.marker.ImplicitReturn")) {
+            return produce(r, draft => {
+                this.ensureSpace(draft.expression!.prefix);
+            });
+        }
+        return r;
+    }
+
+    protected async visitThrow(thrown: J.Throw, p: P): Promise<J | undefined> {
+        const ret = await super.visitThrow(thrown, p) as J.Throw;
+        return ret && produce(ret, draft => {
+           this.ensureSpace(draft.exception.prefix);
+        });
+    }
+
+    protected async visitTypeDeclaration(typeDeclaration: JS.TypeDeclaration, p: P): Promise<J | undefined> {
+        const ret = await super.visitTypeDeclaration(typeDeclaration, p) as JS.TypeDeclaration;
+        return produce(ret, draft => {
+            if (draft.modifiers.length > 0) {
+                this.ensureSpace(draft.name.before);
+            }
+            this.ensureSpace(draft.name.element.prefix);
+        });
+    }
+
+    protected async visitTypeOf(typeOf: JS.TypeOf, p: P): Promise<J | undefined> {
+        const ret = await super.visitTypeOf(typeOf, p) as JS.TypeOf;
+        return produce(ret, draft => {
+            this.ensureSpace(draft.expression.prefix);
+        });
+    }
+
+    protected async visitTypeParameter(typeParam: J.TypeParameter, p: P): Promise<J | undefined> {
+        const ret = await super.visitTypeParameter(typeParam, p) as J.TypeParameter;
+        return produce(ret, draft => {
+            if (draft.bounds && draft.bounds.elements.length > 0) {
+                this.ensureSpace(draft.bounds.before);
+                this.ensureSpace(draft.bounds.elements[0].element.prefix);
+            }
+        });
+    }
+
+    protected async visitVariableDeclarations(v: J.VariableDeclarations, p: P): Promise<J | undefined> {
+        let ret = await super.visitVariableDeclarations(v, p) as J.VariableDeclarations;
+        let first = ret.leadingAnnotations.length === 0;
+
+        if (first && ret.modifiers.length > 0) {
+            ret = produce(ret, draft => {
+                for (let i = 1; i < draft.modifiers.length; i++) {
+                    this.ensureSpace(draft.modifiers[i].prefix);
+                }
+            });
+            first = false;
+        }
+
+        if (!first) {
+            ret = produce(ret, draft => {
+                this.ensureSpace(draft.variables[0].element.prefix);
+            });
+        }
+
+        return ret;
+    }
+
+
+    protected async visitCase(caseNode: J.Case, p: P): Promise<J | undefined> {
+        const c = await super.visitCase(caseNode, p) as J.Case;
+
+        if (c.guard && c.caseLabels.elements.length > 0 && c.caseLabels.elements[c.caseLabels.elements.length - 1].after.whitespace === "") {
+            return produce(c, draft => {
+                const last = draft.caseLabels.elements.length - 1;
+                draft.caseLabels.elements[last].after.whitespace = " ";
+            });
+        }
+
+        return c;
+    }
+
+    private ensureSpace(spaceDraft: Draft<J.Space>) {
+        if (spaceDraft.whitespace.length === 0 && spaceDraft.comments.length === 0) {
+            spaceDraft.whitespace = " ";
+        }
+    }
+}