False positive CA2021 when calling Enumerable.Cast on types that have a primitive type conversion

[Wazner]

Describe the bug

I am getting false positives of rule CA2021 in my project on code that does work at runtime.

To Reproduce

uint[] a = [1, 2, 3];
var sequence = a.Cast<int>();

Here the Cast triggers CA2021, even though generic uint can be casted to int no problem.

Runtime does fail for widening or narrowing conversions (int -> long, etc), so there the diagnostic is correct.
Just this specific path is a false positive.

Exceptions (if any)

No exception

Further technical details

Package 'Microsoft.CodeAnalysis.NetAnalyzers' version 10.0.102

[KalleOlaviNiemitalo]

This cast working at run time is specific to one-dimensional arrays, where the runtime allows casting uint[] to int[] and therefore the array object implements both IEnumerable<uint> and IEnumerable<int>. It doesn't work with other IEnumerable<uint> implementations.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
class C {
    static void Main() {
        uint[] ua = {uint.MaxValue};
        
        Console.WriteLine(ua is int[]); // False, compiler hardcodes
        Console.WriteLine((object)ua is int[]); // True
        int[] ia = (int[])(object)ua; // No exception

        Console.WriteLine(ua is IEnumerable<int>); // False
        Console.WriteLine((object)ua is IEnumerable<int>); // True
        
        Console.WriteLine(ua.Cast<int>().First()); // -1
        
        IEnumerable<uint> ue = UInt32Iterator();
        Console.WriteLine((object)ue is IEnumerable<int>); // False
        
        Console.WriteLine(ue.Cast<int>().First()); // InvalidCastEdception
    }
    
    static IEnumerable<uint> UInt32Iterator() {
        yield return uint.MaxValue;
    }
}

SharpLab

[KalleOlaviNiemitalo]

In the previous example, the InvalidCastException is thrown because Enumerable.Cast detects that the object does not directly implement IEnumerable<int>, so it goes to the iterator path, which reads the object Current property of IEnumerator and attempts to unbox that to int, which the runtime does not allow when it's actually uint.

However, the runtime allows such cross-type unboxing when the underlying type of an enum matches:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
class C {
    static void Main() {
        IEnumerable<int> ie = Int32Iterator();
        Console.WriteLine((object)ie is IEnumerable<DayOfWeek>); // False
        
        Console.WriteLine(ie.Cast<DayOfWeek>().First()); // Wednesday
    }
    
    static IEnumerable<int> Int32Iterator() {
        yield return 3;
    }
}

SharpLab

[Wazner]

Wow, that is very weird behavior!
Even though it works, I understand why it might be a code smell to use .Cast to cast a primitive type to another.
We use warnings as errors, so I have already changed it to .Select(v => (int)v); to be able to compile with the new analyzer.

I imagine it would be difficult to detect this edge case, because the receiver type at compile-time is the same in both cases.

public static void Main() {
    uint[] ua = {421u};

    IEnumerable<uint> x = ua;
    Console.WriteLine(x.Cast<int>()); // this works

    IEnumerable<uint> q = a();
    Console.WriteLine(q.Cast<int>()); // this throws InvalidCastException
}

private static IEnumerable<uint> a() {
    yield return 10;	
}

Either we produce a false positive, or a false negative. Depending on the type at runtime.