Extract rule: template-no-unused-block-params

Author: NullVoxPopuli

README.md

@@ -255,6 +255,7 @@ rules in templates can be disabled with eslint directives with mustache or html
 | [template-no-obsolete-elements](docs/rules/template-no-obsolete-elements.md)                                       | disallow obsolete HTML elements                                              |    |    |    |
 | [template-no-outlet-outside-routes](docs/rules/template-no-outlet-outside-routes.md)                               | disallow {{outlet}} outside of route templates                               |    |    |    |
 | [template-no-page-title-component](docs/rules/template-no-page-title-component.md)                                 | disallow usage of ember-page-title component                                 |    |    |    |
+| [template-no-unused-block-params](docs/rules/template-no-unused-block-params.md)                                   | disallow unused block parameters in templates                                |    |    |    |
 | [template-no-valueless-arguments](docs/rules/template-no-valueless-arguments.md)                                   | disallow valueless named arguments                                           |    |    |    |
 | [template-no-whitespace-for-layout](docs/rules/template-no-whitespace-for-layout.md)                               | disallow using whitespace for layout purposes                                |    |    |    |
 | [template-no-yield-block-params-to-else-inverse](docs/rules/template-no-yield-block-params-to-else-inverse.md)     | disallow yielding block params to else or inverse block                      |    |    |    |

docs/rules/template-no-unused-block-params.md

@@ -0,0 +1,57 @@
+# ember/template-no-unused-block-params
+
+<!-- end auto-generated rule header -->
+
+Disallow unused block parameters in templates.
+
+## Rule Details
+
+This rule reports block parameters that are declared but never used within the block.
+
+## Examples
+
+Examples of **incorrect** code for this rule:
+
+```gjs
+<template>
+  {{#each items as |item|}}
+    Hello
+  {{/each}}
+</template>
+
+<template>
+  {{#each items as |item index|}}
+    {{item.name}}
+  {{/each}}
+</template>
+```
+
+Examples of **correct** code for this rule:
+
+```gjs
+<template>
+  {{#each items as |item|}}
+    {{item.name}}
+  {{/each}}
+</template>
+
+<template>
+  {{#each items as |item index|}}
+    {{index}}: {{item.name}}
+  {{/each}}
+</template>
+
+<template>
+  {{#let user as |u|}}
+    {{u.name}}
+  {{/let}}
+</template>
+```
+
+## Related rules
+
+- [eslint/no-unused-vars](https://eslint.org/docs/rules/no-unused-vars)
+
+## References
+
+- [Ember Guides - Block Parameters](https://guides.emberjs.com/release/components/block-content/)

lib/rules/template-no-unused-block-params.js

@@ -0,0 +1,173 @@
+function collectChildNodes(n) {
+  const children = [];
+  if (n.program) {
+    children.push(n.program);
+  }
+  if (n.inverse) {
+    children.push(n.inverse);
+  }
+  if (n.params) {
+    children.push(...n.params);
+  }
+  if (n.hash?.pairs) {
+    children.push(...n.hash.pairs.map((p) => p.value));
+  }
+  if (n.body) {
+    children.push(...n.body);
+  }
+  if (n.path) {
+    children.push(n.path);
+  }
+  if (n.attributes) {
+    children.push(...n.attributes.map((a) => a.value));
+  }
+  if (n.children) {
+    children.push(...n.children);
+  }
+  return children;
+}
+
+function markParamIfUsed(name, blockParams, usedParams, shadowedParams) {
+  const firstPart = name.split('.')[0];
+  if (blockParams.includes(firstPart) && !shadowedParams.has(firstPart)) {
+    usedParams.add(firstPart);
+  }
+}
+
+function isPartialStatement(n) {
+  return (
+    (n.type === 'GlimmerMustacheStatement' || n.type === 'GlimmerBlockStatement') &&
+    n.path?.original === 'partial'
+  );
+}
+
+function buildShadowedSet(shadowedParams, innerBlockParams, outerBlockParams) {
+  const newShadowed = new Set(shadowedParams);
+  for (const p of innerBlockParams) {
+    if (outerBlockParams.includes(p)) {
+      newShadowed.add(p);
+    }
+  }
+  return newShadowed;
+}
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'disallow unused block parameters in templates',
+      category: 'Best Practices',
+      url: 'https://github.com/ember-cli/eslint-plugin-ember/tree/master/docs/rules/template-no-unused-block-params.md',
+      templateMode: 'both',
+    },
+    schema: [],
+    messages: {
+      unusedBlockParam: 'Block param "{{param}}" is unused',
+    },
+    originallyFrom: {
+      name: 'ember-template-lint',
+      rule: 'lib/rules/no-unused-block-params.js',
+      docs: 'docs/rule/no-unused-block-params.md',
+      tests: 'test/unit/rules/no-unused-block-params-test.js',
+    },
+  },
+
+  create(context) {
+    return {
+      GlimmerBlockStatement(node) {
+        const blockParams = node.program?.blockParams || [];
+        if (blockParams.length === 0) {
+          return;
+        }
+
+        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);
+
+        if (unusedTrailing.length > 0) {
+          context.report({
+            node,
+            messageId: 'unusedBlockParam',
+            data: { param: unusedTrailing.join(', ') },
+          });
+        }
+      },
+    };
+  },
+};
+
+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);
+  }
+}