Possible using static bug? Compiler resolution to type when a type couldn't possibly be an acceptable value

[louthy]

Version Used:
8.0

Steps to Reproduce:

using System.Linq;
using static ConsoleApp28.Prelude;

namespace ConsoleApp28
{
    class Program
    {
        static void Main(string[] args)
        {
            var seq = new[] { 1, 2, 3, 4 };

            // FAILS
            var resA = seq.Select(Right<string, int>);

            // WORKS
            var resV = seq.Select(Prelude.Right<string, int>);

        }
    }

    public static class Prelude
    {
        public static Either<L, R> Left<L, R>(L value) => new Left<L, R>(value);
        public static Either<L, R> Right<L, R>(R value) => new Right<L, R>(value);
    }

    public interface Either<L, R>
    { }

    public sealed class Left<L, R> : Either<L, R>
    {
        public readonly L Value;
        internal Left(L value) => Value = value;
        public void Deconstruct(out L Value) => Value = this.Value;
    }

    public sealed class Right<L, R> : Either<L, R>
    {
        public readonly R Value;
        internal Right(R value) => Value = value;
        public void Deconstruct(out R Value) => Value = this.Value;
    }
}

Expected Behavior:

In the example above there's no way a method (in this case Select) should accept a type as an argument and so it should prefer the static method Right when resolving (which has been brought into scope by using static ConsoleApp28.Prelude at the top of the file).

Actual Behavior:

error CS0119: 'Right<string, int>' is a type, which is not valid in the given context

Conclusion

This has been causing me problems ever since the using static feature was brought in. The amount of times I've tripped over this is large (because language-ext has a large Prelude class that is used to bring type-constructing methods into the namespace - like Some(x), Left(x), etc.).

[jcouv]

I think this is by-design per current name resolution rules. Whether the type Right is useful or not in that context doesn't change the fact that it is found first.

[louthy]

Whether the type Right is useful or not in that context doesn't change the fact that it is found first.

I guess my follow-up would be: why stick with a broken design? A type can never be an argument to a method (as far as I am aware). Is there scope here to look at the name resolution rules? The existing rules appear to allow contextual decision making. It seems this could be modified without breaking any existing code.

[jcouv]

Is there scope here to look at the name resolution rules?

I don't have a good idea for an alternative design, but the discussion is certainly open :)
Language design changes are typically discussed on the csharplang repo. The rolsyn repo is focused on implementation issues.