fix(template-require-valid-alt-text): unwrap mustache literals via shared helper (Copilot review)

Extract a new `getStaticAttrValue` util that resolves literal-valued
mustaches (`{{"foo"}}`, `{{true}}`, `{{-1}}`) and single-part concat
statements (`"{{true}}"`) to their static string value. `hasNonEmptyTextAttr`
now delegates to the helper — `aria-label={{""}}` / `aria-label="{{""}}"`
normalise to the empty string and flag the same as the text-node equivalent;
genuinely dynamic values (PathExpressions, multi-part concat) still
short-circuit to "assume truthy". Closes the bypass where authors wrapped
an empty accessible name in mustaches.

Byte-identical carrier of lib/utils/static-attr-value.js across all PRs
that land it.

Author: johanrd

lib/rules/template-require-valid-alt-text.js

@@ -1,3 +1,5 @@
+const { getStaticAttrValue } = require('../utils/static-attr-value');
+
 const REDUNDANT_WORDS = ['image', 'photo', 'picture', 'logo', 'spacer'];
 
 function findAttr(node, name) {
@@ -25,11 +27,16 @@ function hasNonEmptyTextAttr(node, name) {
   if (!attr?.value) {
     return false;
   }
-  if (attr.value.type === 'GlimmerTextNode') {
-    return attr.value.chars.trim() !== '';
+  // Resolve mustache-literal / single-part concat forms to their static
+  // string via the shared helper. `aria-label={{""}}` / `aria-label="{{""}}"`
+  // now normalise to the empty string and are treated the same as the
+  // text-node empty value.
+  const resolved = getStaticAttrValue(attr.value);
+  if (resolved === undefined) {
+    // Genuinely dynamic — assume truthy (can't verify at lint time).
+    return true;
   }
-  // Mustache / concat — dynamic; assume truthy.
-  return true;
+  return resolved.trim() !== '';
 }
 
 function hasAnyNonEmptyTextAttr(node, names) {

lib/utils/static-attr-value.js

@@ -0,0 +1,64 @@
+'use strict';
+
+/**
+ * Return the statically-known string value of a Glimmer attribute value node,
+ * or `undefined` when the value is dynamic (cannot be resolved at lint time).
+ *
+ * Unwraps:
+ *   - GlimmerTextNode → chars
+ *   - GlimmerMustacheStatement with a literal path (boolean/string/number) → stringified value
+ *   - GlimmerConcatStatement whose parts are all statically resolvable → joined string
+ *
+ * A missing/undefined value (valueless attribute, e.g. `<input disabled>`)
+ * returns the empty string. Pass `attr.value` — not the attribute itself.
+ */
+function getStaticAttrValue(value) {
+  if (value === null || value === undefined) {
+    return '';
+  }
+  if (value.type === 'GlimmerTextNode') {
+    return value.chars;
+  }
+  if (value.type === 'GlimmerMustacheStatement') {
+    return extractLiteral(value.path);
+  }
+  if (value.type === 'GlimmerConcatStatement') {
+    const parts = value.parts || [];
+    let out = '';
+    for (const part of parts) {
+      if (part.type === 'GlimmerTextNode') {
+        out += part.chars;
+        continue;
+      }
+      if (part.type === 'GlimmerMustacheStatement') {
+        const literal = extractLiteral(part.path);
+        if (literal === undefined) {
+          return undefined;
+        }
+        out += literal;
+        continue;
+      }
+      return undefined;
+    }
+    return out;
+  }
+  return undefined;
+}
+
+function extractLiteral(path) {
+  if (!path) {
+    return undefined;
+  }
+  if (path.type === 'GlimmerBooleanLiteral') {
+    return path.value ? 'true' : 'false';
+  }
+  if (path.type === 'GlimmerStringLiteral') {
+    return path.value;
+  }
+  if (path.type === 'GlimmerNumberLiteral') {
+    return String(path.value);
+  }
+  return undefined;
+}
+
+module.exports = { getStaticAttrValue };

tests/lib/rules/template-require-valid-alt-text.js

@@ -57,6 +57,9 @@ ruleTester.run('template-require-valid-alt-text', rule, {
     '<template><area aria-labelledby="some-alt"></template>',
     '<template><area aria-label="some-alt"></template>',
     '<template><img role={{unless this.altText "presentation"}} alt={{this.altText}}></template>',
+    // Mustache-string-literal forms resolve to their static value — a
+    // non-empty literal supplies an accessible name the same as a text node.
+    '<template><input type="image" aria-label={{"valid"}} /></template>',
   ],
   invalid: [
     // Empty-string aria-label / aria-labelledby / alt provides no accessible
@@ -125,6 +128,18 @@ ruleTester.run('template-require-valid-alt-text', rule, {
       output: null,
       errors: [{ messageId: 'areaMissing' }],
     },
+    // Mustache-string-literal forms that resolve to an empty string are
+    // treated the same as the text-node empty value — no accessible name.
+    {
+      code: '<template><input type="image" aria-label={{""}} /></template>',
+      output: null,
+      errors: [{ messageId: 'inputImage' }],
+    },
+    {
+      code: '<template><input type="image" aria-label="{{""}}" /></template>',
+      output: null,
+      errors: [{ messageId: 'inputImage' }],
+    },
     {
       code: '<template><img src="/test.jpg" /></template>',
       output: null,

tests/lib/utils/static-attr-value-test.js

@@ -0,0 +1,129 @@
+'use strict';
+
+const { getStaticAttrValue } = require('../../../lib/utils/static-attr-value');
+
+describe('getStaticAttrValue', () => {
+  it('returns empty string for null/undefined (valueless attribute)', () => {
+    expect(getStaticAttrValue(null)).toBe('');
+    expect(getStaticAttrValue(undefined)).toBe('');
+  });
+
+  it('returns chars for GlimmerTextNode', () => {
+    expect(getStaticAttrValue({ type: 'GlimmerTextNode', chars: 'hello' })).toBe('hello');
+    expect(getStaticAttrValue({ type: 'GlimmerTextNode', chars: '' })).toBe('');
+  });
+
+  it('unwraps GlimmerMustacheStatement with BooleanLiteral', () => {
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerMustacheStatement',
+        path: { type: 'GlimmerBooleanLiteral', value: true },
+      })
+    ).toBe('true');
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerMustacheStatement',
+        path: { type: 'GlimmerBooleanLiteral', value: false },
+      })
+    ).toBe('false');
+  });
+
+  it('unwraps GlimmerMustacheStatement with StringLiteral', () => {
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerMustacheStatement',
+        path: { type: 'GlimmerStringLiteral', value: 'foo' },
+      })
+    ).toBe('foo');
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerMustacheStatement',
+        path: { type: 'GlimmerStringLiteral', value: '' },
+      })
+    ).toBe('');
+  });
+
+  it('unwraps GlimmerMustacheStatement with NumberLiteral', () => {
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerMustacheStatement',
+        path: { type: 'GlimmerNumberLiteral', value: -1 },
+      })
+    ).toBe('-1');
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerMustacheStatement',
+        path: { type: 'GlimmerNumberLiteral', value: 0 },
+      })
+    ).toBe('0');
+  });
+
+  it('returns undefined for GlimmerMustacheStatement with a dynamic PathExpression', () => {
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerMustacheStatement',
+        path: { type: 'GlimmerPathExpression', original: 'this.foo' },
+      })
+    ).toBeUndefined();
+  });
+
+  it('joins GlimmerConcatStatement with only static parts', () => {
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerConcatStatement',
+        parts: [
+          { type: 'GlimmerTextNode', chars: 'prefix-' },
+          {
+            type: 'GlimmerMustacheStatement',
+            path: { type: 'GlimmerStringLiteral', value: 'mid' },
+          },
+          { type: 'GlimmerTextNode', chars: '-suffix' },
+        ],
+      })
+    ).toBe('prefix-mid-suffix');
+  });
+
+  it('joins concat with boolean and number literal parts', () => {
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerConcatStatement',
+        parts: [
+          {
+            type: 'GlimmerMustacheStatement',
+            path: { type: 'GlimmerBooleanLiteral', value: true },
+          },
+        ],
+      })
+    ).toBe('true');
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerConcatStatement',
+        parts: [
+          {
+            type: 'GlimmerMustacheStatement',
+            path: { type: 'GlimmerNumberLiteral', value: -1 },
+          },
+        ],
+      })
+    ).toBe('-1');
+  });
+
+  it('returns undefined for GlimmerConcatStatement with a dynamic part', () => {
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerConcatStatement',
+        parts: [
+          { type: 'GlimmerTextNode', chars: 'x-' },
+          {
+            type: 'GlimmerMustacheStatement',
+            path: { type: 'GlimmerPathExpression', original: 'this.foo' },
+          },
+        ],
+      })
+    ).toBeUndefined();
+  });
+
+  it('returns undefined for an unknown node type', () => {
+    expect(getStaticAttrValue({ type: 'GlimmerSubExpression' })).toBeUndefined();
+  });
+});