Fix #2490. Update incompatible with await tests according to the changed rule

[sgrekhov]

No description provided.

[eernstg]

Again some tricky corners to consider. ;-)

[eernstg]

One more comment.

[eernstg]

We could probably do something like this:

extension type E1(Object _) {} // Incompatible with await.
extension type E2(Future<int> _) implements E1, Future<int> {} // Compatible.

Future<void> foo<X extends E1>(X x) async {
  E1 y = x;
  // await y; // Error, reported today.
  await x; // Error, `E` is not compatible with await. Not reported.
  if (x is E2) { // `x` has type `X & E2`.
    await x; // OK, result has type `int`.
  }
}

void main() async {
  await foo(E1(Future.value(1)));
}

(By the way, I just tried a completely fresh CFE, it does report an error for the line marked 'Not reported'. Moving fast. ;-)

[sgrekhov]

I removed static_analysis_extension_types_A08_t12.dar. Indeed we can't do this. So, only update of asserts left.

extension type E1(Object _) {} // Incompatible with await.
extension type E2(Future<int> _) implements E1, Future<int> {} // Compatible.

Future<void> foo<X extends E1>(X x) async {
  E1 y = x;
  // await y; // Error, reported today.  <- this checked in `static_analysis_extension_types_A08_t01.dart`
  await x; // Error, `E` is not compatible with await. Not reported. <- checked in `static_analysis_extension_types_A08_t07.dart`
  if (x is E2) { // `x` has type `X & E2`.
    await x; // OK, result has type `int`. <- checked in `static_analysis_extension_types_A08_t11.dart`
  }
}

void main() async {
  await foo(E1(Future.value(1)));
}

So, I think, there is no need to add the test above. Please take another look

[eernstg]

OK, updated asserts is a safe bet: Landing this.

However, I'm still wondering: Do we have a test that covers the case where we can a await e where e has type X & B where B is an extension type which is compatible with await, but X isn't (because the bound of X is an extension type that is not compatible)?

// Like this.
extension type E1(Object _) {} // Incompatible with await.
extension type E2(Future<int> _) implements E1, Future<int> {} // Compatible.

This is a tricky case because an algorithm that searches for an extension type that doesn't implement Future could search and find E1 and then conclude that X & E2 is incompatible with await, even though we're supposed to use the check on E2 directly (and ignore that we have a "bad" type in the superinterface graph).

[eernstg]

LGTM

[sgrekhov]

OK, updated asserts is a safe bet: Landing this.

However, I'm still wondering: Do we have a test that covers the case where we can a await e where e has type X & B where B is an extension type which is compatible with await, but X isn't (because the bound of X is an extension type that is not compatible)?

// Like this.
extension type E1(Object _) {} // Incompatible with await.
extension type E2(Future<int> _) implements E1, Future<int> {} // Compatible.

This is a tricky case because an algorithm that searches for an extension type that doesn't implement Future could search and find E1 and then conclude that X & E2 is incompatible with await, even though we're supposed to use the check on E2 directly (and ignore that we have a "bad" type in the superinterface graph).

Please see

co19/LanguageFeatures/Extension-types/static_analysis_extension_types_A08_t11.dart

Lines 19 to 37 in 5125c01

	// SharedOptions=--enable-experiment=inline-class
	import 'dart:async';
	extension type ObjectET(Object _) implements Object {}
	extension type FutureIntET(Future<int> _) implements Future<int>, ObjectET {}
	test<X extends ObjectET>(X x) async {
	if (x is FutureIntET) {
	await x;
	}
	if (x is FutureIntET?) {
	await x;
	}
	}
	main() {
	test(FutureIntET(Future<int>.value(42)));
	}

[eernstg]

Great, thanks!