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

package/src/simplify-boolean-literal.ts

@@ -0,0 +1,220 @@
+/*
+ * 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, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {capture, JavaScriptVisitor, JS, pattern, rewrite, template} from "@openrewrite/rewrite/javascript";
+import {J} from "@openrewrite/rewrite/java";
+
+/**
+ * Simplifies boolean expressions that compare against boolean literals.
+ *
+ * Comparisons against `true` or `false` are redundant and make code
+ * harder to read. A direct boolean expression or its negation is
+ * clearer and more idiomatic.
+ *
+ * Handles both strict (`===`/`!==`) and loose (`==`/`!=`) equality operators.
+ */
+export class SimplifyBooleanLiteral extends Recipe {
+    name = "org.openrewrite.javascript.cleanup.SimplifyBooleanLiteral";
+    displayName = "Simplify boolean literal comparisons";
+    description = "Removes redundant comparisons against boolean literals. " +
+        "For example, `x === true` becomes `x` and `x === false` becomes `!x`. " +
+        "Handles both strict (`===`/`!==`) and loose (`==`/`!=`) equality.";
+    tags = ["RSPEC-S1125"];
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        // x === true -> x
+        const equalsTrue = rewrite(() => {
+            const x = capture();
+            return {
+                before: pattern`${x} === true`,
+                after: template`${x}`
+            };
+        });
+
+        // true === x -> x
+        const trueEquals = rewrite(() => {
+            const x = capture();
+            return {
+                before: pattern`true === ${x}`,
+                after: template`${x}`
+            };
+        });
+
+        // x === false -> !x
+        const equalsFalse = rewrite(() => {
+            const x = capture();
+            return {
+                before: pattern`${x} === false`,
+                after: template`!${x}`
+            };
+        });
+
+        // false === x -> !x
+        const falseEquals = rewrite(() => {
+            const x = capture();
+            return {
+                before: pattern`false === ${x}`,
+                after: template`!${x}`
+            };
+        });
+
+        // x !== true -> !x
+        const notEqualsTrue = rewrite(() => {
+            const x = capture();
+            return {
+                before: pattern`${x} !== true`,
+                after: template`!${x}`
+            };
+        });
+
+        // true !== x -> !x
+        const trueNotEquals = rewrite(() => {
+            const x = capture();
+            return {
+                before: pattern`true !== ${x}`,
+                after: template`!${x}`
+            };
+        });
+
+        // x !== false -> x
+        const notEqualsFalse = rewrite(() => {
+            const x = capture();
+            return {
+                before: pattern`${x} !== false`,
+                after: template`${x}`
+            };
+        });
+
+        // false !== x -> x
+        const falseNotEquals = rewrite(() => {
+            const x = capture();
+            return {
+                before: pattern`false !== ${x}`,
+                after: template`${x}`
+            };
+        });
+
+        // Loose equality: x == true -> x
+        const looseEqualsTrue = rewrite(() => {
+            const x = capture();
+            return {
+                before: pattern`${x} == true`,
+                after: template`${x}`
+            };
+        });
+
+        // true == x -> x
+        const trueLooseEquals = rewrite(() => {
+            const x = capture();
+            return {
+                before: pattern`true == ${x}`,
+                after: template`${x}`
+            };
+        });
+
+        // x == false -> !x
+        const looseEqualsFalse = rewrite(() => {
+            const x = capture();
+            return {
+                before: pattern`${x} == false`,
+                after: template`!${x}`
+            };
+        });
+
+        // false == x -> !x
+        const falseLooseEquals = rewrite(() => {
+            const x = capture();
+            return {
+                before: pattern`false == ${x}`,
+                after: template`!${x}`
+            };
+        });
+
+        // x != true -> !x
+        const looseNotEqualsTrue = rewrite(() => {
+            const x = capture();
+            return {
+                before: pattern`${x} != true`,
+                after: template`!${x}`
+            };
+        });
+
+        // true != x -> !x
+        const trueLooseNotEquals = rewrite(() => {
+            const x = capture();
+            return {
+                before: pattern`true != ${x}`,
+                after: template`!${x}`
+            };
+        });
+
+        // x != false -> x
+        const looseNotEqualsFalse = rewrite(() => {
+            const x = capture();
+            return {
+                before: pattern`${x} != false`,
+                after: template`${x}`
+            };
+        });
+
+        // false != x -> x
+        const falseLooseNotEquals = rewrite(() => {
+            const x = capture();
+            return {
+                before: pattern`false != ${x}`,
+                after: template`${x}`
+            };
+        });
+
+        // Strict equality rules (=== / !==) match JS.Binary nodes
+        const strictRules = equalsTrue
+            .orElse(trueEquals)
+            .orElse(equalsFalse)
+            .orElse(falseEquals)
+            .orElse(notEqualsTrue)
+            .orElse(trueNotEquals)
+            .orElse(notEqualsFalse)
+            .orElse(falseNotEquals);
+
+        // Loose equality rules (== / !=) match J.Binary nodes
+        const looseRules = looseEqualsTrue
+            .orElse(trueLooseEquals)
+            .orElse(looseEqualsFalse)
+            .orElse(falseLooseEquals)
+            .orElse(looseNotEqualsTrue)
+            .orElse(trueLooseNotEquals)
+            .orElse(looseNotEqualsFalse)
+            .orElse(falseLooseNotEquals);
+
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitBinary(
+                binary: J.Binary,
+                ctx: ExecutionContext
+            ): Promise<J | undefined> {
+                binary = await super.visitBinary(binary, ctx) as J.Binary;
+                return await looseRules.tryOn(this.cursor, binary) || binary;
+            }
+
+            override async visitBinaryExtensions(
+                binary: JS.Binary,
+                ctx: ExecutionContext
+            ): Promise<J | undefined> {
+                binary = await super.visitBinaryExtensions(binary, ctx) as JS.Binary;
+                return await strictRules.tryOn(this.cursor, binary) || binary;
+            }
+        };
+    }
+}

package/src/simplify-redundant-logical-expression.ts

@@ -0,0 +1,75 @@
+/*
+ * 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";
+
+/**
+ * Simplifies redundant logical expressions where both operands are identical.
+ *
+ * `x && x` always evaluates to `x`, and `x || x` always evaluates to `x`.
+ * The duplicated operand adds noise and may hide a copy-paste bug where
+ * the programmer intended a different second condition.
+ *
+ * Only targets `&&` and `||`. Arithmetic and comparison operators are
+ * left alone because `n + n` is `2 * n`, not `n`.
+ */
+export class SimplifyRedundantLogicalExpression extends Recipe {
+    name = "org.openrewrite.javascript.cleanup.SimplifyRedundantLogicalExpression";
+    displayName = "Simplify redundant logical expressions";
+    description = "Replace `x && x` with `x` and `x || x` with `x`. " +
+        "Identical operands in a logical expression are redundant " +
+        "and often indicate a copy-paste mistake.";
+    tags = ["RSPEC-S1764"];
+    estimatedEffortPerOccurrence = 2;
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitBinary(
+                binary: J.Binary,
+                ctx: ExecutionContext
+            ): Promise<J | undefined> {
+                binary = await super.visitBinary(binary, ctx) as J.Binary;
+
+                const op = binary.operator.element;
+                if (op !== J.Binary.Type.And && op !== J.Binary.Type.Or) {
+                    return binary;
+                }
+
+                if (await expressionsEqual(binary.left as Expression & J, binary.right as Expression & J)) {
+                    // Replace the binary with just the left operand,
+                    // preserving the binary's prefix (leading whitespace)
+                    return {...(binary.left as any), prefix: binary.prefix};
+                }
+
+                return binary;
+            }
+        };
+    }
+}
+
+async function printNode(node: J): Promise<string> {
+    const p = printer("org.openrewrite.javascript.tree.JS$CompilationUnit");
+    return await p.print(node);
+}
+
+async function expressionsEqual(a: Expression & J, b: Expression & J): Promise<boolean> {
+    // The printer includes the node's prefix (leading whitespace),
+    // so we trim to compare just the expression text.
+    const aText = (await printNode(a)).trim();
+    const bText = (await printNode(b)).trim();
+    return aText === bText;
+}