@discourse/lint-configs 2.44.1 → 2.45.0

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

@@ -0,0 +1,436 @@
+/**
+ * @fileoverview ESLint rule to replace computed property macro decorators
+ * from `@ember/object/computed` and `discourse/lib/computed` with native
+ * getters using `@computed` or `@dependentKeyCompat` + `@tracked`.
+ */
+
+import { analyzeMacroUsage } from "./no-computed-macros/computed-macros-analysis.mjs";
+import { createClassFix } from "./no-computed-macros/computed-macros-fixer.mjs";
+import { MACRO_SOURCES } from "./no-computed-macros/macro-transforms.mjs";
+import {
+  collectImports,
+  getImportedLocalNames,
+} from "./utils/analyze-imports.mjs";
+import { buildImportStatement, fixImport } from "./utils/fix-import.mjs";
+
+const USE_NATIVE_GETTER_INSTEAD = "Use a native getter instead of `@{{name}}`";
+
+export default {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Replace computed property macros with native getters",
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      replaceMacro: `${USE_NATIVE_GETTER_INSTEAD}.`,
+      addTracked:
+        "Add `@tracked` to `{{name}}` (dependency of a converted macro).",
+      cannotAutoFixComplex: `${USE_NATIVE_GETTER_INSTEAD}: {{reason}}.`,
+      cannotAutoFixDynamic: `${USE_NATIVE_GETTER_INSTEAD}: it has non-literal arguments (convert manually).`,
+      cannotAutoFixSelfReference: `${USE_NATIVE_GETTER_INSTEAD}: \`{{propName}}\` references itself (convert manually).`,
+    },
+  },
+
+  create(context) {
+    const sourceCode = context.getSourceCode();
+    let analysis = null;
+    let importsMap = null;
+    let importFixGenerated = false;
+
+    function ensureAnalysis() {
+      if (analysis) {
+        return analysis;
+      }
+      importsMap = collectImports(sourceCode);
+      analysis = analyzeMacroUsage(sourceCode, importsMap);
+      return analysis;
+    }
+
+    // Precompute per-class fixable usages and existing nodes to decorate.
+    // Lazily initialised on first access (like analysis).
+    let classFixes = null;
+    function ensureClassFixes() {
+      if (classFixes) {
+        return classFixes;
+      }
+      const { usages } = ensureAnalysis();
+      classFixes = new Map();
+
+      for (const usage of usages) {
+        if (!usage.canAutoFix) {
+          continue;
+        }
+        const classBody = usage.propertyNode.parent;
+        if (!classFixes.has(classBody)) {
+          classFixes.set(classBody, {
+            fixableUsages: [],
+            existingNodesToDecorate: new Set(),
+          });
+        }
+        const entry = classFixes.get(classBody);
+        entry.fixableUsages.push(usage);
+        if (usage.existingNodesToDecorate) {
+          for (const node of usage.existingNodesToDecorate) {
+            entry.existingNodesToDecorate.add(node);
+          }
+        }
+      }
+
+      return classFixes;
+    }
+
+    // Track which class bodies have already had a combined fix attached
+    const classFixAttached = new Set();
+
+    return {
+      // Report on macro import declarations — only the import-level fix here
+      ImportDeclaration(node) {
+        if (!MACRO_SOURCES.has(node.source.value)) {
+          return;
+        }
+
+        const { usages, importedMacros, macroImportNodes } = ensureAnalysis();
+
+        // Only report specifiers that have at least one usage in a native class
+        const usedLocalNames = new Set(usages.map((u) => u.localName));
+        const macroSpecifiers = node.specifiers.filter(
+          (spec) =>
+            spec.type === "ImportSpecifier" &&
+            importedMacros.has(spec.local.name) &&
+            usedLocalNames.has(spec.local.name)
+        );
+
+        if (macroSpecifiers.length === 0) {
+          return;
+        }
+
+        const fixableUsages = usages.filter((u) => u.canAutoFix);
+        const hasAnyFix = fixableUsages.length > 0;
+
+        // Build the import fix ONCE across all macro import declarations.
+        // When a file imports from both @ember/object/computed and
+        // discourse/lib/computed, we must handle all import nodes in a
+        // single fix to avoid duplicate new import lines.
+        let importFix;
+        if (hasAnyFix && !importFixGenerated) {
+          importFixGenerated = true;
+          importFix = (fixer) =>
+            buildImportFixes(fixer, {
+              sourceCode,
+              importsMap,
+              usages: fixableUsages,
+              macroImportNodes,
+            });
+        }
+
+        let fixAttached = false;
+        for (const spec of macroSpecifiers) {
+          const macroName = importedMacros.get(spec.local.name);
+          context.report({
+            node: spec,
+            messageId: "replaceMacro",
+            data: { name: macroName },
+            fix: !fixAttached ? importFix : undefined,
+          });
+          fixAttached = true;
+        }
+      },
+
+      // Report on each macro usage in class bodies.
+      // The combined class-body fix (remove macros + insert getters at the
+      // correct position) is attached to the FIRST fixable macro per class.
+      PropertyDefinition(node) {
+        if (!node.decorators) {
+          return;
+        }
+
+        const { usages } = ensureAnalysis();
+        const usage = usages.find((u) => u.propertyNode === node);
+
+        if (!usage) {
+          return;
+        }
+
+        let fix;
+        if (usage.canAutoFix) {
+          const classBody = node.parent;
+          const fixesMap = ensureClassFixes();
+          const classEntry = fixesMap.get(classBody);
+          if (classEntry && !classFixAttached.has(classBody)) {
+            classFixAttached.add(classBody);
+            fix = createClassFix(
+              classEntry.fixableUsages,
+              classEntry.existingNodesToDecorate,
+              sourceCode
+            );
+          }
+        }
+
+        context.report({
+          node: usage.decoratorNode || node,
+          messageId: usage.messageId || "replaceMacro",
+          data: usage.reportData || { name: usage.macroName },
+          fix,
+        });
+      },
+
+      // Report @tracked additions for existing class members.
+      // The actual fix is included in the combined class-body fix
+      // (attached to the first fixable macro in each class) to avoid
+      // overlapping fix ranges.
+      "Program:exit"() {
+        const { usages } = ensureAnalysis();
+        const decorated = new Set();
+
+        for (const usage of usages) {
+          if (!usage.canAutoFix || !usage.existingNodesToDecorate) {
+            continue;
+          }
+          for (const memberNode of usage.existingNodesToDecorate) {
+            if (decorated.has(memberNode)) {
+              continue;
+            }
+            decorated.add(memberNode);
+
+            const name =
+              memberNode.key.type === "Identifier"
+                ? memberNode.key.name
+                : String(memberNode.key.value);
+            context.report({
+              node: memberNode,
+              messageId: "addTracked",
+              data: { name },
+            });
+          }
+        }
+      },
+    };
+  },
+};
+
+// ---------------------------------------------------------------------------
+// Import fix builder
+// ---------------------------------------------------------------------------
+
+/**
+ * Build import-related fixes for ALL fixable macro usages.
+ *
+ * This function handles ALL macro import nodes at once to avoid producing
+ * duplicate new import lines when a file imports macros from both
+ * `@ember/object/computed` and `discourse/lib/computed`.
+ *
+ * Note: adding `@tracked` to existing class members is handled by the
+ * combined class-body fix (in `createClassFix`), not here.
+ *
+ * @returns {import('eslint').Rule.Fix[]}
+ */
+function buildImportFixes(
+  fixer,
+  { sourceCode, importsMap, usages, macroImportNodes }
+) {
+  const fixes = [];
+  const allImportedNames = getImportedLocalNames(sourceCode);
+
+  // Exclude names we're about to remove from the collision set
+  const fixableLocalNames = new Set(usages.map((u) => u.localName));
+  for (const name of fixableLocalNames) {
+    allImportedNames.delete(name);
+  }
+
+  // Collect all required new imports from fixable usages
+  const newImports = collectRequiredImports(usages);
+
+  // Determine conditional imports based on dep classification
+  const needsComputed = usages.some((u) => !u.allLocal);
+  const needsDependentKeyCompat = usages.some((u) => u.allLocal);
+  const needsTracked = usages.some(
+    (u) =>
+      (u.allLocal &&
+        (u.trackedDeps?.length > 0 || u.existingNodesToDecorate?.length > 0)) ||
+      u.transform.overrideTrackedFields
+  );
+
+  // Add in the order we want them to appear in the output
+  if (needsTracked) {
+    addToImportSet(newImports, "@glimmer/tracking", "tracked");
+  }
+  if (needsComputed) {
+    addToImportSet(newImports, "@ember/object", "computed");
+  }
+  // Setter-specific imports (e.g. set from @ember/object for alias).
+  // Added after computed so that named imports appear in the right order.
+  for (const usage of usages) {
+    if (!usage.allLocal && usage.transform.setterRequiredImports) {
+      for (const req of usage.transform.setterRequiredImports) {
+        addToImportSet(newImports, req.source, req.name, req.isDefault);
+      }
+    }
+  }
+  if (needsDependentKeyCompat) {
+    addToImportSet(newImports, "@ember/object/compat", "dependentKeyCompat");
+  }
+
+  // Build new import lines for required imports (once for all macro sources)
+  const newImportLines = [];
+  for (const [source, names] of newImports) {
+    const existing = importsMap.get(source);
+
+    if (existing) {
+      // Modify existing import — generate a fixImport call
+      const existingNamedSet = new Set(
+        existing.specifiers
+          .filter((s) => s.type === "ImportSpecifier")
+          .map((s) => s.imported.name)
+      );
+      const defaultSpec = existing.specifiers.find(
+        (s) => s.type === "ImportDefaultSpecifier"
+      );
+
+      const namedToAdd = [];
+      let defaultToAdd;
+
+      for (const { name, isDefault } of names) {
+        if (isDefault) {
+          if (!defaultSpec) {
+            defaultToAdd = name;
+          }
+        } else if (!existingNamedSet.has(name)) {
+          const localName = allImportedNames.has(name) ? `${name}Import` : name;
+          namedToAdd.push(
+            localName === name ? name : `${name} as ${localName}`
+          );
+        }
+      }
+
+      if (namedToAdd.length > 0 || defaultToAdd) {
+        fixes.push(
+          fixImport(fixer, existing.node, {
+            defaultImport: defaultToAdd,
+            namedImportsToAdd: namedToAdd,
+          })
+        );
+      }
+    } else {
+      // Build a new import line string (will be appended below)
+      newImportLines.push(
+        resolveNewImportLine(source, names, allImportedNames)
+      );
+    }
+  }
+
+  // Process each macro import node — remove/replace specifiers
+  let newImportsPlaced = false;
+  for (const [, importNode] of macroImportNodes) {
+    const removableSpecifiers = importNode.specifiers.filter(
+      (spec) =>
+        spec.type === "ImportSpecifier" &&
+        fixableLocalNames.has(spec.local.name) &&
+        usages
+          .filter((u) => u.localName === spec.local.name)
+          .every((u) => u.canAutoFix)
+    );
+    const remainingSpecifiers = importNode.specifiers.filter(
+      (s) => !removableSpecifiers.includes(s)
+    );
+
+    if (removableSpecifiers.length === 0) {
+      continue;
+    }
+
+    if (remainingSpecifiers.length === 0) {
+      // All specifiers removed — replace with new imports or remove entirely
+      if (!newImportsPlaced && newImportLines.length > 0) {
+        fixes.push(fixer.replaceText(importNode, newImportLines.join("\n")));
+        newImportsPlaced = true;
+      } else {
+        // Remove the entire import line (including trailing newline)
+        const text = sourceCode.getText();
+        let end = importNode.range[1];
+        if (end < text.length && text[end] === "\n") {
+          end++;
+        }
+        fixes.push(fixer.removeRange([importNode.range[0], end]));
+      }
+    } else {
+      // Some specifiers remain — remove fixable ones
+      const namesToRemove = removableSpecifiers.map((s) => s.imported.name);
+      fixes.push(
+        fixImport(fixer, importNode, {
+          namedImportsToRemove: namesToRemove,
+        })
+      );
+
+      // Append new import lines after this import (only once)
+      if (!newImportsPlaced && newImportLines.length > 0) {
+        for (const line of newImportLines) {
+          fixes.push(fixer.insertTextAfter(importNode, `\n${line}`));
+        }
+        newImportsPlaced = true;
+      }
+    }
+  }
+
+  return fixes;
+}
+
+/**
+ * Resolve import names (handling collisions) and delegate to
+ * the shared `buildImportStatement` utility.
+ *
+ * @param {string} source
+ * @param {Array<{name: string, isDefault?: boolean}>} names
+ * @param {Set<string>} allImportedNames
+ * @returns {string}
+ */
+function resolveNewImportLine(source, names, allImportedNames) {
+  const namedImports = [];
+  let defaultImport;
+
+  for (const { name, isDefault } of names) {
+    if (isDefault) {
+      defaultImport = name;
+    } else {
+      const localName = allImportedNames.has(name) ? `${name}Import` : name;
+      namedImports.push(localName === name ? name : `${name} as ${localName}`);
+    }
+  }
+
+  return buildImportStatement(source, { defaultImport, namedImports });
+}
+
+// ---------------------------------------------------------------------------
+// Import helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Collect all required imports from fixable usages into a Map.
+ */
+function collectRequiredImports(usages) {
+  const result = new Map();
+
+  for (const usage of usages) {
+    if (!usage.canAutoFix || !usage.transform.requiredImports) {
+      continue;
+    }
+    for (const req of usage.transform.requiredImports) {
+      addToImportSet(result, req.source, req.name, req.isDefault);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Add a named or default import to the import set, avoiding duplicates.
+ */
+function addToImportSet(importSet, source, name, isDefault = false) {
+  if (!importSet.has(source)) {
+    importSet.set(source, []);
+  }
+  const list = importSet.get(source);
+  if (!list.some((i) => i.name === name && i.isDefault === isDefault)) {
+    list.push({ name, isDefault });
+  }
+}

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

@@ -4,7 +4,7 @@ import {
   collectImports,
   getImportedLocalNames,
 } from "./utils/analyze-imports.mjs";
-import { fixImport } from "./utils/fix-import.mjs";
+import { buildImportStatement, fixImport } from "./utils/fix-import.mjs";
 
 const USE_COMPUTED_INSTEAD = "Use `@computed` instead of `@{{name}}`";
 
@@ -75,12 +75,10 @@ function fixDiscourseImport(
             })
           );
         } else {
-          fixes.push(
-            fixer.insertTextAfter(
-              importNode,
-              `\nimport { ${computedImportString} } from "@ember/object";`
-            )
-          );
+          const newImport = buildImportStatement("@ember/object", {
+            namedImports: [computedImportString],
+          });
+          fixes.push(fixer.insertTextAfter(importNode, `\n${newImport}`));
         }
       }
     } else {
@@ -103,7 +101,9 @@ function fixDiscourseImport(
           fixes.push(
             fixer.replaceText(
               importNode,
-              `import { ${computedImportString} } from "@ember/object";`
+              buildImportStatement("@ember/object", {
+                namedImports: [computedImportString],
+              })
             )
           );
         }
@@ -128,13 +128,15 @@ function fixDiscourseImport(
         }
       });
 
-      let newImportStatement = "import discourseComputed";
-      if (namedImportStrings.length > 0) {
-        newImportStatement += `, { ${namedImportStrings.join(", ")} }`;
-      }
-      newImportStatement += ` from "${importNode.source.value}";`;
-
-      fixes.push(fixer.replaceText(importNode, newImportStatement));
+      fixes.push(
+        fixer.replaceText(
+          importNode,
+          buildImportStatement(importNode.source.value, {
+            defaultImport: "discourseComputed",
+            namedImports: namedImportStrings,
+          })
+        )
+      );
     }
 
     if (!hasComputedImport) {
@@ -145,12 +147,10 @@ function fixDiscourseImport(
           })
         );
       } else {
-        fixes.push(
-          fixer.insertTextAfter(
-            importNode,
-            `\nimport { ${computedImportString} } from "@ember/object";`
-          )
-        );
+        const newImport = buildImportStatement("@ember/object", {
+          namedImports: [computedImportString],
+        });
+        fixes.push(fixer.insertTextAfter(importNode, `\n${newImport}`));
       }
     }
   }

package/eslint-rules/truth-helpers-imports.mjs

@@ -1,3 +1,5 @@
+import { buildImportStatement } from "./utils/fix-import.mjs";
+
 export default {
   meta: {
     type: "suggestion",
@@ -24,11 +26,13 @@ export default {
                 sourceName = "notEq";
               }
 
-              if (localName === sourceName) {
-                code = `import { ${localName} } from 'truth-helpers';`;
-              } else {
-                code = `import { ${sourceName} as ${localName} } from 'truth-helpers';`;
-              }
+              const namedImport =
+                localName === sourceName
+                  ? localName
+                  : `${sourceName} as ${localName}`;
+              code = buildImportStatement("truth-helpers", {
+                namedImports: [namedImport],
+              });
 
               return fixer.replaceText(node, code);
             },

package/eslint-rules/utils/fix-import.mjs

@@ -1,3 +1,31 @@
+/**
+ * Build an import statement string from its parts.
+ *
+ * @param {string} source - The import source (e.g. "@ember/object").
+ * @param {Object} [options]
+ * @param {string|null} [options.defaultImport] - Default import name, or null.
+ * @param {string[]} [options.namedImports] - Named import specifiers (may include aliases like "foo as bar").
+ * @param {string} [options.quote] - Quote style: `"` (default) or `'`.
+ * @returns {string} A complete import statement string.
+ */
+export function buildImportStatement(
+  source,
+  { defaultImport = null, namedImports = [] } = {}
+) {
+  let stmt = "import ";
+  if (defaultImport) {
+    stmt += defaultImport;
+    if (namedImports.length > 0) {
+      stmt += ", ";
+    }
+  }
+  if (namedImports.length > 0) {
+    stmt += `{ ${namedImports.join(", ")} }`;
+  }
+  stmt += ` from "${source}";`;
+  return stmt;
+}
+
 /**
  * Fix an import declaration
  *
@@ -51,18 +79,10 @@ export function fixImport(
     ])
   );
 
-  // Construct the new import statement
-  let newImportStatement = "import ";
-  if (finalDefaultImport) {
-    newImportStatement += `${finalDefaultImport}`;
-    if (finalNamedImports.length > 0) {
-      newImportStatement += ", ";
-    }
-  }
-  if (finalNamedImports.length > 0) {
-    newImportStatement += `{ ${finalNamedImports.join(", ")} }`;
-  }
-  newImportStatement += ` from "${importDeclarationNode.source.value}";`;
+  const newImportStatement = buildImportStatement(
+    importDeclarationNode.source.value,
+    { defaultImport: finalDefaultImport, namedImports: finalNamedImports }
+  );
 
   // Replace the entire import declaration
   return fixer.replaceText(importDeclarationNode, newImportStatement);

package/eslint.mjs

@@ -23,6 +23,7 @@ import lineBeforeDefaultExport from "./eslint-rules/line-before-default-export.m
 import linesBetweenClassMembers from "./eslint-rules/lines-between-class-members.mjs";
 import migrateTrackedBuiltInsToEmberCollections from "./eslint-rules/migrate-tracked-built-ins-to-ember-collections.mjs";
 import movedPackagesImportPaths from "./eslint-rules/moved-packages-import-paths.mjs";
+import noComputedMacros from "./eslint-rules/no-computed-macros.mjs";
 import noCurlyComponents from "./eslint-rules/no-curly-components.mjs";
 import noDiscourseComputed from "./eslint-rules/no-discourse-computed.mjs";
 import noOnclick from "./eslint-rules/no-onclick.mjs";
@@ -146,6 +147,7 @@ export default [
           "no-route-template": noRouteTemplate,
           "template-tag-no-self-this": templateTagNoSelfThis,
           "moved-packages-import-paths": movedPackagesImportPaths,
+          "no-computed-macros": noComputedMacros,
           "no-discourse-computed": noDiscourseComputed,
           "test-filename-suffix": testFilenameSuffix,
           "no-unnecessary-tracked": noUnnecessaryTracked,
@@ -313,8 +315,9 @@ export default [
       "discourse/no-route-template": ["error"],
       "discourse/moved-packages-import-paths": ["error"],
       "discourse/test-filename-suffix": ["error"],
-      "discourse/keep-array-sorted": ["error"],
+      "discourse/no-computed-macros": ["error"],
       "discourse/no-discourse-computed": ["error"],
+      "discourse/keep-array-sorted": ["error"],
       "discourse/no-unnecessary-tracked": ["warn"],
       "discourse/migrate-tracked-built-ins-to-ember-collections": ["error"],
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@discourse/lint-configs",
-  "version": "2.44.1",
+  "version": "2.45.0",
   "description": "Shareable lint configs for Discourse core, plugins, and themes",
   "author": "Discourse",
   "license": "MIT",