whitemagic/WhiteMagic/MarshalCache.cs

using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

namespace WhiteMagic;

/// <summary>
/// Caches the widths marshalling decisions for type <typeparamref name="T"/>
/// once, at static-constructor time. <see cref="MemoryBase.Read{T}(nint, bool)"/> and
/// <see cref="MemoryBase.Write{T}(nint, T, bool)"/> branch on <see cref="TypeRequiresMarshal"/>
/// and pick the appropriate width from this cache.
/// </summary>
/// <typeparam name="T">The type to cache metadata for.</typeparam>
public static class MarshalCache<T>
{
    /// <summary>
    /// The blittable (managed layout) width of <typeparamref name="T"/>. This is
    /// what <see cref="MemoryMarshal.Read{T}"/> / <see cref="MemoryMarshal.Write{T}"/>
    /// actually consume. Equals <see cref="Unsafe.SizeOf{T}"/> in the general case,
    /// with fixed-width overrides for <see cref="bool"/>, <see cref="char"/>, and
    /// enums so the cache value matches the primitive layout width used by those
    /// paths.
    /// </summary>
    public static readonly int Size;

    /// <summary>
    /// The unmanaged (interop) width via <see cref="Marshal.SizeOf(System.Type)"/>. The marshal
    /// path (<see cref="Marshal.PtrToStructure(nint, System.Type)"/>/<see cref="Marshal.StructureToPtr"/>)
    /// reads/writes this many bytes. Exceeds <see cref="Size"/> whenever a struct
    /// carries inline unmanaged data that the marshaler expands — inline
    /// <c>ByValTStr</c>/<c>ByValArray</c> buffers, <c>bool</c> fields (4 bytes per
    /// default Win32 BOOL marshaling vs 1 byte managed), etc. For types that do
    /// not go through the marshal path, this field is still populated but unused
    /// by MemoryBase.
    /// </summary>
    /// <remarks>
    /// <c>Marshal.SizeOf</c> throws for some reference-containing shapes (e.g. a
    /// bare <see cref="string"/>). When that happens, we fall back to
    /// <see cref="Size"/> — the fallback path is unreachable from production code
    /// because types with a reference field always have
    /// <see cref="TypeRequiresMarshal"/> true, so MemoryBase reads this field only
    /// when it is known to be populated.
    /// </remarks>
    public static readonly int MarshalSize;

    /// <summary>
    /// <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(nint, System.Type)"/> /
    /// <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.
    /// </remarks>
    public static readonly bool TypeRequiresMarshal;

    static MarshalCache()
    {
        if (typeof(T) == typeof(bool))
        {
            Size = 1;
        }
        else if (typeof(T) == typeof(char))
        {
            // Marshal.SizeOf<char> reports 1 (ANSI char), but the blittable
            // MemoryMarshal path reads/writes a char as a 2-byte UTF-16 code unit.
            Size = 2;
        }
        else if (typeof(T).IsEnum)
        {
            Size = Marshal.SizeOf(typeof(T).GetEnumUnderlyingType());
        }
        else
        {
            // 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> disagrees when a struct contains a
            // `bool` field (unmanaged 4 vs managed 1).
            Size = Unsafe.SizeOf<T>();
        }

        bool hasMarshalAsField =
            typeof(T).GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
                .Any(f => f.GetCustomAttributes(typeof(MarshalAsAttribute), true).Length != 0);

        TypeRequiresMarshal =
            hasMarshalAsField || RuntimeHelpers.IsReferenceOrContainsReferences<T>();

        // MarshalSize is only consulted when TypeRequiresMarshal is true; for the
        // rare case where Marshal.SizeOf refuses a shape (ref-containing structs),
        // fall back to the managed size so the field stays populated.
        try
        {
            MarshalSize = Marshal.SizeOf<T>();
        }
        catch (ArgumentException)
        {
            MarshalSize = Size;
        }
    }
}