Reland "[vm] Avoid type parameter check of _Future._asyncComplete() when caller knows its safe"

Currently we have to do a runtime `as FutureOr<T>` check for the
parameter to `_Future<T>.asyncComplete(FutureOr<T> value)`. Although
needed for general cases, for the particular usage in the VM's
async/await transformer, we know that the test is going to suceed.

This CL adds two VM-specific methods on `_Future` that take `dynamic`
and downcast via `unsafeCast<>()` to avoid this rather large runtime
type checking overhead.

Issue #48226

Change after revert: Replace the
    assert(value is T || value is Future<T>);
with
    assert((value as FutureOr<T>) == value);

The former doesn't allow `null` while the ladder might (depending
on nullability of `T`).

TEST=ci

Change-Id: I2379c625003fea6aa836ac74beb1cd59201b3560
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/231704
Reviewed-by: Alexander Markov <[email protected]>
Commit-Queue: Martin Kustermann <[email protected]>

Author: mkustermann

pkg/vm/testcases/transformations/type_flow/transformer/enum_from_lib_used_as_type.dart.expect

@@ -22,6 +22,6 @@ class Class extends core::Object {
   synthetic constructor •() → self::Class
     : super core::Object::•()
     ;
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:3395,getterSelectorId:3396]  method method([@vm.inferred-type.metadata=dart.core::Null? (value: null)] self::Enum e) → core::int
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:3397,getterSelectorId:3398]  method method([@vm.inferred-type.metadata=dart.core::Null? (value: null)] self::Enum e) → core::int
     return [@vm.inferred-type.metadata=!] e.{core::_Enum::index}{core::int};
 }

pkg/vm/testcases/transformations/type_flow/transformer/tree_shake_enum_from_lib.dart.expect

@@ -51,6 +51,6 @@ class ConstClass extends core::Object {
   synthetic constructor •() → self::ConstClass
     : super core::Object::•()
     ;
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:3399,getterSelectorId:3400]  method method([@vm.inferred-type.metadata=dart.core::Null? (value: null)] self::ConstEnum e) → core::int
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:3401,getterSelectorId:3402]  method method([@vm.inferred-type.metadata=dart.core::Null? (value: null)] self::ConstEnum e) → core::int
     return [@vm.inferred-type.metadata=!] e.{core::_Enum::index}{core::int};
 }

sdk/lib/_internal/vm/lib/async_patch.dart

@@ -257,7 +257,7 @@ void _completeOnAsyncReturn(_Future _future, Object? value, bool is_sync) {
   // allow then and error handlers to be attached.
   // async_jump_var=0 is prior to first await, =1 is first await.
   if (!is_sync || value is Future) {
-    _future._asyncComplete(value);
+    _future._asyncCompleteUnchecked(value);
   } else {
     _future._completeWithValue(value);
   }

sdk/lib/async/future_impl.dart

@@ -598,6 +598,26 @@ class _Future<T> implements Future<T> {
     _asyncCompleteWithValue(value as dynamic); // Value promoted to T.
   }
 
+  /// Internal helper function used by the implementation of `async` functions.
+  ///
+  /// Like [_asyncComplete], but avoids type checks that are guaranteed to
+  /// succeed by the way the function is called.
+  /// Should be used judiciously.
+  void _asyncCompleteUnchecked(/*FutureOr<T>*/ dynamic value) {
+    assert((value as FutureOr<T>) == value);
+    final typedValue = unsafeCast<FutureOr<T>>(value);
+
+    // Doing just "is Future" is not sufficient.
+    // If `T` is Object` and `value` is `Future<Object?>.value(null)`,
+    // then value is a `Future`, but not a `Future<T>`, and going through the
+    // `_chainFuture` branch would end up assigning `null` to `Object`.
+    if (typedValue is Future<T>) {
+      _chainFuture(typedValue);
+      return;
+    }
+    _asyncCompleteWithValue(unsafeCast<T>(typedValue));
+  }
+
   void _asyncCompleteWithValue(T value) {
     _setPendingComplete();
     _zone.scheduleMicrotask(() {