fix(sort-regexp): detect wildcard shadowing after multi-character prefixes

Author: azat-io

rules/sort-regexp/get-first-character-paths.ts

@@ -17,6 +17,9 @@ export interface FirstCharacterPath {
 
   /** Indicates whether additional characters must follow to complete the match. */
   requiresMore: boolean
+
+  /** Indicates whether the alternative can consume more characters after the prefix. */
+  canMatchMore: boolean
 }
 
 /** Matcher produced from a character class AST node. */
@@ -60,8 +63,14 @@ interface AnalysisContext {
   /** Cache storing computed minimum lengths for AST nodes. */
   minLengthCache: WeakMap<object, LengthResult>
 
+  /** Cache storing computed maximum lengths for AST nodes. */
+  maxLengthCache: WeakMap<object, LengthResult>
+
   /** Alternatives currently on the recursion stack. */
-  activeAlternatives: Set<Alternative>
+  minLengthActiveAlternatives: Set<Alternative>
+
+  /** Alternatives on the recursion stack for maximum-length calculation. */
+  maxLengthActiveAlternatives: Set<Alternative>
 
   /** Indicates whether collection exceeded the maximum allowed paths. */
   limitExceeded: boolean
@@ -72,8 +81,9 @@ interface AnalysisContext {
 
 /** Internal extension that includes metadata needed during traversal. */
 interface FirstCharacterPathInternal extends FirstCharacterPath {
-  /** Mirrors the public flag for convenience when mutating paths. */
+  /** Mirrors the public flags for convenience when mutating paths. */
   requiresMore: boolean
+  canMatchMore: boolean
 }
 
 type LengthResult = LengthInfo | null
@@ -92,7 +102,9 @@ export function getFirstCharacterPaths(
 ): FirstCharacterPath[] {
   let context: AnalysisContext = {
     minLengthCache: new WeakMap(),
-    activeAlternatives: new Set(),
+    maxLengthCache: new WeakMap(),
+    minLengthActiveAlternatives: new Set(),
+    maxLengthActiveAlternatives: new Set(),
     limitExceeded: false,
     pathCount: 0,
   }
@@ -128,6 +140,7 @@ function collectFirstCharacterPathsFromElement(
         {
           matcher: { type: 'character-class', value: element },
           requiresMore: false,
+          canMatchMore: false,
         },
       ]
     }
@@ -146,6 +159,7 @@ function collectFirstCharacterPathsFromElement(
         {
           matcher: { type: 'character-set', value: element },
           requiresMore: false,
+          canMatchMore: false,
         },
       ]
     }
@@ -157,6 +171,7 @@ function collectFirstCharacterPathsFromElement(
         {
           matcher: { value: element.value, type: 'character' },
           requiresMore: false,
+          canMatchMore: false,
         },
       ]
     }
@@ -195,11 +210,15 @@ function collectFirstCharacterPathsFromAlternative(
 
     if (elementPaths.length > 0) {
       let restLength = getElementsMinLength(elements, index + 1, context)
+      let restMaxLength = getElementsMaxLength(elements, index + 1, context)
 
       if (restLength !== null) {
+        let restCanMatchMore = restMaxLength !== 0
+
         for (let path of elementPaths) {
           addPath(results, context, {
             requiresMore: path.requiresMore || restLength > 0,
+             canMatchMore: path.canMatchMore || restCanMatchMore,
             matcher: path.matcher,
           })
         }
@@ -299,10 +318,16 @@ function collectFirstCharacterPathsFromQuantifier(
     return []
   }
 
+  let innerMaxLength = getElementMaxLength(quantifier.element, context)
   let requiresAdditionalIterations = quantifier.min > 1 && innerMinLength > 0
+  let elementCanConsumeCharacters = innerMaxLength !== 0
+  let allowsAdditionalIterations =
+    elementCanConsumeCharacters &&
+    (quantifier.max === Infinity || quantifier.max > 1)
 
   return innerPaths.map(path => ({
     requiresMore: path.requiresMore || requiresAdditionalIterations,
+    canMatchMore: path.canMatchMore || allowsAdditionalIterations,
     matcher: path.matcher,
   }))
 }
@@ -324,15 +349,15 @@ function getAlternativeMinLength(
     return cached
   }
 
-  if (context.activeAlternatives.has(alternative)) {
+  if (context.minLengthActiveAlternatives.has(alternative)) {
     return null
   }
 
-  context.activeAlternatives.add(alternative)
+  context.minLengthActiveAlternatives.add(alternative)
 
   let length = getElementsMinLength(alternative.elements, 0, context)
 
-  context.activeAlternatives.delete(alternative)
+  context.minLengthActiveAlternatives.delete(alternative)
   context.minLengthCache.set(alternative, length)
 
   return length
@@ -403,6 +428,184 @@ function getGroupMinLength(
   return minLength
 }
 
+/**
+ * Computes the maximum possible length for an element.
+ *
+ * @param element - AST element to analyze.
+ * @param context - Shared traversal context.
+ * @returns Maximum length in characters, `2` for "two or more", or `null` if
+ *   unknown.
+ */
+function getElementMaxLength(
+  element: Element,
+  context: AnalysisContext,
+): LengthResult {
+  // Defensive guard triggers only when traversal exceeded path limit earlier.
+  /* c8 ignore next 3 */
+  if (context.limitExceeded) {
+    return null
+  }
+
+  let cached = context.maxLengthCache.get(element)
+
+  if (cached !== undefined) {
+    return cached
+  }
+
+  let result: LengthResult = null
+
+  switch (element.type) {
+    case 'CharacterClass':
+    case 'CharacterSet':
+    case 'Character': {
+      result = 1
+      break
+    }
+    case 'CapturingGroup':
+    case 'Group': {
+      result = getGroupMaxLength(element, context)
+      break
+    }
+    case 'Backreference': {
+      result = null
+      break
+    }
+    case 'Quantifier': {
+      let innerLength = getElementMaxLength(element.element, context)
+
+      if (innerLength === null) {
+        result = null
+        break
+      }
+
+      // Numerical sentinels are unreachable with current AST inputs.
+      /* c8 ignore start */
+      if (innerLength === 0 || element.max === 0) {
+        result = 0
+        break
+      }
+
+      if (element.max === Infinity) {
+        result = 2
+        break
+      }
+      /* c8 ignore stop */
+
+      result = multiplyMaxLength(innerLength, element.max)
+      break
+    }
+    case 'Assertion': {
+      result = 0
+      break
+    }
+    default: {
+      result = null
+    }
+  }
+
+  context.maxLengthCache.set(element, result)
+
+  return result
+}
+
+/**
+ * Computes the maximum possible length for an alternative.
+ *
+ * @param alternative - Alternative whose elements should be measured.
+ * @param context - Shared traversal context.
+ * @returns Maximum length for the entire alternative.
+ */
+function getAlternativeMaxLength(
+  alternative: Alternative,
+  context: AnalysisContext,
+): LengthResult {
+  let cached = context.maxLengthCache.get(alternative)
+
+  // Cache reuse only occurs for recursive alternatives, which tests do not create.
+  /* c8 ignore next 3 */
+  if (cached !== undefined) {
+    return cached
+  }
+
+  if (context.maxLengthActiveAlternatives.has(alternative)) {
+    return null
+  }
+
+  context.maxLengthActiveAlternatives.add(alternative)
+
+  let length = getElementsMaxLength(alternative.elements, 0, context)
+
+  context.maxLengthActiveAlternatives.delete(alternative)
+  context.maxLengthCache.set(alternative, length)
+
+  return length
+}
+
+/**
+ * Computes the maximum length of a suffix of elements.
+ *
+ * @param elements - Sequence of elements belonging to an alternative.
+ * @param startIndex - Index from which the suffix begins.
+ * @param context - Shared traversal context.
+ * @returns Maximum length for the suffix.
+ */
+function getElementsMaxLength(
+  elements: Alternative['elements'],
+  startIndex: number,
+  context: AnalysisContext,
+): LengthResult {
+  let length: LengthResult = 0
+
+  for (let index = startIndex; index < elements.length; index++) {
+    let element = elements[index]!
+    let elementLength = getElementMaxLength(element, context)
+
+    length = addMaxLengths(length, elementLength)
+
+    if (length === null) {
+      return null
+    }
+
+    if (length === 2) {
+      return 2
+    }
+  }
+
+  return length
+}
+
+/**
+ * Computes the maximum length among the alternatives contained in a group.
+ *
+ * @param group - Capturing or non-capturing group to analyze.
+ * @param context - Shared traversal context.
+ * @returns Maximum length across the group's alternatives.
+ */
+function getGroupMaxLength(
+  group: CapturingGroup | Group,
+  context: AnalysisContext,
+): LengthResult {
+  let maxLength: LengthResult = 0
+
+  for (let alternative of group.alternatives) {
+    let alternativeLength = getAlternativeMaxLength(alternative, context)
+
+    if (alternativeLength === null) {
+      return null
+    }
+
+    if (alternativeLength > maxLength) {
+      maxLength = alternativeLength
+    }
+
+    if (maxLength === 2) {
+      break
+    }
+  }
+
+  return maxLength
+}
+
 /**
  * Multiplies a minimum length by a quantifier count while respecting sentinel
  * values.
@@ -431,6 +634,38 @@ function multiplyLength(length: LengthResult, count: number): LengthResult {
   return 2
 }
 
+/**
+ * Multiplies a maximum length by a quantifier count while respecting sentinel
+ * values.
+ *
+ * @param length - Maximum length of the repeated element.
+ * @param count - Maximum number of repetitions.
+ * @returns Combined maximum length or `null` when unknown.
+ */
+// Exhaustive runtime coverage would require crafting pathological recursive
+// quantifiers and backreferences, so skip coverage for this helper.
+/* c8 ignore start */
+function multiplyMaxLength(length: LengthResult, count: number): LengthResult {
+  if (length === null) {
+    return null
+  }
+
+  if (length === 0 || count === 0) {
+    return 0
+  }
+
+  if (length === 2) {
+    return 2
+  }
+
+  if (count === 1) {
+    return length
+  }
+
+  return 2
+}
+/* c8 ignore stop */
+
 /**
  * Adds a collected path to the results while accounting for the safety limit.
  *
@@ -476,6 +711,31 @@ function addLengths(a: LengthResult, b: LengthResult): LengthResult {
   return sum as LengthInfo
 }
 
+/**
+ * Adds two maximum-length values together, preserving sentinel semantics.
+ *
+ * @param a - First length operand.
+ * @param b - Second length operand.
+ * @returns Sum of the operands, clamped to the sentinel space.
+ */
+function addMaxLengths(a: LengthResult, b: LengthResult): LengthResult {
+  if (a === null || b === null) {
+    return null
+  }
+
+  if (a === 2 || b === 2) {
+    return 2
+  }
+
+  let sum = a + b
+
+  if (sum >= 2) {
+    return 2
+  }
+
+  return sum as LengthInfo
+}
+
 /**
  * Determines whether a given element can match an empty string.
  *