Proposal: Resolve method call with duplicate interface method definitions

Background

Consider an interface with multiple generic type parameters and that defines overloaded methods that differ only by the generic type used as the type of a parameter. When the same type is used as the generic type arguments, these overloaded methods definitions are essentially duplicated. These duplicated methods definitions can only be implemented by a single method, in an implementing class.

Example:

Interface:

interface IMap<T,U> 
{
	bool Contains(T val);
	bool Contains(U val);
}

Implementation:

class Map<T> : IMap<T,T> 
{
	public bool Contains(T val) => true;
}

Currently, when calling Contains on a IMap<T,T>, the error CS0121 for ambiguous method call is raised.

IMap<int,int> map = new Map<int>();
...
map.Contains(42); // CS0121

Proposal

Since these duplicate interface method definitions can only resolve to a single method, the calling method should resolve to the last defined method that matches in the interface.

[svick]

These duplicated methods definitions can only be implemented by a single method, in an implementing class.

That’s not true, consider the following generic implementation:

class Map<T, U> : IMap<T, U>
{
    public bool Contains(T val) => true;
    public bool Contains(U val) => false;
}

Usage:

IMap<int,int> map = new Map<int, int>();
// map.Contains(42); // still CS0121

void M<T, U>(IMap<T, U> map)
{
    Console.WriteLine(map.Contains(default(T))); // true
    Console.WriteLine(map.Contains(default(U))); // false
}

M(map);

[UpperAvenue]

@svick I see what you’re saying now. You’re right, we wouldn’t able to resolve the method at compile time in your example. Thanks for taking the time!