fix: suppress S6640 for intentional unsafe pointer overloads

samtrion · samtrion · commit c7517d192d25 · 2026-07-28T00:06:24.000+02:00
SonarAnalyzer.CSharp 10.28+ reports the unsafe blocks in the char*
Append/AppendIf/AppendLine/AppendLineIf overloads (and their tests)
as build errors. These pointer overloads are an intentional
high-performance API surface, so suppress S6640 locally instead of
removing them.
diff --git a/src/NetEvolve.CodeBuilder/CSharpCodeBuilder.Append.cs b/src/NetEvolve.CodeBuilder/CSharpCodeBuilder.Append.cs
@@ -124,6 +124,7 @@ public CSharpCodeBuilder Append(char[]? value)
     /// <param name="length">The number of characters to append.</param>
     /// <returns>The current <see cref="CSharpCodeBuilder"/> instance to allow for method chaining.</returns>
     /// <remarks>If the pointer is null or length is negative, the method returns without appending anything.</remarks>
+#pragma warning disable S6640 // Unsafe code is intentional to support pointer-based, high-performance overloads
     public unsafe CSharpCodeBuilder Append(char* value, int length)
     {
         if (value == null || length < 0)
@@ -135,6 +136,7 @@ public unsafe CSharpCodeBuilder Append(char* value, int length)
         _ = _builder.Append(value, length);
         return this;
     }
+#pragma warning restore S6640 // Unsafe code is intentional to support pointer-based, high-performance overloads
 
     /// <summary>
     /// Appends a read-only memory of characters to the current builder.
diff --git a/src/NetEvolve.CodeBuilder/CSharpCodeBuilder.AppendIf.cs b/src/NetEvolve.CodeBuilder/CSharpCodeBuilder.AppendIf.cs
@@ -68,8 +68,10 @@ public CSharpCodeBuilder AppendIf(bool condition, char[]? value, int startIndex,
     /// <returns>The current <see cref="CSharpCodeBuilder"/> instance to allow for method chaining.</returns>
     /// <remarks>If the pointer is null or length is negative, the method returns without appending anything.</remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#pragma warning disable S6640 // Unsafe code is intentional to support pointer-based, high-performance overloads
     public unsafe CSharpCodeBuilder AppendIf(bool condition, char* value, int length) =>
         condition ? Append(value, length) : this;
+#pragma warning restore S6640 // Unsafe code is intentional to support pointer-based, high-performance overloads
 
     /// <summary>
     /// Appends a read-only memory of characters to the current builder if the specified condition is true.
diff --git a/src/NetEvolve.CodeBuilder/CSharpCodeBuilder.AppendLine.cs b/src/NetEvolve.CodeBuilder/CSharpCodeBuilder.AppendLine.cs
@@ -101,7 +101,9 @@ public CSharpCodeBuilder AppendLine(char[]? value, int startIndex, int charCount
     /// <returns>The current <see cref="CSharpCodeBuilder"/> instance to allow for method chaining.</returns>
     /// <remarks>If the pointer is null or length is negative, only the line terminator is appended.</remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#pragma warning disable S6640 // Unsafe code is intentional to support pointer-based, high-performance overloads
     public unsafe CSharpCodeBuilder AppendLine(char* value, int length) => Append(value, length).AppendLine();
+#pragma warning restore S6640 // Unsafe code is intentional to support pointer-based, high-performance overloads
 
     /// <summary>
     /// Appends a character followed by a line terminator to the current builder.
diff --git a/src/NetEvolve.CodeBuilder/CSharpCodeBuilder.AppendLineIf.cs b/src/NetEvolve.CodeBuilder/CSharpCodeBuilder.AppendLineIf.cs
@@ -103,8 +103,10 @@ public CSharpCodeBuilder AppendLineIf(bool condition, char[]? value, int startIn
     /// <returns>The current <see cref="CSharpCodeBuilder"/> instance to allow for method chaining.</returns>
     /// <remarks>If the pointer is null or length is negative, the method returns without appending anything.</remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#pragma warning disable S6640 // Unsafe code is intentional to support pointer-based, high-performance overloads
     public unsafe CSharpCodeBuilder AppendLineIf(bool condition, char* value, int length) =>
         condition ? AppendLine(value, length) : this;
+#pragma warning restore S6640 // Unsafe code is intentional to support pointer-based, high-performance overloads
 
     /// <summary>
     /// Appends a character followed by a line terminator to the current builder if the specified condition is true.
diff --git a/tests/NetEvolve.CodeBuilder.Tests.Unit/CSharpCodeBuilderTests.AppendIf.cs b/tests/NetEvolve.CodeBuilder.Tests.Unit/CSharpCodeBuilderTests.AppendIf.cs
@@ -206,13 +206,15 @@ public async Task AppendIf_CharPointer_Condition_True_Should_Append_Characters()
         var builder = new CSharpCodeBuilder(10);
         var chars = "abc".ToCharArray();
 
+#pragma warning disable S6640 // Unsafe code is intentional for pointer-based test scenarios
         unsafe
         {
             fixed (char* ptr = chars)
             {
                 _ = builder.AppendIf(true, ptr, chars.Length);
             }
         }
+#pragma warning restore S6640 // Unsafe code is intentional for pointer-based test scenarios
 
         _ = await Assert.That(builder.ToString()).IsEqualTo("abc");
     }
@@ -223,13 +225,15 @@ public async Task AppendIf_CharPointer_Condition_False_Should_Not_Append()
         var builder = new CSharpCodeBuilder(10);
         var chars = "abc".ToCharArray();
 
+#pragma warning disable S6640 // Unsafe code is intentional for pointer-based test scenarios
         unsafe
         {
             fixed (char* ptr = chars)
             {
                 _ = builder.AppendIf(false, ptr, chars.Length);
             }
         }
+#pragma warning restore S6640 // Unsafe code is intentional for pointer-based test scenarios
 
         _ = await Assert.That(builder.ToString()).IsEqualTo("");
     }
@@ -241,13 +245,15 @@ public async Task AppendIf_CharPointer_Should_Return_Same_Instance()
         var chars = "abc".ToCharArray();
         CSharpCodeBuilder result;
 
+#pragma warning disable S6640 // Unsafe code is intentional for pointer-based test scenarios
         unsafe
         {
             fixed (char* ptr = chars)
             {
                 result = builder.AppendIf(true, ptr, chars.Length);
             }
         }
+#pragma warning restore S6640 // Unsafe code is intentional for pointer-based test scenarios
 
         _ = await Assert.That(result).IsEqualTo(builder);
     }
diff --git a/tests/NetEvolve.CodeBuilder.Tests.Unit/CSharpCodeBuilderTests.AppendLine.cs b/tests/NetEvolve.CodeBuilder.Tests.Unit/CSharpCodeBuilderTests.AppendLine.cs
@@ -206,13 +206,15 @@ public async Task AppendLine_Unsafe_CharPointer_Should_Append_Characters_With_Ne
         CSharpCodeBuilder result;
         string builderResult;
 
+#pragma warning disable S6640 // Unsafe code is intentional for pointer-based test scenarios
         unsafe
         {
             fixed (char* ptr = text)
             {
                 result = builder.AppendLine(ptr, text.Length);
             }
         }
+#pragma warning restore S6640 // Unsafe code is intentional for pointer-based test scenarios
 
         builderResult = builder.ToString();
         _ = await Assert.That(result).IsEqualTo(builder);
@@ -226,10 +228,12 @@ public async Task AppendLine_Unsafe_CharPointer_Null_Should_Append_Only_Newline(
         CSharpCodeBuilder result;
         string builderResult;
 
+#pragma warning disable S6640 // Unsafe code is intentional for pointer-based test scenarios
         unsafe
         {
             result = builder.AppendLine(null, 0);
         }
+#pragma warning restore S6640 // Unsafe code is intentional for pointer-based test scenarios
 
         builderResult = builder.ToString();
         _ = await Assert.That(result).IsEqualTo(builder);
@@ -244,13 +248,15 @@ public async Task AppendLine_Unsafe_CharPointer_Negative_Length_Should_Append_On
         CSharpCodeBuilder result;
         string builderResult;
 
+#pragma warning disable S6640 // Unsafe code is intentional for pointer-based test scenarios
         unsafe
         {
             fixed (char* ptr = text)
             {
                 result = builder.AppendLine(ptr, -1);
             }
         }
+#pragma warning restore S6640 // Unsafe code is intentional for pointer-based test scenarios
 
         builderResult = builder.ToString();
         _ = await Assert.That(result).IsEqualTo(builder);
diff --git a/tests/NetEvolve.CodeBuilder.Tests.Unit/CSharpCodeBuilderTests.AppendLineIf.cs b/tests/NetEvolve.CodeBuilder.Tests.Unit/CSharpCodeBuilderTests.AppendLineIf.cs
@@ -254,13 +254,15 @@ public async Task AppendLineIf_CharPointer_Condition_True_Should_Append_Characte
         var builder = new CSharpCodeBuilder(10);
         var chars = "abc".ToCharArray();
 
+#pragma warning disable S6640 // Unsafe code is intentional for pointer-based test scenarios
         unsafe
         {
             fixed (char* ptr = chars)
             {
                 _ = builder.AppendLineIf(true, ptr, chars.Length);
             }
         }
+#pragma warning restore S6640 // Unsafe code is intentional for pointer-based test scenarios
 
         _ = await Assert.That(builder.ToString()).IsEqualTo("abc" + Environment.NewLine);
     }
@@ -271,13 +273,15 @@ public async Task AppendLineIf_CharPointer_Condition_False_Should_Not_Append()
         var builder = new CSharpCodeBuilder(10);
         var chars = "abc".ToCharArray();
 
+#pragma warning disable S6640 // Unsafe code is intentional for pointer-based test scenarios
         unsafe
         {
             fixed (char* ptr = chars)
             {
                 _ = builder.AppendLineIf(false, ptr, chars.Length);
             }
         }
+#pragma warning restore S6640 // Unsafe code is intentional for pointer-based test scenarios
 
         _ = await Assert.That(builder.ToString()).IsEqualTo("");
     }
@@ -289,13 +293,15 @@ public async Task AppendLineIf_CharPointer_Should_Return_Same_Instance()
         var chars = "abc".ToCharArray();
         CSharpCodeBuilder result;
 
+#pragma warning disable S6640 // Unsafe code is intentional for pointer-based test scenarios
         unsafe
         {
             fixed (char* ptr = chars)
             {
                 result = builder.AppendLineIf(true, ptr, chars.Length);
             }
         }
+#pragma warning restore S6640 // Unsafe code is intentional for pointer-based test scenarios
 
         _ = await Assert.That(result).IsEqualTo(builder);
     }

Original file line number	Diff line number	Diff line change
`@@ -124,6 +124,7 @@ public CSharpCodeBuilder Append(char[]? value)`
`124`	`124`	`/// <param name="length">The number of characters to append.</param>`
`125`	`125`	`/// <returns>The current <see cref="CSharpCodeBuilder"/> instance to allow for method chaining.</returns>`
`126`	`126`	`/// <remarks>If the pointer is null or length is negative, the method returns without appending anything.</remarks>`
	`127`	`+#pragma warning disable S6640 // Unsafe code is intentional to support pointer-based, high-performance overloads`
`127`	`128`	`public unsafe CSharpCodeBuilder Append(char* value, int length)`
`128`	`129`	`{`
`129`	`130`	`if (value == null \|\| length < 0)`
`@@ -135,6 +136,7 @@ public unsafe CSharpCodeBuilder Append(char* value, int length)`
`135`	`136`	`_ = _builder.Append(value, length);`
`136`	`137`	`return this;`
`137`	`138`	`}`
	`139`	`+#pragma warning restore S6640 // Unsafe code is intentional to support pointer-based, high-performance overloads`
`138`	`140`
`139`	`141`	`/// <summary>`
`140`	`142`	`/// Appends a read-only memory of characters to the current builder.`
Original file line number	Diff line number	Diff line change
`@@ -206,13 +206,15 @@ public async Task AppendIf_CharPointer_Condition_True_Should_Append_Characters()`
`206`	`206`	`var builder = new CSharpCodeBuilder(10);`
`207`	`207`	`var chars = "abc".ToCharArray();`
`208`	`208`
	`209`	`+#pragma warning disable S6640 // Unsafe code is intentional for pointer-based test scenarios`
`209`	`210`	`unsafe`
`210`	`211`	`{`
`211`	`212`	`fixed (char* ptr = chars)`
`212`	`213`	`{`
`213`	`214`	`_ = builder.AppendIf(true, ptr, chars.Length);`
`214`	`215`	`}`
`215`	`216`	`}`
	`217`	`+#pragma warning restore S6640 // Unsafe code is intentional for pointer-based test scenarios`
`216`	`218`
`217`	`219`	`_ = await Assert.That(builder.ToString()).IsEqualTo("abc");`
`218`	`220`	`}`
`@@ -223,13 +225,15 @@ public async Task AppendIf_CharPointer_Condition_False_Should_Not_Append()`
`223`	`225`	`var builder = new CSharpCodeBuilder(10);`
`224`	`226`	`var chars = "abc".ToCharArray();`
`225`	`227`
	`228`	`+#pragma warning disable S6640 // Unsafe code is intentional for pointer-based test scenarios`
`226`	`229`	`unsafe`
`227`	`230`	`{`
`228`	`231`	`fixed (char* ptr = chars)`
`229`	`232`	`{`
`230`	`233`	`_ = builder.AppendIf(false, ptr, chars.Length);`
`231`	`234`	`}`
`232`	`235`	`}`
	`236`	`+#pragma warning restore S6640 // Unsafe code is intentional for pointer-based test scenarios`
`233`	`237`
`234`	`238`	`_ = await Assert.That(builder.ToString()).IsEqualTo("");`
`235`	`239`	`}`
`@@ -241,13 +245,15 @@ public async Task AppendIf_CharPointer_Should_Return_Same_Instance()`
`241`	`245`	`var chars = "abc".ToCharArray();`
`242`	`246`	`CSharpCodeBuilder result;`
`243`	`247`
	`248`	`+#pragma warning disable S6640 // Unsafe code is intentional for pointer-based test scenarios`
`244`	`249`	`unsafe`
`245`	`250`	`{`
`246`	`251`	`fixed (char* ptr = chars)`
`247`	`252`	`{`
`248`	`253`	`result = builder.AppendIf(true, ptr, chars.Length);`
`249`	`254`	`}`
`250`	`255`	`}`
	`256`	`+#pragma warning restore S6640 // Unsafe code is intentional for pointer-based test scenarios`
`251`	`257`
`252`	`258`	`_ = await Assert.That(result).IsEqualTo(builder);`
`253`	`259`	`}`
Original file line number	Diff line number	Diff line change
`@@ -254,13 +254,15 @@ public async Task AppendLineIf_CharPointer_Condition_True_Should_Append_Characte`
`254`	`254`	`var builder = new CSharpCodeBuilder(10);`
`255`	`255`	`var chars = "abc".ToCharArray();`
`256`	`256`
	`257`	`+#pragma warning disable S6640 // Unsafe code is intentional for pointer-based test scenarios`
`257`	`258`	`unsafe`
`258`	`259`	`{`
`259`	`260`	`fixed (char* ptr = chars)`
`260`	`261`	`{`
`261`	`262`	`_ = builder.AppendLineIf(true, ptr, chars.Length);`
`262`	`263`	`}`
`263`	`264`	`}`
	`265`	`+#pragma warning restore S6640 // Unsafe code is intentional for pointer-based test scenarios`
`264`	`266`
`265`	`267`	`_ = await Assert.That(builder.ToString()).IsEqualTo("abc" + Environment.NewLine);`
`266`	`268`	`}`
`@@ -271,13 +273,15 @@ public async Task AppendLineIf_CharPointer_Condition_False_Should_Not_Append()`
`271`	`273`	`var builder = new CSharpCodeBuilder(10);`
`272`	`274`	`var chars = "abc".ToCharArray();`
`273`	`275`
	`276`	`+#pragma warning disable S6640 // Unsafe code is intentional for pointer-based test scenarios`
`274`	`277`	`unsafe`
`275`	`278`	`{`
`276`	`279`	`fixed (char* ptr = chars)`
`277`	`280`	`{`
`278`	`281`	`_ = builder.AppendLineIf(false, ptr, chars.Length);`
`279`	`282`	`}`
`280`	`283`	`}`
	`284`	`+#pragma warning restore S6640 // Unsafe code is intentional for pointer-based test scenarios`
`281`	`285`
`282`	`286`	`_ = await Assert.That(builder.ToString()).IsEqualTo("");`
`283`	`287`	`}`
`@@ -289,13 +293,15 @@ public async Task AppendLineIf_CharPointer_Should_Return_Same_Instance()`
`289`	`293`	`var chars = "abc".ToCharArray();`
`290`	`294`	`CSharpCodeBuilder result;`
`291`	`295`
	`296`	`+#pragma warning disable S6640 // Unsafe code is intentional for pointer-based test scenarios`
`292`	`297`	`unsafe`
`293`	`298`	`{`
`294`	`299`	`fixed (char* ptr = chars)`
`295`	`300`	`{`
`296`	`301`	`result = builder.AppendLineIf(true, ptr, chars.Length);`
`297`	`302`	`}`
`298`	`303`	`}`
	`304`	`+#pragma warning restore S6640 // Unsafe code is intentional for pointer-based test scenarios`
`299`	`305`
`300`	`306`	`_ = await Assert.That(result).IsEqualTo(builder);`
`301`	`307`	`}`