@doubleloop-io/oxlint-plugin-effect 0.1.1 → 0.1.2

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @doubleloop-io/oxlint-plugin-effect
 
+## 0.1.2
+
+### Patch Changes
+
+- [#42](https://github.com/doubleloop-io/oxlint-plugin-effect/pull/42) [`00de7c6`](https://github.com/doubleloop-io/oxlint-plugin-effect/commit/00de7c6780be261181bd49e34c183f020733754f) Thanks [@iacoware](https://github.com/iacoware)! - `no-inline-yield-star` adds a hint when the `yield*` sits inside a larger conditional branch, where binding it first would run it unconditionally: extract the effect into a named function and transform its result inside it (`Effect.map`), so the branch is a single `yield*`.
+
+- [#41](https://github.com/doubleloop-io/oxlint-plugin-effect/pull/41) [`a71cd0f`](https://github.com/doubleloop-io/oxlint-plugin-effect/commit/a71cd0fbcc82be7e9961550ec4924ae483b64016) Thanks [@iacoware](https://github.com/iacoware)! - `no-inline-yield-star` autofix names a `const` whose name is taken after the object it is read from (`reader.rows` → `readerRows`, `Effect.scope` → `effectScope`) before falling back to a numeric suffix.
+
+- [#39](https://github.com/doubleloop-io/oxlint-plugin-effect/pull/39) [`469f03d`](https://github.com/doubleloop-io/oxlint-plugin-effect/commit/469f03d1eb92126a918d8cf456e8483b05c4fdd9) Thanks [@d4v1d82](https://github.com/d4v1d82)! - Prevent `no-inline-yield-star` autofixes from generating duplicate `const` bindings when multiple statements in the same generator extract the same base name.
+
 ## 0.1.1
 
 ### Patch Changes

package/README.md

@@ -1,6 +1,6 @@
 # @doubleloop-io/oxlint-plugin-effect
 
-An oxlint plugin that enforces a catalog of patterns for Effect 4 code.
+An [oxlint](https://github.com/oxc-project/oxc) plugin that enforces a catalog of patterns for [Effect](https://github.com/Effect-TS/effect/) 4 code.
 
 The rules are written and tested against Effect 4. Where an Effect 3 API has the same intent, the rules recognize its v3 name too: each rule's Trigger names them. The [Rules overview](https://doubleloop-io.github.io/oxlint-plugin-effect/rules-overview/) lists every rule.
 

package/dist/rules/no-inline-yield-star.js

@@ -35,6 +35,29 @@ const statementOf = (node) => {
     return current;
 };
 const logicalAssignments = new Set(["&&=", "||=", "??="]);
+const isConditionalBranch = (child, parent) => {
+    switch (parent.type) {
+        case "ConditionalExpression":
+            return parent.test !== child;
+        case "LogicalExpression":
+            return parent.right === child;
+        case "AssignmentExpression":
+            return parent.right === child && logicalAssignments.has(parent.operator);
+        default:
+            return false;
+    }
+};
+// A branch that is the `yield*` itself can be bound whole; a larger branch cannot be bound first
+// without running the effect unconditionally.
+const isNestedInConditionalBranch = (node, statement) => {
+    let child = node.parent;
+    while (child !== statement && child.parent) {
+        if (isConditionalBranch(child, child.parent))
+            return true;
+        child = child.parent;
+    }
+    return false;
+};
 // The extracted `const` runs before its statement, once and unconditionally: any position that
 // short-circuits, repeats or belongs to a nested statement would change when the effect runs.
 const runsOnceBeforeStatement = (child, parent, statement) => {
@@ -89,13 +112,32 @@ const trailingName = (node) => {
             return undefined;
     }
 };
-// `yield* readSheet()` becomes `sheet`, `yield* reader.rows` becomes `rows`.
-const baseName = (node) => {
-    const name = node.argument ? trailingName(node.argument)?.replace(verbPrefix, "") : undefined;
-    if (name === undefined || name === "")
-        return "value";
-    const variable = name.charAt(0).toLowerCase() + name.slice(1);
-    return reservedWords.has(variable) ? "value" : variable;
+const memberOwner = (node) => {
+    switch (node.type) {
+        case "MemberExpression":
+            return node.computed ? undefined : node.object;
+        case "CallExpression":
+        case "NewExpression":
+            return memberOwner(node.callee);
+        default:
+            return undefined;
+    }
+};
+const lowerFirst = (name) => name.charAt(0).toLowerCase() + name.slice(1);
+const upperFirst = (name) => name.charAt(0).toUpperCase() + name.slice(1);
+// `yield* readSheet()` becomes `sheet`, `yield* reader.rows` becomes `rows`, or `readerRows`
+// when `rows` is taken: the owner tells the reader where the value comes from, a suffix does not.
+const names = (node) => {
+    const { argument } = node;
+    const name = argument ? trailingName(argument)?.replace(verbPrefix, "") : undefined;
+    if (!argument || name === undefined || name === "")
+        return { base: "value" };
+    const base = lowerFirst(name);
+    if (reservedWords.has(base))
+        return { base: "value" };
+    const owner = memberOwner(argument);
+    const ownerName = owner ? trailingName(owner) : undefined;
+    return ownerName ? { base, qualified: lowerFirst(ownerName) + upperFirst(base) } : { base };
 };
 const namesInUse = (scope) => {
     const names = new Set();
@@ -130,12 +172,14 @@ const replacedRange = (node, sourceCode) => {
     }
     return wrappers[wrappers.length - 1 - callParens] ?? node.range;
 };
-const extraction = (statement, hoisted, sourceCode) => {
-    const taken = namesInUse(sourceCode.getScope(statement).variableScope);
+const extraction = (statement, hoisted, sourceCode, namesByOwner, owner) => {
+    const taken = namesByOwner.get(owner) ?? namesInUse(sourceCode.getScope(statement).variableScope);
+    namesByOwner.set(owner, taken);
     const replacements = hoisted.map((node) => {
-        let name = baseName(node);
+        const { base, qualified } = names(node);
+        let name = taken.has(base) && qualified !== undefined ? qualified : base;
         for (let suffix = 2; taken.has(name); suffix++)
-            name = `${baseName(node)}${suffix}`;
+            name = `${base}${suffix}`;
         taken.add(name);
         return { node, name, range: replacedRange(node, sourceCode) };
     });
@@ -161,6 +205,7 @@ const extraction = (statement, hoisted, sourceCode) => {
     const guarded = startsLine && /^[[(`+\-/]/.test(remainder) ? `;${remainder}` : remainder;
     return [...declarations, guarded].join(startsLine ? `\n${indentation}` : "; ");
 };
+const inlineYieldStarMessage = "This `yield*` runs inside a larger expression. Bind its result first (`const rows = yield* reader.rows`), so each statement runs one effect in reading order.";
 export const noInlineYieldStarRule = defineRule({
     meta: {
         type: "suggestion",
@@ -169,7 +214,8 @@ export const noInlineYieldStarRule = defineRule({
             description: "Bind the result of a `yield*` to a `const` instead of using it inside a larger expression.",
         },
         messages: {
-            inlineYieldStar: "This `yield*` runs inside a larger expression. Bind its result first (`const rows = yield* reader.rows`), so each statement runs one effect in reading order.",
+            inlineYieldStar: inlineYieldStarMessage,
+            conditionalYieldStar: `${inlineYieldStarMessage} When inside a conditional branch, binding it first would run it unconditionally. Instead, extract the effect into a named function and transform its result inside it (\`Effect.map\`), so the branch is a single \`yield*\`.`,
         },
     },
     createOnce(context) {
@@ -197,6 +243,7 @@ export const noInlineYieldStarRule = defineRule({
             VariableDeclarator: collect,
             "Program:exit"() {
                 const byStatement = new Map();
+                const namesByOwner = new Map();
                 for (const node of inline) {
                     const statement = statementOf(node);
                     byStatement.set(statement, [...(byStatement.get(statement) ?? []), node]);
@@ -212,12 +259,14 @@ export const noInlineYieldStarRule = defineRule({
                         hoisted.length > 0 &&
                         !reordersEffects(hoisted, evaluatedInStatement);
                     const replacement = fixable
-                        ? extraction(statement, hoisted, context.sourceCode)
+                        ? extraction(statement, hoisted, context.sourceCode, namesByOwner, owner)
                         : undefined;
                     for (const node of yields) {
                         context.report({
                             node,
-                            messageId: "inlineYieldStar",
+                            messageId: isNestedInConditionalBranch(node, statement)
+                                ? "conditionalYieldStar"
+                                : "inlineYieldStar",
                             ...(replacement !== undefined && hoisted.includes(node)
                                 ? { fix: (fixer) => fixer.replaceText(statement, replacement) }
                                 : {}),

package/docs/user-guide/README.md

@@ -2,7 +2,7 @@
 title: "@doubleloop-io/oxlint-plugin-effect"
 ---
 
-An oxlint plugin that enforces a catalog of patterns for Effect 4 code.
+An [oxlint](https://github.com/oxc-project/oxc) plugin that enforces a catalog of patterns for [Effect](https://github.com/Effect-TS/effect/) 4 code.
 
 The rules are written and tested against Effect 4. Where an Effect 3 API has the same intent, the rules recognize its v3 name too: each rule's Trigger names them.
 

package/docs/user-guide/rules/no-inline-yield-star.md

@@ -20,7 +20,7 @@ function* () {
 
 **Trigger**: a `yield*` whose result is used inside a larger expression: argument, operand, member, property, template.
 
-**Exemptions and blind spots**: a `yield*` that is the whole value of a statement (`yield* x`, `return yield* x`, `if (yield* x)`, `for (… of yield* x)`), a declaration or an assignment. Also the whole branch of a ternary, or the right operand of `&&`/`||`/`??`, in one of those positions (`const a = cached ?? (yield* x)`): binding first would run the effect unconditionally. The autofix extracts every nested `yield*` into `const`s, innermost first, named after the argument's last identifier without a verb prefix (`readSheet()` → `sheet`). There is no autofix when moving the effect could change when or how often it runs: branches of a ternary or `&&`/`||`/`??` inside a larger expression, optional chaining, `while`/`for` conditions, statements without braces, another call evaluated before the `yield*`.
+**Exemptions and blind spots**: a `yield*` that is the whole value of a statement (`yield* x`, `return yield* x`, `if (yield* x)`, `for (… of yield* x)`), a declaration or an assignment. Also the whole branch of a ternary, or the right operand of `&&`/`||`/`??`, in one of those positions (`const a = cached ?? (yield* x)`): binding first would run the effect unconditionally. The autofix extracts every nested `yield*` into `const`s, innermost first, named after the argument's last identifier without a verb prefix (`readSheet()` → `sheet`); when that name is taken, prefixed by the object it is read from (`reader.rows` → `readerRows`), else numbered (`sheet2`). There is no autofix when moving the effect could change when or how often it runs: branches of a ternary or `&&`/`||`/`??` inside a larger expression, optional chaining, `while`/`for` conditions, statements without braces, another call evaluated before the `yield*`.
 
 **Why**: with several `yield*`s in one expression the order of effects can only be inferred from precedence. One `const` per effect makes the order the reading order and names the intermediate value.
 

package/docs/user-guide/versioning.md

@@ -5,4 +5,4 @@ order: 7
 
 Versions are `0.x`: any minor release may add, remove or change rules, options, settings and messages.
 
-Supported oxlint is the `peerDependencies` range, `^1.82.0`; CI tests the tarball against `1.82.0`. oxlint's JS plugin API is still experimental, so a newer oxlint minor may break the plugin before the range is narrowed.
+Supported oxlint is the `peerDependencies` range, `^1.82.0`; CI tests the tarball against `1.82.0`, and a weekly workflow runs the tests and the tarball against the latest oxlint. oxlint's JS plugin API is still experimental, so a newer oxlint minor may break the plugin before the range is narrowed.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doubleloop-io/oxlint-plugin-effect",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Oxlint rules for Effect 4 code",
   "homepage": "https://doubleloop-io.github.io/oxlint-plugin-effect/",
   "license": "MIT",