class UsingTest
{
    struct TypeA : IDisposable
    {
        public void Dispose() { }

        public static implicit operator TypeB(in TypeA a) => new();
    }

    struct TypeB { }

    static void Test()
    {
        using (TypeA a = new())
            Empty(a);
    }

    static void Empty(TypeB b) { }
}

internal class UsingTest
{
    [StructLayout(LayoutKind.Sequential, Size = 1)]
    private struct TypeA : IDisposable
    {
        public void Dispose()
        {
        }

        public static implicit operator TypeB(in TypeA a)
        {
            return default(TypeB);
        }
    }

    [StructLayout(LayoutKind.Sequential, Size = 1)]
    private struct TypeB
    {
    }

    private static void Test()
    {
        TypeA a = default(TypeA);

        try
        {
            Empty(a);
        }
        finally
        {
            ((IDisposable)a/*cast due to .constrained prefix*/).Dispose();
        }
    }

    private static void Empty(TypeB b)
    {
    }
}