@openrewrite/recipes-code-quality 0.1.0-20260409-154017

package/src/merge-identical-branches.ts

@@ -0,0 +1,149 @@
+/*
+ * 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 {ExecutionContext, printer, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS, template} from "@openrewrite/rewrite/javascript";
+import {emptySpace, Expression, J, Statement} from "@openrewrite/rewrite/java";
+
+/**
+ * Merges consecutive if/else-if branches that have identical bodies.
+ *
+ * When two adjacent branches execute the same code, their conditions
+ * can be joined with `||` and the duplicate body removed. This eliminates
+ * copy-paste redundancy and makes the relationship between the conditions
+ * explicit.
+ */
+export class MergeIdenticalBranches extends Recipe {
+    name = "org.openrewrite.javascript.cleanup.MergeIdenticalBranches";
+    displayName = "Merge consecutive branches with identical bodies";
+    description = "Combine consecutive `if`/`else if` branches that have the same body " +
+        "into a single branch with conditions joined by `||`.";
+    tags = ["RSPEC-S1871"];
+    estimatedEffortPerOccurrence = 10;
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitIf(
+                ifStmt: J.If,
+                ctx: ExecutionContext
+            ): Promise<J | undefined> {
+                ifStmt = await super.visitIf(ifStmt, ctx) as J.If;
+
+                // Only process top-level if (not else-if branches)
+                const parentCursor = this.cursor.parent;
+                if (parentCursor) {
+                    const parentIf = parentCursor.firstEnclosing(
+                        (n): n is J.If => n.kind === J.Kind.If
+                    );
+                    if (parentIf) {
+                        return ifStmt;
+                    }
+                }
+
+                // Check if the if has an else-if with the same body
+                if (!ifStmt.elsePart) {
+                    return ifStmt;
+                }
+
+                const elseBody = ifStmt.elsePart.body.element;
+                if (elseBody.kind !== J.Kind.If) {
+                    return ifStmt;
+                }
+
+                const elseIf = elseBody as J.If;
+                const ifBody = ifStmt.thenPart.element as Statement & J;
+                const elseIfBody = elseIf.thenPart.element as Statement & J;
+
+                if (!await bodiesEqual(ifBody, elseIfBody)) {
+                    return ifStmt;
+                }
+
+                // Build combined condition: ifCond || elseIfCond
+                const ifCond = ifStmt.ifCondition.tree.element as Expression & J;
+                const elseIfCond = elseIf.ifCondition.tree.element as Expression & J;
+
+                // If either condition is && expression, wrap in parens
+                const leftNeedsParens = ifCond.kind === J.Kind.Binary &&
+                    (ifCond as J.Binary).operator.element === J.Binary.Type.And;
+                const rightNeedsParens = elseIfCond.kind === J.Kind.Binary &&
+                    (elseIfCond as J.Binary).operator.element === J.Binary.Type.And;
+
+                const cleanLeft = {...ifCond, prefix: emptySpace} as Expression;
+                const cleanRight = {...elseIfCond, prefix: emptySpace} as Expression;
+
+                let combined: J | undefined;
+                if (leftNeedsParens && rightNeedsParens) {
+                    combined = await template`(${cleanLeft}) || (${cleanRight})`.apply(
+                        ifStmt.ifCondition.tree.element, this.cursor
+                    );
+                } else if (leftNeedsParens) {
+                    combined = await template`(${cleanLeft}) || ${cleanRight}`.apply(
+                        ifStmt.ifCondition.tree.element, this.cursor
+                    );
+                } else if (rightNeedsParens) {
+                    combined = await template`${cleanLeft} || (${cleanRight})`.apply(
+                        ifStmt.ifCondition.tree.element, this.cursor
+                    );
+                } else {
+                    combined = await template`${cleanLeft} || ${cleanRight}`.apply(
+                        ifStmt.ifCondition.tree.element, this.cursor
+                    );
+                }
+
+                if (!combined) {
+                    return ifStmt;
+                }
+
+                // Unwrap ExpressionStatement if the template wrapped it
+                if (combined.kind === JS.Kind.ExpressionStatement) {
+                    combined = (combined as JS.ExpressionStatement).expression as J;
+                }
+
+                // Strip any leading newline from the combined expression
+                combined = stripLeadingNewline(combined);
+
+                // Build the merged if: combined condition, keep the if-body,
+                // skip the else-if and connect to whatever follows it
+                return await this.produceJava(ifStmt, ctx, draft => {
+                    (draft.ifCondition.tree as any).element = combined;
+                    draft.elsePart = elseIf.elsePart as any;
+                });
+            }
+        };
+    }
+}
+
+async function printNode(node: J): Promise<string> {
+    const p = printer("org.openrewrite.javascript.tree.JS$CompilationUnit");
+    return (await p.print(node)).trim();
+}
+
+async function bodiesEqual(a: Statement & J, b: Statement & J): Promise<boolean> {
+    return await printNode(a) === await printNode(b);
+}
+
+function stripLeadingNewline(node: J): J {
+    if (node.prefix.whitespace.includes('\n')) {
+        return {...node, prefix: emptySpace};
+    }
+    if (node.kind === J.Kind.Binary) {
+        const bin = node as J.Binary;
+        const newLeft = stripLeadingNewline(bin.left as J);
+        if (newLeft !== bin.left) {
+            return {...bin, left: newLeft as Expression} as unknown as J;
+        }
+    }
+    return node;
+}

package/src/remove-duplicate-conditions.ts

@@ -0,0 +1,165 @@
+/*
+ * 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 {ExecutionContext, printer, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor} from "@openrewrite/rewrite/javascript";
+import {Expression, J} from "@openrewrite/rewrite/java";
+
+/**
+ * Removes dead duplicate-condition branches in if/else-if chains.
+ *
+ * When the same condition appears more than once in an if/else-if chain,
+ * the later branch is dead code because the earlier branch already
+ * handles that case. Removing the unreachable branch eliminates confusion
+ * and prevents maintenance hazards.
+ */
+export class RemoveDuplicateConditions extends Recipe {
+    name = "org.openrewrite.javascript.cleanup.RemoveDuplicateConditions";
+    displayName = "Remove duplicate conditions in if/else-if chains";
+    description = "Remove `else if` branches whose condition is identical to an earlier " +
+        "branch in the same `if`/`else if` chain, since the duplicate branch " +
+        "is dead code that can never execute.";
+    tags = ["RSPEC-S1862"];
+    estimatedEffortPerOccurrence = 10;
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitIf(
+                ifStmt: J.If,
+                ctx: ExecutionContext
+            ): Promise<J | undefined> {
+                ifStmt = await super.visitIf(ifStmt, ctx) as J.If;
+
+                // Only process top-level if (not else-if branches).
+                // Start from parent cursor to avoid matching self.
+                const parentCursor = this.cursor.parent;
+                if (parentCursor) {
+                    const parentIf = parentCursor.firstEnclosing(
+                        (n): n is J.If => n.kind === J.Kind.If
+                    );
+                    if (parentIf) {
+                        return ifStmt;
+                    }
+                }
+
+                const result = await removeDuplicates(ifStmt);
+                if (result === ifStmt) {
+                    return ifStmt;
+                }
+
+                return await this.produceJava(ifStmt, ctx, draft => {
+                    Object.assign(draft, result);
+                });
+            }
+        };
+    }
+}
+
+async function printExpr(node: J): Promise<string> {
+    const p = printer("org.openrewrite.javascript.tree.JS$CompilationUnit");
+    return (await p.print(node)).trim();
+}
+
+async function expressionsEqual(a: Expression & J, b: Expression & J): Promise<boolean> {
+    return await printExpr(a) === await printExpr(b);
+}
+
+async function removeDuplicates(ifStmt: J.If): Promise<J.If> {
+    const seen: (Expression & J)[] = [ifStmt.ifCondition.tree.element as Expression & J];
+    let result = ifStmt;
+    let changed = false;
+    let current: J.If = ifStmt;
+
+    while (current.elsePart) {
+        const body = current.elsePart.body.element;
+        if (body.kind !== J.Kind.If) {
+            break;
+        }
+
+        const elseIf = body as J.If;
+        const cond = elseIf.ifCondition.tree.element as Expression & J;
+        let isDuplicate = false;
+        for (const prev of seen) {
+            if (await expressionsEqual(prev, cond)) {
+                isDuplicate = true;
+                break;
+            }
+        }
+
+        if (isDuplicate) {
+            // Skip this else-if: connect current to the duplicate's else
+            const newElse = elseIf.elsePart;
+            result = replaceElse(result, current, newElse);
+            changed = true;
+            // Find the updated current node in the rebuilt tree
+            const updated = findById(result, current.id);
+            if (updated) {
+                current = updated;
+            } else {
+                break;
+            }
+        } else {
+            seen.push(cond);
+            current = elseIf;
+        }
+    }
+
+    return changed ? result : ifStmt;
+}
+
+function replaceElse(root: J.If, target: J.If, newElse: J.If.Else | undefined): J.If {
+    if (root.id === target.id) {
+        return {...root, elsePart: newElse};
+    }
+
+    const elsePart = root.elsePart;
+    if (!elsePart) {
+        return root;
+    }
+
+    const body = elsePart.body.element;
+    if (body.kind !== J.Kind.If) {
+        return root;
+    }
+
+    const branch = body as J.If;
+    const updated = replaceElse(branch, target, newElse);
+    if (updated === branch) {
+        return root;
+    }
+
+    return {
+        ...root,
+        elsePart: {
+            ...elsePart,
+            body: {...elsePart.body, element: updated}
+        }
+    };
+}
+
+function findById(root: J.If, id: string): J.If | undefined {
+    if (root.id === id) {
+        return root;
+    }
+    const elsePart = root.elsePart;
+    if (!elsePart) {
+        return undefined;
+    }
+    const body = elsePart.body.element;
+    if (body.kind === J.Kind.If) {
+        return findById(body as J.If, id);
+    }
+    return undefined;
+}

package/src/remove-self-assignment.ts

@@ -0,0 +1,98 @@
+/*
+ * 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 {ExecutionContext, printer, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS} from "@openrewrite/rewrite/javascript";
+import {Expression, J} from "@openrewrite/rewrite/java";
+
+/**
+ * Removes statements that assign a variable to itself.
+ *
+ * A self-assignment like `x = x` has no effect and is almost certainly
+ * a mistake -- the programmer likely intended to assign a different
+ * value or assign to a different target. Removing the statement keeps
+ * the code honest about what it actually does.
+ *
+ * Handles simple identifiers (`x = x`) and member access on `this`
+ * (`this.x = this.x`). Does not flag `this.x = x` because those
+ * deliberately copy a parameter into an instance field.
+ */
+export class RemoveSelfAssignment extends Recipe {
+    name = "org.openrewrite.javascript.cleanup.RemoveSelfAssignment";
+    displayName = "Remove self-assignments";
+    description = "Removes assignment statements where a variable is assigned to itself, " +
+        "such as `x = x` or `this.x = this.x`. These statements have no effect and " +
+        "typically indicate a programming error.";
+    tags = ["RSPEC-S1656"];
+    estimatedEffortPerOccurrence = 3;
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitBlock(
+                block: J.Block,
+                ctx: ExecutionContext
+            ): Promise<J | undefined> {
+                block = await super.visitBlock(block, ctx) as J.Block;
+
+                const stmts = block.statements;
+                if (stmts.length === 0) {
+                    return block;
+                }
+
+                const toRemove = new Set<number>();
+                for (let i = 0; i < stmts.length; i++) {
+                    const assign = getAssignment(stmts[i].element);
+                    if (assign && await isSelfAssignment(assign)) {
+                        toRemove.add(i);
+                    }
+                }
+
+                if (toRemove.size === 0) {
+                    return block;
+                }
+
+                const newStmts = stmts.filter((_, idx) => !toRemove.has(idx));
+                return this.produceJava(block, ctx, draft => {
+                    draft.statements = newStmts as any;
+                });
+            }
+        };
+    }
+}
+
+function getAssignment(stmt: J): J.Assignment | undefined {
+    if (stmt.kind === JS.Kind.ExpressionStatement) {
+        const expr = (stmt as JS.ExpressionStatement).expression;
+        if (expr.kind === J.Kind.Assignment) {
+            return expr as J.Assignment;
+        }
+    }
+    if (stmt.kind === J.Kind.Assignment) {
+        return stmt as J.Assignment;
+    }
+    return undefined;
+}
+
+async function printNode(node: J): Promise<string> {
+    const p = printer("org.openrewrite.javascript.tree.JS$CompilationUnit");
+    return (await p.print(node)).trim();
+}
+
+async function isSelfAssignment(assign: J.Assignment): Promise<boolean> {
+    const variable = assign.variable;
+    const value = assign.assignment.element as Expression & J;
+
+    return await printNode(variable as J) === await printNode(value as J);
+}

package/src/remove-unconditional-value-overwrite.ts

@@ -0,0 +1,128 @@
+/*
+ * 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 {ExecutionContext, printer, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS} from "@openrewrite/rewrite/javascript";
+import {J, Expression} from "@openrewrite/rewrite/java";
+
+/**
+ * Removes consecutive assignments that write to the same object property
+ * or bracket-accessed key.
+ *
+ * When a value written to a property or bracket key is immediately
+ * overwritten in the very next statement, the first write is dead code.
+ * Removing it keeps the code focused on the value that actually persists.
+ *
+ * Handles both bracket notation (`obj["key"] = ...`) and dot notation
+ * (`obj.key = ...`).
+ */
+export class RemoveUnconditionalValueOverwrite extends Recipe {
+    name = "org.openrewrite.javascript.cleanup.RemoveUnconditionalValueOverwrite";
+    displayName = "Remove unconditional value overwrites";
+    description = "Remove consecutive assignments that write to the same object property " +
+        "or bracket-accessed key, since the first value is immediately " +
+        "overwritten and never used.";
+    tags = ["RSPEC-S4143"];
+    estimatedEffortPerOccurrence = 5;
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitBlock(
+                block: J.Block,
+                ctx: ExecutionContext
+            ): Promise<J | undefined> {
+                block = await super.visitBlock(block, ctx) as J.Block;
+
+                const stmts = block.statements;
+                if (stmts.length < 2) {
+                    return block;
+                }
+
+                const toRemove = new Set<number>();
+                for (let i = 0; i < stmts.length - 1; i++) {
+                    if (toRemove.has(i)) {
+                        continue;
+                    }
+                    const aAssign = getAssignment(stmts[i].element);
+                    if (!aAssign || !isPropertyAssign(aAssign)) {
+                        continue;
+                    }
+                    const bAssign = getAssignment(stmts[i + 1].element);
+                    if (!bAssign) {
+                        continue;
+                    }
+                    if (await isDuplicateWrite(aAssign, bAssign)) {
+                        toRemove.add(i);
+                    }
+                }
+
+                if (toRemove.size === 0) {
+                    return block;
+                }
+
+                const newStmts = stmts.filter((_, idx) => !toRemove.has(idx));
+                return this.produceJava(block, ctx, draft => {
+                    draft.statements = newStmts as any;
+                });
+            }
+        };
+    }
+}
+
+function getAssignment(stmt: J): J.Assignment | undefined {
+    if (stmt.kind === JS.Kind.ExpressionStatement) {
+        const expr = (stmt as JS.ExpressionStatement).expression;
+        if (expr.kind === J.Kind.Assignment) {
+            return expr as J.Assignment;
+        }
+    }
+    if (stmt.kind === J.Kind.Assignment) {
+        return stmt as J.Assignment;
+    }
+    return undefined;
+}
+
+function isPropertyAssign(assign: J.Assignment): boolean {
+    const v = assign.variable;
+    return v.kind === J.Kind.ArrayAccess || v.kind === J.Kind.FieldAccess;
+}
+
+async function printNode(node: J): Promise<string> {
+    const p = printer("org.openrewrite.javascript.tree.JS$CompilationUnit");
+    return await p.print(node);
+}
+
+async function isDuplicateWrite(a: J.Assignment, b: J.Assignment): Promise<boolean> {
+    const va = a.variable;
+    const vb = b.variable;
+
+    // Both bracket notation: obj["key"] = ...
+    if (va.kind === J.Kind.ArrayAccess && vb.kind === J.Kind.ArrayAccess) {
+        const aa = va as J.ArrayAccess;
+        const ab = vb as J.ArrayAccess;
+        return await printNode(aa.indexed) === await printNode(ab.indexed) &&
+            await printNode(aa.dimension.index.element as Expression & J) === await printNode(ab.dimension.index.element as Expression & J);
+    }
+
+    // Both dot notation: obj.key = ...
+    if (va.kind === J.Kind.FieldAccess && vb.kind === J.Kind.FieldAccess) {
+        const fa = va as J.FieldAccess;
+        const fb = vb as J.FieldAccess;
+        return fa.name.element.simpleName === fb.name.element.simpleName &&
+            await printNode(fa.target) === await printNode(fb.target);
+    }
+
+    return false;
+}