Return s_defaultResultTask from Task.FromResult in more cases

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]