Handle nullable in string concatenation

[asashour]

void f(int? i) {
  var s1 = '' + i;

  var s2 = '$i';
}

It is currently not allowed to assign a nullable (int, String, etc.) to a String as required by the concatenation +.

However, interpolation handles it gracefully.

Would it make sense to also handle it in concatenation, after the +, or even before (if detected as concatenation)?

So the below would be allowed:

void f(String? s) {
  var s1 = s + s;

  var s2 = '$s$s';
}

I know that interpolation is the preferred way, but as concatenation is there, I guess it would make the language a little smarter.

[eernstg]

I'm afraid that won't be easy.

String interpolation is specified to call v.toString() on the value v of each interpolated expression, and this implies that '$s$s' will evaluate to 'nullnull' when the value of s is null. However, + on strings is an instance method, so the receiver (the left operand) needs to have the static type String (or, for a dynamic invocation, it needs to have a run-time type which is a subtype of String), and then the operand must be assignable to String, and the result is a String.

It would be a rather deep change to the language to make an instance method behave in a different way. For instance, there's nothing that supports the idea that we must use string concatenation when the receiver is null. We could also consider null to be a kind of int and then try to int-add the right operand, etc, for all implementations of operator + in scope. I think it's fair to say that it would at least give rise to a long list of questions if we were to make s + s a kind of string concatenation in the case where s has type String?, or anything else which isn't guaranteed to be a String.

[Levi-Lesches]

Also see the discussion at #2053

[asashour]

Thanks a lot, I am closing this, as the other thread is the opposite, and has much useful discussions.