Fix chunk-boundary scrubber bugs and test-adapter defects

Scrubbers (Verify core):
- UserMachineScrubber: fix IndexOutOfRangeException when a match ends exactly
  on a chunk boundary with a following chunk (read the trailing char via the
  builder indexer instead of chunkSpan[neededFromCurrent])
- UserMachineScrubber, GuidScrubber, DirectoryReplacements: roll the carryover
  forward across chunks so a token spanning three or more chunks (with a middle
  chunk shorter than the token) is no longer silently left unscrubbed
- DateFormatLengthCalculator: 'K' contributes 0 to the minimum length (it can
  render as "", "Z" or "+11:00"), so round-trip/"o" formats now scrub the Z and
  offset-less forms instead of only the offset form
- LinesScrubber.ReplaceLines: guard the trailing-newline trim on the rebuilt
  builder length, not the original string length, fixing an
  ArgumentOutOfRangeException when every line is replaced with null

Test-framework adapters:
- MSTest Verifier: only apply TestData parameters when their count matches the
  method parameter count (matches XunitV3; params-array DataRows no longer break
  parameterized snapshot naming)
- MSTest Verifier_Archive: forward the dropped archiveExtension in the
  VerifyZip(Stream) overload
- MSTest TestExecutionContext: resolve Method lazily so the method scan runs
  only when a verifier is built
- MSTest source generator: require an attribute list in the syntax predicate so
  the uncached CreateSyntaxProvider transform no longer runs semantic work for
  every class on every keystroke
- NUnit VerifyBase_Tuple: pass sourceFile so snapshots resolve to the test's
  path rather than the package build path
- NUnit VerifyBase_Stream: use settings ?? this.settings in the Task<T> and
  ValueTask<T> stream overloads so instance settings are honored

Add repro tests for the scrubber fixes.

Author: SimonCropp

src/Verify.MSTest.SourceGenerator/UsesVerifyGenerator.cs

@@ -118,8 +118,12 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
     static bool HasTestClassAttribute(INamedTypeSymbol symbol, INamedTypeSymbol testClassType) =>
         !symbol.HasAttributeOfType(testClassType, includeDerived: true);
 
+    // Require at least one attribute list: both paths only care about classes
+    // carrying [UsesVerify] or [TestClass]. Without this filter the uncached
+    // CreateSyntaxProvider transform runs semantic work for every class in the
+    // consuming project on every keystroke.
     static bool IsSyntaxEligibleForGeneration(SyntaxNode node, Cancel _) =>
-        node is ClassDeclarationSyntax;
+        node is ClassDeclarationSyntax { AttributeLists.Count: > 0 };
 
     static bool IsAssemblyEligibleForGeneration(IAssemblySymbol assembly, INamedTypeSymbol markerType) =>
         assembly.HasAttributeOfType(markerType, includeDerived: false);

src/Verify.MSTest/TestExecutionContext.cs

@@ -3,7 +3,12 @@ namespace VerifyMSTest;
 public record TestExecutionContext(TestContext TestContext, Type TestClass)
 {
     public Assembly Assembly { get; } = TestClass.Assembly;
-    public MethodInfo Method { get; } = FindMethod(TestClass, TestContext);
+
+    MethodInfo? method;
+
+    // Resolved lazily: the method scan is only needed when a Verify call actually
+    // builds a verifier, not for every test that constructs a context.
+    public MethodInfo Method => method ??= FindMethod(TestClass, TestContext);
 
     static MethodInfo FindMethod(Type type, TestContext context)
     {

src/Verify.MSTest/Verifier.cs

@@ -33,7 +33,12 @@ public static InnerVerifier BuildVerifier(VerifySettings settings, string source
         if (!settings.HasParameters)
         {
             var data = context.TestContext.TestData;
-            if (data != null)
+            // Only apply when the data length matches the method parameter count.
+            // A params-array DataRow exposes raw pre-binding data whose length does
+            // not match the parameter count, which would break parameterized
+            // snapshot file naming. XunitV3 applies the same guard.
+            if (data != null &&
+                data.Length == method.ParameterNames()?.Count)
             {
                 settings.SetParameters(data);
             }

src/Verify.MSTest/Verifier_Archive.cs

@@ -47,7 +47,7 @@ public static SettingsTask VerifyZip(
         bool persistArchive = false,
         string? archiveExtension = null,
         [CallerFilePath] string sourceFile = "") =>
-        Verify(settings, sourceFile, _ => _.VerifyZip(stream, include, info, fileScrubber, includeStructure, persistArchive), true);
+        Verify(settings, sourceFile, _ => _.VerifyZip(stream, include, info, fileScrubber, includeStructure, persistArchive, archiveExtension), true);
 
     /// <summary>
     /// Verifies the contents of a <see cref="ZipArchive" />

src/Verify.NUnit/VerifyBase_Stream.cs

@@ -40,7 +40,7 @@ public SettingsTask Verify<T>(
         VerifySettings? settings = null,
         object? info = null)
         where T : Stream =>
-        Verifier.Verify(target, extension, settings, info, sourceFile);
+        Verifier.Verify(target, extension, settings ?? this.settings, info, sourceFile);
 
     [Pure]
     public SettingsTask Verify<T>(
@@ -49,7 +49,7 @@ public SettingsTask Verify<T>(
         VerifySettings? settings = null,
         object? info = null)
         where T : Stream =>
-        Verifier.Verify(target, extension, settings, info, sourceFile);
+        Verifier.Verify(target, extension, settings ?? this.settings, info, sourceFile);
 
     [Pure]
     public SettingsTask Verify(

src/Verify.NUnit/VerifyBase_Tuple.cs

@@ -7,6 +7,6 @@ public partial class VerifyBase
     public SettingsTask VerifyTuple(
         Expression<Func<ITuple>> target,
         VerifySettings? settings = null) =>
-        Verifier.VerifyTuple(target, settings ?? this.settings);
+        Verifier.VerifyTuple(target, settings ?? this.settings, sourceFile);
 }
 #endif

src/Verify.Tests/DateFormatLengthCalculatorTests.cs

@@ -43,8 +43,11 @@
     [InlineData("zz", 3, 3)]
     [InlineData("zzz", 6, 6)]
     [InlineData("zzzz", 6, 6)]
-    [InlineData("K", 6, 6)]
-    [InlineData("KK", 12, 12)]
+    // K renders as "" (Unspecified), "Z" (Utc, 1 char) or "+11:00" (offset, 6 chars),
+    // so its minimum contribution is 0 (not 6) — otherwise round-trip/"o" formats
+    // scrub only the offset form and leak the Z / offset-less forms.
+    [InlineData("K", 6, 0)]
+    [InlineData("KK", 12, 0)]
     [InlineData(":", 1, 1)]
     [InlineData("':'", 1, 1)]
     [InlineData("/", 1, 1)]

src/Verify.Tests/GuidScrubberTests.cs

@@ -101,6 +101,23 @@ public void MultipleChunks()
         Assert.Equal("[Guid_1][Guid_2]", builder.ToString());
     }
 
+    [Fact]
+    public void GuidSpanningThreeChunks()
+    {
+        // Capacity 4 forces small chunks [4][4][rest]; the 36-char guid spans all
+        // three, and the 4-char middle chunk is shorter than the 35-char carryover.
+        // The carryover must accumulate across chunks or the prefix is dropped and
+        // the guid is never found (silent leak).
+        var guid = "173535ae-995b-4cc6-a74e-8cd4be57039c";
+        var builder = new StringBuilder(capacity: 4);
+        builder.Append(guid[..4]);  // chunk0
+        builder.Append(guid[4..8]); // chunk1 (short middle chunk)
+        builder.Append(guid[8..]);  // chunk2
+        using var counter = Counter.Start();
+        GuidScrubber.ReplaceGuids(builder, counter);
+        Assert.Equal("Guid_1", builder.ToString());
+    }
+
     #region NamedGuidFluent
 
     [Fact]

src/Verify.Tests/LinesScrubberTests.cs

@@ -78,6 +78,29 @@ public Task ScrubLinesContaining_case_sensitive()
                     """);
     }
 
+    [Fact]
+    public void ReplaceLines_AllRemovedNoTrailingNewline()
+    {
+        // Single line, no trailing newline, and every line replaced with null.
+        // The trailing-newline trim must guard on the rebuilt builder length, not
+        // the original string length, otherwise Length -= 1 underflows.
+        var builder = new StringBuilder("single line");
+
+        builder.ReplaceLines(_ => null);
+
+        Assert.Equal(string.Empty, builder.ToString());
+    }
+
+    [Fact]
+    public void ReplaceLines_ReplacesLines()
+    {
+        var builder = new StringBuilder("a\nb\nc");
+
+        builder.ReplaceLines(line => line == "b" ? "B" : line);
+
+        Assert.Equal("a\nB\nc", builder.ToString());
+    }
+
     [Fact]
     public void FilterLines_RemovesSingleLine()
     {

src/Verify.Tests/Serialization/DirectoryReplacementTests.cs

@@ -45,6 +45,22 @@ public void MultipleChunks()
         Assert.Equal("{Child} {Parent} ", builder.ToString());
     }
 
+    [Fact]
+    public void PathSpanningThreeChunks()
+    {
+        // Capacity 4 forces small chunks [4][4][rest]; the 16-char path spans all
+        // three, and the 4-char middle chunk is shorter than the carryover. The
+        // carryover must accumulate across chunks or the prefix is dropped and the
+        // path leaks unscrubbed.
+        List<DirectoryReplacements.Pair> pairs = [new("C:/Parent/ChildX", "{replace}")];
+        var builder = new StringBuilder(capacity: 4);
+        builder.Append("C:/P"); // chunk0
+        builder.Append("aren"); // chunk1 (short middle chunk)
+        builder.Append("t/ChildX.");
+        DirectoryReplacements.Replace(builder, pairs);
+        Assert.Equal("{replace}.", builder.ToString());
+    }
+
     [Fact]
     public void ProcessLongerDirectoryFirst()
     {