fix: CS0121 in earlier C# versions for Append with string-like types

Author: linkdotnet

CHANGELOG.md

@@ -6,6 +6,10 @@ All notable changes to **ValueStringBuilder** will be documented in this file. T
 
 ## [Unreleased]
 
+### Fixed
+
+- Resolved `CS0121` overload ambiguity when passing a no-hole interpolated string (e.g. `Append($"text")`) to `Append`/`AppendLine` on C# 13 and earlier, by adding `Append(string?)` and `AppendLine(string?)` overloads. Reported by [@SMAH1](https://github.com/SMAH1) in #283
+
 ## [3.4.1] - 2026-02-19
 
 ### Fixed

src/LinkDotNet.StringBuilder/ValueStringBuilder.Append.cs

@@ -86,6 +86,13 @@ ref Unsafe.As<char, byte>(ref strRef),
         bufferPosition += str.Length;
     }
 
+    /// <summary>
+    /// Appends a string.
+    /// </summary>
+    /// <param name="value">The string to be added to this builder.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Append(string? value) => Append(value.AsSpan());
+
     /// <summary>
     /// Appends a character buffer.
     /// </summary>
@@ -158,6 +165,17 @@ public void AppendLine(scoped ReadOnlySpan<char> str)
         Append(Environment.NewLine);
     }
 
+    /// <summary>
+    /// Calls <see cref="Append(string)"/> and appends <see cref="Environment.NewLine"/>.
+    /// </summary>
+    /// <param name="value">The string to be added to this builder.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void AppendLine(string? value)
+    {
+        Append(value.AsSpan());
+        Append(Environment.NewLine);
+    }
+
     /// <summary>
     /// Appends a span of the given length, which can be written to later.
     /// </summary>

tests/LinkDotNet.StringBuilder.UnitTests/ValueStringBuilder.Append.Tests.cs

@@ -253,4 +253,38 @@ public void GivenStringBuilder_WhenAddingIncreasinglyLargerStrings_ThenShouldBeA
 
         builder.ToString().ShouldMatch("[a]{256}[b]{512}[c]{1024}[d]{2048}[e]{4096}[f]{8192}");
     }
+
+    [Fact]
+    public void ShouldAppendVerbatimString()
+    {
+        using var builder = new ValueStringBuilder();
+
+        builder.Append(@"C:\temp");
+
+        builder.ToString().ShouldBe(@"C:\temp");
+    }
+
+    [Fact]
+    public void ShouldAppendRawStringLiteral()
+    {
+        using var builder = new ValueStringBuilder();
+
+        builder.Append("""raw""");
+
+        builder.ToString().ShouldBe("raw");
+    }
+
+    [Theory]
+    [InlineData("\n", "\n")]
+    [InlineData("\r\n", "\r\n")]
+    [InlineData("\t", "\t")]
+    [InlineData("\\", "\\")]
+    public void ShouldAppendEscapeAndLineTerminatorSequences(string value, string expected)
+    {
+        using var builder = new ValueStringBuilder();
+
+        builder.Append(value);
+
+        builder.ToString().ShouldBe(expected);
+    }
 }

tests/LinkDotNet.StringBuilder.UnitTests/ValueStringBuilder.InterpolatedString.Tests.cs

@@ -90,6 +90,49 @@ public void ShouldClearAndThenAppendInterpolatedString()
         builder.ToString().ShouldBe("New 1");
     }
 
+    [Fact]
+    public void ShouldAppendNoHoleInterpolatedString()
+    {
+        using var builder = new ValueStringBuilder();
+
+        // Regression guard: a no-hole interpolated string is a constant that converts to both
+        // ReadOnlySpan<char> and AppendInterpolatedStringHandler. On C# 13 and earlier this was
+        // ambiguous (CS0121) because ValueStringBuilder had no Append(string) overload.
+        builder.Append($"Test1\n");
+
+        builder.ToString().ShouldBe("Test1\n");
+    }
+
+    [Fact]
+    public void ShouldAppendLineNoHoleInterpolatedString()
+    {
+        using var builder = new ValueStringBuilder();
+
+        builder.AppendLine($"NoHole");
+
+        builder.ToString().ShouldBe($"NoHole{Environment.NewLine}");
+    }
+
+    [Fact]
+    public void ShouldAppendNoHoleVerbatimInterpolatedString()
+    {
+        using var builder = new ValueStringBuilder();
+
+        builder.Append($@"C:\temp");
+
+        builder.ToString().ShouldBe(@"C:\temp");
+    }
+
+    [Fact]
+    public void ShouldAppendNoHoleRawInterpolatedString()
+    {
+        using var builder = new ValueStringBuilder();
+
+        builder.Append($"""raw""");
+
+        builder.ToString().ShouldBe("raw");
+    }
+
     private class CustomType
     {
         public string Value { get; set; } = string.Empty;