Add additional test cases to cover edge cases. Clean up code comments.

Author: sidhsharma1992

lib/util/labelUtils.ts

@@ -9,30 +9,22 @@ import { JSXOpeningElement } from "estree-jsx";
 import { TSESTree } from "@typescript-eslint/utils";
 
 /**
- * Utility helpers used by several rules to determine whether a JSX control is
- * associated with a visual label (via id/htmlFor/aria-labelledby/aria-describedby).
+ * Utility helpers for determining whether JSX controls are associated with visual labels
+ * via id/htmlFor/aria-labelledby/aria-describedby attributes.
  *
- * Supported attribute RHS shapes (matched by `idOrExprRegex` and in AST inspection):
- *  - "double-quoted" and 'single-quoted' attribute values
- *  - expression containers with quoted strings:    htmlFor={"id"} or id={'id'}
- *  - expression containers with an Identifier:     htmlFor={someId} or id={someId}
- *  - simple constant BinaryExpression concatenations made only of Literals: {"my-" + 1}
- *  - TemplateLiterals: `my-${value}` (we canonicalize literal parts and allow any expression inside ${...})
+ * Supports these attribute value forms:
+ *  - Literal strings: id="value" or id='value'
+ *  - Expression containers: id={"value"} or id={variable}
+ *  - Binary concatenations: id={"prefix" + suffix}
+ *  - Template literals: id={`prefix-${variable}`}
  *
- * getAttributeValueInfo normalizes the attribute into one of:
- *   - { kind: "string", raw: string, tokens: string[], exprText?: string }
- *   - { kind: "identifier", name: string }
- *   - { kind: "template", template: string }
- *   - { kind: "empty" }
- *   - { kind: "none" }
- *
- * Design notes:
- *  - Prefer AST inspection (JSXExpressionContainer) where available for precision.
- *  - Evaluate BinaryExpression concatenations only when composed entirely of Literals (conservative).
- *  - For TemplateLiteral matching we compare literal parts but allow any expression inside ${...}.
- *  - For some binary-constant cases we reconstruct a small source form (exprText) and attempt to
- *    find an exact-matching expression occurrence in the raw source when necessary.
+ * getAttributeValueInfo normalizes attributes into these canonical forms:
+ *  - { kind: "string", raw: string, tokens: string[], exprText?: string }
+ *  - { kind: "identifier", name: string }
+ *  - { kind: "template", template: string }
+ *  - { kind: "empty" | "none" }
  */
+
 const validIdentifierRe = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 
 /**
@@ -45,10 +37,7 @@ const isInsideLabelTag = (context: TSESLint.RuleContext<string, unknown[]>): boo
         return tagName.toLowerCase() === "label";
     });
 
-/* id / expression alternatives used when matching id/htmlFor attributes in source text.
-   Capture groups (when this alternation is embedded in a surrounding regex) occupy
-   consecutive groups so extractCapturedId reads groups 2..6 (group 1 is typically the tag).
-*/
+/** Regex patterns for matching id/htmlFor attributes in source text. */
 const idLiteralDouble = '"([^"]*)"';
 const idLiteralSingle = "'([^']*)'";
 const exprStringDouble = '\\{\\s*"([^"]*)"\\s*\\}';
@@ -65,16 +54,16 @@ const escapeForRegExp = (s: string): string => s.replace(/[.*+?^${}()|[\]\\]/g,
 const getSourceText = (context: TSESLint.RuleContext<string, unknown[]>) => (context.getSourceCode() as any).text as string;
 
 /**
- * Return captured id value from regex match where idOrExprRegex was used as the RHS.
- * match[2]..match[6] are the possible capture positions.
+ * Extracts captured id value from regex match using idOrExprRegex.
+ * Returns the first non-empty capture group from positions 2-6.
  */
 const extractCapturedId = (match: RegExpExecArray): string | undefined => {
     return match[2] || match[3] || match[4] || match[5] || match[6] || undefined;
 };
 
 /**
- * Evaluate simple constant BinaryExpression concatenations (left/right are Literals or nested BinaryExpressions).
- * Returns string when evaluation succeeds, otherwise undefined.
+ * Evaluates constant BinaryExpression concatenations composed entirely of Literals.
+ * Returns the computed string value or undefined if evaluation fails.
  */
 const evalConstantString = (node: any): string | undefined => {
     if (!node || typeof node !== "object") return undefined;
@@ -92,19 +81,15 @@ const evalConstantString = (node: any): string | undefined => {
 };
 
 /**
- * Reconstruct a small, predictable source-like form for Literal and BinaryExpression nodes.
- * Used for conservative source-text matching of constant binary concatenations.
- * - Strings are JSON.stringify'd to preserve quoting.
- * - Numbers are converted with String().
- * - BinaryExpressions are rendered as "<left> + <right>" with spaces (consistent formatting).
- *
- * Note: this deliberately avoids attempting to stringify arbitrary expressions.
+ * Reconstructs source-like representation for Literal and BinaryExpression nodes.
+ * Used for source-text matching of constant binary concatenations.
+ * Strings are JSON.stringify'd, numbers use String(), binary expressions use "left + right" format.
  */
 const renderSimpleExprSource = (node: any): string | undefined => {
     if (!node || typeof node !== "object") return undefined;
     if (node.type === "Literal") {
         const val = (node as any).value;
-        if (typeof val === "string") return JSON.stringify(val); // keep the quotes "..."
+        if (typeof val === "string") return JSON.stringify(val);
         return String(val);
     }
     if (node.type === "BinaryExpression" && node.operator === "+") {
@@ -114,13 +99,40 @@ const renderSimpleExprSource = (node: any): string | undefined => {
         if (right === undefined) return undefined;
         return `${left} + ${right}`;
     }
-    // Not attempting to render arbitrary expressions (Identifiers, MemberExpression, etc.)
     return undefined;
 };
 
 /**
- * Normalize attribute values into canonical shapes so callers can reason about
- * id/htmlFor/aria attributes in a small set of cases.
+ * Builds regex pattern from template literal that matches literal parts
+ * but allows any expression inside ${...} placeholders.
+ */
+const buildTemplatePattern = (template: string): string => {
+    const placeholderRe = /\$\{[^}]*\}/g;
+    let pattern = "";
+    let idx = 0;
+    let m: RegExpExecArray | null;
+    while ((m = placeholderRe.exec(template)) !== null) {
+        pattern += escapeForRegExp(template.slice(idx, m.index));
+        pattern += "\\$\\{[^}]*\\}";
+        idx = m.index + m[0].length;
+    }
+    pattern += escapeForRegExp(template.slice(idx));
+    return pattern;
+};
+
+/**
+ * Tests if template matches any Label/label or other element with the specified attribute.
+ */
+const hasTemplateMatch = (template: string, attributeName: string, context: TSESLint.RuleContext<string, unknown[]>): boolean => {
+    const src = getSourceText(context);
+    const pattern = buildTemplatePattern(template);
+    const labelRe = new RegExp(`<(?:Label|label)[^>]*\\b${attributeName}\\s*=\\s*\\{\\s*${pattern}\\s*\\}`, "i");
+    const otherRe = new RegExp(`<(?:div|span|p|h[1-6])[^>]*\\b${attributeName}\\s*=\\s*\\{\\s*${pattern}\\s*\\}`, "i");
+    return labelRe.test(src) || otherRe.test(src);
+};
+
+/**
+ * Normalizes attribute values into canonical shapes for consistent processing.
  */
 const getAttributeValueInfo = (
     openingElement: TSESTree.JSXOpeningElement,
@@ -129,7 +141,6 @@ const getAttributeValueInfo = (
 ): any => {
     const prop = getProp(openingElement.attributes as unknown as JSXOpeningElement["attributes"], attrName);
 
-    // Prefer inspecting the AST expression container directly when present
     if (prop && prop.value && (prop.value as any).type === "JSXExpressionContainer") {
         const expr = (prop.value as any).expression;
 
@@ -141,20 +152,17 @@ const getAttributeValueInfo = (
             return { kind: "none" };
         }
 
-        // Expression container with a literal string: {"x"} or {'x'}
         if (expr && expr.type === "Literal" && typeof (expr as any).value === "string") {
             const trimmed = ((expr as any).value as string).trim();
             if (trimmed === "") return { kind: "empty" };
             return { kind: "string", raw: trimmed, tokens: trimmed.split(/\s+/), exprText: JSON.stringify((expr as any).value) };
         }
 
-        // BinaryExpression evaluation for constant concatenations only when composed of Literals.
         if (expr && expr.type === "BinaryExpression") {
             const v = evalConstantString(expr);
             if (typeof v === "string") {
                 const trimmed = v.trim();
                 if (trimmed === "") return { kind: "empty" };
-                // Reconstruct a small source-like form for matching in raw source.
                 const exprText = renderSimpleExprSource(expr);
                 if (exprText) {
                     return { kind: "string", raw: trimmed, tokens: trimmed.split(/\s+/), exprText };
@@ -163,8 +171,6 @@ const getAttributeValueInfo = (
             }
         }
 
-        // TemplateLiteral: reconstruct a canonical template string (preserve literal parts and insert
-        // ${name} placeholders for identifiers, ${} for unknown expressions).
         if (expr && expr.type === "TemplateLiteral") {
             try {
                 const quasis = (expr as any).quasis || [];
@@ -181,20 +187,19 @@ const getAttributeValueInfo = (
                         } else if (e && e.type === "Literal") {
                             templateRaw += "${" + String((e as any).value) + "}";
                         } else {
-                            // unknown expression placeholder — include empty placeholder
                             templateRaw += "${}";
                         }
                     }
                 }
                 templateRaw += "`";
                 return { kind: "template", template: templateRaw };
             } catch {
-                // If anything goes wrong, fall through to fallback.
+                // Fall through to getPropValue fallback
             }
         }
     }
 
-    // Fallback: try to resolve via getPropValue (covers literal attrs and some resolvable cases)
+    // Fallback to jsx-ast-utils for literal attributes and other resolvable cases
     const resolved = prop ? getPropValue(prop) : undefined;
     if (typeof resolved === "string") {
         const trimmed = resolved.trim();
@@ -206,8 +211,7 @@ const getAttributeValueInfo = (
 };
 
 /**
- * Look for an element with the given attribute written as a braced id: e.g. <Label id={foo}></Label>
- * Used as a narrow fallback for identifier-based matches.
+ * Searches for elements with braced attribute values (e.g., <Label id={variable}>).
  */
 const hasBracedAttrId = (
     tagPattern: string,
@@ -222,7 +226,7 @@ const hasBracedAttrId = (
 };
 
 /**
- * Checks if a Label exists with htmlFor that matches idValue.
+ * Checks if any Label exists with htmlFor matching the given value.
  */
 const hasLabelWithHtmlForId = (idValue: string, context: TSESLint.RuleContext<string, unknown[]>): boolean => {
     if (!idValue) return false;
@@ -239,7 +243,7 @@ const hasLabelWithHtmlForId = (idValue: string, context: TSESLint.RuleContext<st
 };
 
 /**
- * Checks if a Label exists with id that matches idValue.
+ * Checks if any Label exists with id matching the given value.
  */
 const hasLabelWithHtmlId = (idValue: string, context: TSESLint.RuleContext<string, unknown[]>): boolean => {
     if (!idValue) return false;
@@ -256,7 +260,7 @@ const hasLabelWithHtmlId = (idValue: string, context: TSESLint.RuleContext<strin
 };
 
 /**
- * Checks other simple elements (div/span/p/h1..h6) for id matching idValue.
+ * Checks if any other element (div/span/p/h1-h6) has id matching the given value.
  */
 const hasOtherElementWithHtmlId = (idValue: string, context: TSESLint.RuleContext<string, unknown[]>): boolean => {
     if (!idValue) return false;
@@ -273,13 +277,8 @@ const hasOtherElementWithHtmlId = (idValue: string, context: TSESLint.RuleContex
 };
 
 /**
- * Generic helper for aria-* attributes.
- *
- * - For string-kind attributes we check label/other elements by raw token id and also
- *   attempt to match binary-constant expressions via exprText (when available).
- * - For identifier-kind attributes we look for braced identifier matches in the source.
- * - For template-kind attributes we build a flexible pattern that matches literal parts of the
- *   template while permitting any expression text inside ${...} placeholders.
+ * Checks if aria-* attribute references existing label or other elements.
+ * Handles string tokens, identifier variables, and template literals.
  */
 const hasAssociatedAriaText = (
     openingElement: TSESTree.JSXOpeningElement,
@@ -293,8 +292,6 @@ const hasAssociatedAriaText = (
             if (hasLabelWithHtmlId(id, context) || hasOtherElementWithHtmlId(id, context)) {
                 return true;
             }
-            // If this string was produced by evaluating a BinaryExpression in the source,
-            // attempt to match the exact binary-expression source in other element id attributes.
             if (info.exprText) {
                 const labelRe = new RegExp(`<(?:Label|label)[^>]*\\bid\\s*=\\s*\\{\\s*${escapeForRegExp(info.exprText)}\\s*\\}`, "i");
                 const otherRe = new RegExp(`<(?:div|span|p|h[1-6])[^>]*\\bid\\s*=\\s*\\{\\s*${escapeForRegExp(info.exprText)}\\s*\\}`, "i");
@@ -311,24 +308,7 @@ const hasAssociatedAriaText = (
     }
 
     if (info.kind === "template") {
-        const templ = info.template as string;
-        const src = getSourceText(context);
-        // Build a pattern which matches the template's literal parts but allows any expression
-        // inside `${...}` placeholders. This lets templates with non-Identifier expressions
-        // (e.g. `${a.b}`) match the canonicalized template produced from the AST.
-        const placeholderRe = /\$\{[^}]*\}/g;
-        let pattern = "";
-        let idx = 0;
-        let m: RegExpExecArray | null;
-        while ((m = placeholderRe.exec(templ)) !== null) {
-            pattern += escapeForRegExp(templ.slice(idx, m.index));
-            pattern += "\\$\\{[^}]*\\}";
-            idx = m.index + m[0].length;
-        }
-        pattern += escapeForRegExp(templ.slice(idx));
-        const labelRe = new RegExp(`<(?:Label|label)[^>]*\\bid\\s*=\\s*\\{\\s*${pattern}\\s*\\}`, "i");
-        const otherRe = new RegExp(`<(?:div|span|p|h[1-6])[^>]*\\bid\\s*=\\s*\\{\\s*${pattern}\\s*\\}`, "i");
-        return labelRe.test(src) || otherRe.test(src);
+        return hasTemplateMatch(info.template as string, "id", context);
     }
 
     return false;
@@ -344,13 +324,15 @@ const hasAssociatedLabelViaAriaDescribedby = (
     context: TSESLint.RuleContext<string, unknown[]>
 ) => hasAssociatedAriaText(openingElement, context, "aria-describedby");
 
+/**
+ * Checks if element's id attribute has an associated Label with matching htmlFor.
+ * Handles string literals, identifier variables, and template literals.
+ */
 const hasAssociatedLabelViaHtmlFor = (openingElement: TSESTree.JSXOpeningElement, context: TSESLint.RuleContext<string, unknown[]>) => {
     const info = getAttributeValueInfo(openingElement, context, "id");
 
     if (info.kind === "string") {
-        // primary: match literal/htmlFor forms
         if (hasLabelWithHtmlForId(info.raw, context)) return true;
-        // fallback: match htmlFor written as a BinaryExpression / other expression that matches the same source text
         if (info.exprText) {
             const src = getSourceText(context);
             const htmlForRe = new RegExp(`<(?:Label|label)[^>]*\\bhtmlFor\\s*=\\s*\\{\\s*${escapeForRegExp(info.exprText)}\\s*\\}`, "i");
@@ -365,22 +347,7 @@ const hasAssociatedLabelViaHtmlFor = (openingElement: TSESTree.JSXOpeningElement
     }
 
     if (info.kind === "template") {
-        const templ = info.template as string;
-        const src = getSourceText(context);
-        // Build a pattern which matches the template's literal parts but allows any expression
-        // inside `${...}` placeholders. This lets templates with non-Identifier expressions
-        // (e.g. `${a.b}`) match the canonicalized template produced from the AST.
-        const placeholderRe = /\$\{[^}]*\}/g;
-        let pattern = "";
-        let idx = 0;
-        let m: RegExpExecArray | null;
-        while ((m = placeholderRe.exec(templ)) !== null) {
-            pattern += escapeForRegExp(templ.slice(idx, m.index));
-            pattern += "\\$\\{[^}]*\\}";
-            idx = m.index + m[0].length;
-        }
-        pattern += escapeForRegExp(templ.slice(idx));
-        return new RegExp(`<(?:Label|label)[^>]*\\bhtmlFor\\s*=\\s*\\{\\s*${pattern}\\s*\\}`, "i").test(src);
+        return hasTemplateMatch(info.template as string, "htmlFor", context);
     }
 
     return false;