Generic constraints with extension methods

[Julien-Mialon]

Version Used:
Visual Studio 15.3
Steps to Reproduce:
Compile the following code

using System;

namespace A
{
    public interface InterfaceA { }

    public static class Extensions
    {
        public static void DoSomething<T>(this T instance) where T : InterfaceA
        {
            Console.WriteLine("Do something on A");
        }
    }
}

namespace B
{
    public interface InterfaceB { }

    public class ClassB : InterfaceB { }

    public static class Extensions
    {
        public static void DoSomething<T>(this T instance) where T : InterfaceB
        {
            Console.WriteLine("Do something on B");
        }
    }
}

namespace Run
{
    using A;
    using B;

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");

            ClassB classB = new ClassB();
            InterfaceB interfaceB = classB;

            classB.DoSomething();
            interfaceB.DoSomething();
        }
    }
}

Expected Behavior:
Does generic constraint shouldn't be taking in account at a moment and discard the not wrong extension method from the candidate list ?

Actual Behavior:
Compiler error

 error CS0121: The call is ambiguous between the following methods or properties: 'A.Extensions.DoSomething<T>(T)' and 'B.Extensions.DoSomething<T>(T)'

[ufcpp]

dotnet/csharplang#98

[jaredpar]

Believe this behavior is "by design" as constraints can't be used to limit our candidate list. Will let @gafter verify.

[gafter]

This is by design. However, a proposal under consideration (dotnet/csharplang#98, item 2) would fix this.