Factor positive lookaheads better into find optimizations

[stephentoub]

A positive lookahead at the start of a pattern can be used for determining find optimizations even when the non-zero-width portions of the pattern aren't. This helps particularly in cases where the positive lookahead contains an anchor or a literal.

Also extends the existing alternation reduction optimization to factor out anchors that begin every branch of an alternation.

As an example of how this applies, this is one of the expressions in our list:

(?=^\bset\b.*;\s*\bselect\b|^\bselect\b).*?\s+from\s+(?:[\s\(\[`\"]*([^,;\[\s\]\(\)`\"\.]*)[\s\)\]`\"]*)(?:\.[\s\(\[`\"]*([^,;\[\s\]\(\)`\"\.]*)[\s\)\]`\"]*)*

Note that the pattern begins with a positive lookahead and that what comes after it isn't particularly searchable. This leads to the following generated TryFindNextPossibleStartingPosition routine:

                private bool TryFindNextPossibleStartingPosition(ReadOnlySpan<char> inputSpan)
                {
                    int pos = base.runtextpos;
                    
                    // Any possible match is at least 6 characters.
                    if (pos <= inputSpan.Length - 6)
                    {
                        return true;
                    }
                    
                    // No match found.
                    base.runtextpos = inputSpan.Length;
                    return false;
                }

which effectively always just returns true (as long as the input is long enough), which means we end up trying to match at most positions.

Now with the change, we get this:

                private bool TryFindNextPossibleStartingPosition(ReadOnlySpan<char> inputSpan)
                {
                    int pos = base.runtextpos;
                    
                    // Any possible match is at least 6 characters.
                    if (pos <= inputSpan.Length - 6)
                    {
                        // The pattern leads with a beginning (\A) anchor.
                        if (pos == 0)
                        {
                            return true;
                        }
                    }
                    
                    // No match found.
                    base.runtextpos = inputSpan.Length;
                    return false;
                }

Note the new pos == 0 check. That happens because we will now factor in the ^ from the positive lookahead's alternation.

[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.

Copilot reviewed 6 out of 6 changed files in this pull request and generated no comments.

Tip: If you use Visual Studio Code, you can request a review from Copilot before you push from the "Source Control" tab. Learn more