ref struct wrapper struct rules

[hamarb123]

This is a pattern I've written a few times:

struct Wrapper<T> : IInterface
{
    T field;
    // ... implement interface via field
}

void DoSomething<T>(ref T myT)
{
    SomeMethodThatExpectsAnIInterface(ref Unsafe.As<T, Wrapper<T>>(ref myT));
}

Now, ideally I'd be able to mark DoSomething's T as allows ref struct in a lot of cases, but doing that with this pattern would require marking Wrapper<T> as a ref struct, like so:

ref struct Wrapper<T> : IInterface where T : allows ref struct
{
    T field;
    // ... implement interface via field
}

void DoSomething<T>(ref T myT) where T : allows ref struct
{
    SomeMethodThatExpectsAnIInterface(ref Unsafe.As<T, Wrapper<T>>(ref myT));
}

But, ref structs are supposed to be not on the managed heap, which I obviously violate above - my understanding, however, is that the runtime currently only makes assumptions about this when it actually has an interior reference in it - so my question is basically, assuming my understanding is correct to begin with, is that something I can rely on, or not?

An adjacent question, to which I assume the answer is probably no, is whether it's legal to define the following type in IL:

struct Wrapper<T> where T : allows ref struct //only instantiated when T is not a ref struct
{
    T field;
}

If so, then it could be used as an alternative to just having the 1 ref struct wrapper, with the real solution either being the answer to the first question being "yes, it's fine to rely on that" and/or getting generic bridges.

The answer to neither of these questions is clear to me based on the addendum.

/cc @jkotas @tannergooding

[jkotas]

The JIT optimizations are depending more and more on accurate type information and type safety. The unsafe casts that reinterpret data as a different type have potential to confuse JIT optimizations today or in the future. I do not think that this is a reliable pattern.