Specially handle more scenarios for type parameters with 'allows ref struct' constraint

[AlekseyTs]

No description provided.

[AlekseyTs]

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

[AlekseyTs]

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

[jjonescz]

Consider adjusting this comment to reflect the implementation changes. #Resolved

[jjonescz]

This sounds confusing. S implements I1, so h2 is of type I1 in a sense, only the is operator cannot be applied to it. Should the diagnostic message be changed to reflect that? #Resolved

[AlekseyTs]

This sounds confusing. S implements I1, so h2 is of type I1 in a sense, only the is operator cannot be applied to it. Should the diagnostic message be changed to reflect that?

I would say this is a preexisting condition, which can be demonstrated with a scenario not involving interfaces:

warning CS0184: The given expression is never of the provided ('ValueType') type
if (h2 is System.ValueType) 

[jjonescz]

Is pattern dispose not allowed on allows ref struct type parameters? Do we have tests for that? #Resolved

[AlekseyTs]

Is pattern dispose not allowed on allows ref struct type parameters? Do we have tests for that?

I think Using_06 covers that. The fact is also explicitly stated in https://github.com/dotnet/csharplang/blob/main/proposals/ref-struct-interfaces.md#using-statement section.

[AlekseyTs]

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

[cston]

if (refKind != RefKind.None || type.IsRestrictedType())

Are we testing ErrorCode.ERR_AnonDelegateCantUseLocal? #Resolved

[AlekseyTs]

Are we testing ErrorCode.ERR_AnonDelegateCantUseLocal?

No, I think this code path is covered by a test for ERR_AnonDelegateCantUseRefLike.

[AlekseyTs]

I will add the following test in the next PR:

        [Fact]
        public void IllegalCapturing_03()
        {
            var source = @"
ref struct R1
{
}

class C
{
    void M<T>(R1 r1, T t)
        where T : allows ref struct
    {
        R1 r2 = r1;
        T t2 = t;

        var d1 = () => r2;
        var d2 = () => t2;
    }
}
";
            var comp = CreateCompilation(source, targetFramework: s_targetFrameworkSupportingByRefLikeGenerics);

            comp.VerifyEmitDiagnostics(
                // (14,24): error CS8175: Cannot use ref local 'r2' inside an anonymous method, lambda expression, or query expression
                //         var d1 = () => r2;
                Diagnostic(ErrorCode.ERR_AnonDelegateCantUseLocal, "r2").WithArguments("r2").WithLocation(14, 24),
                // (15,24): error CS8175: Cannot use ref local 't2' inside an anonymous method, lambda expression, or query expression
                //         var d2 = () => t2;
                Diagnostic(ErrorCode.ERR_AnonDelegateCantUseLocal, "t2").WithArguments("t2").WithLocation(15, 24)
                );
        }

[cston]

Consider testing:

class Helper1<T, U>
    where T : allows ref struct
    where U : T, allows ref struct
{
    public static void Test1(T h1)
    {
        if (h1 is U)
        {
        }
    }
    public static void Test2(U h2)
    {
        if (h2 is T)
        {
        }
    }
}
``` #Resolved

[AlekseyTs]

Consider testing:

I will add the following test in the next PR:

        [Fact]
        public void IsOperator_10()
        {
            var src = @"
class Helper1<T, U>
    where T : allows ref struct
    where U : T, allows ref struct
{
    public static void Test1(T h1)
    {
        if (h1 is U)
        {
        }
    }
    public static void Test2(U h2)
    {
        if (h2 is T)
        {
        }
    }
}
";

            var comp = CreateCompilation(src, targetFramework: s_targetFrameworkSupportingByRefLikeGenerics);
            comp.VerifyDiagnostics(
                // (8,13): error CS0019: Operator 'is' cannot be applied to operands of type 'T' and 'U'
                //         if (h1 is U)
                Diagnostic(ErrorCode.ERR_BadBinaryOps, "h1 is U").WithArguments("is", "T", "U").WithLocation(8, 13),
                // (14,13): error CS0019: Operator 'is' cannot be applied to operands of type 'U' and 'T'
                //         if (h2 is T)
                Diagnostic(ErrorCode.ERR_BadBinaryOps, "h2 is T").WithArguments("is", "U", "T").WithLocation(14, 13)
                );
        }

[cston]

Consider testing:

class Helper1<T, U>
    where T : allows ref struct
    where U : T, allows ref struct
{
    public static void Test1(T h1)
    {
        if (h1 is U u)
        {
        }
    }
    public static void Test2(U h2)
    {
        if (h2 is T t)
        {
        }
    }
}
``` #Resolved

[AlekseyTs]

Consider testing:

I will add the following test in the next PR:

        [Fact]
        public void IsPattern_10()
        {
            var src = @"
class Helper1<T, U>
    where T : allows ref struct
    where U : T, allows ref struct
{
    public static void Test1(T h1)
    {
        if (h1 is U u)
        {
        }
    }
    public static void Test2(U h2)
    {
        if (h2 is T t)
        {
        }
    }
}
";

            var comp = CreateCompilation(src, targetFramework: s_targetFrameworkSupportingByRefLikeGenerics);
            comp.VerifyDiagnostics(
                // (8,19): error CS8121: An expression of type 'T' cannot be handled by a pattern of type 'U'.
                //         if (h1 is U u)
                Diagnostic(ErrorCode.ERR_PatternWrongType, "U").WithArguments("T", "U").WithLocation(8, 19),
                // (14,19): error CS8121: An expression of type 'U' cannot be handled by a pattern of type 'T'.
                //         if (h2 is T t)
                Diagnostic(ErrorCode.ERR_PatternWrongType, "T").WithArguments("U", "T").WithLocation(14, 19)
                );
        }

[cston]

WRN_IsAlwaysFalse

The severity of the diagnostic for t is Span<int> was reduced from an error to a warning. Will that affect success cases in C# 12 (say overload resolution with lambda arguments)? #Resolved

[AlekseyTs]

WRN_IsAlwaysFalse

The severity of the diagnostic for t is Span<int> was reduced from an error to a warning. Will that affect success cases in C# 12 (say overload resolution with lambda arguments)?

Quite possibly, but we, usually, do not worry about changes in behavior for scenarios like that.