Improved type inference when generic argument has struct constraint

[gafter]

@kingces95 commented on Thu Apr 20 2017

Given:

public interface IFoo<T> { }
public struct Foo<T> : IFoo<T> { }
public static class Program {
    public static void Main() {
        Method(default(Foo<int>));
    }

    public static void Method<TFoo, T>(TFoo foo) where TFoo : struct, IFoo<T> { }
}

Expected Behavior: Compiler is able to infer type arguments for Method as <Foo<int>, int>.
Actual Behavior: Compiler generates an error; Compiler is unable to infer type arguments.

Whenever a generic argument (e.g. TFoo) has a struct constraint (e.g. TFoo : struct) and a struct is passed as an argument for that parameter (e.g. Foo<int>) than the generic argument necessarily must be of the struct type (e.g. Foo<int>) (this works; compiler infers correctly in this case). If the same generic argument with struct constraint also has an interface constraint containing other generic arguments (e.g. TFoo : struct, IFoo<T>) and the struct argument implements one version of that interface (e.g. Foo<int> : IFoo<int>) then those other generic arguments (e.g. T) must assume the types of the struct argument interface instantiation (e.g. int).

---

@gafter commented on Fri Apr 21 2017

This is a language feature request. Moving to the csharplang repo.

[kingces95]

@gafter Should we close this and track with #741?

[gafter]

@agocke is investigating extending type inference to take constraints into account.