fix: PINNED_BACKREFERENCE bugs from PR #94 review

Require group/backref pair to span the whole pattern, enforce
group/separator length bounds in generated bytecode, and fix
matchBounded to report absolute (not substring-relative) spans.
Patterns with anchors outside the span now correctly fall through
to VARIABLE_CAPTURE_BACKREF.

Author: jbachorik

reggie-codegen/src/main/java/com/datadoghq/reggie/codegen/analysis/PatternAnalyzer.java

@@ -3575,6 +3575,14 @@ private PinnedBackreferenceInfo detectPinnedBackreference(RegexNode ast) {
       return null;
     }
 
+    // The generated matcher only ever scans the group, the optional separator, and the
+    // backreference echo - it has no code path for anything else in the concatenation. A
+    // non-empty prefix/suffix (e.g. the \b anchors in \b(\w+)\s+\1\b) would therefore be silently
+    // ignored rather than evaluated, so require the group/backref pair to span the whole pattern.
+    if (groupIndex != 0 || backrefIndex != children.size() - 1) {
+      return null;
+    }
+
     // The codegen forward-scans the group's content as a single flat "one-or-more chars from
     // groupCharSet" loop with no notion of an upper bound, so only an unbounded (max == -1),
     // greedy, min >= 1 quantifier directly wrapping a charset-bearing child is safe - this
@@ -3605,6 +3613,8 @@ private PinnedBackreferenceInfo detectPinnedBackreference(RegexNode ast) {
     // earlier occurrence of the same backreference) is rejected rather than approximated.
     RegexNode separator = null;
     CharSet separatorCharSet = null;
+    int separatorMinLength = 0;
+    int separatorMaxLength = -1;
     if (backrefIndex > groupIndex + 1) {
       List<RegexNode> sepNodes = children.subList(groupIndex + 1, backrefIndex);
       if (sepNodes.size() != 1) {
@@ -3613,6 +3623,27 @@ private PinnedBackreferenceInfo detectPinnedBackreference(RegexNode ast) {
       separator = sepNodes.get(0);
       separatorCharSet = getFirstCharSet(separator);
 
+      // The scan can't backtrack, so it always consumes the longest run of separator-charset
+      // chars available; that's only correct if the separator's quantifier bounds either equal
+      // that run (min <= run) or don't cap it below that run (max == -1 or max >= run). Track the
+      // bounds here so codegen can reject a candidate whose actual run falls outside them, instead
+      // of accepting whatever length the greedy scan happens to consume.
+      if (separator instanceof QuantifierNode) {
+        QuantifierNode sepQuant = (QuantifierNode) separator;
+        if (!sepQuant.greedy) {
+          return null;
+        }
+        separatorMinLength = sepQuant.min;
+        separatorMaxLength = sepQuant.max;
+      } else {
+        // No quantifier wrapping the separator node means exactly one occurrence.
+        separatorMinLength = 1;
+        separatorMaxLength = 1;
+      }
+      if (separatorMinLength < 1) {
+        return null;
+      }
+
       // Disjointness condition 2: separator vs. group content.
       if (separatorCharSet == null || !groupCharSet.isDisjoint(separatorCharSet)) {
         return null;
@@ -3623,8 +3654,11 @@ private PinnedBackreferenceInfo detectPinnedBackreference(RegexNode ast) {
         capturingGroup.groupNumber,
         capturingGroup.child,
         groupCharSet,
+        groupQuant.min,
         separator,
-        separatorCharSet);
+        separatorCharSet,
+        separatorMinLength,
+        separatorMaxLength);
   }
 
   /** Check if a node represents a single character or character class. */

reggie-codegen/src/main/java/com/datadoghq/reggie/codegen/analysis/PinnedBackreferenceInfo.java

@@ -42,6 +42,9 @@ public class PinnedBackreferenceInfo implements PatternInfo {
   /** Character set the group's content matches. */
   public final CharSet groupCharSet;
 
+  /** Minimum number of chars the group's quantifier requires (e.g. 2 for {@code \w{2,}}). */
+  public final int groupMinLength;
+
   /**
    * Node(s) between the group's close and the backreference site, or null if the backreference
    * directly follows the group.
@@ -51,17 +54,34 @@ public class PinnedBackreferenceInfo implements PatternInfo {
   /** Character set of the separator, or null if there is no separator. */
   public final CharSet separatorCharSet;
 
+  /**
+   * Minimum number of chars the separator's quantifier requires. Unused if there's no separator.
+   */
+  public final int separatorMinLength;
+
+  /**
+   * Maximum number of chars the separator's quantifier allows, or -1 if unbounded. Unused if
+   * there's no separator.
+   */
+  public final int separatorMaxLength;
+
   public PinnedBackreferenceInfo(
       int groupIndex,
       RegexNode groupBody,
       CharSet groupCharSet,
+      int groupMinLength,
       RegexNode separator,
-      CharSet separatorCharSet) {
+      CharSet separatorCharSet,
+      int separatorMinLength,
+      int separatorMaxLength) {
     this.groupIndex = groupIndex;
     this.groupBody = Objects.requireNonNull(groupBody);
     this.groupCharSet = Objects.requireNonNull(groupCharSet);
+    this.groupMinLength = groupMinLength;
     this.separator = separator;
     this.separatorCharSet = separatorCharSet;
+    this.separatorMinLength = separatorMinLength;
+    this.separatorMaxLength = separatorMaxLength;
   }
 
   /** Whether a separator exists between the group's close and the backreference site. */
@@ -75,8 +95,11 @@ public int structuralHashCode() {
     hash = 31 * hash + groupIndex;
     hash = 31 * hash + groupBody.getClass().getName().hashCode();
     hash = 31 * hash + groupCharSet.hashCode();
+    hash = 31 * hash + groupMinLength;
     hash = 31 * hash + (separator != null ? separator.getClass().getName().hashCode() : 0);
     hash = 31 * hash + (separatorCharSet != null ? separatorCharSet.hashCode() : 0);
+    hash = 31 * hash + separatorMinLength;
+    hash = 31 * hash + separatorMaxLength;
     return hash;
   }