Use UTF8 string literals when creating Utf8.TryWriteInterpolatedStringHandlers

[Arithmomaniac]

Take the following benchmark code:

byte[] buffer = new byte[1];

[Benchmark]
public void Direct() => Utf8.TryWrite(buffer, $",", out var _);

[Benchmark]
public void Interpolated() => Utf8.TryWrite(buffer, $"{","u8}", out var _);

Surprisingly, the latter behaves better when I run on LinqPad:

Method	Mean	Min	Max	Range	AllocatedBytes
Direct	0.35 ns	0.26 ns	0.54 ns	79%	0
Interpolated	0.08 ns	0.02 ns	0.22 ns	250%	0

Presumably, this is because the former uses "regular" string interpolation, which carries some cost (certainly when doing AOT compilation):

handler.AppendLiteral(",");

Whereas the latter uses a compile-time UTF8 literal directly, without any extra conversion:

handler.AppendFormatted(new ReadOnlySpan<byte>(Unsafe.AsPointer(ref <PrivateImplementationDetails>.D8FA32DD40B181D8250A4ECDE2F2F17BD7BFDF2793278D06EA5AFC647F3D5762), 1));

IMO the compiler should be smart enough to render the latter instead of the former when building Utf8.TryWriteInterpolatedStringHandlers.

[huoyaoyuan]

The compiler assumes that AppendLiteral is more optimal than AppendFormatted. This is a reasonable assumption. The real thing lacking would be AppendLiteral(ROS<byte>), and the ability to use ","u8 literal or a UTF-8 interpolated string $"{..}"u8.

[Arithmomaniac]

The ability to use ","u8 instead would also be a great option.

Re a dedicated (ReadOnlySpan<byte>) method, it already effectively exists. It's just named AppendFormatted(ReadOnlySpan<byte>) instead.

[huoyaoyuan]

Yeah, but the compiler infers their priority based on the names. I'm not sure whether it's written in the language spec.

[333fred]

https://github.com/dotnet/csharplang/blob/main/proposals/csharp-10.0/improved-interpolated-strings.md#append-method-overload-resolution

It is specified, and it is required to be string as currently specified. I wouldn't be opposed to considering a language change to allow this to be optimized, but it needs to be a language change, not a compiler optimization.

[333fred]

And we'd also have to figure out what the change would actually be. To the compiler, this is just a regular interpolation. There's no knowledge that using a utf-8 literal would be helpful.

[Arithmomaniac]

If InterpolatedStringHandlerAttribute could take a type T like char or byte, maybe that would be enough to allow adding/using any ReadOnlySpan<T> using +? e.g.

Utf8.TryWrite(buffer, $"{a}" + ","u8 + $"{b}", out var _);

[Arithmomaniac]

It just occurred to me that this also possibly be "patched in" with a C# interceptor source generator that looks for calls to Utf8.TryWrite, instead of changing the language or compiler.