Add suppressor for pattern matching false positives

- Introduce StringComparablePatternMatchingSuppressor to hide IDE pattern matching suggestions (IDE0078, IDE0083, IDE0260, RCS1246) for StringComparable/SpanComparable types, preventing false positives.
- Add manual verification guide and automated config test for the suppressor.
- Update XML docs for StringComparable/SpanComparable to warn about pattern matching limitations and recommend the analyzer.
- Add PatternMatchingAssumptionTests to document .NET/IDE behavior and limitations.
- Reference analyzer in test project to ensure suppressor is active during tests.
- Clarify OPENTXT002/OPENTXT008 diagnostics and update EXAMPLES.md/README.md to better explain allocation behavior and alternatives for SplitAsSegments and SplitToEnumerable.
- Add full test suites for EnumValueCaseIgnored<T> and StringBuilderHelper.
- Clean up usings, comments, and performance notes; ensure analyzer suppressions are respected in tests.

Author: electricessence

Analyzers.Tests/SmartDetectionTests.cs

@@ -1,9 +1,8 @@
-using System;
 using System.Threading.Tasks;
 using Xunit;
-using VerifySubstring = Open.Text.Analyzers.Tests.CSharpAnalyzerVerifier<Open.Text.Analyzers.SubstringAnalyzer>;
-using VerifySplit = Open.Text.Analyzers.Tests.CSharpAnalyzerVerifier<Open.Text.Analyzers.SplitAnalyzer>;
 using VerifyConcat = Open.Text.Analyzers.Tests.CSharpAnalyzerVerifier<Open.Text.Analyzers.StringConcatenationAnalyzer>;
+using VerifySplit = Open.Text.Analyzers.Tests.CSharpAnalyzerVerifier<Open.Text.Analyzers.SplitAnalyzer>;
+using VerifySubstring = Open.Text.Analyzers.Tests.CSharpAnalyzerVerifier<Open.Text.Analyzers.SubstringAnalyzer>;
 using VerifyTrim = Open.Text.Analyzers.Tests.CSharpAnalyzerVerifier<Open.Text.Analyzers.TrimEqualsAnalyzer>;
 
 namespace Open.Text.Analyzers.Tests;

Analyzers.Tests/SplitAnalyzerTests.cs

@@ -1,9 +1,6 @@
 using System.Threading.Tasks;
 using Xunit;
 using VerifyAnalyzer = Open.Text.Analyzers.Tests.CSharpAnalyzerVerifier<Open.Text.Analyzers.SplitAnalyzer>;
-using VerifyCodeFix = Open.Text.Analyzers.Tests.CSharpCodeFixVerifier<
-	Open.Text.Analyzers.SplitAnalyzer,
-	Open.Text.Analyzers.SplitCodeFixProvider>;
 
 namespace Open.Text.Analyzers.Tests;
 

Analyzers.Tests/StringComparablePatternMatchingSuppressorManualTests.cs

@@ -0,0 +1,85 @@
+using System.Diagnostics.CodeAnalysis;
+using Xunit;
+
+namespace Open.Text.Analyzers.Tests;
+
+/// <summary>
+/// <para>MANUAL VERIFICATION TESTS for StringComparablePatternMatchingSuppressor</para>
+/// <para>To verify the suppressor works:</para>
+/// <para>
+/// 1. Create a new test console app:
+///    dotnet new console -n SuppressorTest
+///    cd SuppressorTest
+/// </para>
+/// <para>
+/// 2. Add Open.Text package:
+///    dotnet add package Open.Text
+/// </para>
+/// <para>3. Add this code to Program.cs:</para>
+/// <para>   using Open.Text;</para>
+/// <para>   string text = "HELLO";</para>
+/// <para>
+///    // TEST 1: Regular string - SHOULD show IDE0078 suggestion
+///    bool test1 = text == "hello" || text == "world";
+///    //           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+///    //           You SHOULD see: "Use pattern matching" suggestion
+/// </para>
+/// <para>
+///    // TEST 2: StringComparable - should NOT show suggestion (initially)
+///    var comparable = text.AsCaseInsensitive();
+///    bool test2 = comparable == "hello" || comparable == "world";
+///    //           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+///    //           You WILL see: "Use pattern matching" suggestion (without analyzer)
+/// </para>
+/// <para>4. Verify the IDE shows suggestion for BOTH (this is the problem!)</para>
+/// <para>
+/// 5. Now install the analyzer:
+///    dotnet add package Open.Text.Analyzers
+/// </para>
+/// <para>
+/// 6. Rebuild and check:
+///    - TEST 1: Still shows suggestion ? (correct)
+///    - TEST 2: NO suggestion anymore ? (suppressed!)
+/// </para>
+/// <para>
+/// 7. Try to apply the suggestion on TEST 2 (it won't compile):
+///    bool test2 = comparable is "hello" or "world";
+///    //           Error CS0029: Cannot implicitly convert type 'string' to 'Open.Text.StringComparable'
+/// </para>
+/// <para>
+/// EXPECTED RESULTS:
+/// - Without analyzer: Both show IDE0078
+/// - With analyzer: Only test1 shows IDE0078, test2 is suppressed
+/// </para>
+/// </summary>
+[ExcludeFromCodeCoverage]
+[SuppressMessage("Usage", "xUnit1004:Test methods should not be skipped")]
+public class StringComparablePatternMatchingSuppressorManualTests
+{
+	[Fact(Skip = "Manual verification required - see class documentation")]
+	public void ManualVerification_Instructions()
+	{
+		// This test is skipped - it documents how to manually verify the suppressor works
+		// Follow the instructions in the class XML documentation above
+	}
+
+	/// <summary>
+	/// Automated test to verify the suppressor is properly configured.
+	/// This doesn't test if it WORKS, but verifies it's set up correctly.
+	/// </summary>
+	[Fact]
+	public void Suppressor_IsProperlyConfigured()
+	{
+		var suppressor = new StringComparablePatternMatchingSuppressor();
+
+		// Verify it has the expected suppressions
+		var suppressions = suppressor.SupportedSuppressions;
+		Assert.Equal(4, suppressions.Length);
+
+		// Verify it suppresses IDE0078
+		Assert.Contains(suppressions, s => s.SuppressedDiagnosticId == "IDE0078");
+		Assert.Contains(suppressions, s => s.SuppressedDiagnosticId == "IDE0083");
+		Assert.Contains(suppressions, s => s.SuppressedDiagnosticId == "IDE0260");
+		Assert.Contains(suppressions, s => s.SuppressedDiagnosticId == "RCS1246");
+	}
+}

Analyzers/DiagnosticDescriptors.cs

@@ -22,12 +22,12 @@ internal static class DiagnosticDescriptors
 
 	public static readonly DiagnosticDescriptor UseSplitAsSegments = new(
 		id: "OPENTXT002",
-		title: "Use SplitAsSegments for zero-allocation splitting",
-		messageFormat: "Consider using '.SplitAsSegments({0})' instead of '.Split({0})' to avoid allocating an array and individual strings",
+		title: "Use SplitAsSegments to reduce string allocations",
+		messageFormat: "Consider using '.SplitAsSegments({0})' instead of '.Split({0})' to avoid allocating an array and individual strings. Use '.SplitToEnumerable({0})' if you still need strings with lazy evaluation.",
 		category: Category,
 		defaultSeverity: DiagnosticSeverity.Info,
 		isEnabledByDefault: true,
-		description: "SplitAsSegments returns IEnumerable<StringSegment> which avoids allocating strings until ToString() is called.",
+		description: "SplitAsSegments returns IEnumerable<StringSegment> which defers string allocation until ToString() is called. SplitToEnumerable provides lazy string allocation with IEnumerable<string>.",
 		helpLinkUri: HelpLinkUriBase + "OPENTXT002.md");
 
 	public static readonly DiagnosticDescriptor UseSpanForIndexOfSubstring = new(
@@ -82,11 +82,11 @@ internal static class DiagnosticDescriptors
 
 	public static readonly DiagnosticDescriptor UseSplitToEnumerable = new(
 		id: "OPENTXT008",
-		title: "Use SplitToEnumerable for deferred execution",
-		messageFormat: "Consider using '.SplitToEnumerable({0})' instead of '.Split({0})' when iterating results for lazy evaluation",
+		title: "Use SplitToEnumerable for lazy string evaluation",
+		messageFormat: "Consider using '.SplitToEnumerable({0})' instead of '.Split({0})' when iterating results to avoid allocating the full array upfront. For even less allocation, use '.SplitAsSegments({0})' which returns StringSegments.",
 		category: Category,
 		defaultSeverity: DiagnosticSeverity.Info,
 		isEnabledByDefault: true,
-		description: "SplitToEnumerable provides lazy evaluation and avoids allocating the full array upfront.",
+		description: "SplitToEnumerable returns IEnumerable<string> with lazy evaluation, avoiding the upfront allocation of the full string array. Strings are still created on demand during iteration.",
 		helpLinkUri: HelpLinkUriBase + "OPENTXT008.md");
 }

Analyzers/EXAMPLES.md

@@ -23,7 +23,7 @@ public ReadOnlySpan<char> ExtractDomain(string email)
     int atIndex = email.IndexOf('@');
     if (atIndex == -1) return ReadOnlySpan<char>.Empty;
 
-    // Zero allocation! Returns a span view
+    // No string allocation! Returns a span view
     return email.AsSpan(atIndex + 1);
 }
 
@@ -39,8 +39,8 @@ public string ExtractDomainString(string email)
 ```
 
 **Performance Impact:** 
-- Before: ~100ns, 40 bytes allocated
-- After: ~15ns, 0 bytes allocated (until ToString())
+- Before: ~100ns, 40 bytes allocated per call
+- After: ~15ns, 0 bytes allocated for string (until ToString())
 
 ---
 
@@ -69,7 +69,7 @@ void ProcessColumn(string column)
 ```csharp
 public void ProcessCsvLine(string line)
 {
-    // Zero allocations! Returns IEnumerable<StringSegment>
+    // Avoids array + string allocations! Returns IEnumerable<StringSegment>
     var columns = line.SplitAsSegments(',');
 
     foreach (var column in columns)
@@ -87,7 +87,7 @@ void ProcessColumn(StringSegment column)
 
 **Performance Impact:**
 - Before: ~500ns, 200+ bytes allocated (array + 5 strings)
-- After: ~150ns, 0 bytes allocated (lazy evaluation)
+- After: ~150ns, minimal allocations (enumerator only, no string array)
 
 ---
 

Analyzers/IndexOfSubstringAnalyzer.cs

@@ -76,7 +76,7 @@ assignment.Left is IdentifierNameSyntax identifier &&
 				if (IsIndexOfCall(indexOfCall, context))
 				{
 					var variableName = identifier.Identifier.Text;
-				if (FindSubstringUsage(statements.Skip(i + 1), variableName, out var substringLocation))
+					if (FindSubstringUsage(statements.Skip(i + 1), variableName, out var substringLocation))
 					{
 						var diagnostic = Diagnostic.Create(
 							DiagnosticDescriptors.UseSpanForIndexOfSubstring,