Return s_defaultResultTask from Task.FromResult in more cases (dotnet…

…#76349)

* Return s_defaultResultTask from Task.FromResult in more cases

Today we return a cached task from Task.FromResult when the TResult is a primitive and its value is 0.  But it needn't be constrained to only being a primitive; what matters is that we need to be able to efficiently compare its bit pattern to 0.  And we can do that easily now by using Unsafe.SizeOf to check if the size is the same as a primitive, Unsafe casting to that primitive, and then comparing against 0.

* Update tests

src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/Task.cs

@@ -5249,21 +5249,18 @@ public static Task<TResult> FromResult<TResult>(TResult result)
                         return Unsafe.As<Task<TResult>>(task); // Unsafe.As avoids a type check we know will succeed
                     }
                 }
-                // For other known value types, we only special-case 0 / default(TResult).  We don't include
-                // floating point types as == may return true for different bit representations of the same value.
-                else if (
-                    (typeof(TResult) == typeof(uint) && default == (uint)(object)result!) ||
-                    (typeof(TResult) == typeof(byte) && default(byte) == (byte)(object)result!) ||
-                    (typeof(TResult) == typeof(sbyte) && default(sbyte) == (sbyte)(object)result!) ||
-                    (typeof(TResult) == typeof(char) && default(char) == (char)(object)result!) ||
-                    (typeof(TResult) == typeof(long) && default == (long)(object)result!) ||
-                    (typeof(TResult) == typeof(ulong) && default == (ulong)(object)result!) ||
-                    (typeof(TResult) == typeof(short) && default(short) == (short)(object)result!) ||
-                    (typeof(TResult) == typeof(ushort) && default(ushort) == (ushort)(object)result!) ||
-                    (typeof(TResult) == typeof(IntPtr) && default == (IntPtr)(object)result!) ||
-                    (typeof(TResult) == typeof(UIntPtr) && default == (UIntPtr)(object)result!))
+                // For other value types, we special-case default(TResult) if we can easily compare bit patterns to default/0.
+                else if (!RuntimeHelpers.IsReferenceOrContainsReferences<TResult>())
                 {
-                    return Task<TResult>.s_defaultResultTask;
+                    // We don't need to go through the equality operator of the TResult because we cached a task for default(TResult),
+                    // so we only need to confirm that this TResult has the same bits as default(TResult).
+                    if ((Unsafe.SizeOf<TResult>() == sizeof(byte) && Unsafe.As<TResult, byte>(ref result) == default(byte)) ||
+                        (Unsafe.SizeOf<TResult>() == sizeof(ushort) && Unsafe.As<TResult, ushort>(ref result) == default(ushort)) ||
+                        (Unsafe.SizeOf<TResult>() == sizeof(uint) && Unsafe.As<TResult, uint>(ref result) == default) ||
+                        (Unsafe.SizeOf<TResult>() == sizeof(ulong) && Unsafe.As<TResult, ulong>(ref result) == default))
+                    {
+                        return Task<TResult>.s_defaultResultTask;
+                    }
                 }
             }
 

src/libraries/System.Threading.Tasks/tests/Task/TaskRtTests.cs

@@ -512,6 +512,21 @@ public static void FromResult_KnownResults_Cached()
             Assert.Same(Task.FromResult(UIntPtr.Zero), Task.FromResult(UIntPtr.Zero));
             Assert.Equal(UIntPtr.Zero, Task.FromResult(UIntPtr.Zero).Result);
 
+            Assert.Same(Task.FromResult((Half)default), Task.FromResult((Half)default));
+            Assert.Equal((Half)default, Task.FromResult((Half)default).Result);
+
+            Assert.Same(Task.FromResult((float)default), Task.FromResult((float)default));
+            Assert.Equal((float)default, Task.FromResult((float)default).Result);
+
+            Assert.Same(Task.FromResult((double)default), Task.FromResult((double)default));
+            Assert.Equal((double)default, Task.FromResult((double)default).Result);
+
+            Assert.Same(Task.FromResult((TimeSpan)default), Task.FromResult((TimeSpan)default));
+            Assert.Equal((TimeSpan)default, Task.FromResult((TimeSpan)default).Result);
+
+            Assert.Same(Task.FromResult((DateTime)default), Task.FromResult((DateTime)default));
+            Assert.Equal((DateTime)default, Task.FromResult((DateTime)default).Result);
+
             Assert.Same(Task.FromResult((object)null), Task.FromResult((object)null));
             Assert.Null(Task.FromResult((object)null).Result);
 
@@ -526,10 +541,11 @@ public static void FromResult_KnownResults_Cached()
                 Assert.Equal(i, Task.FromResult(i).Result);
             }
 
-            Assert.NotSame(Task.FromResult((double)0), Task.FromResult((double)0));
-            Assert.NotSame(Task.FromResult((float)0), Task.FromResult((float)0));
-            Assert.NotSame(Task.FromResult((decimal)0), Task.FromResult((decimal)0));
-            Assert.NotSame(Task.FromResult((Half)0), Task.FromResult((Half)0));
+            Assert.NotSame(Task.FromResult((double)(+0.0)), Task.FromResult((double)(-0.0)));
+            Assert.NotSame(Task.FromResult((float)(+0.0)), Task.FromResult((float)(-0.0)));
+            Assert.NotSame(Task.FromResult((Half)(+0.0)), Task.FromResult((Half)(-0.0)));
+
+            Assert.NotSame(Task.FromResult((decimal)default), Task.FromResult((decimal)default));
         }
 
         [Fact]