Regex (?:(?'G')|){n}(?#n > 0) always capture only once in .NET10

[longxya]

Description

In .NET10, regex (?:(?'G')|){n}(?#n > 0) always capture only once.

Reproduction Steps

using System;
using System.Text.RegularExpressions;

var input = "1";
var pattern = @"\w(?:(?'G')|){3}";
{
	Console.WriteLine("--------------------interpreter---------------------");
	var mh = Regex.Match(input, pattern);
	foreach(Capture capture in mh.Groups["G"].Captures)
	{
		Console.WriteLine($"Index:{capture.Index}, Length:{capture.Length}");
	}
}
{
	Console.WriteLine("--------------------Compiled---------------------");
	var mh = new Regex(pattern, RegexOptions.Compiled).Match(input);
	foreach(Capture capture in mh.Groups["G"].Captures)
	{
		Console.WriteLine($"Index:{capture.Index}, Length:{capture.Length}");
	}
}

Expected behavior

--------------------interpreter---------------------
Index:1, Length:0
Index:1, Length:0
Index:1, Length:0
--------------------Compiled---------------------
Index:1, Length:0
Index:1, Length:0
Index:1, Length:0

Actual behavior

--------------------interpreter---------------------
Index:1, Length:0
--------------------Compiled---------------------
Index:1, Length:0

Regression?

No response

Known Workarounds

No response

Configuration

No response

Other information

No response

[dotnet-policy-service]

Tagging subscribers to this area: @dotnet/area-system-text-regularexpressions
See info in area-owners.md if you want to be subscribed.

[jeffhandley]

Findings Summary

Confirmed regression, introduced in .NET 10.0.0‑rc.1; still present in .NET 11 preview 7.

Triaging into .NET 12 for the moment, but we will consider backporting the fix into .NET 10 and .NET 11.

Repro

Pattern \w(?n)((?'G')|){3} against input "1". Group G should capture once per loop iteration
(3×, each Index:1, Length:0) — for both the interpreter and RegexOptions.Compiled.

	Expected (≤ .NET 9)	Actual (.NET 10+)
G.Captures.Count	3	1

Behavior matrix (measured on win‑arm64)

Framework	Runtime	Interpreter	Compiled
.NET Framework 4.8.1	4.8.9337	3	3
.NET 8	8.0.30	3	3
.NET 9	9.0.19	3	3
.NET 10	10.0.11	1	1
.NET 11	11.0.0‑preview.7	1	1

Bisection (same net10 binary run on each runtime via dotnet exec --fx-version)

preview.1 … preview.7 → 3 (OK) | rc.1 → 1 (regressed) | rc.2, GA → 1.
First bad milestone: 10.0.0‑rc.1.

Root cause

PR dotnet/runtime#118087 — "Transform regex
X| into X?" (commit 27cc30f0, stephentoub, 2025‑07‑29), in the shared RegexNode.cs reduction
— which is why interpreter, Compiled, and source‑gen all changed together.
It rewrites (?'G')| → (?'G')?, turning ((?'G')|){3} into ((?'G')?){3}, whose empty loop
iterations collapse to a single capture.

• Intent: optimization — the X? form feeds loop coalescing (a+(?:a|)→a+, (?:a|)a*→a*).
• Blast radius: PR's regexdiff changed generated code for 659 / 18,857 (~3.5%) real patterns.
• The reduction is unconditional — no check for whether the branch captures; tests covered only
  non‑capturing literals; no reviewer raised capture semantics.

Is the new behavior correct? — No.

1. Self‑inconsistent on .NET 10: ((?'G')){3} → 3 but ((?'G')|){3} → 1, even though
   appending an empty alternative to a branch that already matches empty is a no‑op.
2. Premise fails for captures: (a|) equals a? for the matched language but not for .NET's
   observable CaptureCollection; .NET 9 already distinguishes them (3 vs 1).

Only per‑iteration captures of a zero‑width capturing group change; Match.Success, Match.Value,
and non‑zero‑width captures are unaffected. The consistent, back‑compat answer is 3.

Recommended fix

Guard the X|→X? / |X→X?? reduction to skip when the branch contains a capture (the standard
guard other RegexNode reductions already use): keeps the optimization for the non‑capturing majority
while restoring correct captures.

[longxya]

Oh,it seems like I made a mistake. I thought it was due to ExplicitCapture.
I constructed a super complex regex to solve leetcode#55 and found that the matching results of the regex would out of expectation when explicit capture was turned on.

Here is the original regex:

^(?'max0')(?>(?>\d(?>\d{0,3})(?!\k'success')(?>\d(?'success')|(?>(?'-max0')|(?'-max1')(?'max0'){9}|(?'-max2')(?'max1'){9}(?'max0'){9}|(?'-max3')(?'max2'){9}(?'max1'){9}(?'max0'){9})(?>(?<=(?>,|^)0+)|(?<=(((?=\d\d(\d(\d((?'-n')(?'num3')|){9}|((?'-n')(?'num2')|){9})|((?'-n')(?'num1')|){9}))|((?'-n')(?'num0')|){9})(?=[147](?'n')|)(?=[258](?'n'){2}|)(?=[3459](?'n'){3}|)(?=[6789](?'n'){6}|)\d)+)(?>(?!(?!(?>(?'-num3')(?'-max3')|){9}(?>(?'-num2')(?'-max2')|){9}(?>(?'-num1')(?'-max1')|){9}(?>(?'-num0')(?'-max0')|){9}(?>(?'-num3')|(?'-num2')|(?'-num1')|(?'-num0'))))(?>(?'-max3')|){9}(?>(?'-max2')|){9}(?>(?'-max1')|){9}(?>(?'-max0')|){9}(?>(?'-num3')(?'max3')|){9}(?>(?'-num2')(?'max2')|){9}(?>(?'-num1')(?'max1')|){9}(?>(?'-num0')(?'max0')|){9}|(?>(?'-num3')|){9}(?>(?'-num2')|){9}(?>(?'-num1')|){9}(?>(?'-num0')|){9}))(?>,?))))+(?>$|\k'success')

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new Regex(@"^(?'max0')(?>(?>\d(?>\d{0,3})(?!\k'success')(?>\d(?'success')|(?>(?'-max0')|(?'-max1')(?'max0'){9}|(?'-max2')(?'max1'){9}(?'max0'){9}|(?'-max3')(?'max2'){9}(?'max1'){9}(?'max0'){9})(?>(?<=(?>,|^)0+)|(?<=(((?=\d\d(\d(\d((?'-n')(?'num3')|){9}|((?'-n')(?'num2')|){9})|((?'-n')(?'num1')|){9}))|((?'-n')(?'num0')|){9})(?=[147](?'n')|)(?=[258](?'n'){2}|)(?=[3459](?'n'){3}|)(?=[6789](?'n'){6}|)\d)+)(?>(?!(?!(?>(?'-num3')(?'-max3')|){9}(?>(?'-num2')(?'-max2')|){9}(?>(?'-num1')(?'-max1')|){9}(?>(?'-num0')(?'-max0')|){9}(?>(?'-num3')|(?'-num2')|(?'-num1')|(?'-num0'))))(?>(?'-max3')|){9}(?>(?'-max2')|){9}(?>(?'-max1')|){9}(?>(?'-max0')|){9}(?>(?'-num3')(?'max3')|){9}(?>(?'-num2')(?'max2')|){9}(?>(?'-num1')(?'max1')|){9}(?>(?'-num0')(?'max0')|){9}|(?>(?'-num3')|){9}(?>(?'-num2')|){9}(?>(?'-num1')|){9}(?>(?'-num0')|){9}))(?>,?))))+(?>$|\k'success')"
, RegexOptions.Compiled/*|RegexOptions.ExplicitCapture*/);
    public bool CanJump(int[] nums) {
        return regex.IsMatch(string.Join(",", nums));
    }
}

If create a Regex instance with RegexOptions.ExplicitCapture as a parameter, or prepend the inline option (?n) to the regex, it causes the matching results to deviate from expectations and fails some test cases, such as 2,0,0.

That is to say:

using System;
using System.Text.RegularExpressions;

var input = "2,0,0";
var pattern = @"(?n)^(?'max0')(?>(?>\d(?>\d{0,3})(?!\k'success')(?>\d(?'success')|(?>(?'-max0')|(?'-max1')(?'max0'){9}|(?'-max2')(?'max1'){9}(?'max0'){9}|(?'-max3')(?'max2'){9}(?'max1'){9}(?'max0'){9})(?>(?<=(?>,|^)0+)|(?<=(((?=\d\d(\d(\d((?'-n')(?'num3')|){9}|((?'-n')(?'num2')|){9})|((?'-n')(?'num1')|){9}))|((?'-n')(?'num0')|){9})(?=[147](?'n')|)(?=[258](?'n'){2}|)(?=[3459](?'n'){3}|)(?=[6789](?'n'){6}|)\d)+)(?>(?!(?!(?>(?'-num3')(?'-max3')|){9}(?>(?'-num2')(?'-max2')|){9}(?>(?'-num1')(?'-max1')|){9}(?>(?'-num0')(?'-max0')|){9}(?>(?'-num3')|(?'-num2')|(?'-num1')|(?'-num0'))))(?>(?'-max3')|){9}(?>(?'-max2')|){9}(?>(?'-max1')|){9}(?>(?'-max0')|){9}(?>(?'-num3')(?'max3')|){9}(?>(?'-num2')(?'max2')|){9}(?>(?'-num1')(?'max1')|){9}(?>(?'-num0')(?'max0')|){9}|(?>(?'-num3')|){9}(?>(?'-num2')|){9}(?>(?'-num1')|){9}(?>(?'-num0')|){9}))(?>,?))))+(?>$|\k'success')";
var result = Regex.IsMatch(input, pattern);
Console.WriteLine(result);//Should echo `True`, but result is `False` in .NET10

---

I tried to simplify it to \w(?n)((?'G')|){3}.
It seems like the regex could be further simplified into \w(?:(?'G')|){3}.

But I'm not so sure they are a same issue.

[jeffhandley]

Thanks @longxya — this is really helpful.

You're right that ExplicitCapture isn't the underlying cause. (?n) and (?:…) simply make the wrapping group non-capturing, which exposes the real issue: an X| (empty-alternation) inside a bounded loop is being reduced to X?, collapsing the repeated zero-width captures of X. That reduction is what changed in .NET 10.

The important thing your additional findings surface is the dropped captures can change the actual match result, not just Captures.Count. I can reproduce your "2,0,0" → False regression, and it distills to a minimal balancing-group case:

Regex.IsMatch("", @"^(?:(?'G')|){3}(?<-G>){3}$"); // true through .NET 9, false in .NET 10

It looks like it's the same root cause and #132988 will address both symptoms. It guards the X|→X? / |X→X?? reduction so it's skipped when the branch contains captures. Every looped branch in your regex ((?'G'), (?'num0'), (?'-max0'), …) qualifies, which restores both the capture counts and the match result.

I'm adding additional balancing-group match-result tests to confirm before it merges.

Thanks again for the thorough follow-up and the great repro!