Allow implicit conversions in default values for optional parameters

[emumanu]

Hello,

I have this class:

public class Union<T1, T2>
{
    protected Union();

    public static implicit operator Union<T1, T2>(T1 t);
    public static implicit operator Union<T1, T2>(T2 t);
    public static explicit operator T1(Union<T1, T2> value);
    public static explicit operator T2(Union<T1, T2> value);
}

And I have a method like this:

public static void AddCategory(Union<string, string[]> cat = "none")
{
}

I want it to work, but currently it is giving me the following error:

Error CS1750 A value of type 'string' cannot be used as a default parameter because there are no standard conversions to type 'Union<string, string[]>'

It would be nice to support that case.

Thank you

[ufcpp]

This code is not enough?

public static void AddCategory(Union<string, string[]> cat = null)
{
    cat = cat ?? "none";
}

[emumanu]

Short answer: no.

Long answer:
I'm using bridge.net to wrap a Javascript library and use it in c#. Bridge.net uses roslyn to convert from c# to javascript. The wrappers are created with all the methods marked as extern because the body of the method is in javascript and the only important thing for the c# consumer is to be able to call the methods.

[Unknown6656]

@ufcpp : Is this still a good pattern considering the upcoming nullable-reference-type feature in C# 8.0?

I have also done your solution multiple times in the past, but I never considered it very clean, so I usually made two methods overloading each other, e.g.:

public static void AddCategory() => AddCategory("none");

public static void AddCategory(Union<string, string[]> cat)
{
    // ...
}

[stakx]

AFAIK, the only legal default value for reference types (except string) is null. So even if the compiler performed an implicit conversion of "none" to Union<,>, you'd then get another compilation error (possibly a CS1736: Default parameter value for 'cat' must be a compile-time constant).

To support this scenario, two rather unlikely things would have to occur:

1. The compiler would have to be able to serialize an instance of Union<string, string[]> into metadata somehow. Given the flexibility of ECMA-335 metadata, this might be theoretically possible, but even if so, the BCL wouldn't support it (e.g. you couldn't retrieve that default value using Reflection) and you'd likely violate CLS (language interoperability) rules.

2. Even if (1) weren't a problem, the compiler would have to know the Union<string, string[]> instance to be serialized at compile-time. That is, it would have to run your implicit conversion operator at compile-time and pass "none" to it. It seems unlikely to me that the compiler will be able to execute parts of your code while compiling it.

[emumanu]

@stakx, You can change the Union<,> to a struct and you still have the problem. I created the issue to discuss if limitations for default values can be relaxed (if "the only legal default value for reference types (except string) is null" can be relaxed, it would be nice too).

[stakx]

@emumanu: The same restrictions I mentioned above apply to structs (except primitive types and certain special cases like decimal, for which there is dedicated BCL support). Sorry, I should've made this clearer.