Allow ref structs to implement interfaces, respect "allows ref struct" during constraints check.

[AlekseyTs]

No description provided.

[AlekseyTs]

@cston, @jjonescz, @dotnet/roslyn-compiler Please review

[cston]

The type '{2}' may not be a ref struct or a type parameter allowing ref structs in order to use it as parameter '{1}' in the generic type or method '{0}'

Perhaps: "The type ... must not be a ref struct ... in order to use it as type parameter ..." #Resolved

[AlekseyTs]

For "may not be a", I think I used the following message as a template:

  <data name="ERR_LambdaInIsAs" xml:space="preserve">
    <value>The first operand of an 'is' or 'as' operator may not be a lambda expression, anonymous method, or method group.</value>
  </data>

For "in order to use it as parameter", there is a "prior art" too:

  <data name="ERR_RefConstraintNotSatisfied" xml:space="preserve">
    <value>The type '{2}' must be a reference type in order to use it as parameter '{1}' in the generic type or method '{0}'</value>
  </data>

I can make the suggested change if you still think it is needed. Please let me know.

[cston]

}

Consider testing explicit cast as well: return (object)x;. #Resolved

[cston]

Are we testing boxing for this?

interface I { }
ref struct R : I
{
    I ImplicitCast => this;
    I ExplicitCast => (I)this;
}

[AlekseyTs]

Are we testing boxing for this?

Why would this make a difference? Conversion from ref struct to an interface is covered in ImplementAnInterface_02_IllegalBoxing. I do not find anything interesting in the suggested scenario. If I am missing something, please let me know.

[cston]

}

Consider testing explicit cast as well: return (I1)x;.

Also:

static U Test1<T, U>(T x)
    where T : allows ref struct
    where U : T
{
    return x;
}
static U Test2<T, U>(T x)
    where T : allows ref struct
    where U : T
{
    return (U)x;
}
``` #Resolved

[AlekseyTs]

Consider testing explicit cast as well: return (I1)x;.

Testing boxing is not a goal of this PR. It is known that proper checks are not in place and the added tests are sufficient to make the knowledge obvious

[cston]

}

Consider testing:

_ = typeof(C<T, T>);
_ = typeof(C<S, S>);
``` #Resolved

[cston]

}

Consider testing variance error cases as well:

interface I<T>
{
    void M(T t);
}
interface IOut<out T>
{
    T MOut();
}
ref struct S : I<object>, IOut<object>
{
    public void M(object o) { }
    public object MOut() => null;
}
class Program
{
    static void Main()
    {
        Test1(new S());
        Test2(new S());
    }
    static void Test1<T>(T x) where T : I<string>, allows ref struct
    {
    }
    static void Test2<T>(T x) where T : IOut<string>, allows ref struct
    {
    }
}``` #Resolved

[AlekseyTs]

@jjonescz, @dotnet/roslyn-compiler For the second review.

[jjonescz]

Why is this check needed specifically for ref struct type arguments - i.e., why they need different handling then normal structs for example? #Resolved

[AlekseyTs]

Why is this check needed specifically for ref struct type arguments - i.e., why they need different handling then normal structs for example?

There are no boxing conversion for ref structs, therefore, the conversions.HasBoxingConversion check above fails.

[jjonescz]

Should we also test RegularPreview to ensure this keeps working in C#14+? #Resolved

[AlekseyTs]

Should we also test RegularPreview to ensure this keeps working in C# 14+?

It is tested, that is the default option for our tests. Therefore, the CompileAndVerify covers that

[jjonescz]

I've overlooked that, thanks.