fix(template-no-autofocus-attribute): narrow mustache check to native-input helpers (Copilot review)

Previously the GlimmerMustacheStatement visitor fired on ANY mustache
with an autofocus hash pair — but arbitrary custom components taking
'autofocus' as a prop are opaque. We can't statically tell whether the
prop forwards to a native <input autofocus> or is used for something
else. Narrow to the two built-ins that deterministically render a
native input:
  - {{input …}}
  - {{component "input" …}}

Future: when type-aware linting lands (Glint integration or template-
type-check), we can resolve custom components that forward 'autofocus'
to a native <input> and flag those too. For now we stay conservative
to avoid false positives on unrelated helpers.

Author: johanrd

lib/rules/template-no-autofocus-attribute.js

@@ -39,6 +39,28 @@ function isMustacheBooleanFalse(value) {
  *
  * https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dialog
  */
+// Returns true for `{{input ...}}` and `{{component "input" ...}}` mustache
+// invocations — the only built-ins that deterministically render a native
+// <input> with forwarded attributes.
+function isNativeInputHelper(node) {
+  const path = node.path;
+  if (!path) {
+    return false;
+  }
+  // Direct invocation: `{{input ...}}`.
+  if (path.type === 'GlimmerPathExpression' && path.original === 'input') {
+    return true;
+  }
+  // Contextual component: `{{component "input" ...}}`.
+  if (path.type === 'GlimmerPathExpression' && path.original === 'component') {
+    const firstParam = node.params && node.params[0];
+    if (firstParam && firstParam.type === 'GlimmerStringLiteral' && firstParam.value === 'input') {
+      return true;
+    }
+  }
+  return false;
+}
+
 function isInsideDialog(node) {
   if (node.type === 'GlimmerElementNode' && node.tag === 'dialog') {
     return true;
@@ -127,6 +149,25 @@ module.exports = {
           return;
         }
 
+        // Narrow to helpers that deterministically render a native `autofocus`
+        // attribute. The rule's purpose is the HTML attribute; arbitrary
+        // components taking an `autofocus` prop are opaque — we can't tell
+        // statically whether that prop forwards to HTML or is used for
+        // something else.
+        //   - `{{input ...}}` — Ember's classic input helper renders a native
+        //     <input> with forwarded attributes.
+        //   - `{{component "input" ...}}` — contextual component resolution
+        //     points at the same helper.
+        //
+        // FUTURE: when type-aware linting lands (e.g., Glint integration or
+        // a template-type-check step), we can resolve custom components that
+        // forward `autofocus` to a native <input> and flag those too. For now
+        // we stay conservative to avoid false positives on unrelated helpers
+        // that happen to take an `autofocus` prop.
+        if (!isNativeInputHelper(node)) {
+          return;
+        }
+
         // Mustache hash-pair `{{input autofocus=false}}` — boolean literal
         // false at the hash-pair level is unambiguous and renders no attr.
         // Note: `autofocus="false"` in mustache syntax IS still flagged — per

tests/lib/rules/template-no-autofocus-attribute.js

@@ -62,6 +62,14 @@ ruleTester.run('template-no-autofocus-attribute', rule, {
         </div>
       </dialog>
     </template>`,
+
+    // Custom helpers / components taking an `autofocus` prop are opaque —
+    // we can't know whether the prop forwards to a native <input autofocus>
+    // or is used for something else. Narrow to {{input}} / {{component
+    // "input"}} which deterministically render native inputs.
+    `<template>{{my-wrapper autofocus=true}}</template>`,
+    `<template>{{some-component autofocus=true name="foo"}}</template>`,
+    `<template>{{component "some-other-helper" autofocus=true}}</template>`,
   ],
 
   invalid: [