.

SimonCropp · SimonCropp · commit d5bd5b23a330 · 2025-11-25T21:33:53.000+11:00
diff --git a/src/Verify/Serialization/Scrubbers/CrossChunkMatcher.cs b/src/Verify/Serialization/Scrubbers/CrossChunkMatcher.cs
@@ -17,14 +17,14 @@ public static void ReplaceAll<TContext>(
         int carryoverSize,
         TContext context,
         CrossChunkHandler<TContext> onCrossChunk,
-        WithinChunkHandler<TContext> onWithinChunk,
-        Func<TContext, List<Match>> getMatches)
+        WithinChunkHandler<TContext> onWithinChunk)
     {
         Span<char> carryoverBuffer = stackalloc char[carryoverSize];
         var carryoverLength = 0;
         var previousChunkAbsoluteEnd = 0;
         var absolutePosition = 0;
-
+        List<Match> matches  = [];
+        var addMatch = matches.Add;
         foreach (var chunk in builder.GetChunks())
         {
             var chunkSpan = chunk.Span;
@@ -44,7 +44,8 @@ public static void ReplaceAll<TContext>(
                         remainingInCarryover,
                         chunkSpan,
                         startPosition,
-                        context);
+                        context,
+                        addMatch);
                 }
             }
 
@@ -53,7 +54,7 @@ public static void ReplaceAll<TContext>(
             while (chunkIndex < chunk.Length)
             {
                 var absoluteIndex = absolutePosition + chunkIndex;
-                var skipAhead = onWithinChunk(chunk, chunkSpan, chunkIndex, absoluteIndex, context);
+                var skipAhead = onWithinChunk(chunk, chunkSpan, chunkIndex, absoluteIndex, context, addMatch);
                 chunkIndex += skipAhead > 0 ? skipAhead : 1;
             }
 
@@ -66,7 +67,6 @@ public static void ReplaceAll<TContext>(
         }
 
         // Apply matches in descending position order
-        var matches = getMatches(context);
         foreach (var match in matches.OrderByDescending(_ => _.Index))
         {
             builder.Overwrite(match.Value, match.Index, match.Length);
@@ -83,7 +83,8 @@ public delegate void CrossChunkHandler<TContext>(
         int remainingInCarryover,
         CharSpan currentChunkSpan,
         int absoluteStartPosition,
-        TContext context);
+        TContext context,
+        Action<Match> addMatch);
 
     /// <summary>
     /// Callback for processing positions within a chunk.
@@ -94,7 +95,8 @@ public delegate int WithinChunkHandler<TContext>(
         CharSpan chunkSpan,
         int chunkIndex,
         int absoluteIndex,
-        TContext context);
+        TContext context,
+        Action<Match> addMatch);
 }
 
 
diff --git a/src/Verify/Serialization/Scrubbers/DateScrubber.cs b/src/Verify/Serialization/Scrubbers/DateScrubber.cs
@@ -213,8 +213,7 @@ static void ReplaceInner(StringBuilder builder, string format, Counter counter,
             carryoverSize: max - 1,
             context,
             OnCrossChunk,
-            OnWithinChunk,
-            getMatches: c => c.Matches);
+            OnWithinChunk);
     }
 
     static void OnCrossChunk(
@@ -224,7 +223,8 @@ static void OnCrossChunk(
         int remainingInCarryover,
         CharSpan currentChunkSpan,
         int absoluteStartPosition,
-        MatchContext context)
+        MatchContext context,
+        Action<Match> addMatch)
     {
         Span<char> combinedBuffer = stackalloc char[context.MaxLength];
 
@@ -247,7 +247,7 @@ static void OnCrossChunk(
 
             if (context.TryConvert(slice, context.Format, context.Counter, context.Culture, out var convert))
             {
-                context.Matches.Add(new(absoluteStartPosition, length, convert));
+                addMatch(new(absoluteStartPosition, length, convert));
                 return; // Found match at this position
             }
         }
@@ -258,7 +258,8 @@ static int OnWithinChunk(
         CharSpan chunkSpan,
         int chunkIndex,
         int absoluteIndex,
-        MatchContext context)
+        MatchContext context,
+        Action<Match> addMatch)
     {
         // Try lengths from longest to shortest (greedy matching)
         for (var length = context.MaxLength; length >= context.MinLength; length--)
@@ -272,7 +273,7 @@ static int OnWithinChunk(
 
             if (context.TryConvert(slice, context.Format, context.Counter, context.Culture, out var convert))
             {
-                context.Matches.Add(new(absoluteIndex, length, convert));
+                addMatch(new(absoluteIndex, length, convert));
                 return length; // Skip past match
             }
         }
@@ -294,6 +295,5 @@ sealed class MatchContext(
         public TryConvert TryConvert { get; } = tryConvert;
         public int MaxLength { get; } = maxLength;
         public int MinLength { get; } = minLength;
-        public List<Match> Matches { get; } = [];
     }
 }
diff --git a/src/Verify/Serialization/Scrubbers/DirectoryReplacements_StringBuilder.cs b/src/Verify/Serialization/Scrubbers/DirectoryReplacements_StringBuilder.cs
@@ -46,8 +46,7 @@ public static void Replace(StringBuilder builder, List<Pair> paths)
             carryoverSize: maxLength - 1,
             context,
             OnCrossChunk,
-            OnWithinChunk,
-            getMatches: c => c.Matches);
+            OnWithinChunk);
     }
 
     static void OnCrossChunk(
@@ -57,7 +56,8 @@ static void OnCrossChunk(
         int remainingInCarryover,
         CharSpan currentChunkSpan,
         int absoluteStartPosition,
-        MatchContext context)
+        MatchContext context,
+        Action<Match> addMatch)
     {
         Span<char> combinedBuffer = stackalloc char[context.MaxLength * 2];
 
@@ -93,7 +93,7 @@ static void OnCrossChunk(
                 continue;
             }
 
-            context.Matches.Add(new(absoluteStartPosition, matchLength, pair.Replace));
+            addMatch(new(absoluteStartPosition, matchLength, pair.Replace));
             context.AddMatchedRange(absoluteStartPosition, absoluteStartPosition + matchLength);
             // Found a match at this position, skip other pairs
             break;
@@ -105,7 +105,8 @@ static int OnWithinChunk(
         CharSpan chunkSpan,
         int chunkIndex,
         int absoluteIndex,
-        MatchContext context)
+        MatchContext context,
+        Action<Match> addMatch)
     {
         // Skip if already matched
         if (context.IsPositionMatched(absoluteIndex))
@@ -133,7 +134,7 @@ static int OnWithinChunk(
                 continue;
             }
 
-            context.Matches.Add(new(absoluteIndex, matchLength, pair.Replace));
+            addMatch(new(absoluteIndex, matchLength, pair.Replace));
             context.AddMatchedRange(absoluteIndex, absoluteIndex + matchLength);
             // Skip past this match
             return matchLength;
@@ -269,7 +270,6 @@ static bool IsPathMatchAt(CharSpan chunk, int chunkPos, string find)
     sealed class MatchContext(List<Pair> pairs)
     {
         public List<Pair> Pairs { get; } = pairs;
-        public List<Match> Matches { get; } = [];
         public int MaxLength { get; } = pairs.Count > 0 ? pairs[0].Find.Length : 0;
 
         List<(int Start, int End)> matchedRanges = [];
diff --git a/src/Verify/Serialization/Scrubbers/GuidScrubber.cs b/src/Verify/Serialization/Scrubbers/GuidScrubber.cs
@@ -20,8 +20,7 @@ public static void ReplaceGuids(StringBuilder builder, Counter counter)
             carryoverSize: 35,
             context,
             OnCrossChunk,
-            OnWithinChunk,
-            getMatches: c => c.Matches);
+            OnWithinChunk);
     }
 
     static void OnCrossChunk(
@@ -31,7 +30,8 @@ static void OnCrossChunk(
         int remainingInCarryover,
         CharSpan currentChunkSpan,
         int absoluteStartPosition,
-        MatchContext context)
+        MatchContext context,
+        Action<Match> addMatch)
     {
         var neededFromCurrent = 36 - remainingInCarryover;
 
@@ -66,15 +66,16 @@ static void OnCrossChunk(
         }
 
         var convert = context.Counter.Convert(guid);
-        context.Matches.Add(new(absoluteStartPosition, 36, convert));
+        addMatch(new(absoluteStartPosition, 36, convert));
     }
 
     static int OnWithinChunk(
         ReadOnlyMemory<char> chunk,
         CharSpan chunkSpan,
         int chunkIndex,
         int absoluteIndex,
-        MatchContext context)
+        MatchContext context,
+        Action<Match> addMatch)
     {
         var end = chunkIndex + 36;
         if (end > chunk.Length)
@@ -101,7 +102,7 @@ static int OnWithinChunk(
         }
 
         var convert = context.Counter.Convert(guid);
-        context.Matches.Add(new(absoluteIndex, 36, convert));
+        addMatch(new(absoluteIndex, 36, convert));
         return 36; // Skip past the matched GUID
     }
 
@@ -122,6 +123,5 @@ static bool IsInvalidStartingChar(char ch) =>
     sealed class MatchContext(Counter counter)
     {
         public Counter Counter { get; } = counter;
-        public List<Match> Matches { get; } = [];
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -213,8 +213,7 @@ static void ReplaceInner(StringBuilder builder, string format, Counter counter,`
`213`	`213`	`carryoverSize: max - 1,`
`214`	`214`	`context,`
`215`	`215`	`OnCrossChunk,`
`216`		`- OnWithinChunk,`
`217`		`- getMatches: c => c.Matches);`
	`216`	`+ OnWithinChunk);`
`218`	`217`	`}`
`219`	`218`
`220`	`219`	`static void OnCrossChunk(`
`@@ -224,7 +223,8 @@ static void OnCrossChunk(`
`224`	`223`	`int remainingInCarryover,`
`225`	`224`	`CharSpan currentChunkSpan,`
`226`	`225`	`int absoluteStartPosition,`
`227`		`- MatchContext context)`
	`226`	`+ MatchContext context,`
	`227`	`+ Action<Match> addMatch)`
`228`	`228`	`{`
`229`	`229`	`Span<char> combinedBuffer = stackalloc char[context.MaxLength];`
`230`	`230`
`@@ -247,7 +247,7 @@ static void OnCrossChunk(`
`247`	`247`
`248`	`248`	`if (context.TryConvert(slice, context.Format, context.Counter, context.Culture, out var convert))`
`249`	`249`	`{`
`250`		`- context.Matches.Add(new(absoluteStartPosition, length, convert));`
	`250`	`+ addMatch(new(absoluteStartPosition, length, convert));`
`251`	`251`	`return; // Found match at this position`
`252`	`252`	`}`
`253`	`253`	`}`
`@@ -258,7 +258,8 @@ static int OnWithinChunk(`
`258`	`258`	`CharSpan chunkSpan,`
`259`	`259`	`int chunkIndex,`
`260`	`260`	`int absoluteIndex,`
`261`		`- MatchContext context)`
	`261`	`+ MatchContext context,`
	`262`	`+ Action<Match> addMatch)`
`262`	`263`	`{`
`263`	`264`	`// Try lengths from longest to shortest (greedy matching)`
`264`	`265`	`for (var length = context.MaxLength; length >= context.MinLength; length--)`
`@@ -272,7 +273,7 @@ static int OnWithinChunk(`
`272`	`273`
`273`	`274`	`if (context.TryConvert(slice, context.Format, context.Counter, context.Culture, out var convert))`
`274`	`275`	`{`
`275`		`- context.Matches.Add(new(absoluteIndex, length, convert));`
	`276`	`+ addMatch(new(absoluteIndex, length, convert));`
`276`	`277`	`return length; // Skip past match`
`277`	`278`	`}`
`278`	`279`	`}`
`@@ -294,6 +295,5 @@ sealed class MatchContext(`
`294`	`295`	`public TryConvert TryConvert { get; } = tryConvert;`
`295`	`296`	`public int MaxLength { get; } = maxLength;`
`296`	`297`	`public int MinLength { get; } = minLength;`
`297`		`- public List<Match> Matches { get; } = [];`
`298`	`298`	`}`
`299`	`299`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,8 +20,7 @@ public static void ReplaceGuids(StringBuilder builder, Counter counter)`
`20`	`20`	`carryoverSize: 35,`
`21`	`21`	`context,`
`22`	`22`	`OnCrossChunk,`
`23`		`- OnWithinChunk,`
`24`		`- getMatches: c => c.Matches);`
	`23`	`+ OnWithinChunk);`
`25`	`24`	`}`
`26`	`25`
`27`	`26`	`static void OnCrossChunk(`
`@@ -31,7 +30,8 @@ static void OnCrossChunk(`
`31`	`30`	`int remainingInCarryover,`
`32`	`31`	`CharSpan currentChunkSpan,`
`33`	`32`	`int absoluteStartPosition,`
`34`		`- MatchContext context)`
	`33`	`+ MatchContext context,`
	`34`	`+ Action<Match> addMatch)`
`35`	`35`	`{`
`36`	`36`	`var neededFromCurrent = 36 - remainingInCarryover;`
`37`	`37`
`@@ -66,15 +66,16 @@ static void OnCrossChunk(`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`var convert = context.Counter.Convert(guid);`
`69`		`- context.Matches.Add(new(absoluteStartPosition, 36, convert));`
	`69`	`+ addMatch(new(absoluteStartPosition, 36, convert));`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`static int OnWithinChunk(`
`73`	`73`	`ReadOnlyMemory<char> chunk,`
`74`	`74`	`CharSpan chunkSpan,`
`75`	`75`	`int chunkIndex,`
`76`	`76`	`int absoluteIndex,`
`77`		`- MatchContext context)`
	`77`	`+ MatchContext context,`
	`78`	`+ Action<Match> addMatch)`
`78`	`79`	`{`
`79`	`80`	`var end = chunkIndex + 36;`
`80`	`81`	`if (end > chunk.Length)`
`@@ -101,7 +102,7 @@ static int OnWithinChunk(`
`101`	`102`	`}`
`102`	`103`
`103`	`104`	`var convert = context.Counter.Convert(guid);`
`104`		`- context.Matches.Add(new(absoluteIndex, 36, convert));`
	`105`	`+ addMatch(new(absoluteIndex, 36, convert));`
`105`	`106`	`return 36; // Skip past the matched GUID`
`106`	`107`	`}`
`107`	`108`
`@@ -122,6 +123,5 @@ static bool IsInvalidStartingChar(char ch) =>`
`122`	`123`	`sealed class MatchContext(Counter counter)`
`123`	`124`	`{`
`124`	`125`	`public Counter Counter { get; } = counter;`
`125`		`- public List<Match> Matches { get; } = [];`
`126`	`126`	`}`
`127`	`127`	`}`