Run toString(null) for explicit nullable abstract

[tobil4sk]

If the abstract is declared over Null<T>, then null is part of the type so the user should be able to handle the null case within the toString method. It is also useful to be able to have custom empty values for an abstract that wraps a nullable type.

This is also in-line what null safety has to say, as it forces the user to add a null check to toString when the concrete type is Null<T>.

[Simn]

There's also this case:

private abstract MyStringT<T>(T) from T {
	function toString() {
		if (this == null)
			return "EMPTY";
		return "FULL";
	}
}

function main() {
	var ms:MyStringT<Null<String>> = null;
	trace(ms);
}

Instead of using a_this directly we can use Abstract.get_underlying_type, which I think addresses this.

[Simn]

We discussed this and agreed that the function shouldn't be called in my example. The reasoning is that without the abstract itself being defined over Null<T>, it is unlikely that its functions were written with null-values in mind.

[tobil4sk]

Using Abstract.get_underlying_type would also solve the following case:

private abstract MyString(Null<String>) from Null<String> {
    function toString() {
        if (this == null)
            return "EMPTY MyString";
        return this;
    }
}

private abstract MyStringWrapper(MyString) from MyString {
    function toString() {
        if (this == null)
            return "EMPTY MyStringWrapper";
        return Std.string(this);
    }
}

function main() {
    final a:MyString = null;
    trace(a);
    final b:MyStringWrapper = null;
    trace(b);
}

After further discussion, it seems that in the abstract A<T>(T) case, the unconstrained T is too abstract to allow doing anything (sensible) that could break when null is passed. However, it gets more complicated when constraints are involved, since Null<T> currently satisfies : T: #12020.

Perhaps we can find a solution for the constraint problem in #12020, in which case a non-nullable type constraint will guarantee that the external null check would be generated. Otherwise a more complicated workaround will be needed.