Non-boxing union access pattern does not work with `IUnionMembers`

[BarionLP]

I tried combining the non boxing access pattern for unions with the union member providers interface documented here:
when looking at the generated code in .NET Lab it uses the Value property instead of the TryGetValue methods

Version Used:
5.10.0-1.26367.9 via https://lab.razor.fyi/#csharp

Steps to Reproduce:
look at the lowered code for this:

IntOrBool foo = 1;

int bar = foo switch
{
    int i => i,
    bool => -1,
};

Console.WriteLine(bar);


[System.Runtime.CompilerServices.Union]
public struct IntOrBool : IntOrBool.IUnionMembers
{
    private readonly int _intValue;
    private readonly bool _boolValue;
    private readonly byte _tag; // 0 = none, 1 = int, 2 = bool

    public IntOrBool(int? value)
    {
        if (value.HasValue)
        {
            _intValue = value.Value;
            _tag = 1;
        }
    }

    public IntOrBool(bool? value)
    {
        if (value.HasValue)
        {
            _boolValue = value.Value;
            _tag = 2;
        }
    }

    public object? Value => _tag switch
    {
        1 => _intValue,
        2 => _boolValue,
        _ => null
    };

    public bool HasValue => _tag != 0;

    public bool TryGetValue(out int value)
    {
        value = _intValue;
        return _tag == 1;
    }

    public bool TryGetValue(out bool value)
    {
        value = _boolValue;
        return _tag == 2;
    }

    public interface IUnionMembers
    {
        static IntOrBool Create(int? value) => new(value);
        static IntOrBool Create(bool? value) => new(value);
        object? Value { get; }
    }
}

Expected Behavior:

IntOrBool intOrBool = IntOrBool.IUnionMembers.Create(1);
int value;
int num2 = default(int);
bool value2;
if (intOrBool.TryGetValue(out value))
{
    int num = value;
    num2 = num;
}
else if (intOrBool.TryGetValue(out value2))
{
    num2 = -1;
}
else
{
    <PrivateImplementationDetails>.ThrowSwitchExpressionException(intOrBool);
}
int value3 = num2;
Console.WriteLine(value3);

Actual Behavior:

IntOrBool intOrBool = IntOrBool.IUnionMembers.Create(1);
object value = ((IntOrBool.IUnionMembers)intOrBool).Value;
int num2 = default(int);
if (value is int)
{
	int num = (int)value;
	num2 = num;
}
else if (value is bool)
{
	num2 = -1;
}
else
{
	<PrivateImplementationDetails>.ThrowSwitchExpressionException(intOrBool);
}
int value2 = num2;
Console.WriteLine(value2);

[AlekseyTs]

The behavior looks expected to me. Per https://github.com/dotnet/csharplang/blob/main/proposals/unions.md#union-member-providers:

However, if the union type directly contains a declaration of an interface called IUnionMembers then the interface acts as a union member provider. In that case, union members are only found on the union member provider, not on the union type itself.

In the repro scenario above, IUnionMembers doesn't declare any TruGetValue methods. The code can be "fixed" by adding the following declarations to the interface:

        public bool TryGetValue(out int value);
        public bool TryGetValue(out bool value);

[BarionLP]

The code can be "fixed" by adding the following declarations to the interface:

yes, that does work, sorry for bothering.

Maybe this should be documented more clearly?
from the docs

A union type can delegate its union members to a nested IUnionMembers interface.

is quite clear given just this sentence but in the following lines it only talks about factory methods so I just assumed this was only for that case
Edit: maybe add something like "If a IUnionMembers interface is used all members must be defined on the interface" in a note block

[AlekseyTs]

Maybe this should be documented more clearly?

@BillWagner

[BarionLP]

opened a pr for this dotnet/docs#55183