@discourse/lint-configs 2.40.0 → 2.42.0

package/eslint-rules/no-discourse-computed/discourse-computed-fixer.mjs

@@ -0,0 +1,319 @@
+import { propertyPathToOptionalChaining } from "../utils/property-path.mjs";
+
+/**
+ * Create a fixer function that converts a method with parameters into a getter
+ * that reads from this.<property>. The fixer will:
+ * - replace the decorator callee with the computed import name
+ * - insert the `get ` keyword before the method name if absent
+ * - remove the parameter list from the method signature
+ * - replace identifier occurrences of parameters with `this.<path>` accesses
+ *
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {import('estree').MethodDefinition} node
+ * @param {string[]} decoratorArgs
+ * @param {string} computedImportName
+ * @param {{simpleReassignments?: Array}} [options]
+ * @returns {(fixer: import('eslint').Rule.RuleFixer) => import('eslint').Rule.Fix[]}
+ */
+export function createMethodFix(
+  sourceCode,
+  node,
+  decoratorArgs,
+  computedImportName,
+  options = {}
+) {
+  return function (fixer) {
+    const fixes = [];
+
+    // replace decorator callee/name
+    const deco = node.decorators && node.decorators.find((d) => d.expression);
+    const decoratorExpression = deco && deco.expression;
+    if (decoratorExpression) {
+      if (decoratorExpression.type === "CallExpression") {
+        fixes.push(
+          fixer.replaceText(decoratorExpression.callee, computedImportName)
+        );
+      } else {
+        fixes.push(fixer.replaceText(decoratorExpression, computedImportName));
+      }
+    }
+
+    const methodKey = node.key;
+    const hasParams = node.value.params && node.value.params.length > 0;
+    const paramNames = node.value.params
+      ? node.value.params.map((p) => p.name)
+      : [];
+
+    if (node.kind !== "get") {
+      fixes.push(fixer.insertTextBefore(methodKey, "get "));
+    }
+
+    if (hasParams) {
+      const paramsStart = node.value.params[0].range[0];
+      const paramsEnd =
+        node.value.params[node.value.params.length - 1].range[1];
+      fixes.push(fixer.removeRange([paramsStart, paramsEnd]));
+
+      const paramToProperty = {};
+      paramNames.forEach((name, i) => {
+        paramToProperty[name] = decoratorArgs[i] || name;
+      });
+
+      // Small expression replacer used for simple-reassignment right-hand sides
+      const replaceIdentifiersInExpression = (expr) => {
+        if (!expr || typeof expr !== "object") {
+          return sourceCode.getText(expr);
+        }
+        if (expr.type === "Identifier") {
+          if (paramToProperty[expr.name]) {
+            return propertyPathToOptionalChaining(
+              paramToProperty[expr.name],
+              true,
+              false
+            );
+          }
+          return expr.name;
+        }
+        if (expr.type === "CallExpression") {
+          const callee = replaceIdentifiersInExpression(expr.callee);
+          const args = expr.arguments
+            .map((a) => replaceIdentifiersInExpression(a))
+            .join(", ");
+          return `${callee}(${args})`;
+        }
+        if (expr.type === "MemberExpression") {
+          const object = replaceIdentifiersInExpression(expr.object);
+          if (expr.computed) {
+            const property = replaceIdentifiersInExpression(expr.property);
+            return `${object}[${property}]`;
+          }
+          return `${object}.${expr.property.name}`;
+        }
+        if (expr.type === "ArrayExpression") {
+          return `[${expr.elements.map((el) => (el ? replaceIdentifiersInExpression(el) : "")).join(", ")}]`;
+        }
+        if (expr.type === "ObjectExpression") {
+          return sourceCode.getText(expr);
+        }
+        if (
+          expr.type === "LogicalExpression" ||
+          expr.type === "BinaryExpression"
+        ) {
+          return `${replaceIdentifiersInExpression(expr.left)} ${expr.operator} ${replaceIdentifiersInExpression(expr.right)}`;
+        }
+        if (expr.type === "ConditionalExpression") {
+          return `${replaceIdentifiersInExpression(expr.test)} ? ${replaceIdentifiersInExpression(expr.consequent)} : ${replaceIdentifiersInExpression(expr.alternate)}`;
+        }
+        return sourceCode.getText(expr);
+      };
+
+      // Collect replacements for identifier occurrences
+      const replacements = [];
+
+      // Apply simple reassignments first if provided (these were detected earlier).
+      const simpleReassignments = options.simpleReassignments || [];
+      const handledRanges = [];
+
+      if (simpleReassignments.length > 0) {
+        for (const reassignment of simpleReassignments) {
+          const { statement, paramName, info, isGuard } = reassignment;
+
+          if (isGuard) {
+            // Guard clause: if (!foo) { foo = []; }
+            const assignmentExpr = statement.consequent.body[0].expression;
+            const access = propertyPathToOptionalChaining(
+              paramToProperty[paramName],
+              true,
+              false
+            );
+            const newRight = replaceIdentifiersInExpression(
+              assignmentExpr.right
+            );
+            // Example: let foo = this.foo || [];
+            // We use 'let' because it was inside an 'if', implying it might be reassigned
+            // (though our analysis ensures it's the ONLY assignment in simple cases)
+            replacements.push({
+              range: statement.range,
+              text: `let ${paramName} = ${access} || ${newRight};`,
+            });
+          } else {
+            // Direct assignment: foo = foo || [];
+            const assignmentExpr = statement.expression;
+            const useConst = info.assignments.length === 1;
+            const keyword = useConst ? "const" : "let";
+            const newRight = replaceIdentifiersInExpression(
+              assignmentExpr.right
+            );
+            replacements.push({
+              range: statement.range,
+              text: `${keyword} ${paramName} = ${newRight};`,
+            });
+          }
+          handledRanges.push(statement.range);
+          // prevent further replacements for this param
+          delete paramToProperty[paramName];
+        }
+      }
+
+      // Use ESLint scope analysis to find all references to parameters
+      const scope = sourceCode.getScope(node.value);
+      for (const variable of scope.variables) {
+        if (!paramToProperty[variable.name] || variable.scope !== scope) {
+          continue;
+        }
+
+        const propertyPath = paramToProperty[variable.name];
+
+        for (const reference of variable.references) {
+          const refNode = reference.identifier;
+
+          // Skip if this reference is inside a range already handled by simpleReassignments
+          if (
+            handledRanges.some(
+              (range) =>
+                refNode.range[0] >= range[0] && refNode.range[1] <= range[1]
+            )
+          ) {
+            continue;
+          }
+
+          const parent = refNode.parent;
+
+          // contexts to skip
+          if (
+            parent &&
+            parent.type === "Property" &&
+            parent.key === refNode &&
+            !parent.shorthand
+          ) {
+            continue;
+          }
+          if (
+            parent &&
+            parent.type === "Property" &&
+            parent.key === refNode &&
+            parent.value !== refNode
+          ) {
+            continue;
+          }
+          if (
+            parent &&
+            parent.type === "MemberExpression" &&
+            parent.property === refNode &&
+            !parent.computed
+          ) {
+            continue;
+          }
+          if (reference.isWrite()) {
+            continue;
+          }
+
+          // shorthand property: { foo } -> { foo: this.foo }
+          if (parent && parent.type === "Property" && parent.shorthand) {
+            const access = propertyPathToOptionalChaining(
+              propertyPath,
+              true,
+              false
+            );
+            replacements.push({
+              range: refNode.range,
+              text: `${refNode.name}: ${access}`,
+            });
+            continue;
+          }
+
+          const isInMemberExpression =
+            parent &&
+            parent.type === "MemberExpression" &&
+            parent.object === refNode;
+
+          const access = propertyPathToOptionalChaining(
+            propertyPath,
+            true,
+            isInMemberExpression
+          );
+
+          if (isInMemberExpression && access.endsWith("?.")) {
+            // Replace identifier with access without trailing '?.'
+            replacements.push({
+              range: refNode.range,
+              text: access.slice(0, -2),
+            });
+
+            // adjust following punctuation to avoid '?..' (replace '.' with '?.' or insert '?.' before '[')
+            const fullText = sourceCode.getText();
+            let pos = refNode.range[1];
+            while (pos < fullText.length && /\s/.test(fullText.charAt(pos))) {
+              pos++;
+            }
+            const ch = fullText.charAt(pos);
+            const nextCh = fullText.charAt(pos + 1);
+
+            if (ch === "?" && nextCh === ".") {
+              // already '?.' — nothing
+            } else if (ch === ".") {
+              replacements.push({ range: [pos, pos + 1], text: "?." });
+            } else if (ch === "[") {
+              replacements.push({ range: [pos, pos], text: "?." });
+            } else if (ch === "\n") {
+              // Multiline member expression: prefer replacing the '.' at the start of the next
+              // non-whitespace character with '?.' so lines like '\n  .filter' become '\n  ?.filter'.
+              let insertPos = pos;
+              while (
+                insertPos < fullText.length &&
+                /\s/.test(fullText.charAt(insertPos))
+              ) {
+                insertPos++;
+              }
+              const nextChar = fullText.charAt(insertPos);
+              if (nextChar === ".") {
+                replacements.push({
+                  range: [insertPos, insertPos + 1],
+                  text: "?.",
+                });
+              } else {
+                // Fallback: insert '?.' at the computed position
+                replacements.push({
+                  range: [insertPos, insertPos],
+                  text: "?.",
+                });
+              }
+            }
+
+            // Additionally, propagate optional chaining to chained call/member sequences.
+            let ancestor = parent.parent;
+            while (ancestor) {
+              if (
+                ancestor.type === "CallExpression" &&
+                ancestor.parent &&
+                ancestor.parent.type === "MemberExpression"
+              ) {
+                const afterCallPos = ancestor.range[1];
+                let p = afterCallPos;
+                while (p < fullText.length && /\s/.test(fullText.charAt(p))) {
+                  p++;
+                }
+                if (fullText.charAt(p) === ".") {
+                  replacements.push({ range: [p, p + 1], text: "?." });
+                }
+                ancestor = ancestor.parent.parent;
+                continue;
+              }
+              break;
+            }
+          } else {
+            replacements.push({ range: refNode.range, text: access });
+          }
+        }
+      }
+
+      // Apply replacements from end to start in a single pass so fixes don't overlap
+      replacements.sort((a, b) => b.range[0] - a.range[0]);
+      for (const r of replacements) {
+        fixes.push(fixer.replaceTextRange(r.range, r.text));
+      }
+    }
+
+    return fixes;
+  };
+}

package/eslint-rules/no-discourse-computed.mjs

@@ -0,0 +1,388 @@
+import { analyzeDiscourseComputedUsage as analyzeDiscourseComputedUsageUtil } from "./no-discourse-computed/discourse-computed-analysis.mjs";
+import { createMethodFix } from "./no-discourse-computed/discourse-computed-fixer.mjs";
+import {
+  collectImports,
+  getImportedLocalNames,
+} from "./utils/analyze-imports.mjs";
+import { fixImport } from "./utils/fix-import.mjs";
+
+const USE_COMPUTED_INSTEAD = "Use `@computed` instead of `@{{name}}`";
+
+/**
+ * Fixer for the discourseComputed import.
+ * Handles removing or modifying the import based on whether all usages were converted.
+ */
+function fixDiscourseImport(
+  fixer,
+  importNode,
+  usageInfo,
+  sourceCode,
+  hasComputedImport,
+  emberObjectImportNode,
+  computedImportName,
+  discourseComputedLocalName
+) {
+  const fixes = [];
+  const {
+    hasFixableDecorators,
+    hasClassicClassDecorators,
+    hasParameterReassignments,
+    hasParametersInSpread,
+    hasUnsafeOptionalChaining,
+    hasParameterInNestedFunction,
+  } = usageInfo;
+
+  // Only provide fixes if there are fixable decorators
+  if (!hasFixableDecorators) {
+    return fixes;
+  }
+
+  // Check if there are other named imports in discourse/lib/decorators
+  const namedSpecifiers = importNode.specifiers.filter(
+    (spec) => spec.type === "ImportSpecifier"
+  );
+
+  // Determine the import string to use (with alias if needed)
+  const computedImportString =
+    computedImportName === "computed"
+      ? "computed"
+      : `computed as ${computedImportName}`;
+
+  // If there are no classic class decorators or non-fixable decorators remaining,
+  // we can potentially remove the discourseComputed import.
+  const hasRemainingUsage =
+    hasClassicClassDecorators ||
+    hasParameterReassignments ||
+    hasParametersInSpread ||
+    hasUnsafeOptionalChaining ||
+    hasParameterInNestedFunction;
+
+  if (!hasRemainingUsage) {
+    if (namedSpecifiers.length > 0) {
+      // Keep named imports, remove default import
+      fixes.push(
+        fixImport(fixer, importNode, {
+          defaultImport: false,
+        })
+      );
+
+      // Add computed to @ember/object import (if not already present)
+      if (!hasComputedImport) {
+        if (emberObjectImportNode) {
+          fixes.push(
+            fixImport(fixer, emberObjectImportNode, {
+              namedImportsToAdd: [computedImportString],
+            })
+          );
+        } else {
+          fixes.push(
+            fixer.insertTextAfter(
+              importNode,
+              `\nimport { ${computedImportString} } from "@ember/object";`
+            )
+          );
+        }
+      }
+    } else {
+      // No named imports, handle entire import line removal or replacement
+      if (!hasComputedImport) {
+        if (emberObjectImportNode) {
+          // Remove discourseComputed import, add computed to @ember/object
+          const nextChar = sourceCode.getText().charAt(importNode.range[1]);
+          const rangeEnd =
+            nextChar === "\n" ? importNode.range[1] + 1 : importNode.range[1];
+          fixes.push(fixer.removeRange([importNode.range[0], rangeEnd]));
+
+          fixes.push(
+            fixImport(fixer, emberObjectImportNode, {
+              namedImportsToAdd: [computedImportString],
+            })
+          );
+        } else {
+          // Replace discourseComputed import with @ember/object import
+          fixes.push(
+            fixer.replaceText(
+              importNode,
+              `import { ${computedImportString} } from "@ember/object";`
+            )
+          );
+        }
+      } else {
+        // computed already imported, just remove discourseComputed
+        const nextChar = sourceCode.getText().charAt(importNode.range[1]);
+        const rangeEnd =
+          nextChar === "\n" ? importNode.range[1] + 1 : importNode.range[1];
+        fixes.push(fixer.removeRange([importNode.range[0], rangeEnd]));
+      }
+    }
+  } else {
+    // Has remaining usages, keep discourseComputed import but add computed for fixable ones
+
+    // If the default import is named 'computed', rename it to 'discourseComputed' to avoid conflict
+    if (discourseComputedLocalName === "computed") {
+      const namedImportStrings = namedSpecifiers.map((spec) => {
+        if (spec.imported.name === spec.local.name) {
+          return spec.imported.name;
+        } else {
+          return `${spec.imported.name} as ${spec.local.name}`;
+        }
+      });
+
+      let newImportStatement = "import discourseComputed";
+      if (namedImportStrings.length > 0) {
+        newImportStatement += `, { ${namedImportStrings.join(", ")} }`;
+      }
+      newImportStatement += ` from "${importNode.source.value}";`;
+
+      fixes.push(fixer.replaceText(importNode, newImportStatement));
+    }
+
+    if (!hasComputedImport) {
+      if (emberObjectImportNode) {
+        fixes.push(
+          fixImport(fixer, emberObjectImportNode, {
+            namedImportsToAdd: [computedImportString],
+          })
+        );
+      } else {
+        fixes.push(
+          fixer.insertTextAfter(
+            importNode,
+            `\nimport { ${computedImportString} } from "@ember/object";`
+          )
+        );
+      }
+    }
+  }
+
+  return fixes;
+}
+
+export default {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description:
+        "Convert @discourseComputed decorators to native Ember @computed",
+    },
+    fixable: "code",
+    schema: [], // no options
+    messages: {
+      replaceImport:
+        'Use `import { computed } from "@ember/object";` instead of `import {{name}} from "discourse/lib/decorators";`.',
+      replaceDecorator: `${USE_COMPUTED_INSTEAD}.`,
+      cannotAutoFixClassic: `${USE_COMPUTED_INSTEAD}: convert this classic Ember class to a native ES6 class first.`,
+      cannotAutoFixNestedFunction: `${USE_COMPUTED_INSTEAD}: replace \`{{param}}\` manually with \`this.{{propertyPath}}\` — it's referenced inside a nested function.`,
+      cannotAutoFixUnsafeOptionalChaining: `${USE_COMPUTED_INSTEAD}: replace \`{{param}}\` manually with \`this.{{propertyPath}}\` — automatic optional chaining would be unsafe (e.g. use \`(this.{{propertyPath}} || "").someMethod()\`).`,
+      cannotAutoFixUpdateExpression: `${USE_COMPUTED_INSTEAD}: \`{{param}}\` uses update expressions (++/--). Convert manually using a local variable (e.g. \`let {{param}} = this.{{propertyPath}}; {{param}}++;\`).`,
+      cannotAutoFixNestedReassignment: `${USE_COMPUTED_INSTEAD}: \`{{param}}\` is reassigned inside a nested block. Convert manually using a local variable (e.g. \`let {{param}} = this.{{propertyPath}}; if (...) { {{param}} = ... }\`).`,
+      cannotAutoFixSpread: `${USE_COMPUTED_INSTEAD}: \`{{param}}\` is used in a spread. Convert manually (e.g. \`...(this.{{propertyPath}} || [])\`).`,
+      cannotAutoFixArguments: `${USE_COMPUTED_INSTEAD}: replace \`...arguments\` with explicit \`this.propertyName\` access.`,
+      cannotAutoFixGeneric: `${USE_COMPUTED_INSTEAD}: replace \`{{param}}\` manually with \`this.{{propertyPath}}\`.`,
+    },
+  },
+
+  create(context) {
+    const sourceCode = context.getSourceCode();
+    let hasComputedImport = false;
+    let emberObjectImportNode = null;
+    let discourseComputedInfo = null; // Cache info about discourseComputed decorators
+    let discourseComputedLocalName = null; // Track the local name used for discourseComputed import
+    let computedImportName = null; // Track what name to use for computed from @ember/object
+    let importsAnalyzed = false; // Track if we've scanned all imports
+
+    // We now use utilities in ./utils to keep this file focused on the rule logic.
+
+    // Wrapper that uses the generic helpers to populate rule-specific import state.
+    // We intentionally compute the specific values here (instead of in the utils
+    // module) so `utils/analyze-imports.mjs` remains generic and reusable.
+    function analyzeAllDiscourseComputedImports() {
+      if (importsAnalyzed) {
+        return;
+      }
+
+      const imports = collectImports(sourceCode);
+      const allImportedIdentifiers = getImportedLocalNames(sourceCode);
+
+      // @ember/object import
+      const emberNode = imports.get("@ember/object");
+      if (emberNode) {
+        emberObjectImportNode = emberNode.node;
+        const computedSpecifier = emberNode.specifiers.find(
+          (spec) =>
+            spec.type === "ImportSpecifier" &&
+            spec.imported &&
+            spec.imported.name === "computed"
+        );
+        if (computedSpecifier) {
+          hasComputedImport = true;
+          computedImportName = computedSpecifier.local.name;
+        }
+      }
+
+      // discourse default import
+      const discourseNode = imports.get("discourse/lib/decorators");
+      if (discourseNode) {
+        const defaultSpecifier = discourseNode.specifiers.find(
+          (spec) => spec.type === "ImportDefaultSpecifier"
+        );
+        if (defaultSpecifier) {
+          discourseComputedLocalName = defaultSpecifier.local.name;
+        }
+      }
+
+      if (!computedImportName) {
+        const isComputedUsedElsewhere =
+          allImportedIdentifiers.has("computed") &&
+          discourseComputedLocalName !== "computed";
+        computedImportName = isComputedUsedElsewhere
+          ? "emberComputed"
+          : "computed";
+      }
+
+      importsAnalyzed = true;
+    }
+
+    function analyzeDiscourseComputedUsage() {
+      if (discourseComputedInfo !== null) {
+        return discourseComputedInfo;
+      }
+      // Delegate to the reusable analyzer; keep result cached locally
+      discourseComputedInfo = analyzeDiscourseComputedUsageUtil(
+        sourceCode,
+        discourseComputedLocalName
+      );
+      return discourseComputedInfo;
+    }
+
+    return {
+      ImportDeclaration(node) {
+        // Analyze all imports first to avoid race conditions
+        analyzeAllDiscourseComputedImports();
+
+        // Handle import from "discourse/lib/decorators"
+        // The default export is discourseComputed, but it could be imported with any name
+        if (node.source.value === "discourse/lib/decorators") {
+          const defaultSpecifier = node.specifiers.find(
+            (spec) => spec.type === "ImportDefaultSpecifier"
+          );
+
+          if (defaultSpecifier) {
+            const usageInfo = analyzeDiscourseComputedUsage();
+
+            context.report({
+              node: defaultSpecifier,
+              messageId: "replaceImport",
+              data: { name: discourseComputedLocalName },
+              fix: (fixer) =>
+                fixDiscourseImport(
+                  fixer,
+                  node,
+                  usageInfo,
+                  sourceCode,
+                  hasComputedImport,
+                  emberObjectImportNode,
+                  computedImportName,
+                  discourseComputedLocalName
+                ),
+            });
+          }
+        }
+      },
+
+      CallExpression(node) {
+        const { usageMap } = analyzeDiscourseComputedUsage();
+        const usage = usageMap.get(node);
+        if (usage) {
+          context.report({
+            node,
+            messageId: usage.messageId,
+            data: usage.reportData,
+          });
+        }
+      },
+
+      Property: function (node) {
+        const { usageMap } = analyzeDiscourseComputedUsage();
+        const discourseDecorator = (node.decorators || []).find((decorator) =>
+          usageMap.has(decorator)
+        );
+
+        if (discourseDecorator) {
+          const usage = usageMap.get(discourseDecorator);
+          context.report({
+            node: discourseDecorator,
+            messageId: usage.messageId,
+            data: usage.reportData,
+          });
+        }
+      },
+
+      MethodDefinition: function (node) {
+        if (!node.decorators || node.decorators.length === 0) {
+          return;
+        }
+
+        const { usageMap, hasParameterReassignments } =
+          analyzeDiscourseComputedUsage();
+        const discourseComputedDecorator = node.decorators.find((decorator) =>
+          usageMap.has(decorator)
+        );
+
+        if (!discourseComputedDecorator) {
+          return;
+        }
+
+        const usage = usageMap.get(discourseComputedDecorator);
+        const { canAutoFix, messageId, reportData, simpleReassignments } =
+          usage;
+
+        // Determine if we need to rename non-fixable decorators
+        // This happens when: import was originally named 'computed', we're keeping it (mixed scenario),
+        // and we renamed it to 'discourseComputed'
+        const needsDecoratorRename =
+          !canAutoFix &&
+          hasParameterReassignments &&
+          discourseComputedLocalName === "computed";
+
+        const decoratorExpression = discourseComputedDecorator.expression;
+        let decoratorArgs = [];
+        if (decoratorExpression.type === "CallExpression") {
+          decoratorArgs = decoratorExpression.arguments
+            .map((arg) => (arg.type === "Literal" ? arg.value : null))
+            .filter(Boolean);
+        }
+
+        context.report({
+          node: discourseComputedDecorator,
+          messageId: messageId || "replaceDecorator",
+          data: reportData,
+          fix: !canAutoFix
+            ? needsDecoratorRename
+              ? function (fixer) {
+                  // Just rename the decorator to match the renamed import
+                  if (decoratorExpression.type === "CallExpression") {
+                    return fixer.replaceText(
+                      decoratorExpression.callee,
+                      "discourseComputed"
+                    );
+                  } else {
+                    return fixer.replaceText(
+                      decoratorExpression,
+                      "discourseComputed"
+                    );
+                  }
+                }
+              : undefined
+            : createMethodFix(
+                sourceCode,
+                node,
+                decoratorArgs,
+                computedImportName,
+                { simpleReassignments }
+              ),
+        });
+      },
+    };
+  },
+};