ARchive old spec

WhiteMagic/MarshalCache.cs

@@ -1,88 +1,77 @@
 using System.Reflection;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
 namespace WhiteMagic;
 
 /// <summary>
-/// Computes and caches marshal-related metadata for type <typeparamref name="T"/>
-/// exactly once. <see cref="MemoryBase.Read{T}"/> and <see cref="MemoryBase.Write{T}"/>
-/// branch on these cached flags to decide between blittable <c>Span</c>/<c>MemoryMarshal</c>
-/// paths and the fallback marshal path.
+/// Computes and caches the byte size and marshalling decision for type
+/// <typeparamref name="T"/> exactly once. <see cref="MemoryBase.Read{T}"/> and
+/// <see cref="MemoryBase.Write{T}"/> branch on <see cref="TypeRequiresMarshal"/>
+/// to decide between the blittable <c>Span</c> /
+/// <see cref="System.Runtime.InteropServices.MemoryMarshal"/> path and the
+/// <see cref="Marshal.PtrToStructure"/> path.
 /// </summary>
 /// <typeparam name="T">The type to cache metadata for.</typeparam>
 public static class MarshalCache<T>
 {
-    /// <summary>The unmanaged size of <typeparamref name="T"/> in bytes.</summary>
+    /// <summary>
+    /// The byte size of <typeparamref name="T"/>. For the blittable path this is
+    /// the managed layout size <see cref="Unsafe.SizeOf{T}"/> — the width that
+    /// <see cref="MemoryMarshal.Read{T}"/> / <see cref="MemoryMarshal.Write{T}"/>
+    /// actually consume. For primitive-sized types (<see cref="bool"/>, <see cref="char"/>,
+    /// and the underlying of enums) the size matches the CLR primitive width.
+    /// </summary>
     public static readonly int Size;
 
-    /// <summary>The unmanaged size of <typeparamref name="T"/> as an unsigned integer.</summary>
-    public static readonly uint SizeU;
-
     /// <summary>
-    /// <see langword="true"/> when <typeparamref name="T"/> cannot be copied through the
-    /// blittable <see cref="System.Runtime.InteropServices.MemoryMarshal"/> path and must
-    /// use <see cref="Marshal.PtrToStructure"/>/<see cref="Marshal.StructureToPtr"/> instead.
-    /// This is the case when a top-level field carries <see cref="MarshalAsAttribute"/>, or
-    /// when <typeparamref name="T"/> contains a managed reference
-    /// (<see cref="System.Runtime.CompilerServices.RuntimeHelpers.IsReferenceOrContainsReferences{T}"/>).
+    /// <see langword="true"/> when <typeparamref name="T"/> cannot be copied through
+    /// the blittable <see cref="System.Runtime.InteropServices.MemoryMarshal"/> path
+    /// and must fall back to <see cref="Marshal.PtrToStructure"/> /
+    /// <see cref="Marshal.StructureToPtr"/>. This is the case when a top-level field
+    /// carries <see cref="MarshalAsAttribute"/>, or when <typeparamref name="T"/>
+    /// contains a managed reference
+    /// (<see cref="RuntimeHelpers.IsReferenceOrContainsReferences{T}"/>).
     /// </summary>
     /// <remarks>
     /// The <see cref="MarshalAsAttribute"/> check inspects only top-level fields; a
     /// <see cref="MarshalAsAttribute"/> on a field of a nested struct is not detected.
-    /// Reference-containing nested structs are still caught, because the reference check
-    /// propagates through nested value types.
+    /// Reference-containing nested structs are still caught, because the reference
+    /// check propagates through nested value types.
     /// </remarks>
     public static readonly bool TypeRequiresMarshal;
 
-    /// <summary><see langword="true"/> when <typeparamref name="T"/> is <see cref="IntPtr"/>.</summary>
-    public static readonly bool IsIntPtr;
-
-    /// <summary>The underlying type code of <typeparamref name="T"/>.</summary>
-    public static readonly TypeCode TypeCode;
-
-    /// <summary>
-    /// The effective type that the marshaler uses. For an enum this is the underlying
-    /// integer type; for all other types it is <typeparamref name="T"/> itself.
-    /// </summary>
-    public static readonly Type RealType;
-
     static MarshalCache()
     {
-        TypeCode = Type.GetTypeCode(typeof(T));
-
         if (typeof(T) == typeof(bool))
         {
             Size = 1;
-            RealType = typeof(T);
         }
         else if (typeof(T) == typeof(char))
         {
-            // Marshal.SizeOf(char) is 1 (ANSI), but the blittable path reads/writes a
-            // char as a 2-byte UTF-16 code unit. Size must match the blittable width.
+            // Marshal.SizeOf<char> reports 1 (ANSI char), but the blittable
+            // MemoryMarshal path reads/writes a char as a 2-byte UTF-16 code unit.
+            // Use the managed layout width so Size matches what the reader actually uses.
             Size = 2;
-            RealType = typeof(T);
         }
         else if (typeof(T).IsEnum)
         {
-            Type underlying = typeof(T).GetEnumUnderlyingType();
-            Size = Marshal.SizeOf(underlying);
-            RealType = underlying;
-            TypeCode = Type.GetTypeCode(underlying);
+            Size = Marshal.SizeOf(typeof(T).GetEnumUnderlyingType());
         }
         else
         {
-            Size = Marshal.SizeOf(typeof(T));
-            RealType = typeof(T);
+            // The blittable path goes through MemoryMarshal, which uses the CLR managed
+            // layout. Use Unsafe.SizeOf<T> so Size agrees with that layout —
+            // Marshal.SizeOf<T> can disagree when a struct contains a `bool` field
+            // (unmanaged width 4 vs managed width 1).
+            Size = Unsafe.SizeOf<T>();
         }
 
-        SizeU = (uint)Size;
-        IsIntPtr = RealType == typeof(IntPtr);
-
         bool hasMarshalAsField =
-            RealType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
+            typeof(T).GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
                 .Any(f => f.GetCustomAttributes(typeof(MarshalAsAttribute), true).Length != 0);
 
         TypeRequiresMarshal =
-            hasMarshalAsField || System.Runtime.CompilerServices.RuntimeHelpers.IsReferenceOrContainsReferences<T>();
+            hasMarshalAsField || RuntimeHelpers.IsReferenceOrContainsReferences<T>();
     }
 }