Why Implicit Conversion Operator does not work for Wrapper Types that feature Generics and Interfaces and fails with CS1503?

[fitdev]

Consider the following code:

public class Class : IInterface { }

public interface IInterface { }

public readonly struct Wrapper<T> {

  public Wrapper(T? value) { Value = value; }

  T? Value { get; }

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

}

public static class Test {

  public static void UseWrapperViaInterafce(Wrapper<IInterface?> value) { }
  public static void UseWrapperViaClass(Wrapper<Class?> value) { }
  
  public static void Test() {

    IInterface instanceAsInterface = new Class();
    UseWrapperViaInterafce(instanceAsInterface ); // <-- CS1503: cannot convert from 'IInterface' to 'Wrapper<IInterface?>'

    Class instanceAsClass = new Class();
    UseWrapperViaInterafce(instanceAsClass ); // <-- Works
    UseWrapperViaClass(instanceAsClass ); // <-- Works

  }

}

What I am trying to understand is why when the T in implicit operator of Wrapper<T> is typed as interface (IInterface) the conversion fails, while if it is typed as class (Class) it works.

Are there any plans to ease this limitation?

[CyrusNajmabadi]

No interfaces can have a user defined operator to a type defined like this. THat's because the end (or subclass) type may truly implement htat interface). In which case, instead of the actual runtime check and downcast, it would go through this user case instead.

Consider this trivial example:

interface IFoo
{
}

class C
{
    public static implicit operator C(IFoo foo) => new C(...);
}

class D : C, IFoo
{
}

IFoo i = new D();
C c = (C)i; // this needs to not call through the conversion operator (which would create a new C), but instead actually just downcast properly.

Are there any plans to ease this limitation?

Unlikely. Casting interfaces to a base class only going through the runtime is deeply part of our language and something we are not likely to ever change.

[fitdev]

Thank you for such a quick and detailed explanation. It does make sense, however I cannot follow how it applies to the wrapper struct in my example? I mean why should the struct care if what is being converted to it is typed as an interface vs as a class?

In other words, why for Wrapper<IInterface?> value argument (Class)instance works while (IInterface)instance produces CS1503 when Class is IInterface for the purposes of meeting Wrapper<IInterface?> value requirement?

[CyrusNajmabadi]

In other words, why for Wrapper<IInterface?> value argument (Class)instance works while (IInterface)instance produces

Because one is a class, and one is an interface. And we don't know at compile time if your types will actually be implementing those interfaces or not (remember that at runtime the inheritance hierarchy may be different). So we will not implicitly convert an interface to another type through a user defined conversion, since a real "runtime converwsin" may exist for that at runtime.