`await futureOr` may return a Future when the generic is `Object`

[rrousselGit]

Consider the following code:

import 'dart:async';

void main() async {
  final value = await fn();
  print(value);
}

FutureOr<Object> fn() async {
  return Future<Object>.value(42);
}

This should print 42 but actually prints Instance of '_Future<dynamic>'

Returning anything other than FutureOr<Object> in fn fixes the issue. This includes changing Object to int.

[eernstg]

This is a somewhat twisted corner of the language, and it does indeed show an issue with a type function called futureValueType.

The async function fn has return type FutureOr<Object> which means that it has a so-called future value type of Object.

The intuition is that the future value type is the "real" returned value for an async function, that is, the kind of object that you will receive by awaiting the Future that the async function returns if it is completed by a value (and not by an error). An async function always returns a Future, also in the case where you declare the return type to be, say, FutureOr<...> or void.

In other words, if the async function returns Future<S> for some S then the future value type is S, and you'll get an S by awaiting the return value from an invocation of that function (or it throws). The declared return type could be any of several different types: Future<S>, Future<S>?, FutureOr<S>, void (in which case S is also void), and more, but it would have to be a supertype of Future<S>, and the declared type is used to compute S in the first place.

So the invocation of fn should return a Future<Object>. In DartPad it actually returns a _Future<dynamic> (where _Future is a class that implements Future). So that's a bug.

[Edit: I tried out the program on the command line, and dart, dart compile js, and dart compile exe all have this behavior.]

Just to finish the story about what should have happened, assume that it returns a Future<Object> (the following works similarly with the Future<dynamic> that we actually get):

The return statement in fn yields an object whose run-time type is Future<Object>. So the return statement must await this future, obtain 42, and use 42 to complete the returned future. So print(value) in main should indeed print '42'.

(We do get that behavior if the return type of fn is changed to Future<Object>.)

So the conclusion is that fn returns a future whose run-time type implements Future<dynamic>; this seems to imply that the future value type is considered to be dynamic (it should have been Object). On the other hand, the return statement in fn does not await the given future, even though it is a Future<Object> which is a subtype of Future<flatten(FutureOr<Object>)> == Future<Object>; this seems to imply that flatten(FutureOr<Object>) is considered to be some type T which is not a supertype of Object, which means that it can't be dynamic after all.

[eernstg]

@chloestefantsova, @johnniwinther, WDYT?

[busslina]

It fails too with this simpler code:

import 'dart:async';

void main() async {
  final value = await fn();
  print(value);
}

FutureOr<Object> fn() async => 42;

But not with:

import 'dart:async';

void main() async {
  final value = await fn();
  print(value);
}

Future<Object> fn() async => 42;

I can suppose that Dart coders would expect same behaviour on both cases.

(This is in line with what @eernstg said)

[eernstg]

Interesting, @busslina! Clearly the return type FutureOr<Object> creates some confusion during compilation. When two async functions have return types Future<Object> and FutureOr<Object>, both of them should have future value type Object, and the future value type should govern the type of the returned future (when we know the future value type we don't have to know anything else about the declared return type), and that should in turn govern the semantics of return statements. I can't think of any way those two functions could behave differently (apart from the static type of invocations, which would be taken directly from the declared return type).

[lrhn]

The most likely reason is that the "future value type" uses the old unsafe approach, and becomes dynamic for FutureOr<Object>.
Then the returned future is a Future<Object?>, and the is Future<Object> test in the await rejects it and passes the future through as an Object.

[johnniwinther]

The CFE generates the right "runtimeCheckType":

  final core::Object value = await self::fn() /* runtimeCheckType= asy::Future<core::Object> */ ;
  core::print(value);

[eernstg]

@johnniwinther just checked the generated code, and it does contain the expected future value type. It looks like there's a need to double check what the backends are doing. I'm creating issues for that.

Subtasks:

• [vm] Async return type FutureOr<Object> returns Future<dynamic> #54316
• [dart2js] Async return type FutureOr<Object> returns Future<dynamic> #54317
• [ddc] Async return type FutureOr<Object> returns Future<dynamic> #54318