fix(template-require-iframe-title): flag empty mustache string-literal titles

`<iframe title={{""}} />` and `<iframe title="{{""}}" />` previously slipped
past the rule because the mustache/concat branches only flagged the named
non-string literal types (boolean / null / undefined / number) and ignored
GlimmerStringLiteral entirely. jsx-a11y's getLiteralPropValue resolves the
empty-string literal and flags the case; this brings parity.

Refactor the title-string handling (trim / empty / duplicate) into a small
`processStaticTitle` helper, then call it from three places:
- the existing GlimmerTextNode branch (no behavior change),
- a new GlimmerStringLiteral sub-case in GlimmerMustacheStatement,
- a new GlimmerStringLiteral sub-case in single-part GlimmerConcatStatement.

The non-string-literal diagnostics (boolean/null/undefined/number → richer
'invalidTitleLiteral' message) are preserved unchanged. Added invalid
regression tests for both the bare-mustache and concat-of-string-literal
forms; replaced the previous valid pin of `title={{""}}` with a positive
case (`title={{"My frame"}}`) to keep coverage of the resolution path.

Author: johanrd

lib/rules/template-require-iframe-title.js

@@ -94,6 +94,44 @@ module.exports = {
     const knownTitles = [];
     let nextDuplicateIndex = 1;
 
+    // Process a statically-known title string (from a text node OR a
+    // mustache string literal OR a single-part concat). Handles the empty /
+    // whitespace / duplicate logic that's shared across those AST shapes.
+    function processStaticTitle(node, raw) {
+      const value = raw.trim();
+      if (value.length === 0) {
+        // Empty-string title always fails: no accessible name for screen readers.
+        // Whitespace-only titles are controlled by `allowWhitespaceOnlyTitle`.
+        if (raw.length === 0 || !allowWhitespaceOnlyTitle) {
+          context.report({ node, messageId: 'emptyTitle' });
+        }
+        return;
+      }
+      // Duplicate check — reports BOTH the first and the current occurrence
+      // on every collision, sharing a `#N` index so users can correlate them.
+      // For three or more duplicates the first occurrence is therefore
+      // re-reported once per collision.
+      const existing = knownTitles.find((entry) => entry.value === value);
+      if (existing) {
+        if (existing.index === null) {
+          existing.index = nextDuplicateIndex++;
+        }
+        const index = existing.index;
+        context.report({
+          node: existing.node,
+          messageId: 'duplicateTitleFirst',
+          data: { index: String(index) },
+        });
+        context.report({
+          node,
+          messageId: 'duplicateTitleOther',
+          data: { title: raw, index: String(index) },
+        });
+      } else {
+        knownTitles.push({ value, node, index: null });
+      }
+    }
+
     return {
       GlimmerElementNode(node) {
         if (node.tag !== 'iframe') {
@@ -117,63 +155,35 @@ module.exports = {
         if (titleAttr.value) {
           switch (titleAttr.value.type) {
             case 'GlimmerTextNode': {
-              const raw = titleAttr.value.chars;
-              const value = raw.trim();
-              if (value.length === 0) {
-                // Empty-string title always fails: no accessible name for screen readers.
-                // Whitespace-only titles are controlled by the `allowWhitespaceOnlyTitle`
-                // option (default false).
-                if (raw.length === 0 || !allowWhitespaceOnlyTitle) {
-                  context.report({ node, messageId: 'emptyTitle' });
-                }
-              } else {
-                // Check for duplicate titles. Reports BOTH the first and the
-                // current occurrence on every collision, sharing a `#N` index
-                // so users can correlate them. For three or more duplicates
-                // the first occurrence is therefore re-reported once per
-                // collision.
-                const existing = knownTitles.find((entry) => entry.value === value);
-                if (existing) {
-                  if (existing.index === null) {
-                    existing.index = nextDuplicateIndex++;
-                  }
-                  const index = existing.index;
-
-                  // Report on the first occurrence on every collision.
-                  context.report({
-                    node: existing.node,
-                    messageId: 'duplicateTitleFirst',
-                    data: { index: String(index) },
-                  });
-
-                  // Report on the current (duplicate) occurrence.
-                  context.report({
-                    node,
-                    messageId: 'duplicateTitleOther',
-                    data: { title: titleAttr.value.chars, index: String(index) },
-                  });
-                } else {
-                  knownTitles.push({ value, node, index: null });
-                }
-              }
+              processStaticTitle(node, titleAttr.value.chars);
               break;
             }
             case 'GlimmerMustacheStatement': {
-              // title={{false}} / title={{null}} / title={{undefined}} / title={{42}}
-              // — any literal that doesn't produce a meaningful accessible name.
+              // Non-string literal mustaches — boolean / null / undefined /
+              // number — get a specific "invalidTitleLiteral" diagnostic
+              // because the literal coerces to a string at runtime that
+              // doesn't describe the frame contents.
               if (isInvalidTitleLiteralPath(titleAttr.value.path)) {
                 context.report({
                   node,
                   messageId: 'invalidTitleLiteral',
                   data: { literalType: getInvalidLiteralType(titleAttr.value.path) },
                 });
+                break;
+              }
+              // String-literal mustaches resolve to their static value — a
+              // non-empty literal supplies an accessible name the same as a
+              // text node. Empty / whitespace literals are flagged the same
+              // way as `title=""` / `title="   "`.
+              if (titleAttr.value.path?.type === 'GlimmerStringLiteral') {
+                processStaticTitle(node, titleAttr.value.path.value);
               }
               break;
             }
             case 'GlimmerConcatStatement': {
-              // title="{{false}}" / "{{undefined}}" / etc. — ConcatStatement
-              // with a single literal part that doesn't produce a name.
               const parts = titleAttr.value.parts || [];
+              // Single-part concat wrapping a non-string literal — same
+              // diagnostic as the bare mustache form.
               if (
                 parts.length === 1 &&
                 parts[0].type === 'GlimmerMustacheStatement' &&
@@ -184,6 +194,16 @@ module.exports = {
                   messageId: 'invalidTitleLiteral',
                   data: { literalType: getInvalidLiteralType(parts[0].path) },
                 });
+                break;
+              }
+              // Single-part concat wrapping a string literal — resolve to
+              // the static value and apply the same checks as a text node.
+              if (
+                parts.length === 1 &&
+                parts[0].type === 'GlimmerMustacheStatement' &&
+                parts[0].path?.type === 'GlimmerStringLiteral'
+              ) {
+                processStaticTitle(node, parts[0].path.value);
               }
               break;
             }

tests/lib/rules/template-require-iframe-title.js

@@ -17,13 +17,9 @@ ruleTester.run('template-require-iframe-title', rule, {
     '<template><iframe title={{someValue}} /></template>',
     '<template><iframe title="" aria-hidden /></template>',
     '<template><iframe title="" hidden /></template>',
-    // Documented divergence — `title={{""}}` is not flagged. jsx-a11y catches
-    // empty-string literals via getLiteralPropValue; our rule inspects only
-    // the named literal AST nodes (Boolean / Null / Undefined / Number) and
-    // an empty-string mustache parses as a concat-of-nothing rather than a
-    // GlimmerStringLiteral, so the under-flag is structural rather than
-    // policy. Pinning the current behavior so any change is intentional.
-    '<template><iframe title={{""}} /></template>',
+    // Mustache string literals resolve to their static value — non-empty
+    // literals supply an accessible name the same as a text node.
+    '<template><iframe title={{"My frame"}} /></template>',
     '<template><iframe title="foo" /><iframe title="bar" /></template>',
     // allowWhitespaceOnlyTitle: true — whitespace-only accepted.
     {
@@ -42,6 +38,20 @@ ruleTester.run('template-require-iframe-title', rule, {
       output: null,
       errors: [{ messageId: 'emptyTitle' }],
     },
+    // Empty string-literal mustaches and concat-with-empty-string-literal
+    // resolve to "" via the static-attr-value handling and are flagged the
+    // same as the text-node empty case. Closes a bypass jsx-a11y already
+    // catches via getLiteralPropValue.
+    {
+      code: '<template><iframe title={{""}} /></template>',
+      output: null,
+      errors: [{ messageId: 'emptyTitle' }],
+    },
+    {
+      code: '<template><iframe title="{{""}}" /></template>',
+      output: null,
+      errors: [{ messageId: 'emptyTitle' }],
+    },
 
     {
       // Both occurrences are reported with a shared `#N` index.