Cannot infer method type argument when using an implicit cast

[gafter]

@RunDevelopment commented on Thu Jun 07 2018

Version Used:

C# 7.3

Steps to Reproduce:

Consider the following example:

class Wrapper<T>
{
    public T Value { get; }
    public Wrapper(T value)
    {
        this.Value = value;
    }

    public static implicit operator Wrapper<T>(T value)
        => new Wrapper<T>(value);
}

void Consume<T>(Wrapper<T> wrapper) { /* some code */ }

Now, let's try to call Consume:

int i = 0;
Consume(i);

Expected Behavior:

The type int is inferred and an implicit cast is performed.

Actual Behavior:

The type is not inferred.
CS0411: The type arguments for method cannot be inferred from the usage. Try specifying the type arguments explicitly.

Additional thoughts

Despite that, the following works just fine.

Wrapper<T> Wrap<T>(T value) => value;

int i = 0;
Consume(Wrap(i));
Consume((Wrapper<int>) i);
Consume<int>(i);

---

@jcouv commented on Sun Jun 10 2018

I believe this follows current language design, but I'll check in the spec.

Completed example:

public class Wrapper<T>
{
    public Wrapper(T value) => throw null;
    public static implicit operator Wrapper<T>(T value) => throw null;
}

class Other
{
    void Consume<U>(Wrapper<U> wrapper) => throw null;
    void M(int i)
    {
        Consume(i); // error CS0411: The type arguments for method 'Other.Consume<U>(Wrapper<U>)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
    }
}

---

@gafter commented on Tue Dec 11 2018

This is a type inference language feature request. Moving to csharplang.

[alrz]

trying to understand the issue here, I think the compiler tries to run overload resolution on Wrapper<T>.op_Implicit(T) but still fails to infer T because it comes from the type. so it should incorporate type parameters from the "receiver" into the type inference on the user-defined operator.

[ZacharyPatten]

Ran into this issue with Array -> Span

using System;

static class Program
{
	static void Main()
	{
		int[] values = default;

		// no implicit conversion
		MethodA(values); // <- works

		// implicit conversion
		MethodB<int>(values); // <- works
		MethodB(values.AsSpan()); // <- works
		MethodB(values); // <- does not work (but could work if type inferencing accounted for implicit casting operators)
	}

	static void MethodA<T>(T[] a) { }
	static void MethodB<T>(Span<T> a) { }
}