Overload resolution should not consider unreferenced types

[TonyValenti]

Let's say I have the following Methods:

public class MyClass {
  public void Foo(string x){ }
  public void Foo(int x){ }
  public void Foo(SomeCrazyTypeFromAThirdPartyAssembly x){ }
}

If I want to call Foo("asdf"), the calling class has to have a reference to SomeCrazyTypeFromAThirdPartyAssembly even though I have no intention of using it. Can this restriction be removed? It should only consider types that the calling assembly references.

[333fred]

No, this restriction cannot be removed. At a fundamental level we have to know what all the types involved mean, because that other type could actually cause an ambiguity or it might end up being a better match. For example:

Assembly 1:

class A { }

Assembly 2 (references 1):

class B
{
    public static implicit operator B(A a) => null;
}

Assembly 3 (references 1):

class C
{
    public static implicit operator C(A a) => null;
}

Assembly 4 (references 1, 2, 3):

class D
{
    public void M1(B b, int i = 1) { }
    public void M1(C c) { }
}

Assembly 5 (references 1, 2, 4):

public class E
{
    public void M2(A a) => D.M1(a);
}

If we allowed Assembly 5 to compile, then overload resolution would erroneously pick M(B b, int i = 1), even though M1(C c) is a better match.

[TonyValenti]

Except it is definitely not a better Match if the necessary assemblies aren’t in scope.

[333fred]

No, it's undefined whether there's a better match. You can't just part of a class's definition that you don't like.