fix: Correct analyzer test spans and clarify allocation documentation

- Fix OPENTXT007 diagnostic span in tests (should include full expression)
- Clarify that SplitToEnumerableNoAlloc allocates strings per segment
- Document that Regex-based methods have unavoidable Match allocations
- Note that JoinNoAlloc(IEnumerable) may box struct enumerators
- Update README with accurate allocation expectations

Author: electricessence

Analyzers.Tests/SmartDetectionTests.cs

@@ -351,7 +351,7 @@ void TestMethod()
 			        string text = "a,b,c,d,e";
 			        
 			        // Split with FirstOrDefault - double diagnostic
-			        string first = {|OPENTXT007:{|OPENTXT002:text.Split(',')|}|}.FirstOrDefault();
+			        string first = {|OPENTXT007:{|OPENTXT002:text.Split(',')|}.FirstOrDefault()|};
 			        
 			        // Split in foreach
 			        foreach (var part in {|OPENTXT008:text.Split(',')|})

Analyzers.Tests/SplitAnalyzerTests.cs

@@ -54,7 +54,7 @@ class TestClass
 				void TestMethod()
 				{
 					string text = "a,b,c";
-					string first = {|OPENTXT007:{|OPENTXT002:text.Split(',')|}|}.First();
+					string first = {|OPENTXT007:{|OPENTXT002:text.Split(',')|}.First()|};
 				}
 			}
 			""";

README.md

@@ -36,7 +36,9 @@ Comparing `string.Split()` (BCL) vs `SplitAsSegments` (IEnumerable) vs `SplitAsS
 | | SplitAsSegments(string) | 215.2 ns | 128 B |
 | | BCL Split(string) | 227.1 ns | 696 B |
 
-> **Key Takeaway:** The `*NoAlloc` methods achieve **zero heap allocations** while maintaining competitive performance—ideal for high-throughput scenarios where GC pressure matters.
+> **Key Takeaway:** The `SplitAsSegmentsNoAlloc` methods achieve **zero heap allocations** when iterating `StringSegment` values—ideal for high-throughput scenarios where GC pressure matters.
+>
+> **Note:** Regex-based split methods have unavoidable `Match` object allocations. Methods returning `string` (like `SplitToEnumerableNoAlloc`) allocate per segment.
 
 ---
 

Source/Extensions.Split.NoAlloc.cs

@@ -7,10 +7,14 @@ public static partial class TextExtensions
 	/// <summary>
 	/// Enumerates a string by segments that are separated by the split character.
 	/// </summary>
+	/// <remarks>
+	/// Note: Each segment allocates a new string via ToString(). For true zero-allocation,
+	/// use <see cref="SplitAsSegmentsNoAlloc(string, char, StringSplitOptions)"/> which returns StringSegments.
+	/// </remarks>
 	/// <param name="source">The source characters to look through.</param>
 	/// <param name="splitCharacter">The character to find.</param>
 	/// <param name="options">Can specify to omit empty entries.</param>
-	/// <returns>A zero-allocation enumerable of the string segments.</returns>
+	/// <returns>A ValueEnumerable of string segments (allocates per segment).</returns>
 	[CLSCompliant(false)]
 	public static ValueEnumerable<ZLinq.Linq.Select<StringSegmentSplitEnumerator, StringSegment, string>, string> SplitToEnumerableNoAlloc(
 		this string source,

Source/Extensions.StringSegment.NoAlloc.cs

@@ -30,12 +30,16 @@ public static ValueEnumerable<StringSegmentSplitEnumerator, StringSegment> Split
 			: throw new ArgumentNullException(nameof(source), "Must be a StringSegment that has a value (is not null).");
 
 	/// <summary>
-	/// Enumerates a string by segments that are separated by the regular expression matches (zero-allocation).
+	/// Enumerates a string by segments that are separated by the regular expression matches.
 	/// </summary>
+	/// <remarks>
+	/// Note: Regex matching internally allocates Match objects per match. The enumerator itself
+	/// is stack-allocated, but regex operations have unavoidable allocations.
+	/// </remarks>
 	/// <param name="source">The source characters to look through.</param>
 	/// <param name="pattern">The pattern to split by.</param>
 	/// <param name="options">Can specify to omit empty entries.</param>
-	/// <returns>A ValueEnumerable of the segments (zero-allocation when used with foreach or ZLinq).</returns>
+	/// <returns>A ValueEnumerable of the segments.</returns>
 	[CLSCompliant(false)]
 	public static ValueEnumerable<RegexSplitSegmentEnumerator, StringSegment> SplitAsSegmentsNoAlloc(
 		this string source,
@@ -81,11 +85,15 @@ public static ValueEnumerable<StringSegmentSequenceSplitEnumerator, StringSegmen
 	}
 
 	/// <summary>
-	/// Joins a sequence of segments with a separator sequence (zero-allocation).
+	/// Joins a sequence of segments with a separator sequence.
 	/// </summary>
+	/// <remarks>
+	/// Note: This overload accepts IEnumerable which may cause boxing if the source is a struct enumerator.
+	/// For true zero-allocation joins, use the ValueEnumerable overloads returned by split operations.
+	/// </remarks>
 	/// <param name="source">The segments to join.</param>
 	/// <param name="between">The segment to place between each segment.</param>
-	/// <returns>A ValueEnumerable of the joined segments (zero-allocation when used with foreach or ZLinq).</returns>
+	/// <returns>A ValueEnumerable of the joined segments.</returns>
 	/// <exception cref="System.ArgumentNullException">The source is null.</exception>
 	[CLSCompliant(false)]
 	public static ValueEnumerable<StringSegmentJoinEnumerator, StringSegment> JoinNoAlloc(

Tests/Open.Text.Tests.csproj

@@ -35,10 +35,7 @@
 	<ItemGroup>
 		<ProjectReference Include="..\Source\Open.Text.csproj" />
 		<!-- Reference the analyzer to suppress false IDE0078 suggestions for StringComparable -->
-		<ProjectReference Include="..\Analyzers\Open.Text.Analyzers.csproj" 
-		                  ReferenceOutputAssembly="false" 
-		                  OutputItemType="Analyzer" 
-		                  PrivateAssets="all" />
+		<ProjectReference Include="..\Analyzers\Open.Text.Analyzers.csproj" ReferenceOutputAssembly="false" OutputItemType="Analyzer" PrivateAssets="all" />
 	</ItemGroup>
 
 </Project>