Strong mode should disallow implicit downcasts of ternary operators

[leafpetersen]

This program passes strong mode because the LUB of the arms of the ternary operator is Object, which is allowed to be downcast to int. If we disallow implicit downcasts we'd catch this, but even in the absence of this I think we could do better. In a typed context, we should always check the arms of the ternary operator against the type from the context.

void main() {
  bool b;
  int test = b ? "123" : 123;
}

[lrhn]

Ob-pedantry: There are two ternary operators in Dart: The conditional operator (o1?o2:o3) and the index-set operator (o1[o2]=o3), so just saying "ternary operator" isn't uniquely identifying the conditional operator by its arity the same way it does in some other language.

[leafpetersen]

Ob-pedantry acknowledged... :)

I think this applies to the ?? operator as well. In general, any where we do a LUB we have the potential to lose all checking if the LUB is top.

[leafpetersen]

Note: pushing types down from the context when present instead of relying on LUB could avoid other unfortunate examples as well. Consider this example (abstracted from real code encountered in the wild):

class A{}
class B{}
class C extends B{}

class E extends C implements A {}
class F extends C implements A {}
void main() {
  bool a = true;
  A y = a ? new E() : new F();
}

This is currently an error, because the LUB of E and F is C, which is unrelated to A. But both arms of the conditional can be typed as A.