Merge branch 'master' into post-merge-review/no-this-in-template-only-components

johanrd · web-flow · commit a950a9f2da1d · 2026-04-12T00:58:46.000+02:00
diff --git a/README.md b/README.md
@@ -284,7 +284,7 @@ rules in templates can be disabled with eslint directives with mustache or html
 | [template-self-closing-void-elements](docs/rules/template-self-closing-void-elements.md)                           | require self-closing on void elements                                        |    | 🔧 |    |
 | [template-simple-modifiers](docs/rules/template-simple-modifiers.md)                                               | require simple modifier syntax                                               |    |    |    |
 | [template-simple-unless](docs/rules/template-simple-unless.md)                                                     | require simple conditions in unless blocks                                   |    |    |    |
-| [template-sort-invocations](docs/rules/template-sort-invocations.md)                                               | require sorted attributes and modifiers                                      |    |    |    |
+| [template-sort-invocations](docs/rules/template-sort-invocations.md)                                               | require sorted attributes and modifiers                                      |    | 🔧 |    |
 | [template-splat-attributes-only](docs/rules/template-splat-attributes-only.md)                                     | disallow ...spread other than ...attributes                                  |    |    |    |
 | [template-style-concatenation](docs/rules/template-style-concatenation.md)                                         | disallow string concatenation in inline styles                               |    |    |    |
 
diff --git a/docs/rules/template-sort-invocations.md b/docs/rules/template-sort-invocations.md
@@ -1,5 +1,7 @@
 # ember/template-sort-invocations
 
+🔧 This rule is automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).
+
 <!-- end auto-generated rule header -->
 
 ## Why use it?
diff --git a/lib/rules/template-no-unused-block-params.js b/lib/rules/template-no-unused-block-params.js
@@ -24,6 +24,9 @@ function collectChildNodes(n) {
   if (n.children) {
     children.push(...n.children);
   }
+  if (n.modifiers) {
+    children.push(...n.modifiers);
+  }
   // GlimmerPathExpression also has 'parts', so make sure we're not treating
   // concat'd path string parts as AST nodes.
   if (n.type === 'GlimmerConcatStatement' && n.parts) {
@@ -56,6 +59,113 @@ function buildShadowedSet(shadowedParams, innerBlockParams, outerBlockParams) {
   return newShadowed;
 }
 
+function checkBlockParts(n, blockParams, usedParams, shadowedParams, newShadowed, checkNodeFn) {
+  // Check the path/params of the block statement itself with current scope
+  if (n.path) {
+    checkNodeFn(n.path, shadowedParams);
+  }
+  if (n.params) {
+    for (const param of n.params) {
+      checkNodeFn(param, shadowedParams);
+    }
+  }
+  if (n.hash?.pairs) {
+    for (const pair of n.hash.pairs) {
+      checkNodeFn(pair.value, shadowedParams);
+    }
+  }
+
+  // Check the program body with the updated shadowed set
+  if (n.program) {
+    checkNodeFn(n.program, newShadowed);
+  }
+  if (n.inverse) {
+    checkNodeFn(n.inverse, newShadowed);
+  }
+}
+
+/**
+ * Scan child nodes for usage of blockParams, then report the first unused
+ * trailing param. Shared by both GlimmerBlockStatement and GlimmerElementNode.
+ */
+function checkUnusedBlockParams(context, node, blockParams, startNodes) {
+  const usedParams = new Set();
+
+  function checkNode(n, shadowedParams) {
+    if (!n) {
+      return;
+    }
+
+    if (n.type === 'GlimmerPathExpression') {
+      markParamIfUsed(n.original, blockParams, usedParams, shadowedParams);
+    }
+
+    if (n.type === 'GlimmerElementNode') {
+      markParamIfUsed(n.tag, blockParams, usedParams, shadowedParams);
+    }
+
+    if (isPartialStatement(n)) {
+      for (const p of blockParams) {
+        if (!shadowedParams.has(p)) {
+          usedParams.add(p);
+        }
+      }
+    }
+
+    // Nested block with its own blockParams — shadow them
+    if (n.type === 'GlimmerBlockStatement' && n.program?.blockParams?.length > 0) {
+      const newShadowed = buildShadowedSet(shadowedParams, n.program.blockParams, blockParams);
+      checkBlockParts(n, blockParams, usedParams, shadowedParams, newShadowed, checkNode);
+      return;
+    }
+
+    // Nested element with block params (e.g. <Component as |x|>) — shadow them
+    if (n.type === 'GlimmerElementNode' && n.blockParams?.length > 0) {
+      const newShadowed = buildShadowedSet(shadowedParams, n.blockParams, blockParams);
+      if (n.attributes) {
+        for (const attr of n.attributes) {
+          checkNode(attr.value, shadowedParams);
+        }
+      }
+      if (n.children) {
+        for (const child of n.children) {
+          checkNode(child, newShadowed);
+        }
+      }
+      return;
+    }
+
+    for (const child of collectChildNodes(n)) {
+      checkNode(child, shadowedParams);
+    }
+  }
+
+  for (const startNode of startNodes) {
+    checkNode(startNode, new Set());
+  }
+
+  // Find the last index of a used param
+  let lastUsedIndex = -1;
+  for (let i = blockParams.length - 1; i >= 0; i--) {
+    if (usedParams.has(blockParams[i])) {
+      lastUsedIndex = i;
+      break;
+    }
+  }
+
+  // Only report trailing unused params (after the last used one)
+  const unusedTrailing = blockParams.slice(lastUsedIndex + 1);
+  const firstUnusedTrailing = unusedTrailing[0];
+
+  if (firstUnusedTrailing) {
+    context.report({
+      node,
+      messageId: 'unusedBlockParam',
+      data: { param: firstUnusedTrailing },
+    });
+  }
+}
+
 /** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
@@ -82,98 +192,17 @@ module.exports = {
     return {
       GlimmerBlockStatement(node) {
         const blockParams = node.program?.blockParams || [];
-        if (blockParams.length === 0) {
-          return;
+        if (blockParams.length > 0) {
+          checkUnusedBlockParams(context, node, blockParams, [node.program]);
         }
+      },
 
-        const usedParams = new Set();
-
-        function checkNode(n, shadowedParams) {
-          if (!n) {
-            return;
-          }
-
-          if (n.type === 'GlimmerPathExpression') {
-            markParamIfUsed(n.original, blockParams, usedParams, shadowedParams);
-          }
-
-          if (n.type === 'GlimmerElementNode') {
-            markParamIfUsed(n.tag, blockParams, usedParams, shadowedParams);
-          }
-
-          if (isPartialStatement(n)) {
-            for (const p of blockParams) {
-              if (!shadowedParams.has(p)) {
-                usedParams.add(p);
-              }
-            }
-          }
-
-          // When entering a nested block, add its blockParams to the shadowed set
-          if (n.type === 'GlimmerBlockStatement' && n.program?.blockParams?.length > 0) {
-            const newShadowed = buildShadowedSet(
-              shadowedParams,
-              n.program.blockParams,
-              blockParams
-            );
-            checkBlockParts(n, blockParams, usedParams, shadowedParams, newShadowed, checkNode);
-            return;
-          }
-
-          // Recursively check children
-          for (const child of collectChildNodes(n)) {
-            checkNode(child, shadowedParams);
-          }
-        }
-
-        checkNode(node.program, new Set());
-
-        // Find the last index of a used param
-        let lastUsedIndex = -1;
-        for (let i = blockParams.length - 1; i >= 0; i--) {
-          if (usedParams.has(blockParams[i])) {
-            lastUsedIndex = i;
-            break;
-          }
-        }
-
-        // Only report trailing unused params (after the last used one)
-        const unusedTrailing = blockParams.slice(lastUsedIndex + 1);
-        const firstUnusedTrailing = unusedTrailing[0];
-
-        if (firstUnusedTrailing) {
-          context.report({
-            node,
-            messageId: 'unusedBlockParam',
-            data: { param: firstUnusedTrailing },
-          });
+      GlimmerElementNode(node) {
+        const blockParams = node.blockParams || [];
+        if (blockParams.length > 0) {
+          checkUnusedBlockParams(context, node, blockParams, node.children || []);
         }
       },
     };
   },
 };
-
-function checkBlockParts(n, blockParams, usedParams, shadowedParams, newShadowed, checkNodeFn) {
-  // Check the path/params of the block statement itself with current scope
-  if (n.path) {
-    checkNodeFn(n.path, shadowedParams);
-  }
-  if (n.params) {
-    for (const param of n.params) {
-      checkNodeFn(param, shadowedParams);
-    }
-  }
-  if (n.hash?.pairs) {
-    for (const pair of n.hash.pairs) {
-      checkNodeFn(pair.value, shadowedParams);
-    }
-  }
-
-  // Check the program body with the updated shadowed set
-  if (n.program) {
-    checkNodeFn(n.program, newShadowed);
-  }
-  if (n.inverse) {
-    checkNodeFn(n.inverse, newShadowed);
-  }
-}
diff --git a/lib/rules/template-sort-invocations.js b/lib/rules/template-sort-invocations.js
@@ -9,7 +9,7 @@ module.exports = {
       url: 'https://github.com/ember-cli/eslint-plugin-ember/tree/master/docs/rules/template-sort-invocations.md',
       templateMode: 'both',
     },
-    fixable: null,
+    fixable: 'code',
     schema: [],
     messages: {
       attributeOrder: '`{{attributeName}}` must appear after `{{expectedAfter}}`',
@@ -26,6 +26,24 @@ module.exports = {
   },
 
   create(context) {
+    const sourceCode = context.sourceCode;
+
+    // Glimmer attribute and modifier nodes can have trailing whitespace
+    // absorbed into their range, so we strip the trailing whitespace from
+    // each side and re-append it at the end of the swapped output.
+    function createSwapFix(fixer, nodeA, nodeB) {
+      const rawA = sourceCode.getText(nodeA);
+      const rawB = sourceCode.getText(nodeB);
+      const contentA = rawA.trimEnd();
+      const contentB = rawB.trimEnd();
+      const separator = sourceCode.text.slice(nodeA.range[0] + contentA.length, nodeB.range[0]);
+      const trailing = rawB.slice(contentB.length);
+      return fixer.replaceTextRange(
+        [nodeA.range[0], nodeB.range[1]],
+        contentB + separator + contentA + trailing
+      );
+    }
+
     function getAttributeName(node) {
       return node.name;
     }
@@ -171,6 +189,9 @@ module.exports = {
                 attributeName: getAttributeName(attributes[index]),
                 expectedAfter: getAttributeName(attributes[index + 1]),
               },
+              fix(fixer) {
+                return createSwapFix(fixer, attributes[index], attributes[index + 1]);
+              },
             });
           }
         }
@@ -186,13 +207,28 @@ module.exports = {
                 modifierName: getModifierName(modifiers[index]),
                 expectedAfter: getModifierName(modifiers[index + 1]),
               },
+              fix(fixer) {
+                return createSwapFix(fixer, modifiers[index], modifiers[index + 1]);
+              },
             });
           }
         }
 
         if (!canSkipSplattributesLast(node)) {
           const splattributes = attributes.at(-1);
 
+          // Swap ...attributes past the first modifier that appears after it;
+          // ESLint's fix loop continues until splattributes is fully sorted.
+          // canSkipSplattributesLast guarantees at least one such modifier exists.
+          const firstModifierAfter = modifiers.find(
+            (mod) =>
+              mod.loc.start.line > splattributes.loc.start.line ||
+              (mod.loc.start.line === splattributes.loc.start.line &&
+                mod.loc.start.column > splattributes.loc.start.column)
+          );
+
+          const splatFixFn = (fixer) => createSwapFix(fixer, splattributes, firstModifierAfter);
+
           // When ...attributes is the only attribute, report as attributeOrder
           // (the ordering issue is that ...attributes should appear after modifiers)
           if (attributes.length === 1) {
@@ -203,11 +239,13 @@ module.exports = {
                 attributeName: '...attributes',
                 expectedAfter: 'modifiers',
               },
+              fix: splatFixFn,
             });
           } else {
             context.report({
               node: splattributes,
               messageId: 'splattributesOrder',
+              fix: splatFixFn,
             });
           }
         }
@@ -225,6 +263,9 @@ module.exports = {
                 hashPairName: getHashPairName(node.hash.pairs[index]),
                 expectedAfter: getHashPairName(node.hash.pairs[index + 1]),
               },
+              fix(fixer) {
+                return createSwapFix(fixer, node.hash.pairs[index], node.hash.pairs[index + 1]);
+              },
             });
           }
         }
@@ -244,6 +285,10 @@ module.exports = {
               node.params.length > 0 &&
               node.params[0].type === 'GlimmerStringLiteral';
 
+            const fixFn = function (fixer) {
+              return createSwapFix(fixer, node.hash.pairs[index], node.hash.pairs[index + 1]);
+            };
+
             if (isComponentInvocation) {
               context.report({
                 node: node.hash.pairs[index],
@@ -252,6 +297,7 @@ module.exports = {
                   attributeName: getHashPairName(node.hash.pairs[index]),
                   expectedAfter: getHashPairName(node.hash.pairs[index + 1]),
                 },
+                fix: fixFn,
               });
             } else {
               context.report({
@@ -261,6 +307,7 @@ module.exports = {
                   hashPairName: getHashPairName(node.hash.pairs[index]),
                   expectedAfter: getHashPairName(node.hash.pairs[index + 1]),
                 },
+                fix: fixFn,
               });
             }
           }
@@ -279,6 +326,9 @@ module.exports = {
                 hashPairName: getHashPairName(node.hash.pairs[index]),
                 expectedAfter: getHashPairName(node.hash.pairs[index + 1]),
               },
+              fix(fixer) {
+                return createSwapFix(fixer, node.hash.pairs[index], node.hash.pairs[index + 1]);
+              },
             });
           }
         }
diff --git a/tests/lib/rules/template-no-unused-block-params.js b/tests/lib/rules/template-no-unused-block-params.js
diff --git a/tests/lib/rules/template-sort-invocations.js b/tests/lib/rules/template-sort-invocations.js
