From afa4b184e83a1049100e7e9ba87d3951d8634017 Mon Sep 17 00:00:00 2001
From: neuecc <ils@neue.cc>
Date: Fri, 24 Nov 2023 02:29:15 +0900
Subject: [PATCH] AppendFormatted<T> JIT

---
 .../Utf8StringInterpolation.csproj            | 12 ++-
 ...cs => Utf8StringWriter.AppendFormatted.cs} | 83 ++++++++++++++++++-
 ...tt => Utf8StringWriter.AppendFormatted.tt} | 27 +++++-
 .../Utf8StringWriter.cs                       |  2 +-
 4 files changed, 116 insertions(+), 8 deletions(-)
 rename src/Utf8StringInterpolation/{Utf8String.AppendFormatted.cs => Utf8StringWriter.AppendFormatted.cs} (94%)
 rename src/Utf8StringInterpolation/{Utf8String.AppendFormatted.tt => Utf8StringWriter.AppendFormatted.tt} (83%)

diff --git a/src/Utf8StringInterpolation/Utf8StringInterpolation.csproj b/src/Utf8StringInterpolation/Utf8StringInterpolation.csproj
index 710765a..00b2afc 100644
--- a/src/Utf8StringInterpolation/Utf8StringInterpolation.csproj
+++ b/src/Utf8StringInterpolation/Utf8StringInterpolation.csproj
@@ -23,20 +23,24 @@
 		<PackageReference Include="System.Memory" Version="4.5.5" />
 	</ItemGroup>
 
+	<ItemGroup Condition="'$(TargetFramework)'=='netstandard2.1'">
+		<PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="6.0.0" />
+	</ItemGroup>
+
 	<ItemGroup>
 		<None Include="../../Icon.png" Pack="true" PackagePath="/" />
 	</ItemGroup>
 
 	<ItemGroup>
 		<Service Include="{508349b6-6b84-4df5-91f0-309beebad82d}" />
-		<None Update="Utf8String.AppendFormatted.tt">
+		<None Update="Utf8StringWriter.AppendFormatted.tt">
 			<Generator>TextTemplatingFileGenerator</Generator>
-			<LastGenOutput>Utf8String.AppendFormatted.cs</LastGenOutput>
+			<LastGenOutput>Utf8StringWriter.AppendFormatted.cs</LastGenOutput>
 		</None>
-		<Compile Update="Utf8String.AppendFormatted.cs">
+		<Compile Update="Utf8StringWriter.AppendFormatted.cs">
 			<DesignTime>True</DesignTime>
 			<AutoGen>True</AutoGen>
-			<DependentUpon>Utf8String.AppendFormatted.tt</DependentUpon>
+			<DependentUpon>Utf8StringWriter.AppendFormatted.tt</DependentUpon>
 		</Compile>
 	</ItemGroup>
 
diff --git a/src/Utf8StringInterpolation/Utf8String.AppendFormatted.cs b/src/Utf8StringInterpolation/Utf8StringWriter.AppendFormatted.cs
similarity index 94%
rename from src/Utf8StringInterpolation/Utf8String.AppendFormatted.cs
rename to src/Utf8StringInterpolation/Utf8StringWriter.AppendFormatted.cs
index 0f10752..8b29034 100644
--- a/src/Utf8StringInterpolation/Utf8String.AppendFormatted.cs
+++ b/src/Utf8StringInterpolation/Utf8StringWriter.AppendFormatted.cs
@@ -6,7 +6,7 @@ namespace Utf8StringInterpolation;
 
 public ref partial struct Utf8StringWriter<TBufferWriter>
 {
-# if true
+#if true
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void AppendFormatted(bool? value, int alignment = 0, string? format = null)
@@ -1398,7 +1398,7 @@ void AppendFormattedAlignment(TimeSpan value, int alignment, string? format)
     }
 #endif
 
-# if true
+#if true
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void AppendFormatted(char? value, int alignment = 0, string? format = null)
@@ -1485,4 +1485,83 @@ void AppendFormattedAlignment(char value, int alignment, string? format)
     }
 #endif
 
+
+    // `if typeof(T) == typeof()` will eliminate in JIT.
+    public void AppendFormatted<T>(T value, int alignment = 0, string? format = null)
+    {
+        if (typeof(T) == typeof(bool))
+        {
+            AppendFormatted(Unsafe.As<T, bool>(ref value), alignment, format);
+        }
+        else if (typeof(T) == typeof(char))
+        {
+            AppendFormatted(Unsafe.As<T, char>(ref value), alignment, format);
+        }
+#if !NET8_0_OR_GREATER
+        else if (typeof(T) == typeof(byte))
+		{
+            AppendFormatted(Unsafe.As<T, byte>(ref value), alignment, format);
+		}
+        else if (typeof(T) == typeof(Decimal))
+		{
+            AppendFormatted(Unsafe.As<T, Decimal>(ref value), alignment, format);
+		}
+        else if (typeof(T) == typeof(Double))
+		{
+            AppendFormatted(Unsafe.As<T, Double>(ref value), alignment, format);
+		}
+        else if (typeof(T) == typeof(Guid))
+		{
+            AppendFormatted(Unsafe.As<T, Guid>(ref value), alignment, format);
+		}
+        else if (typeof(T) == typeof(Int16))
+		{
+            AppendFormatted(Unsafe.As<T, Int16>(ref value), alignment, format);
+		}
+        else if (typeof(T) == typeof(Int32))
+		{
+            AppendFormatted(Unsafe.As<T, Int32>(ref value), alignment, format);
+		}
+        else if (typeof(T) == typeof(Int64))
+		{
+            AppendFormatted(Unsafe.As<T, Int64>(ref value), alignment, format);
+		}
+        else if (typeof(T) == typeof(SByte))
+		{
+            AppendFormatted(Unsafe.As<T, SByte>(ref value), alignment, format);
+		}
+        else if (typeof(T) == typeof(Single))
+		{
+            AppendFormatted(Unsafe.As<T, Single>(ref value), alignment, format);
+		}
+        else if (typeof(T) == typeof(UInt16))
+		{
+            AppendFormatted(Unsafe.As<T, UInt16>(ref value), alignment, format);
+		}
+        else if (typeof(T) == typeof(UInt32))
+		{
+            AppendFormatted(Unsafe.As<T, UInt32>(ref value), alignment, format);
+		}
+        else if (typeof(T) == typeof(UInt64))
+		{
+            AppendFormatted(Unsafe.As<T, UInt64>(ref value), alignment, format);
+		}
+        else if (typeof(T) == typeof(DateTime))
+		{
+            AppendFormatted(Unsafe.As<T, DateTime>(ref value), alignment, format);
+		}
+        else if (typeof(T) == typeof(DateTimeOffset))
+		{
+            AppendFormatted(Unsafe.As<T, DateTimeOffset>(ref value), alignment, format);
+		}
+        else if (typeof(T) == typeof(TimeSpan))
+		{
+            AppendFormatted(Unsafe.As<T, TimeSpan>(ref value), alignment, format);
+		}
+#endif
+        else
+        {
+            AppendFormattedCore<T>(value, alignment, format);
+        }
+    }
 }
\ No newline at end of file
diff --git a/src/Utf8StringInterpolation/Utf8String.AppendFormatted.tt b/src/Utf8StringInterpolation/Utf8StringWriter.AppendFormatted.tt
similarity index 83%
rename from src/Utf8StringInterpolation/Utf8String.AppendFormatted.tt
rename to src/Utf8StringInterpolation/Utf8StringWriter.AppendFormatted.tt
index 1032c3c..4085e11 100644
--- a/src/Utf8StringInterpolation/Utf8String.AppendFormatted.tt
+++ b/src/Utf8StringInterpolation/Utf8StringWriter.AppendFormatted.tt
@@ -29,7 +29,7 @@ namespace Utf8StringInterpolation;
 public ref partial struct Utf8StringWriter<TBufferWriter>
 {
 <# foreach(var x in generateTypes) { #>
-<#= (x.type is not "bool" and not "char") ? "#if !NET8_0_OR_GREATER" : "# if true" #>
+<#= (x.type is not "bool" and not "char") ? "#if !NET8_0_OR_GREATER" : "#if true" #>
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void AppendFormatted(<#= x.type #>? value, int alignment = 0, string? format = null)
@@ -117,4 +117,29 @@ public ref partial struct Utf8StringWriter<TBufferWriter>
 #endif
 
 <# } #>
+
+    // `if typeof(T) == typeof()` will eliminate in JIT.
+    public void AppendFormatted<T>(T value, int alignment = 0, string? format = null)
+    {
+        if (typeof(T) == typeof(bool))
+        {
+            AppendFormatted(Unsafe.As<T, bool>(ref value), alignment, format);
+        }
+        else if (typeof(T) == typeof(char))
+        {
+            AppendFormatted(Unsafe.As<T, char>(ref value), alignment, format);
+        }
+#if !NET8_0_OR_GREATER
+<# foreach(var x in generateTypes.Where(x => x.type is not "bool" and not "char")) { #>
+        else if (typeof(T) == typeof(<#= x.type #>))
+		{
+            AppendFormatted(Unsafe.As<T, <#= x.type #>>(ref value), alignment, format);
+		}
+<# } #>
+#endif
+        else
+        {
+            AppendFormattedCore<T>(value, alignment, format);
+        }
+    }
 }
\ No newline at end of file
diff --git a/src/Utf8StringInterpolation/Utf8StringWriter.cs b/src/Utf8StringInterpolation/Utf8StringWriter.cs
index 04dad48..2d98ef5 100644
--- a/src/Utf8StringInterpolation/Utf8StringWriter.cs
+++ b/src/Utf8StringInterpolation/Utf8StringWriter.cs
@@ -247,7 +247,7 @@ public void AppendFormatted<T>(Nullable<T> value, int alignment = 0, string? for
         AppendFormatted(value.Value, alignment, format);
     }
 
-    public void AppendFormatted<T>(T value, int alignment = 0, string? format = null)
+    void AppendFormattedCore<T>(T value, int alignment = 0, string? format = null)
     {
         // no alignment or add right whitespace
         if (alignment <= 0)