fix: trim+first-token role + skip dynamic <select size> (Copilot review)

- Normalize role via trim() + first-token split before lookup so values
  like 'COMBOBOX' or 'combobox listbox' are handled consistently
  (ARIA role attribute is a space-separated fallback list; only the
  first supported token is effective).
- getSelectImplicitRole() now returns 'combobox' | 'listbox' | 'unknown'.
  A dynamic <select size={{...}}> previously fell through as 'combobox'
  and produced false positives on role="combobox"; we now bail on
  'unknown' instead of flagging.

Author: johanrd

lib/rules/template-no-redundant-role.js

@@ -40,20 +40,29 @@ const ALLOWED_ELEMENT_ROLES = [
 // Per HTML-AAM, <select> maps to "combobox" only when neither `multiple` nor
 // `size > 1` is set; otherwise it maps to "listbox". Mirrors jsx-a11y's
 // src/util/implicitRoles/select.js.
-function selectHasComboboxImplicitRole(node) {
+//
+// Returns 'combobox' / 'listbox' for static cases, or 'unknown' when a
+// dynamic `size` value blocks a decision. Callers should skip flagging on
+// 'unknown' to avoid false positives.
+function getSelectImplicitRole(node) {
   const attrs = node.attributes || [];
   const hasMultiple = attrs.some((a) => a.name === 'multiple');
   if (hasMultiple) {
-    return false;
+    return 'listbox';
   }
   const sizeAttr = attrs.find((a) => a.name === 'size');
-  if (sizeAttr && sizeAttr.value && sizeAttr.value.type === 'GlimmerTextNode') {
+  if (sizeAttr) {
+    if (!sizeAttr.value || sizeAttr.value.type !== 'GlimmerTextNode') {
+      // Dynamic `size` — can't tell whether implicit role is combobox or
+      // listbox, so bail out instead of risking a false positive.
+      return 'unknown';
+    }
     const sizeValue = Number(sizeAttr.value.chars);
     if (Number.isFinite(sizeValue) && sizeValue > 1) {
-      return false;
+      return 'listbox';
     }
   }
-  return true;
+  return 'combobox';
 }
 
 // Mapping of roles to their corresponding HTML elements
@@ -148,8 +157,14 @@ module.exports = {
 
         let roleValue;
         if (roleAttr.value && roleAttr.value.type === 'GlimmerTextNode') {
-          // ARIA role tokens are compared ASCII-case-insensitively.
-          roleValue = (roleAttr.value.chars || '').toLowerCase();
+          // ARIA role tokens are compared ASCII-case-insensitively, and the
+          // attribute is a space-separated fallback list — only the first
+          // supported token is honored as the effective role.
+          const firstToken = (roleAttr.value.chars || '').trim().toLowerCase().split(/\s+/u)[0];
+          if (!firstToken) {
+            return;
+          }
+          roleValue = firstToken;
         } else {
           // Skip dynamic role values
           return;
@@ -168,13 +183,13 @@ module.exports = {
         // <select role="combobox"> is only redundant when <select>'s implicit
         // role actually is "combobox" (no `multiple`, and `size` absent or <= 1).
         // Otherwise the implicit role is "listbox", so the explicit "combobox"
-        // is not redundant and this rule should not flag it.
-        if (
-          node.tag === 'select' &&
-          roleValue === 'combobox' &&
-          !selectHasComboboxImplicitRole(node)
-        ) {
-          return;
+        // is not redundant and this rule should not flag it. When `size` is
+        // dynamic we bail ('unknown') rather than risk a false positive.
+        if (node.tag === 'select' && roleValue === 'combobox') {
+          const implicit = getSelectImplicitRole(node);
+          if (implicit !== 'combobox') {
+            return;
+          }
         }
 
         const isRedundant =