sdk
sdk copied to clipboard
dart-lang
[breaking change] Change the context for the operand of `throw` to `Object`.
Intended Change
The type schema for type inference of the operand of a throw expression will be changed from _ (the unknown type) to non-nullable Object.
Rationale
The type schema for an expression is intended to capture information from the surrounding context about what static type the expression is expected or intended to have. Since the operand of a throw expression is required by the compiler to be assignable to Object, it makes sense for this type to also be the context. Making this change furthers a longstanding goal of removing inconsistencies and unexpected behaviors from the Dart type inference process.
Expected Impact
The impact of this change is expected to be very low, since the operands of most throw expressions do not require any type inference. A trial run of this change over Google's internal Dart code base caused zero breakages.
However, it's theoretically possible that some code could change behavior as a result of this change. Here is an example of a program whose behavior would change:
T f<T>() {
return StateError('f<$T> was called') as T;
}
main() {
try {
throw f();
} on StateError catch (e) {
print(e);
}
}
Today this program prints Bad state: f<dynamic> was called. With the change, it will print Bad state: f<Object> was called.
Mitigation
In the unlikely event that some code is affected by this change, the old behavior may be restored by supplying explicit types inside the operand of the throw expression, so that no type inference is needed. For example, in the code above, the old behavior may be restored by changing throw f() to throw f<dynamic>().
Summary: This change updates the type inference context for throw operands from the unknown type (_) to Object. This aligns the context with the compiler's requirement that throw operands be assignable to Object, improving consistency in type inference.
Curious, does
throw nullbecome a static error?
It already is:
throw null;
produces:
The type 'Null' of the thrown expression must be assignable to 'Object'.
Interesting. :-)
Is that Object not already coming from the context?
Anyway, lgtm on the change.
Yeah, when we implemented null safety we added the requirement that anything being thrown must be assignable to Object (i.e. non-nullable). It would have made sense to change the context to Object at the same time, but we didn't think to do so. (Usually the context matches what type the expression has to be in order to avoid a compile-time error, but there are exceptions, so the implementation has to keep contexts and static error checking separate. As a result, if we don't think to update the context when we add an error condition, it doesn't happen automatically.)
Marking this breaking change as approved. @Hixie if you object, please speak up.
