From de5d18538076f843a7eb75947eee5d78229cc523 Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Thu, 11 Jul 2024 10:26:52 -0400
Subject: [PATCH 01/15] Rent object[] rather than (uint,uint)[][] from the
 ArrayPool

---
 .../Symbolic/MintermClassifier.cs               | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/MintermClassifier.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/MintermClassifier.cs
index 24d2a26f849229..5bf81a6191c046 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/MintermClassifier.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/MintermClassifier.cs
@@ -47,8 +47,11 @@ public MintermClassifier(BDD[] minterms)
             // in order to size the lookup array to minimize steady-state memory consumption of the potentially
             // large lookup array. We prefer to use the byte[] _lookup when possible, in order to keep memory
             // consumption to a minimum; doing so accomodates up to 255 minterms, which is the vast majority case.
-            // However, when there are more than 255 minterms, we need to use int[] _intLookup.
-            (uint, uint)[][] charRangesPerMinterm = ArrayPool<(uint, uint)[]>.Shared.Rent(minterms.Length);
+            // However, when there are more than 255 minterms, we need to use int[] _intLookup. We rent an object[]
+            // rather than a (uint,uint)[][] to avoid the extra type pressure on the ArrayPool (object[]s are common,
+            // (uint,uint)[][]s much less so).
+            object[] arrayPoolArray = ArrayPool<object>.Shared.Rent(minterms.Length);
+            Span<object> charRangesPerMinterm = arrayPoolArray.AsSpan(0, minterms.Length);
 
             int maxChar = -1;
             for (int mintermId = 1; mintermId < minterms.Length; mintermId++)
@@ -70,17 +73,17 @@ public MintermClassifier(BDD[] minterms)
             }
 
             // Return the rented array. We clear it before returning it in order to avoid all the ranges arrays being kept alive.
-            Array.Clear(charRangesPerMinterm, 0, minterms.Length);
-            ArrayPool<(uint, uint)[]>.Shared.Return(charRangesPerMinterm);
+            charRangesPerMinterm.Clear();
+            ArrayPool<object>.Shared.Return(arrayPoolArray);
 
-            // Creates the lookup array.
-            static T[] CreateLookup<T>(BDD[] minterms, ReadOnlySpan<(uint, uint)[]> charRangesPerMinterm, int _maxChar) where T : IBinaryInteger<T>
+            // Creates the lookup array. charRangesPerMinterm needs to have already been populated with (uint, uint)[] instances.
+            static T[] CreateLookup<T>(BDD[] minterms, ReadOnlySpan<object> charRangesPerMinterm, int _maxChar) where T : IBinaryInteger<T>
             {
                 T[] lookup = new T[_maxChar + 1];
                 for (int mintermId = 1; mintermId < minterms.Length; mintermId++)
                 {
                     // Each minterm maps to a range of characters. Set each of the characters in those ranges to the corresponding minterm.
-                    foreach ((uint start, uint end) in charRangesPerMinterm[mintermId])
+                    foreach ((uint start, uint end) in ((uint, uint)[])charRangesPerMinterm[mintermId])
                     {
                         lookup.AsSpan((int)start, (int)(end + 1 - start)).Fill(T.CreateTruncating(mintermId));
                     }

From 6306ab84a243f3984806d594f8a43d94978d93d1 Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Thu, 11 Jul 2024 10:38:01 -0400
Subject: [PATCH 02/15] Remove unnecessary TInputReader generic from functions

---
 .../Symbolic/MintermClassifier.cs             |  4 +-
 .../Symbolic/SymbolicRegexMatcher.cs          | 70 +++++++++----------
 2 files changed, 36 insertions(+), 38 deletions(-)

diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/MintermClassifier.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/MintermClassifier.cs
index 5bf81a6191c046..c336fe93ffe1fb 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/MintermClassifier.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/MintermClassifier.cs
@@ -104,7 +104,9 @@ public int GetMintermID(int c)
             }
             else
             {
-                int[] lookup = _intLookup!;
+                Debug.Assert(_intLookup is not null);
+
+                int[] lookup = _intLookup;
                 return (uint)c < (uint)lookup.Length ? lookup[c] : 0;
             }
         }
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
index 08f423b03344ad..f9e33da926380d 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
@@ -332,10 +332,10 @@ internal TSet GetMintermFromId(int mintermId)
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private uint GetCharKind<TInputReader>(ReadOnlySpan<char> input, int i)
-            where TInputReader : struct, IInputReader => !_pattern._info.ContainsSomeAnchor ?
+        private uint GetCharKind(ReadOnlySpan<char> input, int i) =>
+            !_pattern._info.ContainsSomeAnchor ?
                 CharKind.General : // The previous character kind is irrelevant when anchors are not used.
-                GetPositionKind(TInputReader.GetPositionId(this, input, i));
+                GetPositionKind(FullInputReader.GetPositionId(this, input, i));
 
         private void CheckTimeout(long timeoutOccursAt)
         {
@@ -389,8 +389,8 @@ public SymbolicMatch FindMatch(RegexRunnerMode mode, ReadOnlySpan<char> input, i
             {
                 // Fallback for Z anchor or over 255 minterms
                 matchEnd = _findOpts is not null ?
-                    FindEndPositionFallback<FullInputReader, InitialStateFindOptimizationsHandler, FullNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData) :
-                    FindEndPositionFallback<FullInputReader, NoOptimizationsInitialStateHandler, FullNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData);
+                    FindEndPositionFallback<InitialStateFindOptimizationsHandler, FullNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData) :
+                    FindEndPositionFallback<NoOptimizationsInitialStateHandler, FullNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData);
             }
 
             // If there wasn't a match, we're done.
@@ -425,7 +425,7 @@ public SymbolicMatch FindMatch(RegexRunnerMode mode, ReadOnlySpan<char> input, i
                     if (_optimizedReversalInfo.Kind is MatchReversalKind.MatchStart)
                     {
                         // No fixed-length knowledge. Start at the end of the match.
-                        reversalStartState = new CurrentState(_reverseInitialStates[GetCharKind<FullInputReader>(input, matchEnd)]);
+                        reversalStartState = new CurrentState(_reverseInitialStates[GetCharKind(input, matchEnd)]);
                     }
                     else
                     {
@@ -491,9 +491,9 @@ private int FindEndPositionOptimized<TAcceleratedStateHandler, TOptimizedNullabi
             where TAcceleratedStateHandler : struct, IAcceleratedStateHandler
             where TOptimizedNullabilityHandler : struct, IOptimizedNullabilityHandler
         {
-            // Initial state candidate. (This is not used in the common DFA caseand could potentially be removed in the future.)
+            // Initial state candidate. (This is not used in the common DFA case and could potentially be removed in the future.)
             int initialStatePosCandidate = pos;
-            var currentState = new CurrentState(_dotstarredInitialStates[GetCharKind<FullInputReader>(input, pos - 1)]);
+            var currentState = new CurrentState(_dotstarredInitialStates[GetCharKind(input, pos - 1)]);
             int endPos = NoMatchExists;
             int lengthMinus1 = input.Length - 1;
 
@@ -514,7 +514,7 @@ private int FindEndPositionOptimized<TAcceleratedStateHandler, TOptimizedNullabi
                     // NFA fallback check, assume \Z and full nullability for NFA since it's already extremely rare to get here and it's not worth special-casing.
                     const int NfaCharsPerTimeoutCheck = 1_000;
                     innerLoopLength = _checkTimeout && input.Length - pos > NfaCharsPerTimeoutCheck ? pos + NfaCharsPerTimeoutCheck : input.Length;
-                    done = FindEndPositionDeltasNFA<NfaStateHandler, FullInputReader, NoOptimizationsInitialStateHandler, FullNullabilityHandler>(
+                    done = FindEndPositionDeltasNFA<NfaStateHandler, NoOptimizationsInitialStateHandler, FullNullabilityHandler>(
                         input, innerLoopLength, mode, timeoutOccursAt, ref pos,
                         ref currentState, ref endPos, ref initialStatePosCandidate, ref initialStatePosCandidate);
                 }
@@ -556,14 +556,13 @@ private int FindEndPositionOptimized<TAcceleratedStateHandler, TOptimizedNullabi
         /// <returns>
         /// A one-past-the-end index into input for the preferred match, or first final state position if isMatch is true, or NoMatchExists if no match exists.
         /// </returns>
-        private int FindEndPositionFallback<TInputReader, TFindOptimizationsHandler, TNullabilityHandler>(ReadOnlySpan<char> input, int pos, long timeoutOccursAt, RegexRunnerMode mode, PerThreadData perThreadData)
-            where TInputReader : struct, IInputReader
+        private int FindEndPositionFallback<TFindOptimizationsHandler, TNullabilityHandler>(ReadOnlySpan<char> input, int pos, long timeoutOccursAt, RegexRunnerMode mode, PerThreadData perThreadData)
             where TFindOptimizationsHandler : struct, IInitialStateHandler
             where TNullabilityHandler : struct, INullabilityHandler
         {
             int initialStatePosCandidate = pos;
 
-            var currentState = new CurrentState(_dotstarredInitialStates[GetCharKind<TInputReader>(input, pos - 1)]);
+            var currentState = new CurrentState(_dotstarredInitialStates[GetCharKind(input, pos - 1)]);
 
             int endPos = NoMatchExists;
             int endStateId = -1;
@@ -583,7 +582,7 @@ private int FindEndPositionFallback<TInputReader, TFindOptimizationsHandler, TNu
                 {
                     const int DfaCharsPerTimeoutCheck = 25_000;
                     innerLoopLength = _checkTimeout && input.Length - pos > DfaCharsPerTimeoutCheck ? pos + DfaCharsPerTimeoutCheck : input.Length;
-                    done = FindEndPositionDeltasDFA<DfaStateHandler, TInputReader, TFindOptimizationsHandler, TNullabilityHandler>(
+                    done = FindEndPositionDeltasDFA<DfaStateHandler, TFindOptimizationsHandler, TNullabilityHandler>(
                         input, innerLoopLength, mode, timeoutOccursAt, ref pos, ref currentState, ref endPos, ref endStateId, ref initialStatePosCandidate);
                 }
                 else
@@ -591,7 +590,7 @@ private int FindEndPositionFallback<TInputReader, TFindOptimizationsHandler, TNu
                     // NFA fallback check, assume \Z and full nullability for NFA since it's already extremely rare to get here.
                     const int NfaCharsPerTimeoutCheck = 1_000;
                     innerLoopLength = _checkTimeout && input.Length - pos > NfaCharsPerTimeoutCheck ? pos + NfaCharsPerTimeoutCheck : input.Length;
-                    done = FindEndPositionDeltasNFA<NfaStateHandler, TInputReader, TFindOptimizationsHandler, TNullabilityHandler>(
+                    done = FindEndPositionDeltasNFA<NfaStateHandler, TFindOptimizationsHandler, TNullabilityHandler>(
                         input, innerLoopLength, mode, timeoutOccursAt, ref pos, ref currentState, ref endPos, ref endStateId, ref initialStatePosCandidate);
                 }
 
@@ -732,7 +731,7 @@ private bool FindEndPositionDeltasDFAOptimized<TAcceleratedStateHandler, TOptimi
         }
 
         /// <summary>
-        /// Workhorse inner loop for <see cref="FindEndPositionFallback{TInputReader,TFindOptimizationsHandler,TNullabilityHandler}"/>.  Consumes the <paramref name="input"/> character by character,
+        /// Workhorse inner loop for <see cref="FindEndPositionFallback{TFindOptimizationsHandler,TNullabilityHandler}"/>.  Consumes the <paramref name="input"/> character by character,
         /// starting at <paramref name="posRef"/>, for each character transitioning from one state in the DFA or NFA graph to the next state,
         /// lazily building out the graph as needed.
         /// </summary>
@@ -748,10 +747,9 @@ private bool FindEndPositionDeltasDFAOptimized<TAcceleratedStateHandler, TOptimi
         /// 0 if iteration completed because we reached an initial state.
         /// A negative value if iteration completed because we ran out of input or we failed to transition.
         /// </returns>
-        private bool FindEndPositionDeltasDFA<TStateHandler, TInputReader, TFindOptimizationsHandler, TNullabilityHandler>(ReadOnlySpan<char> input, int length, RegexRunnerMode mode,
+        private bool FindEndPositionDeltasDFA<TStateHandler, TFindOptimizationsHandler, TNullabilityHandler>(ReadOnlySpan<char> input, int length, RegexRunnerMode mode,
             long timeoutOccursAt, ref int posRef, ref CurrentState state, ref int endPosRef, ref int initialStatePosRef, ref int initialStatePosCandidateRef)
             where TStateHandler : struct, IStateHandler
-            where TInputReader : struct, IInputReader
             where TFindOptimizationsHandler : struct, IInitialStateHandler
             where TNullabilityHandler : struct, INullabilityHandler
         {
@@ -776,14 +774,14 @@ private bool FindEndPositionDeltasDFA<TStateHandler, TInputReader, TFindOptimiza
 
                     if (dfaStateId == initialStateId)
                     {
-                        if (!TFindOptimizationsHandler.TryFindNextStartingPosition<TInputReader>(this, input, ref state, ref pos))
+                        if (!TFindOptimizationsHandler.TryFindNextStartingPosition(this, input, ref state, ref pos))
                         {
                             return true;
                         }
                         initialStatePosCandidate = pos;
                     }
 
-                    int positionId = TInputReader.GetPositionId(this, input, pos);
+                    int positionId = FullInputReader.GetPositionId(this, input, pos);
 
                     // If the state is nullable for the next character, meaning it accepts the empty string,
                     // we found a potential end state.
@@ -822,7 +820,7 @@ private bool FindEndPositionDeltasDFA<TStateHandler, TInputReader, TFindOptimiza
         }
 
         /// <summary>
-        /// Workhorse inner loop for <see cref="FindEndPositionFallback{TInputReader,TFindOptimizationsHandler,TNullabilityHandler}"/>.  Consumes the <paramref name="input"/> character by character,
+        /// Workhorse inner loop for <see cref="FindEndPositionFallback{TFindOptimizationsHandler,TNullabilityHandler}"/>.  Consumes the <paramref name="input"/> character by character,
         /// starting at <paramref name="posRef"/>, for each character transitioning from one state in the DFA or NFA graph to the next state,
         /// lazily building out the graph as needed.
         /// </summary>
@@ -838,11 +836,10 @@ private bool FindEndPositionDeltasDFA<TStateHandler, TInputReader, TFindOptimiza
         /// 0 if iteration completed because we reached an initial state.
         /// A negative value if iteration completed because we ran out of input or we failed to transition.
         /// </returns>
-        private bool FindEndPositionDeltasNFA<TStateHandler, TInputReader, TFindOptimizationsHandler, TNullabilityHandler>(
+        private bool FindEndPositionDeltasNFA<TStateHandler, TFindOptimizationsHandler, TNullabilityHandler>(
                 ReadOnlySpan<char> input, int length, RegexRunnerMode mode, long timeoutOccursAt,
                 ref int posRef, ref CurrentState state, ref int endPosRef, ref int initialStatePosRef, ref int initialStatePosCandidateRef)
             where TStateHandler : struct, IStateHandler
-            where TInputReader : struct, IInputReader
             where TFindOptimizationsHandler : struct, IInitialStateHandler
             where TNullabilityHandler : struct, INullabilityHandler
         {
@@ -864,7 +861,7 @@ private bool FindEndPositionDeltasNFA<TStateHandler, TInputReader, TFindOptimiza
                         return true;
                     }
 
-                    int positionId = TInputReader.GetPositionId(this, input, pos);
+                    int positionId = FullInputReader.GetPositionId(this, input, pos);
 
                     // If the state is nullable for the next character, meaning it accepts the empty string,
                     // we found a potential end state.
@@ -1064,7 +1061,7 @@ private Registers FindSubcaptures<TInputReader>(ReadOnlySpan<char> input, int i,
             where TInputReader : struct, IInputReader
         {
             // Pick the correct start state based on previous character kind.
-            MatchingState<TSet> initialState = _initialStates[GetCharKind<TInputReader>(input, i - 1)];
+            MatchingState<TSet> initialState = _initialStates[GetCharKind(input, i - 1)];
 
             Registers initialRegisters = perThreadData.InitialRegisters;
 
@@ -1117,7 +1114,7 @@ private Registers FindSubcaptures<TInputReader>(ReadOnlySpan<char> input, int i,
                             StateFlags flags = _stateFlagsArray[coreStateId];
                             Debug.Assert(coreStateId != _deadStateId);
 
-                            if (flags.IsNullable() || (flags.CanBeNullable() && GetState(coreStateId).IsNullableFor(GetCharKind<TInputReader>(input, i + 1))))
+                            if (flags.IsNullable() || (flags.CanBeNullable() && GetState(coreStateId).IsNullableFor(GetCharKind(input, i + 1))))
                             {
                                 // No lower priority transitions from this or other source states are taken because the
                                 // backtracking engines would return the match ending here.
@@ -1140,11 +1137,11 @@ private Registers FindSubcaptures<TInputReader>(ReadOnlySpan<char> input, int i,
             foreach ((int endStateId, Registers endRegisters) in current.Values)
             {
                 MatchingState<TSet> endState = GetState(GetCoreStateId(endStateId));
-                if (endState.IsNullableFor(GetCharKind<TInputReader>(input, iEnd)))
+                if (endState.IsNullableFor(GetCharKind(input, iEnd)))
                 {
                     // Apply effects for finishing at the stored end state
                     endState.Node.ApplyEffects((effect, args) => args.Registers.ApplyEffect(effect, args.Pos),
-                        CharKind.Context(endState.PrevCharKind, GetCharKind<TInputReader>(input, iEnd)), (Registers: endRegisters, Pos: iEnd));
+                        CharKind.Context(endState.PrevCharKind, GetCharKind(input, iEnd)), (Registers: endRegisters, Pos: iEnd));
                     return endRegisters;
                 }
             }
@@ -1449,7 +1446,7 @@ public static bool IsNullableFor(SymbolicRegexMatcher<TSet> matcher, in CurrentS
             /// <summary>Gets the preferred DFA state for nullability. In DFA mode this is just the state itself.</summary>
             public static int ExtractNullableCoreStateId(SymbolicRegexMatcher<TSet> matcher, in CurrentState state, ReadOnlySpan<char> input, int pos)
             {
-                uint nextCharKind = matcher.GetCharKind<FullInputReader>(input, pos);
+                uint nextCharKind = matcher.GetCharKind(input, pos);
                 foreach (ref KeyValuePair<int, int> nfaState in CollectionsMarshal.AsSpan(state.NfaState!.NfaStateSet.Values))
                 {
                     MatchingState<TSet> coreState = matcher.GetState(matcher.GetCoreStateId(nfaState.Key));
@@ -1613,7 +1610,9 @@ private interface IInputReader
         private readonly struct NoZAnchorInputReader : IInputReader
         {
             public static int GetPositionId(SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, int pos) =>
-                (uint)pos < (uint)input.Length ? matcher._mintermClassifier.GetMintermID(input[pos]) : -1;
+                (uint)pos < (uint)input.Length ?
+                    matcher._mintermClassifier.GetMintermID(input[pos]) :
+                    -1;
         }
 
         /// <summary>This reader includes full handling of an \n as the last character of input for the \Z anchor.</summary>
@@ -1636,10 +1635,9 @@ public static int GetPositionId(SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan
 
         private interface IInitialStateHandler
         {
-            public static abstract bool TryFindNextStartingPosition<TInputReader>(
+            public static abstract bool TryFindNextStartingPosition(
                 SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input,
-                ref CurrentState state, ref int pos)
-                where TInputReader : struct, IInputReader;
+                ref CurrentState state, ref int pos);
         }
 
         /// <summary>
@@ -1713,8 +1711,7 @@ public static bool TryFindNextStartingPosition(
         private readonly struct NoOptimizationsInitialStateHandler : IInitialStateHandler
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static bool TryFindNextStartingPosition<TInputReader>(SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref CurrentState state, ref int pos)
-                where TInputReader : struct, IInputReader =>
+            public static bool TryFindNextStartingPosition(SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref CurrentState state, ref int pos) =>
                 true; // the current position is a possible starting position
         }
 
@@ -1724,15 +1721,14 @@ public static bool TryFindNextStartingPosition<TInputReader>(SymbolicRegexMatche
         private readonly struct InitialStateFindOptimizationsHandler : IInitialStateHandler
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static bool TryFindNextStartingPosition<TInputReader>(SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref CurrentState state, ref int pos)
-                where TInputReader : struct, IInputReader
+            public static bool TryFindNextStartingPosition(SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref CurrentState state, ref int pos)
             {
                 // Find the first position that matches with some likely character.
                 if (matcher._findOpts!.TryFindNextStartingPositionLeftToRight(input, ref pos, 0))
                 {
                     // Update the starting state based on where TryFindNextStartingPosition moved us to.
                     // As with the initial starting state, if it's a dead end, no match exists.
-                    state = new CurrentState(matcher._dotstarredInitialStates[matcher.GetCharKind<TInputReader>(input, pos - 1)]);
+                    state = new CurrentState(matcher._dotstarredInitialStates[matcher.GetCharKind(input, pos - 1)]);
                     return true;
                 }
 

From d2f41ff69dacc16f583e955f6e47654e0943334b Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Thu, 11 Jul 2024 11:06:13 -0400
Subject: [PATCH 03/15] Add more comments and do some renames

---
 .../Symbolic/SymbolicRegexMatcher.Sample.cs   |   2 +-
 .../Symbolic/SymbolicRegexMatcher.cs          | 134 ++++++++++--------
 2 files changed, 76 insertions(+), 60 deletions(-)

diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.Sample.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.Sample.cs
index 6d9e5baca69a8d..ac7cd0c4b6d890 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.Sample.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.Sample.cs
@@ -71,7 +71,7 @@ public override IEnumerable<string> SampleMatches(int k, int randomseed)
                     NfaMatchingState states = new();
                     // Here one could also consider previous characters for example for \b, \B, and ^ anchors
                     // and initialize inputSoFar accordingly
-                    states.InitializeFrom(this, _initialStates[GetCharKind<FullInputReader>([], -1)]);
+                    states.InitializeFrom(this, _initialStates[GetCharKind<DefaultInputReader>([], -1)]);
                     CurrentState statesWrapper = new(states);
 
                     // Used for end suffixes
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
index f9e33da926380d..32971bdb0d2be1 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
@@ -335,7 +335,7 @@ internal TSet GetMintermFromId(int mintermId)
         private uint GetCharKind(ReadOnlySpan<char> input, int i) =>
             !_pattern._info.ContainsSomeAnchor ?
                 CharKind.General : // The previous character kind is irrelevant when anchors are not used.
-                GetPositionKind(FullInputReader.GetPositionId(this, input, i));
+                GetPositionKind(DefaultInputReader.GetPositionId(this, input, i));
 
         private void CheckTimeout(long timeoutOccursAt)
         {
@@ -379,18 +379,18 @@ public SymbolicMatch FindMatch(RegexRunnerMode mode, ReadOnlySpan<char> input, i
                 // Optimize processing for the common case of no Z anchor and <= 255 minterms. Specialize each call with different generic method arguments.
                 matchEnd = (_findOpts is not null, _containsAnyAnchor) switch
                 {
-                    (true, true) =>   FindEndPositionOptimized<AcceleratedStateHandler, AnchorOptimizedNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData),
+                    (true, true) =>   FindEndPositionOptimized<AcceleratedStateHandler, DefaultOptimizedNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData),
                     (true, false) =>  FindEndPositionOptimized<NoAnchorAcceleratedStateHandler, NoAnchorOptimizedNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData),
                     (false, false) => FindEndPositionOptimized<NoAcceleratedStateHandler, NoAnchorOptimizedNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData),
-                    (false, true) =>  FindEndPositionOptimized<NoAcceleratedStateHandler, AnchorOptimizedNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData),
+                    (false, true) =>  FindEndPositionOptimized<NoAcceleratedStateHandler, DefaultOptimizedNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData),
                 };
             }
             else
             {
                 // Fallback for Z anchor or over 255 minterms
                 matchEnd = _findOpts is not null ?
-                    FindEndPositionFallback<InitialStateFindOptimizationsHandler, FullNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData) :
-                    FindEndPositionFallback<NoOptimizationsInitialStateHandler, FullNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData);
+                    FindEndPositionFallback<InitialStateFindOptimizationsHandler, DefaultNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData) :
+                    FindEndPositionFallback<NoOptimizationsInitialStateHandler, DefaultNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData);
             }
 
             // If there wasn't a match, we're done.
@@ -436,8 +436,8 @@ public SymbolicMatch FindMatch(RegexRunnerMode mode, ReadOnlySpan<char> input, i
                         // reversal may already be nullable here in the case of anchors
                         if (_containsAnyAnchor &&
                             _nullabilityArray[reversalStartState.DfaStateId] > 0 &&
-                            FullNullabilityHandler.IsNullableAt<DfaStateHandler>(
-                                this, in reversalStartState, FullInputReader.GetPositionId(this, input, i),
+                            DefaultNullabilityHandler.IsNullableAt<DfaStateHandler>(
+                                this, in reversalStartState, DefaultInputReader.GetPositionId(this, input, i),
                                 DfaStateHandler.GetStateFlags(this, in reversalStartState)))
                         {
                             initialLastStart = i;
@@ -448,10 +448,10 @@ public SymbolicMatch FindMatch(RegexRunnerMode mode, ReadOnlySpan<char> input, i
                     {
                         // Call FindStartPosition with generic method arguments based on the presence of anchors. This is purely an optimization;
                         // the (true, true) case is functionally complete whereas the (false, false) case is the most optimized.
-                        (true, true) =>   FindStartPosition<FullInputReader, FullNullabilityHandler>(reversalStartState, initialLastStart, input, i, startat, perThreadData),
-                        (true, false) =>  FindStartPosition<FullInputReader, NoAnchorsNullabilityHandler>(reversalStartState, initialLastStart, input, i, startat, perThreadData),
-                        (false, true) =>  FindStartPosition<NoZAnchorInputReader, FullNullabilityHandler>(reversalStartState, initialLastStart, input, i, startat, perThreadData),
-                        (false, false) => FindStartPosition<NoZAnchorInputReader, NoAnchorsNullabilityHandler>(reversalStartState, initialLastStart, input, i, startat, perThreadData),
+                        (true, true) =>   FindStartPosition<DefaultInputReader, DefaultNullabilityHandler>(reversalStartState, initialLastStart, input, i, startat, perThreadData),
+                        (true, false) =>  FindStartPosition<DefaultInputReader, NoAnchorsNullabilityHandler>(reversalStartState, initialLastStart, input, i, startat, perThreadData),
+                        (false, true) =>  FindStartPosition<NoZAnchorOptimizedInputReader, DefaultNullabilityHandler>(reversalStartState, initialLastStart, input, i, startat, perThreadData),
+                        (false, false) => FindStartPosition<NoZAnchorOptimizedInputReader, NoAnchorsNullabilityHandler>(reversalStartState, initialLastStart, input, i, startat, perThreadData),
                     };
                     break;
 
@@ -477,8 +477,8 @@ public SymbolicMatch FindMatch(RegexRunnerMode mode, ReadOnlySpan<char> input, i
             else
             {
                 Registers endRegisters = _containsAnyAnchor ?
-                    FindSubcaptures<FullInputReader>(input, matchStart, matchEnd, perThreadData) :
-                    FindSubcaptures<NoZAnchorInputReader>(input, matchStart, matchEnd, perThreadData);
+                    FindSubcaptures<DefaultInputReader>(input, matchStart, matchEnd, perThreadData) :
+                    FindSubcaptures<NoZAnchorOptimizedInputReader>(input, matchStart, matchEnd, perThreadData);
                 return new SymbolicMatch(matchStart, matchEnd - matchStart, endRegisters.CaptureStarts, endRegisters.CaptureEnds);
             }
         }
@@ -514,7 +514,7 @@ private int FindEndPositionOptimized<TAcceleratedStateHandler, TOptimizedNullabi
                     // NFA fallback check, assume \Z and full nullability for NFA since it's already extremely rare to get here and it's not worth special-casing.
                     const int NfaCharsPerTimeoutCheck = 1_000;
                     innerLoopLength = _checkTimeout && input.Length - pos > NfaCharsPerTimeoutCheck ? pos + NfaCharsPerTimeoutCheck : input.Length;
-                    done = FindEndPositionDeltasNFA<NfaStateHandler, NoOptimizationsInitialStateHandler, FullNullabilityHandler>(
+                    done = FindEndPositionDeltasNFA<NfaStateHandler, NoOptimizationsInitialStateHandler, DefaultNullabilityHandler>(
                         input, innerLoopLength, mode, timeoutOccursAt, ref pos,
                         ref currentState, ref endPos, ref initialStatePosCandidate, ref initialStatePosCandidate);
                 }
@@ -781,7 +781,7 @@ private bool FindEndPositionDeltasDFA<TStateHandler, TFindOptimizationsHandler,
                         initialStatePosCandidate = pos;
                     }
 
-                    int positionId = FullInputReader.GetPositionId(this, input, pos);
+                    int positionId = DefaultInputReader.GetPositionId(this, input, pos);
 
                     // If the state is nullable for the next character, meaning it accepts the empty string,
                     // we found a potential end state.
@@ -861,7 +861,7 @@ private bool FindEndPositionDeltasNFA<TStateHandler, TFindOptimizationsHandler,
                         return true;
                     }
 
-                    int positionId = FullInputReader.GetPositionId(this, input, pos);
+                    int positionId = DefaultInputReader.GetPositionId(this, input, pos);
 
                     // If the state is nullable for the next character, meaning it accepts the empty string,
                     // we found a potential end state.
@@ -1596,28 +1596,28 @@ public static void UndoTransition(ref CurrentState state)
 
         /// <summary>
         /// Interface for mapping positions in the input to position IDs, which capture all the information necessary to
-        /// both take transitions and decide nullability. For positions of valid characters that are handled normally,
-        /// these IDs coincide with minterm IDs (i.e. indices to <see cref="_minterms"/>). Positions outside the bounds
-        /// of the input are mapped to -1. Optionally, an end-of-line as the very last character in the input may be
-        /// mapped to _minterms.Length for supporting the \Z anchor.
+        /// both take transitions and decide nullability.
         /// </summary>
         private interface IInputReader
         {
+            /// <summary>Gets the position ID for the specified character in the input.</summary>
+            /// <remarks>
+            /// For positions of valid characters that are handled normally, these IDs coincide with minterm IDs (i.e. indices to <see cref="_minterms"/>).
+            /// Positions outside the bounds of the input are mapped to -1. Optionally, an end-of-line as the very last character in the input may be
+            /// mapped to _minterms.Length for supporting the \Z anchor. The <paramref name="input"/> and <paramref name="pos"/> parameters are specified
+            /// separately, rather than <code>input[pos]</code> being passed in as a single <see cref="char"/>, because some inputs need to act differently
+            /// based on the position itself.
+            /// </remarks>
             public static abstract int GetPositionId(SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, int pos);
         }
 
-        /// <summary>This reader omits the special handling of \n for the \Z anchor.</summary>
-        private readonly struct NoZAnchorInputReader : IInputReader
-        {
-            public static int GetPositionId(SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, int pos) =>
-                (uint)pos < (uint)input.Length ?
-                    matcher._mintermClassifier.GetMintermID(input[pos]) :
-                    -1;
-        }
-
-        /// <summary>This reader includes full handling of an \n as the last character of input for the \Z anchor.</summary>
-        private readonly struct FullInputReader : IInputReader
+        /// <summary>Provides an input reader that includes full handling of an \n as the last character of input for the \Z anchor.</summary>
+        private readonly struct DefaultInputReader : IInputReader
         {
+            /// <summary>
+            /// Gets the minterm ID of the specified character, -1 if the position isn't within the input, or <see cref="_minterms"/>.Length
+            /// for a \n at the very end of the input.
+            /// </summary>
             public static int GetPositionId(SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, int pos)
             {
                 if ((uint)pos < (uint)input.Length)
@@ -1633,6 +1633,16 @@ public static int GetPositionId(SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan
             }
         }
 
+        /// <summary>Provides an optimized input reader that doesn't provide special-handling of \n at the end of the input for the \Z anchor.</summary>
+        private readonly struct NoZAnchorOptimizedInputReader : IInputReader
+        {
+            /// <summary>Gets the minterm ID of the specified character, or -1 if the position isn't within the input.</summary>
+            public static int GetPositionId(SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, int pos) =>
+                (uint)pos < (uint)input.Length ?
+                    matcher._mintermClassifier.GetMintermID(input[pos]) :
+                    -1;
+        }
+
         private interface IInitialStateHandler
         {
             public static abstract bool TryFindNextStartingPosition(
@@ -1737,27 +1747,30 @@ public static bool TryFindNextStartingPosition(SymbolicRegexMatcher<TSet> matche
             }
         }
 
-        /// <summary>Interface for evaluating nullability of states.</summary>
+        /// <summary>Represents a handler for evaluating nullability of states.</summary>
         private interface INullabilityHandler
         {
+            /// <summary>Gets whether the specified position is nullable.</summary>
             public static abstract bool IsNullableAt<TStateHandler>(
                 SymbolicRegexMatcher<TSet> matcher, in CurrentState state, int positionId, StateFlags flags)
                 where TStateHandler : struct, IStateHandler;
         }
 
-        /// <summary>This nullability handler interface can be used in DFAs for patterns that do not contain \Z.</summary>
-        private interface IOptimizedNullabilityHandler
+        /// <summary>Nullability handler that will work for any pattern.</summary>
+        private readonly struct DefaultNullabilityHandler : INullabilityHandler
         {
-            public static abstract bool IsNullable(
-                SymbolicRegexMatcher<TSet> matcher, byte[] nullabilityArray, int currStateId,
-                byte[] lookup, ReadOnlySpan<char> input, int pos);
+            /// <summary>Gets whether the specified position is nullable.</summary>
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static bool IsNullableAt<TStateHandler>(SymbolicRegexMatcher<TSet> matcher, in CurrentState state, int positionId, StateFlags flags)
+                where TStateHandler : struct, IStateHandler =>
+                flags.IsNullable() ||
+                (flags.CanBeNullable() && TStateHandler.IsNullableFor(matcher, in state, matcher.GetPositionKind(positionId)));
         }
 
-        /// <summary>
-        /// Specialized nullability handler for patterns without any anchors.
-        /// </summary>
+        /// <summary>Nullability handler for patterns without any anchors.</summary>
         private readonly struct NoAnchorsNullabilityHandler : INullabilityHandler
         {
+            /// <summary>Gets whether the specified position is nullable.</summary>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public static bool IsNullableAt<TStateHandler>(SymbolicRegexMatcher<TSet> matcher, in CurrentState state, int positionId, StateFlags flags)
                 where TStateHandler : struct, IStateHandler
@@ -1767,44 +1780,47 @@ public static bool IsNullableAt<TStateHandler>(SymbolicRegexMatcher<TSet> matche
             }
         }
 
-        /// <summary>
-        /// Nullability handler that will work for any pattern.
-        /// </summary>
-        private readonly struct FullNullabilityHandler : INullabilityHandler
+        /// <summary>Represents a handler for evaluating nullability of states and for use in DFAs for patterns that do not contain \Z anchors.</summary>
+        private interface IOptimizedNullabilityHandler
         {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static bool IsNullableAt<TStateHandler>(SymbolicRegexMatcher<TSet> matcher, in CurrentState state, int positionId, StateFlags flags)
-                where TStateHandler : struct, IStateHandler =>
-                flags.IsNullable() ||
-                (flags.CanBeNullable() && TStateHandler.IsNullableFor(matcher, in state, matcher.GetPositionKind(positionId)));
+            /// <summary>Gets whether the specified position is nullable.</summary>
+            public static abstract bool IsNullable(
+                SymbolicRegexMatcher<TSet> matcher, byte[] nullabilityArray, int currStateId,
+                byte[] lookup, ReadOnlySpan<char> input, int pos);
         }
 
-        private readonly struct NoAnchorOptimizedNullabilityHandler : IOptimizedNullabilityHandler
+        /// <summary>Optimized nullability handler that works regardless of what additional anchors may exist in a pattern.</summary>
+        private readonly struct DefaultOptimizedNullabilityHandler : IOptimizedNullabilityHandler
         {
+            /// <summary>Gets whether the specified position is nullable.</summary>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public static bool IsNullable(SymbolicRegexMatcher<TSet> matcher, byte[] nullabilityArray, int currStateId, byte[] lookup, ReadOnlySpan<char> input, int pos)
             {
                 Debug.Assert(pos >= 0 && pos < input.Length, "input end should not be handled here");
                 Debug.Assert(currStateId < nullabilityArray.Length, "nullabilityArray grown but the reference is not up to date");
-                return nullabilityArray[currStateId] > 0;
+
+                if (nullabilityArray[currStateId] > 0)
+                {
+                    char c = input[pos];
+                    return matcher.IsNullableWithContext(currStateId, c < (uint)lookup.Length ? lookup[c] : 0);
+                }
+
+                return false;
             }
         }
 
-        private readonly struct AnchorOptimizedNullabilityHandler : IOptimizedNullabilityHandler
+        /// <summary>Optimized nullability handler for when a pattern has no anchors at all.</summary>
+        private readonly struct NoAnchorOptimizedNullabilityHandler : IOptimizedNullabilityHandler
         {
+            /// <summary>Gets whether the specified position is nullable.</summary>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public static bool IsNullable(SymbolicRegexMatcher<TSet> matcher, byte[] nullabilityArray, int currStateId, byte[] lookup, ReadOnlySpan<char> input, int pos)
             {
                 Debug.Assert(pos >= 0 && pos < input.Length, "input end should not be handled here");
                 Debug.Assert(currStateId < nullabilityArray.Length, "nullabilityArray grown but the reference is not up to date");
+                Debug.Assert(!matcher._pattern._info.ContainsSomeAnchor);
 
-                if (nullabilityArray[currStateId] > 0)
-                {
-                    char c = input[pos];
-                    return matcher.IsNullableWithContext(currStateId, c < (uint)lookup.Length ? lookup[c] : 0);
-                }
-
-                return false;
+                return nullabilityArray[currStateId] > 0;
             }
         }
     }

From 9b51dc675567927f2af96af97c5b1fcc27983f27 Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Thu, 11 Jul 2024 11:07:00 -0400
Subject: [PATCH 04/15] Remove unused TFindOptimizationsHandler from
 FindEndPositionDeltasNFA

---
 .../RegularExpressions/Symbolic/SymbolicRegexMatcher.cs    | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
index 32971bdb0d2be1..a117eff279d92f 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
@@ -514,7 +514,7 @@ private int FindEndPositionOptimized<TAcceleratedStateHandler, TOptimizedNullabi
                     // NFA fallback check, assume \Z and full nullability for NFA since it's already extremely rare to get here and it's not worth special-casing.
                     const int NfaCharsPerTimeoutCheck = 1_000;
                     innerLoopLength = _checkTimeout && input.Length - pos > NfaCharsPerTimeoutCheck ? pos + NfaCharsPerTimeoutCheck : input.Length;
-                    done = FindEndPositionDeltasNFA<NfaStateHandler, NoOptimizationsInitialStateHandler, DefaultNullabilityHandler>(
+                    done = FindEndPositionDeltasNFA<NfaStateHandler, DefaultNullabilityHandler>(
                         input, innerLoopLength, mode, timeoutOccursAt, ref pos,
                         ref currentState, ref endPos, ref initialStatePosCandidate, ref initialStatePosCandidate);
                 }
@@ -590,7 +590,7 @@ private int FindEndPositionFallback<TFindOptimizationsHandler, TNullabilityHandl
                     // NFA fallback check, assume \Z and full nullability for NFA since it's already extremely rare to get here.
                     const int NfaCharsPerTimeoutCheck = 1_000;
                     innerLoopLength = _checkTimeout && input.Length - pos > NfaCharsPerTimeoutCheck ? pos + NfaCharsPerTimeoutCheck : input.Length;
-                    done = FindEndPositionDeltasNFA<NfaStateHandler, TFindOptimizationsHandler, TNullabilityHandler>(
+                    done = FindEndPositionDeltasNFA<NfaStateHandler, TNullabilityHandler>(
                         input, innerLoopLength, mode, timeoutOccursAt, ref pos, ref currentState, ref endPos, ref endStateId, ref initialStatePosCandidate);
                 }
 
@@ -836,11 +836,10 @@ private bool FindEndPositionDeltasDFA<TStateHandler, TFindOptimizationsHandler,
         /// 0 if iteration completed because we reached an initial state.
         /// A negative value if iteration completed because we ran out of input or we failed to transition.
         /// </returns>
-        private bool FindEndPositionDeltasNFA<TStateHandler, TFindOptimizationsHandler, TNullabilityHandler>(
+        private bool FindEndPositionDeltasNFA<TStateHandler, TNullabilityHandler>(
                 ReadOnlySpan<char> input, int length, RegexRunnerMode mode, long timeoutOccursAt,
                 ref int posRef, ref CurrentState state, ref int endPosRef, ref int initialStatePosRef, ref int initialStatePosCandidateRef)
             where TStateHandler : struct, IStateHandler
-            where TFindOptimizationsHandler : struct, IInitialStateHandler
             where TNullabilityHandler : struct, INullabilityHandler
         {
             // To avoid frequent reads/writes to ref and out values, make and operate on local copies, which we then copy back once before returning.

From 52718b4fadf6fe6567d04fdfe868fdf0ce1300fe Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Thu, 11 Jul 2024 12:13:02 -0400
Subject: [PATCH 05/15] Fix a stray input reader

---
 .../RegularExpressions/Symbolic/SymbolicRegexMatcher.Sample.cs  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.Sample.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.Sample.cs
index ac7cd0c4b6d890..2bcf4217b790eb 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.Sample.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.Sample.cs
@@ -71,7 +71,7 @@ public override IEnumerable<string> SampleMatches(int k, int randomseed)
                     NfaMatchingState states = new();
                     // Here one could also consider previous characters for example for \b, \B, and ^ anchors
                     // and initialize inputSoFar accordingly
-                    states.InitializeFrom(this, _initialStates[GetCharKind<DefaultInputReader>([], -1)]);
+                    states.InitializeFrom(this, _initialStates[GetCharKind([], -1)]);
                     CurrentState statesWrapper = new(states);
 
                     // Used for end suffixes

From a922f062a37100cba58c4ed0db1ae9d026c4e3b9 Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Thu, 11 Jul 2024 11:11:25 -0400
Subject: [PATCH 06/15] Some more renames

---
 .../Symbolic/SymbolicRegexMatcher.cs          | 118 +++++++++---------
 1 file changed, 60 insertions(+), 58 deletions(-)

diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
index a117eff279d92f..131d56c65dd3eb 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
@@ -379,10 +379,10 @@ public SymbolicMatch FindMatch(RegexRunnerMode mode, ReadOnlySpan<char> input, i
                 // Optimize processing for the common case of no Z anchor and <= 255 minterms. Specialize each call with different generic method arguments.
                 matchEnd = (_findOpts is not null, _containsAnyAnchor) switch
                 {
-                    (true, true) =>   FindEndPositionOptimized<AcceleratedStateHandler, DefaultOptimizedNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData),
-                    (true, false) =>  FindEndPositionOptimized<NoAnchorAcceleratedStateHandler, NoAnchorOptimizedNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData),
-                    (false, false) => FindEndPositionOptimized<NoAcceleratedStateHandler, NoAnchorOptimizedNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData),
-                    (false, true) =>  FindEndPositionOptimized<NoAcceleratedStateHandler, DefaultOptimizedNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData),
+                    (true, true) =>   FindEndPositionOptimized<RegexFindOpsAcceleratedStateHandler, DefaultDfaNoZAnchorOptimizedNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData),
+                    (true, false) =>  FindEndPositionOptimized<NoAnchorRegexFindOpsAcceleratedStateHandler, NoAnchorDfaOptimizedNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData),
+                    (false, false) => FindEndPositionOptimized<NoOptimizationsAcceleratedStateHandler, NoAnchorDfaOptimizedNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData),
+                    (false, true) =>  FindEndPositionOptimized<NoOptimizationsAcceleratedStateHandler, DefaultDfaNoZAnchorOptimizedNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData),
                 };
             }
             else
@@ -489,7 +489,7 @@ public SymbolicMatch FindMatch(RegexRunnerMode mode, ReadOnlySpan<char> input, i
         private int FindEndPositionOptimized<TAcceleratedStateHandler, TOptimizedNullabilityHandler>(
             ReadOnlySpan<char> input, int pos, long timeoutOccursAt, RegexRunnerMode mode, PerThreadData perThreadData)
             where TAcceleratedStateHandler : struct, IAcceleratedStateHandler
-            where TOptimizedNullabilityHandler : struct, IOptimizedNullabilityHandler
+            where TOptimizedNullabilityHandler : struct, IDfaNoZAnchorOptimizedNullabilityHandler
         {
             // Initial state candidate. (This is not used in the common DFA case and could potentially be removed in the future.)
             int initialStatePosCandidate = pos;
@@ -632,7 +632,7 @@ private bool FindEndPositionDeltasDFAOptimized<TAcceleratedStateHandler, TOptimi
             ReadOnlySpan<char> input, int lengthMinus1, RegexRunnerMode mode,
             long timeoutOccursAt, ref int posRef, ref int currentStateIdRef, ref int endPosRef)
             where TAcceleratedStateHandler : struct, IAcceleratedStateHandler
-            where TOptimizedNullabilityHandler : struct, IOptimizedNullabilityHandler
+            where TOptimizedNullabilityHandler : struct, IDfaNoZAnchorOptimizedNullabilityHandler
         {
             // Initial check for input end lifted out of the subsequent hot-path loop.
             if (posRef == input.Length)
@@ -1642,11 +1642,43 @@ public static int GetPositionId(SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan
                     -1;
         }
 
+        /// <summary>Represents a handler used to determine the next possible starting position.</summary>
         private interface IInitialStateHandler
         {
-            public static abstract bool TryFindNextStartingPosition(
-                SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input,
-                ref CurrentState state, ref int pos);
+            /// <summary>Gets the next viable starting position.</summary>
+            /// <returns>true if a viable starting position was found; false if no further possible match exists.</returns>
+            public static abstract bool TryFindNextStartingPosition(SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref CurrentState state, ref int pos);
+        }
+
+        /// <summary>Provides an initial state handler for when there are no initial state optimizations to apply.</summary>
+        private readonly struct NoOptimizationsInitialStateHandler : IInitialStateHandler
+        {
+            /// <summary>Returns true. No optimizations are known to be able to skip states, thus every position is a viable starting position.</summary>
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static bool TryFindNextStartingPosition(SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref CurrentState state, ref int pos) =>
+                true;
+        }
+
+        /// <summary>Provides a handler that uses the matcher's <see cref="RegexFindOptimizations"/> to optimize searching for the next viable starting state.</summary>
+        private readonly struct InitialStateFindOptimizationsHandler : IInitialStateHandler
+        {
+            /// <summary>Gets the next viable starting position.</summary>
+            /// <returns>true if a viable starting position was found; false if no further possible match exists.</returns>
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static bool TryFindNextStartingPosition(SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref CurrentState state, ref int pos)
+            {
+                // Find the first position that matches with some likely character.
+                if (matcher._findOpts!.TryFindNextStartingPositionLeftToRight(input, ref pos, 0))
+                {
+                    // Update the starting state based on where TryFindNextStartingPosition moved us to.
+                    // As with the initial starting state, if it's a dead end, no match exists.
+                    state = new CurrentState(matcher._dotstarredInitialStates[matcher.GetCharKind(input, pos - 1)]);
+                    return true;
+                }
+
+                // No match exists
+                return false;
+            }
         }
 
         /// <summary>
@@ -1659,29 +1691,15 @@ public static abstract bool TryFindNextStartingPosition(
                 byte[] lookup, ref int currentStateId, ref int pos, int initialStateId);
         }
 
-        private readonly struct NoAnchorAcceleratedStateHandler : IAcceleratedStateHandler
+        private readonly struct NoOptimizationsAcceleratedStateHandler : IAcceleratedStateHandler
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public static bool TryFindNextStartingPosition(
-                SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, byte[] lookup, ref int currentStateId, ref int pos, int initialStateId)
-            {
-                if (currentStateId != initialStateId)
-                {
-                    return false;
-                }
-
-                if (!matcher._findOpts!.TryFindNextStartingPositionLeftToRight(input, ref pos, 0))
-                {
-                    // No match exists
-                    currentStateId = matcher._deadStateId;
-                    pos = input.Length;
-                }
-
-                return true;
-            }
+                SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, byte[] lookup, ref int currentStateId, ref int pos, int initialStateId) =>
+                false;
         }
 
-        private readonly struct AcceleratedStateHandler : IAcceleratedStateHandler
+        private readonly struct RegexFindOpsAcceleratedStateHandler : IAcceleratedStateHandler
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public static bool TryFindNextStartingPosition(SymbolicRegexMatcher<TSet> matcher,
@@ -1708,41 +1726,25 @@ public static bool TryFindNextStartingPosition(SymbolicRegexMatcher<TSet> matche
             }
         }
 
-        private readonly struct NoAcceleratedStateHandler : IAcceleratedStateHandler
+        private readonly struct NoAnchorRegexFindOpsAcceleratedStateHandler : IAcceleratedStateHandler
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public static bool TryFindNextStartingPosition(
-                SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, byte[] lookup, ref int currentStateId, ref int pos, int initialStateId) =>
-                false;
-        }
-
-        /// <summary>No-op handler for when there are no initial state optimizations to apply.</summary>
-        private readonly struct NoOptimizationsInitialStateHandler : IInitialStateHandler
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static bool TryFindNextStartingPosition(SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref CurrentState state, ref int pos) =>
-                true; // the current position is a possible starting position
-        }
-
-        /// <summary>
-        /// Handler for when a <see cref="RegexFindOptimizations"/> instance is available.
-        /// </summary>
-        private readonly struct InitialStateFindOptimizationsHandler : IInitialStateHandler
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static bool TryFindNextStartingPosition(SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref CurrentState state, ref int pos)
+                SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, byte[] lookup, ref int currentStateId, ref int pos, int initialStateId)
             {
-                // Find the first position that matches with some likely character.
-                if (matcher._findOpts!.TryFindNextStartingPositionLeftToRight(input, ref pos, 0))
+                if (currentStateId != initialStateId)
                 {
-                    // Update the starting state based on where TryFindNextStartingPosition moved us to.
-                    // As with the initial starting state, if it's a dead end, no match exists.
-                    state = new CurrentState(matcher._dotstarredInitialStates[matcher.GetCharKind(input, pos - 1)]);
-                    return true;
+                    return false;
                 }
 
-                // No match exists
-                return false;
+                if (!matcher._findOpts!.TryFindNextStartingPositionLeftToRight(input, ref pos, 0))
+                {
+                    // No match exists
+                    currentStateId = matcher._deadStateId;
+                    pos = input.Length;
+                }
+
+                return true;
             }
         }
 
@@ -1780,7 +1782,7 @@ public static bool IsNullableAt<TStateHandler>(SymbolicRegexMatcher<TSet> matche
         }
 
         /// <summary>Represents a handler for evaluating nullability of states and for use in DFAs for patterns that do not contain \Z anchors.</summary>
-        private interface IOptimizedNullabilityHandler
+        private interface IDfaNoZAnchorOptimizedNullabilityHandler
         {
             /// <summary>Gets whether the specified position is nullable.</summary>
             public static abstract bool IsNullable(
@@ -1789,7 +1791,7 @@ public static abstract bool IsNullable(
         }
 
         /// <summary>Optimized nullability handler that works regardless of what additional anchors may exist in a pattern.</summary>
-        private readonly struct DefaultOptimizedNullabilityHandler : IOptimizedNullabilityHandler
+        private readonly struct DefaultDfaNoZAnchorOptimizedNullabilityHandler : IDfaNoZAnchorOptimizedNullabilityHandler
         {
             /// <summary>Gets whether the specified position is nullable.</summary>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -1809,7 +1811,7 @@ public static bool IsNullable(SymbolicRegexMatcher<TSet> matcher, byte[] nullabi
         }
 
         /// <summary>Optimized nullability handler for when a pattern has no anchors at all.</summary>
-        private readonly struct NoAnchorOptimizedNullabilityHandler : IOptimizedNullabilityHandler
+        private readonly struct NoAnchorDfaOptimizedNullabilityHandler : IDfaNoZAnchorOptimizedNullabilityHandler
         {
             /// <summary>Gets whether the specified position is nullable.</summary>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]

From 73c8226e7bcc1d2ffa7ed4888ecc2cb555de25ab Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Thu, 11 Jul 2024 12:21:53 -0400
Subject: [PATCH 07/15] Avoid duplicated reads of input character and
 nullability info

---
 .../Symbolic/SymbolicRegexMatcher.Automata.cs |  4 +-
 .../Symbolic/SymbolicRegexMatcher.cs          | 53 +++++++------------
 2 files changed, 21 insertions(+), 36 deletions(-)

diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.Automata.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.Automata.cs
index 327f5666f9e2a5..8c3960a6fb3502 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.Automata.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.Automata.cs
@@ -120,8 +120,8 @@ private static void ArrayResizeAndVolatilePublish<T>(ref T[] array, int newSize)
         /// Pre-computed hot-loop version of nullability check
         /// </summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private bool IsNullableWithContext(int stateId, int mintermId) =>
-            (_nullabilityArray[stateId] & (1 << (int)GetPositionKind(mintermId))) > 0;
+        private bool IsNullableWithContext(byte stateNullability, int mintermId) =>
+            (stateNullability & (1 << (int)GetPositionKind(mintermId))) != 0;
 
         /// <summary>Returns the span from <see cref="_dfaDelta"/> that may contain transitions for the given state</summary>
         private Span<int> GetDeltasFor(MatchingState<TSet> state)
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
index 131d56c65dd3eb..37417d9e102a23 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
@@ -650,7 +650,7 @@ private bool FindEndPositionDeltasDFAOptimized<TAcceleratedStateHandler, TOptimi
             int currStateId = currentStateIdRef;
             int endPos = endPosRef;
 
-            byte[] mtlookup = _mintermClassifier.ByteLookup!;
+            byte[] minterms = _mintermClassifier.ByteLookup!;
             int deadStateId = _deadStateId;
             int initialStateId = _initialStateId;
             try
@@ -664,7 +664,7 @@ private bool FindEndPositionDeltasDFAOptimized<TAcceleratedStateHandler, TOptimi
                         return true;
                     }
 
-                    if (TAcceleratedStateHandler.TryFindNextStartingPosition(this, input, mtlookup, ref currStateId, ref pos, initialStateId))
+                    if (TAcceleratedStateHandler.TryFindNextStartingPosition(this, input, minterms, ref currStateId, ref pos, initialStateId))
                     {
                         if (pos == input.Length)
                         {
@@ -680,8 +680,11 @@ private bool FindEndPositionDeltasDFAOptimized<TAcceleratedStateHandler, TOptimi
                         }
                     }
 
+                    // Get the next character.
+                    char c = input[pos];
+
                     // If the state is nullable for the next character, we found a potential end state.
-                    if (TOptimizedNullabilityHandler.IsNullable(this, _nullabilityArray, currStateId, mtlookup, input, pos))
+                    if (TOptimizedNullabilityHandler.IsNullable(this, _nullabilityArray[currStateId], c, mintermsLookup))
                     {
                         endPos = pos;
 
@@ -694,7 +697,7 @@ private bool FindEndPositionDeltasDFAOptimized<TAcceleratedStateHandler, TOptimi
 
                     // If there is more input available try to transition with the next character.
                     // Note: the order here is important so the transition itself gets taken
-                    if (!DfaStateHandler.TryTakeDFATransition(this, ref currStateId, GetMintermId(mtlookup, input, pos), timeoutOccursAt) ||
+                    if (!DfaStateHandler.TryTakeDFATransition(this, ref currStateId, GetMintermId(minterms, c), timeoutOccursAt) ||
                         pos >= lengthMinus1)
                     {
                         if (pos + 1 < input.Length)
@@ -1149,15 +1152,12 @@ private Registers FindSubcaptures<TInputReader>(ReadOnlySpan<char> input, int i,
             return default;
         }
 
-        /// <summary>Look up the min term ID for the character at the specified position in the input.</summary>
+        /// <summary>Look up the min term ID for the character.</summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static int GetMintermId(byte[] mintermLookup, ReadOnlySpan<char> input, int pos)
-        {
-            Debug.Assert(pos >= 0 && pos < input.Length);
-
-            char c = input[pos];
-            return c < (uint)mintermLookup.Length ? mintermLookup[c] : 0;
-        }
+        private static int GetMintermId(byte[] mintermLookup, char c) =>
+            c < (uint)mintermLookup.Length ?
+                mintermLookup[c] :
+                0;
 
         /// <summary>Stores additional data for tracking capture start and end positions.</summary>
         /// <remarks>The NFA simulation based third phase has one of these for each current state in the current set of live states.</remarks>
@@ -1713,7 +1713,7 @@ public static bool TryFindNextStartingPosition(SymbolicRegexMatcher<TSet> matche
 
                 if (matcher._findOpts!.TryFindNextStartingPositionLeftToRight(input, ref pos, 0))
                 {
-                    currentStateId = matcher._dotstarredInitialStates[matcher._positionKinds[GetMintermId(lookup, input, pos - 1) + 1]].Id;
+                    currentStateId = matcher._dotstarredInitialStates[matcher._positionKinds[GetMintermId(lookup, input[pos - 1]) + 1]].Id;
                 }
                 else
                 {
@@ -1785,9 +1785,7 @@ public static bool IsNullableAt<TStateHandler>(SymbolicRegexMatcher<TSet> matche
         private interface IDfaNoZAnchorOptimizedNullabilityHandler
         {
             /// <summary>Gets whether the specified position is nullable.</summary>
-            public static abstract bool IsNullable(
-                SymbolicRegexMatcher<TSet> matcher, byte[] nullabilityArray, int currStateId,
-                byte[] lookup, ReadOnlySpan<char> input, int pos);
+            public static abstract bool IsNullable(SymbolicRegexMatcher<TSet> matcher, byte stateNullability, char c, byte[] lookup);
         }
 
         /// <summary>Optimized nullability handler that works regardless of what additional anchors may exist in a pattern.</summary>
@@ -1795,19 +1793,9 @@ public static abstract bool IsNullable(
         {
             /// <summary>Gets whether the specified position is nullable.</summary>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static bool IsNullable(SymbolicRegexMatcher<TSet> matcher, byte[] nullabilityArray, int currStateId, byte[] lookup, ReadOnlySpan<char> input, int pos)
-            {
-                Debug.Assert(pos >= 0 && pos < input.Length, "input end should not be handled here");
-                Debug.Assert(currStateId < nullabilityArray.Length, "nullabilityArray grown but the reference is not up to date");
-
-                if (nullabilityArray[currStateId] > 0)
-                {
-                    char c = input[pos];
-                    return matcher.IsNullableWithContext(currStateId, c < (uint)lookup.Length ? lookup[c] : 0);
-                }
-
-                return false;
-            }
+            public static bool IsNullable(SymbolicRegexMatcher<TSet> matcher, byte stateNullability, char c, byte[] lookup) =>
+                stateNullability != 0 &&
+                matcher.IsNullableWithContext(stateNullability, c < (uint)lookup.Length ? lookup[c] : 0);
         }
 
         /// <summary>Optimized nullability handler for when a pattern has no anchors at all.</summary>
@@ -1815,13 +1803,10 @@ public static bool IsNullable(SymbolicRegexMatcher<TSet> matcher, byte[] nullabi
         {
             /// <summary>Gets whether the specified position is nullable.</summary>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static bool IsNullable(SymbolicRegexMatcher<TSet> matcher, byte[] nullabilityArray, int currStateId, byte[] lookup, ReadOnlySpan<char> input, int pos)
+            public static bool IsNullable(SymbolicRegexMatcher<TSet> matcher, byte stateNullability, char c, byte[] lookup)
             {
-                Debug.Assert(pos >= 0 && pos < input.Length, "input end should not be handled here");
-                Debug.Assert(currStateId < nullabilityArray.Length, "nullabilityArray grown but the reference is not up to date");
                 Debug.Assert(!matcher._pattern._info.ContainsSomeAnchor);
-
-                return nullabilityArray[currStateId] > 0;
+                return stateNullability != 0;
             }
         }
     }

From 341c6b7a10cb084d7ad076a6ed8e998ad7a4b771 Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Thu, 11 Jul 2024 15:13:30 -0400
Subject: [PATCH 08/15] Remove initialStateId from TryFindNextStartingPosition
 and make initial accelerators more similar

---
 .../Symbolic/SymbolicRegexMatcher.cs          | 39 +++++++------------
 1 file changed, 15 insertions(+), 24 deletions(-)

diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
index 37417d9e102a23..75089c0738fd0d 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
@@ -664,7 +664,8 @@ private bool FindEndPositionDeltasDFAOptimized<TAcceleratedStateHandler, TOptimi
                         return true;
                     }
 
-                    if (TAcceleratedStateHandler.TryFindNextStartingPosition(this, input, minterms, ref currStateId, ref pos, initialStateId))
+                    if (currStateId == initialStateId &&
+                        TAcceleratedStateHandler.TryFindNextStartingPosition(this, input, ref currStateId, ref pos, minterms))
                     {
                         if (pos == input.Length)
                         {
@@ -777,7 +778,7 @@ private bool FindEndPositionDeltasDFA<TStateHandler, TFindOptimizationsHandler,
 
                     if (dfaStateId == initialStateId)
                     {
-                        if (!TFindOptimizationsHandler.TryFindNextStartingPosition(this, input, ref state, ref pos))
+                        if (!TFindOptimizationsHandler.TryFindNextStartingPosition(this, input, ref state.DfaStateId, ref pos))
                         {
                             return true;
                         }
@@ -792,7 +793,6 @@ private bool FindEndPositionDeltasDFA<TStateHandler, TFindOptimizationsHandler,
                     {
                         endPos = pos;
 
-                        // endStateId = TStateHandler.ExtractNullableCoreStateId(this, in state, input, pos);
                         initialStatePos = initialStatePosCandidate;
 
                         // A match is known to exist.  If that's all we need to know, we're done.
@@ -1647,7 +1647,8 @@ private interface IInitialStateHandler
         {
             /// <summary>Gets the next viable starting position.</summary>
             /// <returns>true if a viable starting position was found; false if no further possible match exists.</returns>
-            public static abstract bool TryFindNextStartingPosition(SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref CurrentState state, ref int pos);
+            public static abstract bool TryFindNextStartingPosition(
+                SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref int currentStateId, ref int pos);
         }
 
         /// <summary>Provides an initial state handler for when there are no initial state optimizations to apply.</summary>
@@ -1655,7 +1656,8 @@ private interface IInitialStateHandler
         {
             /// <summary>Returns true. No optimizations are known to be able to skip states, thus every position is a viable starting position.</summary>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static bool TryFindNextStartingPosition(SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref CurrentState state, ref int pos) =>
+            public static bool TryFindNextStartingPosition(
+                SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref int currentStateId, ref int pos) =>
                 true;
         }
 
@@ -1665,14 +1667,15 @@ public static bool TryFindNextStartingPosition(SymbolicRegexMatcher<TSet> matche
             /// <summary>Gets the next viable starting position.</summary>
             /// <returns>true if a viable starting position was found; false if no further possible match exists.</returns>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static bool TryFindNextStartingPosition(SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref CurrentState state, ref int pos)
+            public static bool TryFindNextStartingPosition(
+                SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref int currentStateId, ref int pos)
             {
                 // Find the first position that matches with some likely character.
                 if (matcher._findOpts!.TryFindNextStartingPositionLeftToRight(input, ref pos, 0))
                 {
                     // Update the starting state based on where TryFindNextStartingPosition moved us to.
                     // As with the initial starting state, if it's a dead end, no match exists.
-                    state = new CurrentState(matcher._dotstarredInitialStates[matcher.GetCharKind(input, pos - 1)]);
+                    currentStateId = matcher._dotstarredInitialStates[matcher.GetCharKind(input, pos - 1)].Id;
                     return true;
                 }
 
@@ -1687,30 +1690,23 @@ public static bool TryFindNextStartingPosition(SymbolicRegexMatcher<TSet> matche
         private interface IAcceleratedStateHandler
         {
             public static abstract bool TryFindNextStartingPosition(
-                SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input,
-                byte[] lookup, ref int currentStateId, ref int pos, int initialStateId);
+                SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref int currentStateId, ref int pos, byte[] lookup);
         }
 
         private readonly struct NoOptimizationsAcceleratedStateHandler : IAcceleratedStateHandler
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public static bool TryFindNextStartingPosition(
-                SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, byte[] lookup, ref int currentStateId, ref int pos, int initialStateId) =>
+                SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref int currentStateId, ref int pos, byte[] lookup) =>
                 false;
         }
 
         private readonly struct RegexFindOpsAcceleratedStateHandler : IAcceleratedStateHandler
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static bool TryFindNextStartingPosition(SymbolicRegexMatcher<TSet> matcher,
-                ReadOnlySpan<char> input,
-                byte[] lookup, ref int currentStateId, ref int pos, int initialStateId)
+            public static bool TryFindNextStartingPosition(
+                SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref int currentStateId, ref int pos, byte[] lookup)
             {
-                if (currentStateId != initialStateId)
-                {
-                    return false;
-                }
-
                 if (matcher._findOpts!.TryFindNextStartingPositionLeftToRight(input, ref pos, 0))
                 {
                     currentStateId = matcher._dotstarredInitialStates[matcher._positionKinds[GetMintermId(lookup, input[pos - 1]) + 1]].Id;
@@ -1730,13 +1726,8 @@ public static bool TryFindNextStartingPosition(SymbolicRegexMatcher<TSet> matche
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public static bool TryFindNextStartingPosition(
-                SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, byte[] lookup, ref int currentStateId, ref int pos, int initialStateId)
+                SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref int currentStateId, ref int pos, byte[] lookup)
             {
-                if (currentStateId != initialStateId)
-                {
-                    return false;
-                }
-
                 if (!matcher._findOpts!.TryFindNextStartingPositionLeftToRight(input, ref pos, 0))
                 {
                     // No match exists

From 9193d6fe0bf9baed763836d63dc8a70c6aa36242 Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Thu, 11 Jul 2024 15:20:34 -0400
Subject: [PATCH 09/15] Remove unused initialStatePos /
 initialStatePosCandidate

It's only ever written and not actually used for anything.
---
 .../Symbolic/SymbolicRegexMatcher.cs          | 41 +++++--------------
 1 file changed, 11 insertions(+), 30 deletions(-)

diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
index 75089c0738fd0d..9ff2d510f0e99a 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
@@ -491,8 +491,7 @@ private int FindEndPositionOptimized<TAcceleratedStateHandler, TOptimizedNullabi
             where TAcceleratedStateHandler : struct, IAcceleratedStateHandler
             where TOptimizedNullabilityHandler : struct, IDfaNoZAnchorOptimizedNullabilityHandler
         {
-            // Initial state candidate. (This is not used in the common DFA case and could potentially be removed in the future.)
-            int initialStatePosCandidate = pos;
+            // Initial state candidate.
             var currentState = new CurrentState(_dotstarredInitialStates[GetCharKind(input, pos - 1)]);
             int endPos = NoMatchExists;
             int lengthMinus1 = input.Length - 1;
@@ -516,7 +515,7 @@ private int FindEndPositionOptimized<TAcceleratedStateHandler, TOptimizedNullabi
                     innerLoopLength = _checkTimeout && input.Length - pos > NfaCharsPerTimeoutCheck ? pos + NfaCharsPerTimeoutCheck : input.Length;
                     done = FindEndPositionDeltasNFA<NfaStateHandler, DefaultNullabilityHandler>(
                         input, innerLoopLength, mode, timeoutOccursAt, ref pos,
-                        ref currentState, ref endPos, ref initialStatePosCandidate, ref initialStatePosCandidate);
+                        ref currentState, ref endPos);
                 }
 
                 // If the inner loop indicates that the search finished (for example due to reaching a deadend state) or
@@ -560,12 +559,9 @@ private int FindEndPositionFallback<TFindOptimizationsHandler, TNullabilityHandl
             where TFindOptimizationsHandler : struct, IInitialStateHandler
             where TNullabilityHandler : struct, INullabilityHandler
         {
-            int initialStatePosCandidate = pos;
-
             var currentState = new CurrentState(_dotstarredInitialStates[GetCharKind(input, pos - 1)]);
 
             int endPos = NoMatchExists;
-            int endStateId = -1;
 
             while (true)
             {
@@ -583,7 +579,7 @@ private int FindEndPositionFallback<TFindOptimizationsHandler, TNullabilityHandl
                     const int DfaCharsPerTimeoutCheck = 25_000;
                     innerLoopLength = _checkTimeout && input.Length - pos > DfaCharsPerTimeoutCheck ? pos + DfaCharsPerTimeoutCheck : input.Length;
                     done = FindEndPositionDeltasDFA<DfaStateHandler, TFindOptimizationsHandler, TNullabilityHandler>(
-                        input, innerLoopLength, mode, timeoutOccursAt, ref pos, ref currentState, ref endPos, ref endStateId, ref initialStatePosCandidate);
+                        input, innerLoopLength, mode, timeoutOccursAt, ref pos, ref currentState, ref endPos);
                 }
                 else
                 {
@@ -591,7 +587,7 @@ private int FindEndPositionFallback<TFindOptimizationsHandler, TNullabilityHandl
                     const int NfaCharsPerTimeoutCheck = 1_000;
                     innerLoopLength = _checkTimeout && input.Length - pos > NfaCharsPerTimeoutCheck ? pos + NfaCharsPerTimeoutCheck : input.Length;
                     done = FindEndPositionDeltasNFA<NfaStateHandler, TNullabilityHandler>(
-                        input, innerLoopLength, mode, timeoutOccursAt, ref pos, ref currentState, ref endPos, ref endStateId, ref initialStatePosCandidate);
+                        input, innerLoopLength, mode, timeoutOccursAt, ref pos, ref currentState, ref endPos);
                 }
 
                 // If the inner loop indicates that the search finished (for example due to reaching a deadend state) or
@@ -747,12 +743,11 @@ private bool FindEndPositionDeltasDFAOptimized<TAcceleratedStateHandler, TOptimi
         /// <see cref="NfaStateHandler"/>.
         /// </remarks>
         /// <returns>
-        /// A positive value if iteration completed because it reached a deadend state or nullable state and the call is an isMatch.
-        /// 0 if iteration completed because we reached an initial state.
-        /// A negative value if iteration completed because we ran out of input or we failed to transition.
+        /// true if all input has been explored and there's no further work to be done; false if there's more input to explore and/or
+        /// we need to transition from DFA mode to NFA mode.
         /// </returns>
         private bool FindEndPositionDeltasDFA<TStateHandler, TFindOptimizationsHandler, TNullabilityHandler>(ReadOnlySpan<char> input, int length, RegexRunnerMode mode,
-            long timeoutOccursAt, ref int posRef, ref CurrentState state, ref int endPosRef, ref int initialStatePosRef, ref int initialStatePosCandidateRef)
+            long timeoutOccursAt, ref int posRef, ref CurrentState state, ref int endPosRef)
             where TStateHandler : struct, IStateHandler
             where TFindOptimizationsHandler : struct, IInitialStateHandler
             where TNullabilityHandler : struct, INullabilityHandler
@@ -760,8 +755,6 @@ private bool FindEndPositionDeltasDFA<TStateHandler, TFindOptimizationsHandler,
             // To avoid frequent reads/writes to ref and out values, make and operate on local copies, which we then copy back once before returning.
             int pos = posRef;
             int endPos = endPosRef;
-            int initialStatePos = initialStatePosRef;
-            int initialStatePosCandidate = initialStatePosCandidateRef;
 
             int deadStateId = _deadStateId;
             int initialStateId = _initialStateId;
@@ -776,13 +769,10 @@ private bool FindEndPositionDeltasDFA<TStateHandler, TFindOptimizationsHandler,
                         return true;
                     }
 
-                    if (dfaStateId == initialStateId)
+                    if (dfaStateId == initialStateId &&
+                        !TFindOptimizationsHandler.TryFindNextStartingPosition(this, input, ref state.DfaStateId, ref pos))
                     {
-                        if (!TFindOptimizationsHandler.TryFindNextStartingPosition(this, input, ref state.DfaStateId, ref pos))
-                        {
-                            return true;
-                        }
-                        initialStatePosCandidate = pos;
+                        return true;
                     }
 
                     int positionId = DefaultInputReader.GetPositionId(this, input, pos);
@@ -793,8 +783,6 @@ private bool FindEndPositionDeltasDFA<TStateHandler, TFindOptimizationsHandler,
                     {
                         endPos = pos;
 
-                        initialStatePos = initialStatePosCandidate;
-
                         // A match is known to exist.  If that's all we need to know, we're done.
                         if (mode == RegexRunnerMode.ExistenceRequired)
                         {
@@ -817,8 +805,6 @@ private bool FindEndPositionDeltasDFA<TStateHandler, TFindOptimizationsHandler,
                 // Write back the local copies of the ref values.
                 posRef = pos;
                 endPosRef = endPos;
-                initialStatePosRef = initialStatePos;
-                initialStatePosCandidateRef = initialStatePosCandidate;
             }
         }
 
@@ -841,15 +827,13 @@ private bool FindEndPositionDeltasDFA<TStateHandler, TFindOptimizationsHandler,
         /// </returns>
         private bool FindEndPositionDeltasNFA<TStateHandler, TNullabilityHandler>(
                 ReadOnlySpan<char> input, int length, RegexRunnerMode mode, long timeoutOccursAt,
-                ref int posRef, ref CurrentState state, ref int endPosRef, ref int initialStatePosRef, ref int initialStatePosCandidateRef)
+                ref int posRef, ref CurrentState state, ref int endPosRef)
             where TStateHandler : struct, IStateHandler
             where TNullabilityHandler : struct, INullabilityHandler
         {
             // To avoid frequent reads/writes to ref and out values, make and operate on local copies, which we then copy back once before returning.
             int pos = posRef;
             int endPos = endPosRef;
-            int initialStatePos = initialStatePosRef;
-            int initialStatePosCandidate = initialStatePosCandidateRef;
             try
             {
                 // Loop through each character in the input, transitioning from state to state for each.
@@ -870,7 +854,6 @@ private bool FindEndPositionDeltasNFA<TStateHandler, TNullabilityHandler>(
                     if (TNullabilityHandler.IsNullableAt<TStateHandler>(this, in state, positionId, flags))
                     {
                         endPos = pos;
-                        initialStatePos = initialStatePosCandidate;
 
                         // A match is known to exist.  If that's all we need to know, we're done.
                         if (mode == RegexRunnerMode.ExistenceRequired)
@@ -894,8 +877,6 @@ private bool FindEndPositionDeltasNFA<TStateHandler, TNullabilityHandler>(
                 // Write back the local copies of the ref values.
                 posRef = pos;
                 endPosRef = endPos;
-                initialStatePosRef = initialStatePos;
-                initialStatePosCandidateRef = initialStatePosCandidate;
             }
         }
 

From b242f8e7473543b49110e48fc5e13265867f9d51 Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Thu, 11 Jul 2024 15:36:39 -0400
Subject: [PATCH 10/15] Remove unnecessary generic args and remove resulting
 dead code

Multiple XxDfa / XxNfa methods took a TStateHandler, but it was only ever DfaStateHandler for XxDfa or NfaStateHandler for XxNfa. We can just use the types directly in those methods, rather than generically parameterizing. Doing that revealed all but one of the members of IStateHandler weren't needed on the interface. And removing those revealed a bunch of dead code on DfaStateHandler/NfaStateHandler, which were removed, as well as arguments to some methods that weren't used.
---
 .../Symbolic/SymbolicRegexMatcher.cs          | 126 ++++--------------
 1 file changed, 29 insertions(+), 97 deletions(-)

diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
index 9ff2d510f0e99a..5299b9b30d3aca 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
@@ -513,8 +513,8 @@ private int FindEndPositionOptimized<TAcceleratedStateHandler, TOptimizedNullabi
                     // NFA fallback check, assume \Z and full nullability for NFA since it's already extremely rare to get here and it's not worth special-casing.
                     const int NfaCharsPerTimeoutCheck = 1_000;
                     innerLoopLength = _checkTimeout && input.Length - pos > NfaCharsPerTimeoutCheck ? pos + NfaCharsPerTimeoutCheck : input.Length;
-                    done = FindEndPositionDeltasNFA<NfaStateHandler, DefaultNullabilityHandler>(
-                        input, innerLoopLength, mode, timeoutOccursAt, ref pos,
+                    done = FindEndPositionDeltasNFA<DefaultNullabilityHandler>(
+                        input, innerLoopLength, mode, ref pos,
                         ref currentState, ref endPos);
                 }
 
@@ -578,16 +578,16 @@ private int FindEndPositionFallback<TFindOptimizationsHandler, TNullabilityHandl
                 {
                     const int DfaCharsPerTimeoutCheck = 25_000;
                     innerLoopLength = _checkTimeout && input.Length - pos > DfaCharsPerTimeoutCheck ? pos + DfaCharsPerTimeoutCheck : input.Length;
-                    done = FindEndPositionDeltasDFA<DfaStateHandler, TFindOptimizationsHandler, TNullabilityHandler>(
-                        input, innerLoopLength, mode, timeoutOccursAt, ref pos, ref currentState, ref endPos);
+                    done = FindEndPositionDeltasDFA<TFindOptimizationsHandler, TNullabilityHandler>(
+                        input, innerLoopLength, mode, ref pos, ref currentState, ref endPos);
                 }
                 else
                 {
                     // NFA fallback check, assume \Z and full nullability for NFA since it's already extremely rare to get here.
                     const int NfaCharsPerTimeoutCheck = 1_000;
                     innerLoopLength = _checkTimeout && input.Length - pos > NfaCharsPerTimeoutCheck ? pos + NfaCharsPerTimeoutCheck : input.Length;
-                    done = FindEndPositionDeltasNFA<NfaStateHandler, TNullabilityHandler>(
-                        input, innerLoopLength, mode, timeoutOccursAt, ref pos, ref currentState, ref endPos);
+                    done = FindEndPositionDeltasNFA<TNullabilityHandler>(
+                        input, innerLoopLength, mode, ref pos, ref currentState, ref endPos);
                 }
 
                 // If the inner loop indicates that the search finished (for example due to reaching a deadend state) or
@@ -735,20 +735,12 @@ private bool FindEndPositionDeltasDFAOptimized<TAcceleratedStateHandler, TOptimi
         /// starting at <paramref name="posRef"/>, for each character transitioning from one state in the DFA or NFA graph to the next state,
         /// lazily building out the graph as needed.
         /// </summary>
-        /// <remarks>
-        /// The <typeparamref name="TStateHandler"/> supplies the actual transitioning logic, controlling whether processing is
-        /// performed in DFA mode or in NFA mode.  However, it expects <paramref name="state"/> to be configured to match,
-        /// so for example if <typeparamref name="TStateHandler"/> is a <see cref="DfaStateHandler"/>, it expects the <paramref name="state"/>'s
-        /// <see cref="CurrentState.DfaStateId"/> to be non-negative and its <see cref="CurrentState.NfaState"/> to be null; vice versa for
-        /// <see cref="NfaStateHandler"/>.
-        /// </remarks>
         /// <returns>
         /// true if all input has been explored and there's no further work to be done; false if there's more input to explore and/or
         /// we need to transition from DFA mode to NFA mode.
         /// </returns>
-        private bool FindEndPositionDeltasDFA<TStateHandler, TFindOptimizationsHandler, TNullabilityHandler>(ReadOnlySpan<char> input, int length, RegexRunnerMode mode,
-            long timeoutOccursAt, ref int posRef, ref CurrentState state, ref int endPosRef)
-            where TStateHandler : struct, IStateHandler
+        private bool FindEndPositionDeltasDFA<TFindOptimizationsHandler, TNullabilityHandler>(ReadOnlySpan<char> input, int length, RegexRunnerMode mode,
+            ref int posRef, ref CurrentState stateRef, ref int endPosRef)
             where TFindOptimizationsHandler : struct, IInitialStateHandler
             where TNullabilityHandler : struct, INullabilityHandler
         {
@@ -756,6 +748,7 @@ private bool FindEndPositionDeltasDFA<TStateHandler, TFindOptimizationsHandler,
             int pos = posRef;
             int endPos = endPosRef;
 
+            CurrentState state = stateRef;
             int deadStateId = _deadStateId;
             int initialStateId = _initialStateId;
             try
@@ -763,13 +756,12 @@ private bool FindEndPositionDeltasDFA<TStateHandler, TFindOptimizationsHandler,
                 // Loop through each character in the input, transitioning from state to state for each.
                 while (true)
                 {
-                    int dfaStateId = state.DfaStateId;
-                    if (dfaStateId == deadStateId)
+                    if (state.DfaStateId == deadStateId)
                     {
                         return true;
                     }
 
-                    if (dfaStateId == initialStateId &&
+                    if (state.DfaStateId == initialStateId &&
                         !TFindOptimizationsHandler.TryFindNextStartingPosition(this, input, ref state.DfaStateId, ref pos))
                     {
                         return true;
@@ -779,7 +771,7 @@ private bool FindEndPositionDeltasDFA<TStateHandler, TFindOptimizationsHandler,
 
                     // If the state is nullable for the next character, meaning it accepts the empty string,
                     // we found a potential end state.
-                    if (TNullabilityHandler.IsNullableAt<TStateHandler>(this, in state, positionId, TStateHandler.GetStateFlags(this, in state)))
+                    if (TNullabilityHandler.IsNullableAt<DfaStateHandler>(this, in state, positionId, DfaStateHandler.GetStateFlags(this, in state)))
                     {
                         endPos = pos;
 
@@ -791,7 +783,7 @@ private bool FindEndPositionDeltasDFA<TStateHandler, TFindOptimizationsHandler,
                     }
 
                     // If there is more input available try to transition with the next character.
-                    if (pos >= length || !TStateHandler.TryTakeTransition(this, ref state, positionId, timeoutOccursAt))
+                    if (pos >= length || !DfaStateHandler.TryTakeTransition(this, ref state, positionId))
                     {
                         return false;
                     }
@@ -805,6 +797,7 @@ private bool FindEndPositionDeltasDFA<TStateHandler, TFindOptimizationsHandler,
                 // Write back the local copies of the ref values.
                 posRef = pos;
                 endPosRef = endPos;
+                stateRef = state;
             }
         }
 
@@ -813,22 +806,14 @@ private bool FindEndPositionDeltasDFA<TStateHandler, TFindOptimizationsHandler,
         /// starting at <paramref name="posRef"/>, for each character transitioning from one state in the DFA or NFA graph to the next state,
         /// lazily building out the graph as needed.
         /// </summary>
-        /// <remarks>
-        /// The <typeparamref name="TStateHandler"/> supplies the actual transitioning logic, controlling whether processing is
-        /// performed in DFA mode or in NFA mode.  However, it expects <paramref name="state"/> to be configured to match,
-        /// so for example if <typeparamref name="TStateHandler"/> is a <see cref="DfaStateHandler"/>, it expects the <paramref name="state"/>'s
-        /// <see cref="CurrentState.DfaStateId"/> to be non-negative and its <see cref="CurrentState.NfaState"/> to be null; vice versa for
-        /// <see cref="NfaStateHandler"/>.
-        /// </remarks>
         /// <returns>
         /// A positive value if iteration completed because it reached a deadend state or nullable state and the call is an isMatch.
         /// 0 if iteration completed because we reached an initial state.
         /// A negative value if iteration completed because we ran out of input or we failed to transition.
         /// </returns>
-        private bool FindEndPositionDeltasNFA<TStateHandler, TNullabilityHandler>(
-                ReadOnlySpan<char> input, int length, RegexRunnerMode mode, long timeoutOccursAt,
+        private bool FindEndPositionDeltasNFA<TNullabilityHandler>(
+                ReadOnlySpan<char> input, int length, RegexRunnerMode mode,
                 ref int posRef, ref CurrentState state, ref int endPosRef)
-            where TStateHandler : struct, IStateHandler
             where TNullabilityHandler : struct, INullabilityHandler
         {
             // To avoid frequent reads/writes to ref and out values, make and operate on local copies, which we then copy back once before returning.
@@ -839,7 +824,7 @@ private bool FindEndPositionDeltasNFA<TStateHandler, TNullabilityHandler>(
                 // Loop through each character in the input, transitioning from state to state for each.
                 while (true)
                 {
-                    StateFlags flags = TStateHandler.GetStateFlags(this, in state);
+                    StateFlags flags = NfaStateHandler.GetStateFlags(this, in state);
 
                     // Dead end here means the set is empty
                     if (state.NfaState!.NfaStateSet.Count == 0)
@@ -851,7 +836,7 @@ private bool FindEndPositionDeltasNFA<TStateHandler, TNullabilityHandler>(
 
                     // If the state is nullable for the next character, meaning it accepts the empty string,
                     // we found a potential end state.
-                    if (TNullabilityHandler.IsNullableAt<TStateHandler>(this, in state, positionId, flags))
+                    if (TNullabilityHandler.IsNullableAt<NfaStateHandler>(this, in state, positionId, flags))
                     {
                         endPos = pos;
 
@@ -863,7 +848,7 @@ private bool FindEndPositionDeltasNFA<TStateHandler, TNullabilityHandler>(
                     }
 
                     // If there is more input available try to transition with the next character.
-                    if (pos >= length || !TStateHandler.TryTakeTransition(this, ref state, positionId, timeoutOccursAt))
+                    if (pos >= length || !NfaStateHandler.TryTakeTransition(this, ref state, positionId))
                     {
                         return false;
                     }
@@ -910,8 +895,8 @@ private int FindStartPosition<TInputReader, TNullabilityHandler>(CurrentState st
             {
                 // Run the DFA or NFA traversal backwards from the current point using the current state.
                 bool done = currentState.NfaState is not null ?
-                    FindStartPositionDeltasNFA<NfaStateHandler, TInputReader, TNullabilityHandler>(input, ref i, matchStartBoundary, ref currentState, ref lastStart) :
-                    FindStartPositionDeltasDFA<DfaStateHandler, TInputReader, TNullabilityHandler>(input, ref i, matchStartBoundary, ref currentState, ref lastStart);
+                    FindStartPositionDeltasNFA<TInputReader, TNullabilityHandler>(input, ref i, matchStartBoundary, ref currentState, ref lastStart) :
+                    FindStartPositionDeltasDFA<TInputReader, TNullabilityHandler>(input, ref i, matchStartBoundary, ref currentState, ref lastStart);
 
                 // If we found the starting position, we're done.
                 if (done)
@@ -937,9 +922,8 @@ private int FindStartPosition<TInputReader, TNullabilityHandler>(CurrentState st
         /// starting at <paramref name="i"/>, for each character transitioning from one state in the DFA or NFA graph to the next state,
         /// lazily building out the graph as needed.
         /// </summary>
-        private bool FindStartPositionDeltasDFA<TStateHandler, TInputReader, TNullabilityHandler>(
+        private bool FindStartPositionDeltasDFA<TInputReader, TNullabilityHandler>(
             ReadOnlySpan<char> input, ref int i, int startThreshold, ref CurrentState state, ref int lastStart)
-            where TStateHandler : struct, IStateHandler
             where TInputReader : struct, IInputReader
             where TNullabilityHandler : struct, INullabilityHandler
         {
@@ -955,7 +939,7 @@ private bool FindStartPositionDeltasDFA<TStateHandler, TInputReader, TNullabilit
                     // If the state accepts the empty string, we found a valid starting position.  Record it and keep going,
                     // since we're looking for the earliest one to occur within bounds.
                     if (_nullabilityArray[state.DfaStateId] > 0 &&
-                        TNullabilityHandler.IsNullableAt<TStateHandler>(this, in state, positionId, TStateHandler.GetStateFlags(this, in state)))
+                        TNullabilityHandler.IsNullableAt<DfaStateHandler>(this, in state, positionId, DfaStateHandler.GetStateFlags(this, in state)))
                     {
                         lastStart = pos;
                     }
@@ -969,7 +953,7 @@ private bool FindStartPositionDeltasDFA<TStateHandler, TInputReader, TNullabilit
                     }
 
                     // Try to transition with the next character, the one before the current position.
-                    if (!TStateHandler.TryTakeTransition(this, ref state, positionId, 0))
+                    if (!DfaStateHandler.TryTakeTransition(this, ref state, positionId))
                     {
                         // Return false to indicate the search didn't finish.
                         return false;
@@ -986,8 +970,7 @@ private bool FindStartPositionDeltasDFA<TStateHandler, TInputReader, TNullabilit
             }
         }
 
-        private bool FindStartPositionDeltasNFA<TStateHandler, TInputReader, TNullabilityHandler>(ReadOnlySpan<char> input, ref int i, int startThreshold, ref CurrentState state, ref int lastStart)
-            where TStateHandler : struct, IStateHandler
+        private bool FindStartPositionDeltasNFA<TInputReader, TNullabilityHandler>(ReadOnlySpan<char> input, ref int i, int startThreshold, ref CurrentState state, ref int lastStart)
             where TInputReader : struct, IInputReader
             where TNullabilityHandler : struct, INullabilityHandler
         {
@@ -1002,7 +985,7 @@ private bool FindStartPositionDeltasNFA<TStateHandler, TInputReader, TNullabilit
 
                     // If the state accepts the empty string, we found a valid starting position.  Record it and keep going,
                     // since we're looking for the earliest one to occur within bounds.
-                    if (TNullabilityHandler.IsNullableAt<TStateHandler>(this, in state, positionId, TStateHandler.GetStateFlags(this, in state)))
+                    if (TNullabilityHandler.IsNullableAt<NfaStateHandler>(this, in state, positionId, NfaStateHandler.GetStateFlags(this, in state)))
                     {
                         lastStart = pos;
                     }
@@ -1016,7 +999,7 @@ private bool FindStartPositionDeltasNFA<TStateHandler, TInputReader, TNullabilit
                     }
 
                     // Try to transition with the next character, the one before the current position.
-                    if (!TStateHandler.TryTakeTransition(this, ref state, positionId, 0))
+                    if (!NfaStateHandler.TryTakeTransition(this, ref state, positionId))
                     {
                         // Return false to indicate the search didn't finish.
                         return false;
@@ -1290,36 +1273,19 @@ public CurrentState(NfaMatchingState nfaState)
         /// <summary>Represents a set of routines for operating over a <see cref="CurrentState"/>.</summary>
         private interface IStateHandler
         {
-            public static abstract bool StartsWithLineAnchor(SymbolicRegexMatcher<TSet> matcher, in CurrentState state);
             public static abstract bool IsNullableFor(SymbolicRegexMatcher<TSet> matcher, in CurrentState state, uint nextCharKind);
-            public static abstract int ExtractNullableCoreStateId(SymbolicRegexMatcher<TSet> matcher, in CurrentState state, ReadOnlySpan<char> input, int pos);
-            public static abstract int FixedLength(SymbolicRegexMatcher<TSet> matcher, in CurrentState state, uint nextCharKind);
-            public static abstract bool TryTakeTransition(SymbolicRegexMatcher<TSet> matcher, ref CurrentState state, int mintermId, long timeoutOccursAt);
-            public static abstract StateFlags GetStateFlags(SymbolicRegexMatcher<TSet> matcher, in CurrentState state);
         }
 
         /// <summary>An <see cref="IStateHandler"/> for operating over <see cref="CurrentState"/> instances configured as DFA states.</summary>
         private readonly struct DfaStateHandler : IStateHandler
         {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static bool StartsWithLineAnchor(SymbolicRegexMatcher<TSet> matcher, in CurrentState state) => matcher.GetState(state.DfaStateId).StartsWithLineAnchor;
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public static bool IsNullableFor(SymbolicRegexMatcher<TSet> matcher, in CurrentState state,
                 uint nextCharKind) => matcher._nullabilityArray[state.DfaStateId] > 0 && ((byte)(1 << (int)nextCharKind) & matcher._nullabilityArray[state.DfaStateId]) > 0;
 
-            /// <summary>Gets the preferred DFA state for nullability. In DFA mode this is just the state itself.</summary>
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static int ExtractNullableCoreStateId(SymbolicRegexMatcher<TSet> matcher, in CurrentState state, ReadOnlySpan<char> input, int pos) => state.DfaStateId;
-
-            /// <summary>Gets the length of any fixed-length marker that exists for this state, or -1 if there is none.</summary>
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static int FixedLength(SymbolicRegexMatcher<TSet> matcher, in CurrentState state, uint nextCharKind) => matcher.GetState(state.DfaStateId).FixedLength(nextCharKind);
-
             /// <summary>Take the transition to the next DFA state.</summary>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static bool TryTakeTransition(SymbolicRegexMatcher<TSet> matcher, ref CurrentState state, int mintermId,
-                long timeoutOccursAt)
+            public static bool TryTakeTransition(SymbolicRegexMatcher<TSet> matcher, ref CurrentState state, int mintermId)
             {
                 Debug.Assert(state.DfaStateId > 0, $"Expected non-zero {nameof(state.DfaStateId)}.");
                 Debug.Assert(state.NfaState is null, $"Expected null {nameof(state.NfaState)}.");
@@ -1423,42 +1389,8 @@ public static bool IsNullableFor(SymbolicRegexMatcher<TSet> matcher, in CurrentS
                 return false;
             }
 
-            /// <summary>Gets the preferred DFA state for nullability. In DFA mode this is just the state itself.</summary>
-            public static int ExtractNullableCoreStateId(SymbolicRegexMatcher<TSet> matcher, in CurrentState state, ReadOnlySpan<char> input, int pos)
-            {
-                uint nextCharKind = matcher.GetCharKind(input, pos);
-                foreach (ref KeyValuePair<int, int> nfaState in CollectionsMarshal.AsSpan(state.NfaState!.NfaStateSet.Values))
-                {
-                    MatchingState<TSet> coreState = matcher.GetState(matcher.GetCoreStateId(nfaState.Key));
-                    if (coreState.IsNullableFor(nextCharKind))
-                    {
-                        return coreState.Id;
-                    }
-                }
-
-                Debug.Fail("ExtractNullableCoreStateId should only be called in nullable state/context.");
-                return -1;
-            }
-
-            /// <summary>Gets the length of any fixed-length marker that exists for this state, or -1 if there is none.</summary>
-            public static int FixedLength(SymbolicRegexMatcher<TSet> matcher, in CurrentState state, uint nextCharKind)
-            {
-                foreach (ref KeyValuePair<int, int> nfaState in CollectionsMarshal.AsSpan(state.NfaState!.NfaStateSet.Values))
-                {
-                    MatchingState<TSet> coreState = matcher.GetState(matcher.GetCoreStateId(nfaState.Key));
-                    if (coreState.IsNullableFor(nextCharKind))
-                    {
-                        return coreState.FixedLength(nextCharKind);
-                    }
-                }
-
-                Debug.Fail("FixedLength should only be called in nullable state/context.");
-                return -1;
-            }
-
             /// <summary>Take the transition to the next NFA state.</summary>
-            public static bool TryTakeTransition(SymbolicRegexMatcher<TSet> matcher, ref CurrentState state, int mintermId,
-                long timeoutOccursAt = 0)
+            public static bool TryTakeTransition(SymbolicRegexMatcher<TSet> matcher, ref CurrentState state, int mintermId)
             {
                 Debug.Assert(state.DfaStateId < 0, $"Expected negative {nameof(state.DfaStateId)}.");
                 Debug.Assert(state.NfaState is not null, $"Expected non-null {nameof(state.NfaState)}.");

From 401b65ae075134307f5b0206694e271ad4b1941b Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Thu, 11 Jul 2024 16:52:22 -0400
Subject: [PATCH 11/15] Put GetStateFlags back in IStateHandler and use it to
 avoid duplication at call sites

---
 .../Symbolic/SymbolicRegexMatcher.cs          | 47 ++++++++++---------
 1 file changed, 24 insertions(+), 23 deletions(-)

diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
index 5299b9b30d3aca..169b8373c7e182 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
@@ -437,8 +437,7 @@ public SymbolicMatch FindMatch(RegexRunnerMode mode, ReadOnlySpan<char> input, i
                         if (_containsAnyAnchor &&
                             _nullabilityArray[reversalStartState.DfaStateId] > 0 &&
                             DefaultNullabilityHandler.IsNullableAt<DfaStateHandler>(
-                                this, in reversalStartState, DefaultInputReader.GetPositionId(this, input, i),
-                                DfaStateHandler.GetStateFlags(this, in reversalStartState)))
+                                this, in reversalStartState, DefaultInputReader.GetPositionId(this, input, i)))
                         {
                             initialLastStart = i;
                         }
@@ -771,7 +770,7 @@ private bool FindEndPositionDeltasDFA<TFindOptimizationsHandler, TNullabilityHan
 
                     // If the state is nullable for the next character, meaning it accepts the empty string,
                     // we found a potential end state.
-                    if (TNullabilityHandler.IsNullableAt<DfaStateHandler>(this, in state, positionId, DfaStateHandler.GetStateFlags(this, in state)))
+                    if (TNullabilityHandler.IsNullableAt<DfaStateHandler>(this, in state, positionId))
                     {
                         endPos = pos;
 
@@ -783,7 +782,7 @@ private bool FindEndPositionDeltasDFA<TFindOptimizationsHandler, TNullabilityHan
                     }
 
                     // If there is more input available try to transition with the next character.
-                    if (pos >= length || !DfaStateHandler.TryTakeTransition(this, ref state, positionId))
+                    if (pos >= length || !DfaStateHandler.TryTakeTransition(this, ref state.DfaStateId, positionId))
                     {
                         return false;
                     }
@@ -824,8 +823,6 @@ private bool FindEndPositionDeltasNFA<TNullabilityHandler>(
                 // Loop through each character in the input, transitioning from state to state for each.
                 while (true)
                 {
-                    StateFlags flags = NfaStateHandler.GetStateFlags(this, in state);
-
                     // Dead end here means the set is empty
                     if (state.NfaState!.NfaStateSet.Count == 0)
                     {
@@ -836,7 +833,7 @@ private bool FindEndPositionDeltasNFA<TNullabilityHandler>(
 
                     // If the state is nullable for the next character, meaning it accepts the empty string,
                     // we found a potential end state.
-                    if (TNullabilityHandler.IsNullableAt<NfaStateHandler>(this, in state, positionId, flags))
+                    if (TNullabilityHandler.IsNullableAt<NfaStateHandler>(this, in state, positionId))
                     {
                         endPos = pos;
 
@@ -938,8 +935,8 @@ private bool FindStartPositionDeltasDFA<TInputReader, TNullabilityHandler>(
 
                     // If the state accepts the empty string, we found a valid starting position.  Record it and keep going,
                     // since we're looking for the earliest one to occur within bounds.
-                    if (_nullabilityArray[state.DfaStateId] > 0 &&
-                        TNullabilityHandler.IsNullableAt<DfaStateHandler>(this, in state, positionId, DfaStateHandler.GetStateFlags(this, in state)))
+                    if (_nullabilityArray[state.DfaStateId] != 0 &&
+                        TNullabilityHandler.IsNullableAt<DfaStateHandler>(this, in state, positionId))
                     {
                         lastStart = pos;
                     }
@@ -953,7 +950,7 @@ private bool FindStartPositionDeltasDFA<TInputReader, TNullabilityHandler>(
                     }
 
                     // Try to transition with the next character, the one before the current position.
-                    if (!DfaStateHandler.TryTakeTransition(this, ref state, positionId))
+                    if (!DfaStateHandler.TryTakeTransition(this, ref state.DfaStateId, positionId))
                     {
                         // Return false to indicate the search didn't finish.
                         return false;
@@ -985,7 +982,7 @@ private bool FindStartPositionDeltasNFA<TInputReader, TNullabilityHandler>(ReadO
 
                     // If the state accepts the empty string, we found a valid starting position.  Record it and keep going,
                     // since we're looking for the earliest one to occur within bounds.
-                    if (TNullabilityHandler.IsNullableAt<NfaStateHandler>(this, in state, positionId, NfaStateHandler.GetStateFlags(this, in state)))
+                    if (TNullabilityHandler.IsNullableAt<NfaStateHandler>(this, in state, positionId))
                     {
                         lastStart = pos;
                     }
@@ -1274,6 +1271,7 @@ public CurrentState(NfaMatchingState nfaState)
         private interface IStateHandler
         {
             public static abstract bool IsNullableFor(SymbolicRegexMatcher<TSet> matcher, in CurrentState state, uint nextCharKind);
+            public static abstract StateFlags GetStateFlags(SymbolicRegexMatcher<TSet> matcher, in CurrentState state);
         }
 
         /// <summary>An <see cref="IStateHandler"/> for operating over <see cref="CurrentState"/> instances configured as DFA states.</summary>
@@ -1285,29 +1283,28 @@ public static bool IsNullableFor(SymbolicRegexMatcher<TSet> matcher, in CurrentS
 
             /// <summary>Take the transition to the next DFA state.</summary>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static bool TryTakeTransition(SymbolicRegexMatcher<TSet> matcher, ref CurrentState state, int mintermId)
+            public static bool TryTakeTransition(SymbolicRegexMatcher<TSet> matcher, ref int dfaStateId, int mintermId)
             {
-                Debug.Assert(state.DfaStateId > 0, $"Expected non-zero {nameof(state.DfaStateId)}.");
-                Debug.Assert(state.NfaState is null, $"Expected null {nameof(state.NfaState)}.");
+                Debug.Assert(dfaStateId > 0, $"Expected non-zero {nameof(dfaStateId)}.");
 
                 // Use the mintermId for the character being read to look up which state to transition to.
                 // If that state has already been materialized, move to it, and we're done. If that state
                 // hasn't been materialized, try to create it; if we can, move to it, and we're done.
-                int dfaOffset = matcher.DeltaOffset(state.DfaStateId, mintermId);
+                int dfaOffset = matcher.DeltaOffset(dfaStateId, mintermId);
                 int nextStateId = matcher._dfaDelta[dfaOffset];
                 if (nextStateId > 0)
                 {
                     // There was an existing DFA transition to some state. Move to it and
                     // return that we're still operating as a DFA and can keep going.
-                    state.DfaStateId = nextStateId;
+                    dfaStateId = nextStateId;
                     return true;
                 }
 
-                if (matcher.TryCreateNewTransition(matcher.GetState(state.DfaStateId), mintermId, dfaOffset, checkThreshold: true, out MatchingState<TSet>? nextState))
+                if (matcher.TryCreateNewTransition(matcher.GetState(dfaStateId), mintermId, dfaOffset, checkThreshold: true, out MatchingState<TSet>? nextState))
                 {
                     // We were able to create a new DFA transition to some state. Move to it and
                     // return that we're still operating as a DFA and can keep going.
-                    state.DfaStateId = nextState.Id;
+                    dfaStateId = nextState.Id;
                     return true;
                 }
 
@@ -1657,7 +1654,7 @@ private interface INullabilityHandler
         {
             /// <summary>Gets whether the specified position is nullable.</summary>
             public static abstract bool IsNullableAt<TStateHandler>(
-                SymbolicRegexMatcher<TSet> matcher, in CurrentState state, int positionId, StateFlags flags)
+                SymbolicRegexMatcher<TSet> matcher, in CurrentState state, int positionId)
                 where TStateHandler : struct, IStateHandler;
         }
 
@@ -1666,10 +1663,14 @@ public static abstract bool IsNullableAt<TStateHandler>(
         {
             /// <summary>Gets whether the specified position is nullable.</summary>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static bool IsNullableAt<TStateHandler>(SymbolicRegexMatcher<TSet> matcher, in CurrentState state, int positionId, StateFlags flags)
-                where TStateHandler : struct, IStateHandler =>
+            public static bool IsNullableAt<TStateHandler>(SymbolicRegexMatcher<TSet> matcher, in CurrentState state, int positionId)
+                where TStateHandler : struct, IStateHandler
+            {
+                var flags = TStateHandler.GetStateFlags(matcher, in state);
+                return
                 flags.IsNullable() ||
                 (flags.CanBeNullable() && TStateHandler.IsNullableFor(matcher, in state, matcher.GetPositionKind(positionId)));
+            }
         }
 
         /// <summary>Nullability handler for patterns without any anchors.</summary>
@@ -1677,11 +1678,11 @@ public static bool IsNullableAt<TStateHandler>(SymbolicRegexMatcher<TSet> matche
         {
             /// <summary>Gets whether the specified position is nullable.</summary>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static bool IsNullableAt<TStateHandler>(SymbolicRegexMatcher<TSet> matcher, in CurrentState state, int positionId, StateFlags flags)
+            public static bool IsNullableAt<TStateHandler>(SymbolicRegexMatcher<TSet> matcher, in CurrentState state, int positionId)
                 where TStateHandler : struct, IStateHandler
             {
                 Debug.Assert(!matcher._pattern._info.ContainsSomeAnchor);
-                return flags.IsNullable();
+                return TStateHandler.GetStateFlags(matcher, in state).IsNullable();
             }
         }
 

From adae5e2ce206af49afaafe62cbb17209ea0faef1 Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Thu, 11 Jul 2024 17:25:25 -0400
Subject: [PATCH 12/15] Put out argument last in TryCreateNewTransition

---
 .../Symbolic/SymbolicRegexMatcher.Automata.cs            | 4 +---
 .../Symbolic/SymbolicRegexMatcher.Explore.cs             | 8 +++++++-
 .../RegularExpressions/Symbolic/SymbolicRegexMatcher.cs  | 9 +++------
 3 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.Automata.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.Automata.cs
index 8c3960a6fb3502..e192bb4b50959b 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.Automata.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.Automata.cs
@@ -355,9 +355,7 @@ private int GetCoreStateId(int nfaStateId)
 
         /// <summary>Gets or creates a new DFA transition.</summary>
         /// <remarks>This function locks the matcher for safe concurrent use of the <see cref="_builder"/></remarks>
-        private bool TryCreateNewTransition(
-            MatchingState<TSet> sourceState, int mintermId, int offset, bool checkThreshold, [NotNullWhen(true)] out MatchingState<TSet>? nextState,
-            long timeoutOccursAt = 0)
+        private bool TryCreateNewTransition(MatchingState<TSet> sourceState, int mintermId, int offset, bool checkThreshold, long timeoutOccursAt, [NotNullWhen(true)] out MatchingState<TSet>? nextState)
         {
             Debug.Assert(offset < _dfaDelta.Length);
             lock (this)
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.Explore.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.Explore.cs
index d30a2d9d02e3f3..f73bf610446a53 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.Explore.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.Explore.cs
@@ -35,16 +35,22 @@ public override void Explore(bool includeDotStarred, bool includeReverse, bool i
                     {
                         // Don't dequeue yet, because a transition might fail
                         MatchingState<TSet> state = toExplore.Peek();
+
                         // Include the special minterm for the last end-of-line if the state is sensitive to it
                         int maxMinterm = state.StartsWithLineAnchor ? _minterms!.Length : _minterms!.Length - 1;
+
                         // Explore successor states for each minterm
                         for (int mintermId = 0; mintermId <= maxMinterm; ++mintermId)
                         {
                             int offset = DeltaOffset(state.Id, mintermId);
-                            if (!TryCreateNewTransition(state, mintermId, offset, true, out MatchingState<TSet>? nextState))
+                            if (!TryCreateNewTransition(state, mintermId, offset, true, 0, out MatchingState<TSet>? nextState))
+                            {
                                 goto DfaLimitReached;
+                            }
+
                             EnqueueIfUnseen(nextState, seen, toExplore);
                         }
+
                         // Safe to dequeue now that the state has been completely handled
                         toExplore.Dequeue();
                     }
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
index 169b8373c7e182..3e0684766c2f3e 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
@@ -1300,7 +1300,7 @@ public static bool TryTakeTransition(SymbolicRegexMatcher<TSet> matcher, ref int
                     return true;
                 }
 
-                if (matcher.TryCreateNewTransition(matcher.GetState(dfaStateId), mintermId, dfaOffset, checkThreshold: true, out MatchingState<TSet>? nextState))
+                if (matcher.TryCreateNewTransition(matcher.GetState(dfaStateId), mintermId, dfaOffset, checkThreshold: true, timeoutOccursAt: 0, out MatchingState<TSet>? nextState))
                 {
                     // We were able to create a new DFA transition to some state. Move to it and
                     // return that we're still operating as a DFA and can keep going.
@@ -1313,8 +1313,7 @@ public static bool TryTakeTransition(SymbolicRegexMatcher<TSet> matcher, ref int
 
             /// <summary>Transition function that only considers DFA state id</summary>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            internal static bool TryTakeDFATransition(SymbolicRegexMatcher<TSet> matcher, ref int state,
-                int mintermId, long timeoutOccursAt)
+            internal static bool TryTakeDFATransition(SymbolicRegexMatcher<TSet> matcher, ref int state, int mintermId, long timeoutOccursAt)
             {
                 Debug.Assert(state > 0, $"Expected {nameof(state)} {state} > 0");
 
@@ -1330,9 +1329,7 @@ internal static bool TryTakeDFATransition(SymbolicRegexMatcher<TSet> matcher, re
                     return true;
                 }
 
-                if (matcher.TryCreateNewTransition(matcher.GetState(state), mintermId,
-                    matcher.DeltaOffset(state, mintermId),
-                    checkThreshold: true, out MatchingState<TSet>? nextState, timeoutOccursAt))
+                if (matcher.TryCreateNewTransition(matcher.GetState(state), mintermId, matcher.DeltaOffset(state, mintermId), checkThreshold: true, timeoutOccursAt, out MatchingState<TSet>? nextState))
                 {
                     // We were able to create a new DFA transition to some state. Move to it and
                     // return that we're still operating as a DFA and can keep going.

From 2d93daa7206c3592f019052c6ea46661d0debe95 Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Thu, 11 Jul 2024 17:27:12 -0400
Subject: [PATCH 13/15] Store state to local in FindStartPositionDeltasDFA

---
 .../Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs  | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
index 3e0684766c2f3e..02edf56a073de7 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
@@ -920,12 +920,13 @@ private int FindStartPosition<TInputReader, TNullabilityHandler>(CurrentState st
         /// lazily building out the graph as needed.
         /// </summary>
         private bool FindStartPositionDeltasDFA<TInputReader, TNullabilityHandler>(
-            ReadOnlySpan<char> input, ref int i, int startThreshold, ref CurrentState state, ref int lastStart)
+            ReadOnlySpan<char> input, ref int i, int startThreshold, ref CurrentState stateRef, ref int lastStart)
             where TInputReader : struct, IInputReader
             where TNullabilityHandler : struct, INullabilityHandler
         {
             // To avoid frequent reads/writes to ref values, make and operate on local copies, which we then copy back once before returning.
             int pos = i;
+            CurrentState state = stateRef;
             try
             {
                 // Loop backwards through each character in the input, transitioning from state to state for each.
@@ -963,6 +964,7 @@ private bool FindStartPositionDeltasDFA<TInputReader, TNullabilityHandler>(
             finally
             {
                 // Write back the local copies of the ref values.
+                stateRef = state;
                 i = pos;
             }
         }

From 9f614258c4913cf7993c3c1636d412dbfe83aae7 Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Thu, 11 Jul 2024 18:28:47 -0400
Subject: [PATCH 14/15] Merge IAcceleratedStateHandler into
 IInitialStateHandler

---
 .../Symbolic/SymbolicRegexMatcher.cs          | 170 ++++++++++--------
 1 file changed, 94 insertions(+), 76 deletions(-)

diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
index 02edf56a073de7..7d002191d8267a 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
@@ -379,17 +379,17 @@ public SymbolicMatch FindMatch(RegexRunnerMode mode, ReadOnlySpan<char> input, i
                 // Optimize processing for the common case of no Z anchor and <= 255 minterms. Specialize each call with different generic method arguments.
                 matchEnd = (_findOpts is not null, _containsAnyAnchor) switch
                 {
-                    (true, true) =>   FindEndPositionOptimized<RegexFindOpsAcceleratedStateHandler, DefaultDfaNoZAnchorOptimizedNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData),
-                    (true, false) =>  FindEndPositionOptimized<NoAnchorRegexFindOpsAcceleratedStateHandler, NoAnchorDfaOptimizedNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData),
-                    (false, false) => FindEndPositionOptimized<NoOptimizationsAcceleratedStateHandler, NoAnchorDfaOptimizedNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData),
-                    (false, true) =>  FindEndPositionOptimized<NoOptimizationsAcceleratedStateHandler, DefaultDfaNoZAnchorOptimizedNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData),
+                    (true, true) =>   FindEndPositionOptimized<NoZAnchorFindOptimizationsInitialStateHandler, DefaultDfaNoZAnchorOptimizedNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData),
+                    (true, false) =>  FindEndPositionOptimized<NoAnchorsFindOptimizationsInitialStateHandler, NoAnchorDfaOptimizedNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData),
+                    (false, true) =>  FindEndPositionOptimized<NoOptimizationsInitialStateHandler, DefaultDfaNoZAnchorOptimizedNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData),
+                    (false, false) => FindEndPositionOptimized<NoOptimizationsInitialStateHandler, NoAnchorDfaOptimizedNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData),
                 };
             }
             else
             {
                 // Fallback for Z anchor or over 255 minterms
                 matchEnd = _findOpts is not null ?
-                    FindEndPositionFallback<InitialStateFindOptimizationsHandler, DefaultNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData) :
+                    FindEndPositionFallback<FindOptimizationsInitialStateHandler, DefaultNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData) :
                     FindEndPositionFallback<NoOptimizationsInitialStateHandler, DefaultNullabilityHandler>(input, startat, timeoutOccursAt, mode, perThreadData);
             }
 
@@ -436,8 +436,7 @@ public SymbolicMatch FindMatch(RegexRunnerMode mode, ReadOnlySpan<char> input, i
                         // reversal may already be nullable here in the case of anchors
                         if (_containsAnyAnchor &&
                             _nullabilityArray[reversalStartState.DfaStateId] > 0 &&
-                            DefaultNullabilityHandler.IsNullableAt<DfaStateHandler>(
-                                this, in reversalStartState, DefaultInputReader.GetPositionId(this, input, i)))
+                            DefaultNullabilityHandler.IsNullableAt<DfaStateHandler>(this, in reversalStartState, DefaultInputReader.GetPositionId(this, input, i)))
                         {
                             initialLastStart = i;
                         }
@@ -485,9 +484,9 @@ public SymbolicMatch FindMatch(RegexRunnerMode mode, ReadOnlySpan<char> input, i
         /// <summary>
         /// Streamlined version of <see cref="FindEndPositionFallback"/> that doesn't handle /z anchors or very large sets of minterms.
         /// </summary>
-        private int FindEndPositionOptimized<TAcceleratedStateHandler, TOptimizedNullabilityHandler>(
+        private int FindEndPositionOptimized<TInitialStateHandler, TOptimizedNullabilityHandler>(
             ReadOnlySpan<char> input, int pos, long timeoutOccursAt, RegexRunnerMode mode, PerThreadData perThreadData)
-            where TAcceleratedStateHandler : struct, IAcceleratedStateHandler
+            where TInitialStateHandler : struct, IInitialStateHandler
             where TOptimizedNullabilityHandler : struct, IDfaNoZAnchorOptimizedNullabilityHandler
         {
             // Initial state candidate.
@@ -503,7 +502,7 @@ private int FindEndPositionOptimized<TAcceleratedStateHandler, TOptimizedNullabi
                 {
                     const int DfaCharsPerTimeoutCheck = 100_000;
                     innerLoopLength = _checkTimeout && lengthMinus1 - pos > DfaCharsPerTimeoutCheck ? pos + DfaCharsPerTimeoutCheck : lengthMinus1;
-                    done = FindEndPositionDeltasDFAOptimized<TAcceleratedStateHandler, TOptimizedNullabilityHandler>(
+                    done = FindEndPositionDeltasDFAOptimized<TInitialStateHandler, TOptimizedNullabilityHandler>(
                         input, innerLoopLength, mode, timeoutOccursAt, ref pos,
                         ref currentState.DfaStateId, ref endPos);
                 }
@@ -554,8 +553,8 @@ private int FindEndPositionOptimized<TAcceleratedStateHandler, TOptimizedNullabi
         /// <returns>
         /// A one-past-the-end index into input for the preferred match, or first final state position if isMatch is true, or NoMatchExists if no match exists.
         /// </returns>
-        private int FindEndPositionFallback<TFindOptimizationsHandler, TNullabilityHandler>(ReadOnlySpan<char> input, int pos, long timeoutOccursAt, RegexRunnerMode mode, PerThreadData perThreadData)
-            where TFindOptimizationsHandler : struct, IInitialStateHandler
+        private int FindEndPositionFallback<TInitialStateHandler, TNullabilityHandler>(ReadOnlySpan<char> input, int pos, long timeoutOccursAt, RegexRunnerMode mode, PerThreadData perThreadData)
+            where TInitialStateHandler : struct, IInitialStateHandler
             where TNullabilityHandler : struct, INullabilityHandler
         {
             var currentState = new CurrentState(_dotstarredInitialStates[GetCharKind(input, pos - 1)]);
@@ -577,7 +576,7 @@ private int FindEndPositionFallback<TFindOptimizationsHandler, TNullabilityHandl
                 {
                     const int DfaCharsPerTimeoutCheck = 25_000;
                     innerLoopLength = _checkTimeout && input.Length - pos > DfaCharsPerTimeoutCheck ? pos + DfaCharsPerTimeoutCheck : input.Length;
-                    done = FindEndPositionDeltasDFA<TFindOptimizationsHandler, TNullabilityHandler>(
+                    done = FindEndPositionDeltasDFA<TInitialStateHandler, TNullabilityHandler>(
                         input, innerLoopLength, mode, ref pos, ref currentState, ref endPos);
                 }
                 else
@@ -623,10 +622,10 @@ private int FindEndPositionFallback<TFindOptimizationsHandler, TNullabilityHandl
         /// which don't check for many inner loop edge cases, e.g. input end or '\n'.
         /// All edge cases are handled before entering the loop.
         /// </summary>
-        private bool FindEndPositionDeltasDFAOptimized<TAcceleratedStateHandler, TOptimizedNullabilityHandler>(
+        private bool FindEndPositionDeltasDFAOptimized<TInitialStateHandler, TOptimizedNullabilityHandler>(
             ReadOnlySpan<char> input, int lengthMinus1, RegexRunnerMode mode,
             long timeoutOccursAt, ref int posRef, ref int currentStateIdRef, ref int endPosRef)
-            where TAcceleratedStateHandler : struct, IAcceleratedStateHandler
+            where TInitialStateHandler : struct, IInitialStateHandler
             where TOptimizedNullabilityHandler : struct, IDfaNoZAnchorOptimizedNullabilityHandler
         {
             // Initial check for input end lifted out of the subsequent hot-path loop.
@@ -645,7 +644,7 @@ private bool FindEndPositionDeltasDFAOptimized<TAcceleratedStateHandler, TOptimi
             int currStateId = currentStateIdRef;
             int endPos = endPosRef;
 
-            byte[] minterms = _mintermClassifier.ByteLookup!;
+            byte[] mintermsLookup = _mintermClassifier.ByteLookup!;
             int deadStateId = _deadStateId;
             int initialStateId = _initialStateId;
             try
@@ -659,9 +658,9 @@ private bool FindEndPositionDeltasDFAOptimized<TAcceleratedStateHandler, TOptimi
                         return true;
                     }
 
-                    if (currStateId == initialStateId &&
-                        TAcceleratedStateHandler.TryFindNextStartingPosition(this, input, ref currStateId, ref pos, minterms))
+                    if (TInitialStateHandler.IsOptimized && currStateId == initialStateId)
                     {
+                        TInitialStateHandler.TryFindNextStartingPosition(this, input, ref currStateId, ref pos, mintermsLookup);
                         if (pos == input.Length)
                         {
                             // patterns such as ^$ can be nullable right away
@@ -672,7 +671,7 @@ private bool FindEndPositionDeltasDFAOptimized<TAcceleratedStateHandler, TOptimi
                             }
 
                             currStateId = deadStateId;
-                            continue;
+                            return true;
                         }
                     }
 
@@ -693,7 +692,7 @@ private bool FindEndPositionDeltasDFAOptimized<TAcceleratedStateHandler, TOptimi
 
                     // If there is more input available try to transition with the next character.
                     // Note: the order here is important so the transition itself gets taken
-                    if (!DfaStateHandler.TryTakeDFATransition(this, ref currStateId, GetMintermId(minterms, c), timeoutOccursAt) ||
+                    if (!DfaStateHandler.TryTakeDFATransition(this, ref currStateId, GetMintermId(mintermsLookup, c), timeoutOccursAt) ||
                         pos >= lengthMinus1)
                     {
                         if (pos + 1 < input.Length)
@@ -738,9 +737,9 @@ private bool FindEndPositionDeltasDFAOptimized<TAcceleratedStateHandler, TOptimi
         /// true if all input has been explored and there's no further work to be done; false if there's more input to explore and/or
         /// we need to transition from DFA mode to NFA mode.
         /// </returns>
-        private bool FindEndPositionDeltasDFA<TFindOptimizationsHandler, TNullabilityHandler>(ReadOnlySpan<char> input, int length, RegexRunnerMode mode,
+        private bool FindEndPositionDeltasDFA<TInitialStateHandler, TNullabilityHandler>(ReadOnlySpan<char> input, int length, RegexRunnerMode mode,
             ref int posRef, ref CurrentState stateRef, ref int endPosRef)
-            where TFindOptimizationsHandler : struct, IInitialStateHandler
+            where TInitialStateHandler : struct, IInitialStateHandler
             where TNullabilityHandler : struct, INullabilityHandler
         {
             // To avoid frequent reads/writes to ref and out values, make and operate on local copies, which we then copy back once before returning.
@@ -755,13 +754,8 @@ private bool FindEndPositionDeltasDFA<TFindOptimizationsHandler, TNullabilityHan
                 // Loop through each character in the input, transitioning from state to state for each.
                 while (true)
                 {
-                    if (state.DfaStateId == deadStateId)
-                    {
-                        return true;
-                    }
-
-                    if (state.DfaStateId == initialStateId &&
-                        !TFindOptimizationsHandler.TryFindNextStartingPosition(this, input, ref state.DfaStateId, ref pos))
+                    if (state.DfaStateId == deadStateId ||
+                        (state.DfaStateId == initialStateId && !TInitialStateHandler.TryFindNextStartingPosition(this, input, ref state.DfaStateId, ref pos, null!)))
                     {
                         return true;
                     }
@@ -1280,8 +1274,9 @@ private interface IStateHandler
         private readonly struct DfaStateHandler : IStateHandler
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static bool IsNullableFor(SymbolicRegexMatcher<TSet> matcher, in CurrentState state,
-                uint nextCharKind) => matcher._nullabilityArray[state.DfaStateId] > 0 && ((byte)(1 << (int)nextCharKind) & matcher._nullabilityArray[state.DfaStateId]) > 0;
+            public static bool IsNullableFor(SymbolicRegexMatcher<TSet> matcher, in CurrentState state, uint nextCharKind) =>
+                matcher._nullabilityArray[state.DfaStateId] > 0 &&
+                ((byte)(1 << (int)nextCharKind) & matcher._nullabilityArray[state.DfaStateId]) > 0;
 
             /// <summary>Take the transition to the next DFA state.</summary>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -1462,7 +1457,7 @@ static int[] GetNextStates(int sourceState, int mintermId, SymbolicRegexMatcher<
             /// In NFA mode:
             /// - an empty set of states means that it is a dead end
             /// - no set of states qualifies as an initial state. This could be made more accurate, but with that the
-            ///   matching logic would need to be updated to handle the fact that <see cref="InitialStateFindOptimizationsHandler"/>
+            ///   matching logic would need to be updated to handle the fact that <see cref="FindOptimizationsInitialStateHandler"/>
             ///   can transition back to a DFA state.
             /// </remarks>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -1551,36 +1546,51 @@ public static int GetPositionId(SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan
                     -1;
         }
 
-        /// <summary>Represents a handler used to determine the next possible starting position.</summary>
+        /// <summary>Represents a handler used to determine the next possible matching position from an initial state.</summary>
         private interface IInitialStateHandler
         {
+            /// <summary>Gets whether the handler performs any meaningful operation. If false, <see cref="TryFindNextStartingPosition"/> always returns true.</summary>
+            /// <remarks>
+            /// This should be implemented to always return a constant true or false. The consumer will inline it and, if this is false, can dead-code eliminate
+            /// anything guarded by the condition.
+            /// </remarks>
+            public static abstract bool IsOptimized { get; }
+
             /// <summary>Gets the next viable starting position.</summary>
-            /// <returns>true if a viable starting position was found; false if no further possible match exists.</returns>
+            /// <returns>true if a possible match location is found; false if no match is possible anywhere in the remaining input.</returns>
+            /// <remarks>This may be used if <see cref="IsOptimized"/> is false but it will then always return true indicating that the current position may be viable.</remarks>
             public static abstract bool TryFindNextStartingPosition(
-                SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref int currentStateId, ref int pos);
+                SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref int currentStateId, ref int pos, byte[]? lookup);
         }
 
         /// <summary>Provides an initial state handler for when there are no initial state optimizations to apply.</summary>
         private readonly struct NoOptimizationsInitialStateHandler : IInitialStateHandler
         {
+            /// <summary>Returns false.</summary>
+            public static bool IsOptimized => false;
+
             /// <summary>Returns true. No optimizations are known to be able to skip states, thus every position is a viable starting position.</summary>
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public static bool TryFindNextStartingPosition(
-                SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref int currentStateId, ref int pos) =>
+                SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref int currentStateId, ref int pos, byte[]? lookup) =>
                 true;
         }
 
         /// <summary>Provides a handler that uses the matcher's <see cref="RegexFindOptimizations"/> to optimize searching for the next viable starting state.</summary>
-        private readonly struct InitialStateFindOptimizationsHandler : IInitialStateHandler
+        private readonly struct FindOptimizationsInitialStateHandler : IInitialStateHandler
         {
+            /// <summary>Returns true.</summary>
+            public static bool IsOptimized => true;
+
             /// <summary>Gets the next viable starting position.</summary>
             /// <returns>true if a viable starting position was found; false if no further possible match exists.</returns>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public static bool TryFindNextStartingPosition(
-                SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref int currentStateId, ref int pos)
+                SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref int currentStateId, ref int pos, byte[]? lookup)
             {
+                Debug.Assert(matcher._findOpts is not null);
+
                 // Find the first position that matches with some likely character.
-                if (matcher._findOpts!.TryFindNextStartingPositionLeftToRight(input, ref pos, 0))
+                if (matcher._findOpts.TryFindNextStartingPositionLeftToRight(input, ref pos, 0))
                 {
                     // Update the starting state based on where TryFindNextStartingPosition moved us to.
                     // As with the initial starting state, if it's a dead end, no match exists.
@@ -1589,62 +1599,70 @@ public static bool TryFindNextStartingPosition(
                 }
 
                 // No match exists
+                Debug.Assert(pos == input.Length);
+                currentStateId = matcher._deadStateId;
                 return false;
             }
         }
 
-        /// <summary>
-        /// Interface for accelerated states, returns true if position was changed
-        /// </summary>
-        private interface IAcceleratedStateHandler
-        {
-            public static abstract bool TryFindNextStartingPosition(
-                SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref int currentStateId, ref int pos, byte[] lookup);
-        }
-
-        private readonly struct NoOptimizationsAcceleratedStateHandler : IAcceleratedStateHandler
+        /// <summary>Provides a handler that uses the matcher's <see cref="RegexFindOptimizations"/> to optimize searching for the next viable starting state.</summary>
+        /// <remarks>This implementation works only when there are no /Z anchors in the pattern.</remarks>
+        private readonly struct NoZAnchorFindOptimizationsInitialStateHandler : IInitialStateHandler
         {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static bool TryFindNextStartingPosition(
-                SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref int currentStateId, ref int pos, byte[] lookup) =>
-                false;
-        }
+            /// <summary>Returns true.</summary>
+            public static bool IsOptimized => true;
 
-        private readonly struct RegexFindOpsAcceleratedStateHandler : IAcceleratedStateHandler
-        {
+            /// <summary>Gets the next viable starting position.</summary>
+            /// <returns>true if a viable starting position was found; false if no further possible match exists.</returns>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public static bool TryFindNextStartingPosition(
-                SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref int currentStateId, ref int pos, byte[] lookup)
+                SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref int currentStateId, ref int pos, byte[]? lookup)
             {
-                if (matcher._findOpts!.TryFindNextStartingPositionLeftToRight(input, ref pos, 0))
+                Debug.Assert(matcher._findOpts is not null);
+                Debug.Assert(lookup is not null, $"{nameof(NoZAnchorFindOptimizationsInitialStateHandler)} must only be used with call sites that pass non-null {nameof(lookup)}.");
+
+                if (matcher._findOpts.TryFindNextStartingPositionLeftToRight(input, ref pos, 0))
                 {
+                    // Update the starting state based on where TryFindNextStartingPosition moved us to.
+                    // This is an optimized version of the update in FindOptimizationsInitialStateHandler that doesn't need to consider the possibility of /Z anchors.
                     currentStateId = matcher._dotstarredInitialStates[matcher._positionKinds[GetMintermId(lookup, input[pos - 1]) + 1]].Id;
-                }
-                else
-                {
-                    // No match exists
-                    currentStateId = matcher._deadStateId;
-                    pos = input.Length;
+                    return true;
                 }
 
-                return true;
+                // No match exists
+                Debug.Assert(pos == input.Length);
+                currentStateId = matcher._deadStateId;
+                return false;
             }
         }
 
-        private readonly struct NoAnchorRegexFindOpsAcceleratedStateHandler : IAcceleratedStateHandler
+        /// <summary>Provides a handler that uses the matcher's <see cref="RegexFindOptimizations"/> to optimize searching for the next viable starting state.</summary>
+        /// <remarks>This implementation works only when there are no anchors in the pattern.</remarks>
+        private readonly struct NoAnchorsFindOptimizationsInitialStateHandler : IInitialStateHandler
         {
+            /// <summary>Returns true.</summary>
+            public static bool IsOptimized => true;
+
+            /// <summary>Gets the next viable starting position.</summary>
+            /// <returns>true if a viable starting position was found; false if no further possible match exists.</returns>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public static bool TryFindNextStartingPosition(
-                SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref int currentStateId, ref int pos, byte[] lookup)
+                SymbolicRegexMatcher<TSet> matcher, ReadOnlySpan<char> input, ref int currentStateId, ref int pos, byte[]? lookup)
             {
-                if (!matcher._findOpts!.TryFindNextStartingPositionLeftToRight(input, ref pos, 0))
+                Debug.Assert(!matcher._containsAnyAnchor);
+                Debug.Assert(matcher._findOpts is not null);
+                Debug.Assert(currentStateId == matcher._initialStateId, "There are no anchors, so the current state should be the sole initial state.");
+
+                if (matcher._findOpts.TryFindNextStartingPositionLeftToRight(input, ref pos, 0))
                 {
-                    // No match exists
-                    currentStateId = matcher._deadStateId;
-                    pos = input.Length;
+                    // There are no anchors, so there's only one starting state, so we don't need to update currentStateId that's already the starting state.
+                    return true;
                 }
 
-                return true;
+                // No match exists
+                Debug.Assert(pos == input.Length);
+                currentStateId = matcher._deadStateId;
+                return false;
             }
         }
 
@@ -1665,10 +1683,10 @@ public static abstract bool IsNullableAt<TStateHandler>(
             public static bool IsNullableAt<TStateHandler>(SymbolicRegexMatcher<TSet> matcher, in CurrentState state, int positionId)
                 where TStateHandler : struct, IStateHandler
             {
-                var flags = TStateHandler.GetStateFlags(matcher, in state);
+                StateFlags flags = TStateHandler.GetStateFlags(matcher, in state);
                 return
-                flags.IsNullable() ||
-                (flags.CanBeNullable() && TStateHandler.IsNullableFor(matcher, in state, matcher.GetPositionKind(positionId)));
+                    flags.IsNullable() ||
+                    (flags.CanBeNullable() && TStateHandler.IsNullableFor(matcher, in state, matcher.GetPositionKind(positionId)));
             }
         }
 

From 4e760f19ef3100a65f2f43d9315f904782d0c682 Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Thu, 11 Jul 2024 20:59:05 -0400
Subject: [PATCH 15/15] Remove MintermClassifier.IntLookup

---
 .../Text/RegularExpressions/Symbolic/MintermClassifier.cs   | 6 ------
 .../RegularExpressions/Symbolic/SymbolicRegexMatcher.cs     | 2 +-
 2 files changed, 1 insertion(+), 7 deletions(-)

diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/MintermClassifier.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/MintermClassifier.cs
index c336fe93ffe1fb..bf4735f2bf1459 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/MintermClassifier.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/MintermClassifier.cs
@@ -116,12 +116,6 @@ public int GetMintermID(int c)
         /// </summary>
         public byte[]? ByteLookup => _lookup;
 
-        /// <summary>
-        /// Gets a mapping from char to minterm for the rare case when there are &gt;= 255 minterms.
-        /// Null in the common case where there are fewer than 255 minterms.
-        /// </summary>
-        public int[]? IntLookup => _intLookup;
-
         /// <summary>
         /// Maximum ordinal character for a non-0 minterm, used to conserve memory
         /// </summary>
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
index 7d002191d8267a..e67a72018dfd57 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
@@ -374,7 +374,7 @@ public SymbolicMatch FindMatch(RegexRunnerMode mode, ReadOnlySpan<char> input, i
 
             // The Z anchor and over 255 minterms are rare enough to consider them separate edge cases.
             int matchEnd;
-            if (!_containsEndZAnchor && _mintermClassifier.IntLookup is null)
+            if (!_containsEndZAnchor && _mintermClassifier.ByteLookup is not null)
             {
                 // Optimize processing for the common case of no Z anchor and <= 255 minterms. Specialize each call with different generic method arguments.
                 matchEnd = (_findOpts is not null, _containsAnyAnchor) switch