Allow type check and cast (operators is & as) on generic arguments with allows ref struct

[kemocca]

Summary

This proposal suggests removing restrictions for operators is and as on generic arguments with allows ref struct anti-constraint. This changes should allows to escape constraints, applied by modifiers scoped and allows ref struct, in methods and types with generic arguments, and do, for example, async processing arguments if they aren't ref struct (see below).

Considerations

Since ref struct don't participate in type casting, should be safety to return false as result of type check, even for object at right side. Same for casting - ref struct may not be casted to any other type, so null is expected.

It's true for all variations except when right side is same type as type of processed value.

Example code

static async Task Handle<V>(V value)
{
    // Do something async
    await Task.Delay(500);
}

static void HandleRef<V>(V value)
    where V : allows ref struct
{
    // Do something sync
}

static R Method<V, R>(Func<V, R> func, V value)
    where V : allows ref struct
    where R : allows ref struct
{
    if (typeof(R) == typeof(Task) && value is object arg)
    {
        Task handleTask = Handle(arg);
        R result = func(value);
        Task resultTask = Unsafe.As<R, Task>(ref result);

        Task chain = Task.WhenAll(handleTask, resultTask);

        return Unsafe.As<Task, R>(ref chain);
    }
    else
    {
        R result = func(value);
        HandleRef(value);
        return result;
    }
}

Actual behaivor

Code will not compile because of operator is don't account possibility of generic parameter V to be a not ref struct type.

Proposed behaivor of operator is

This also not optimal quickfix of actual behaivor.
Using Is<TIn, TOut> instead of operator is in sample above allows it to compile.

class Sample
{
    private delegate bool IsDelegate<TIn, TOut>(TIn @in, out TOut @out)
        where TIn : allows ref struct
        where TOut : allows ref struct;

    private static readonly MethodInfo SafeIsMI = typeof(Sample).GetMethod(nameof(SafeIs), BindingFlags.Static | BindingFlags.NonPublic)!;

    private static bool SafeIs<TIn, TOut>(TIn @in, out TOut? @out)
    {
        if (@in is TOut value)
        {
            @out = value;
            return true;
        }
        else
        {
            @out = default;
            return false;
        }
    }

    public static bool Is<TIn, TOut>(TIn @in, out TOut? @out)
        where TIn : allows ref struct
        where TOut : allows ref struct
    {
        if (typeof(TIn) == typeof(TOut))
        {
            @out = Unsafe.As<TIn, TOut>(ref @in);
            return true;
        }
        else if (!typeof(TIn).IsByRefLike && !typeof(TOut).IsByRefLike && !(typeof(TIn).IsValueType && typeof(TOut).IsValueType))
        {
            IsDelegate<TIn, TOut> safeIs = SafeIsMI.MakeGenericMethod(typeof(TIn), typeof(TOut)).CreateDelegate<IsDelegate<TIn, TOut>>();
            return safeIs(@in, out @out);
        }
        else
        {
            @out = default;
            return false;
        }
    }
}

[huoyaoyuan]

Same for casting - ref struct may not be casted to any other type, so null is expected.

This won't work. Nullable<T> doesn't allow ref struct as type parameter, so there's no way to represent the result type.

Proposal allows to escape constraints, applied by modifiers scoped and allows ref struct, in methods and types with generic arguments, and do, for example, async processing arguments if they aren't ref struct.

This requires dotnet/csharplang#6308 , to treat T as non-ref struct under the branch.

[kemocca]

This requires dotnet/csharplang#6308 , to treat T as non-ref struct under the branch.

It's nice proposal, but there no need to treat T as something other than T. Current proposal about type check, not about less or more restricted generic type.
Of course, if T could be a not allows ref struct generic parameter in some context of a method, then type check and cast will be available. But why operators is and as should be restricted in this context when all information about types are here?

UPD: Proposal description was updated with proposed behaivor of operator is.

[huoyaoyuan]

This requires dotnet/csharplang#6308 , to treat T as non-ref struct under the branch.

It's nice proposal, but there no need to treat T as something other than T. Current proposal about type check, not about less or more restricted generic type.

The syntax rule is not important now. There's currently no way to support either of these. The runtime needs to introduce such support first (#97084).