[cfe] Update test expectations after new async/async* implementation …

…in the VM

The new implementation of async/async* doesn't use async kernel
transformation.

TEST=ci

Issue: #48378
Change-Id: I86594d8c0df382512e64e59847c178569f7fc38e
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/246083
Commit-Queue: Alexander Markov <alexmarkov@google.com>
Reviewed-by: Johnni Winther <johnniwinther@google.com>

pkg/front_end/testcases/extensions/async_extensions.dart.weak.transformed.expect

@@ -1,7 +1,6 @@
 library /*isNonNullableByDefault*/;
 import self as self;
 import "dart:core" as core;
-import "dart:async" as asy;
 
 extension Extension on core::int {
   method syncStarMethod = self::Extension|syncStarMethod;
@@ -25,58 +24,10 @@ static method Extension|syncStarMethod(lowered final core::int #this) → dynami
 }
 static method Extension|get#syncStarMethod(lowered final core::int #this) → () → dynamic
   return () → dynamic => self::Extension|syncStarMethod(#this);
-static method Extension|asyncMethod(lowered final core::int #this) → dynamic /* futureValueType= dynamic */ /* originally async */ {
-  final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
-  core::bool* :is_sync = false;
-  dynamic :return_value;
-  (dynamic) → dynamic :async_op_then;
-  (core::Object, core::StackTrace) → dynamic :async_op_error;
-  core::int :await_jump_var = 0;
-  dynamic :await_ctx_var;
-  function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding 
-    try {
-      #L1:
-      {}
-      asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
-      return;
-    }
-    on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
-      asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
-    }
-  :async_op_then = asy::_asyncThenWrapperHelper(:async_op);
-  :async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
-  :async_op(null, null){() → dynamic};
-  :is_sync = true;
-  return :async_future;
-}
+static method Extension|asyncMethod(lowered final core::int #this) → dynamic async /* futureValueType= dynamic */ {}
 static method Extension|get#asyncMethod(lowered final core::int #this) → () → dynamic
   return () → dynamic => self::Extension|asyncMethod(#this);
-static method Extension|asyncStarMethod(lowered final core::int #this) → dynamic /* originally async* */ {
-  asy::_AsyncStarStreamController<dynamic>? :controller;
-  dynamic :controller_stream;
-  (dynamic) → dynamic :async_op_then;
-  (core::Object, core::StackTrace) → dynamic :async_op_error;
-  core::int :await_jump_var = 0;
-  dynamic :await_ctx_var;
-  function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding 
-    try
-      try {
-        #L2:
-        {}
-        return;
-      }
-      on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
-        :controller.{asy::_AsyncStarStreamController::addError}(exception, stack_trace){(core::Object, core::StackTrace) → void};
-      }
-    finally {
-      :controller.{asy::_AsyncStarStreamController::close}(){() → dynamic};
-    }
-  :async_op_then = asy::_asyncThenWrapperHelper(:async_op);
-  :async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
-  :controller = new asy::_AsyncStarStreamController::•<dynamic>(:async_op);
-  :controller_stream = :controller.{asy::_AsyncStarStreamController::stream}{asy::Stream<dynamic>};
-  return :controller_stream;
-}
+static method Extension|asyncStarMethod(lowered final core::int #this) → dynamic async* {}
 static method Extension|get#asyncStarMethod(lowered final core::int #this) → () → dynamic
   return () → dynamic => self::Extension|asyncStarMethod(#this);
 static method main() → dynamic {

pkg/front_end/testcases/extensions/deferred_explicit_access.dart.weak.transformed.expect

@@ -8,47 +8,21 @@ library /*isNonNullableByDefault*/;
 // ^
 //
 import self as self;
-import "dart:async" as asy;
 import "dart:core" as core;
 import "deferred_explicit_access_lib.dart" as def;
 
 import "org-dartlang-testcase:///deferred_explicit_access_lib.dart" deferred as prefix;
 
-static method main() → dynamic /* futureValueType= dynamic */ /* originally async */ {
-  final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
-  core::bool* :is_sync = false;
-  dynamic :return_value;
-  (dynamic) → dynamic :async_op_then;
-  (core::Object, core::StackTrace) → dynamic :async_op_error;
-  core::int :await_jump_var = 0;
-  dynamic :await_ctx_var;
-  dynamic :saved_try_context_var0;
-  function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding 
-    try {
-      #L1:
-      {
-        [yield] let dynamic #t1 = asy::_awaitHelper(LoadLibrary(prefix), :async_op_then, :async_op_error) in null;
-        :result_or_exception;
-        self::expect(0, let final core::Object* #t2 = CheckLibraryIsLoaded(prefix) in def::Extension|staticField);
-        self::expect(0, let final core::Object* #t3 = CheckLibraryIsLoaded(prefix) in def::Extension|get#property(0));
-        self::expect(42, let final core::Object* #t4 = CheckLibraryIsLoaded(prefix) in let final core::int #t5 = 0 in let final core::int #t6 = 42 in let final void #t7 = def::Extension|set#property(#t5, #t6) in #t6);
-        self::expect(84, let final core::Object* #t8 = CheckLibraryIsLoaded(prefix) in def::Extension|get#property(42));
-        self::expect(85, let final core::Object* #t9 = CheckLibraryIsLoaded(prefix) in def::Extension|method(43));
-        self::expect(42, let final core::Object* #t10 = CheckLibraryIsLoaded(prefix) in def::Extension|staticProperty);
-        self::expect(87, let final core::Object* #t11 = CheckLibraryIsLoaded(prefix) in def::Extension|staticProperty = 87);
-        self::expect(87, let final core::Object* #t12 = CheckLibraryIsLoaded(prefix) in def::Extension|staticMethod());
-      }
-      asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
-      return;
-    }
-    on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
-      asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
-    }
-  :async_op_then = asy::_asyncThenWrapperHelper(:async_op);
-  :async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
-  :async_op(null, null){() → dynamic};
-  :is_sync = true;
-  return :async_future;
+static method main() → dynamic async /* futureValueType= dynamic */ {
+  await LoadLibrary(prefix);
+  self::expect(0, let final core::Object* #t1 = CheckLibraryIsLoaded(prefix) in def::Extension|staticField);
+  self::expect(0, let final core::Object* #t2 = CheckLibraryIsLoaded(prefix) in def::Extension|get#property(0));
+  self::expect(42, let final core::Object* #t3 = CheckLibraryIsLoaded(prefix) in let final core::int #t4 = 0 in let final core::int #t5 = 42 in let final void #t6 = def::Extension|set#property(#t4, #t5) in #t5);
+  self::expect(84, let final core::Object* #t7 = CheckLibraryIsLoaded(prefix) in def::Extension|get#property(42));
+  self::expect(85, let final core::Object* #t8 = CheckLibraryIsLoaded(prefix) in def::Extension|method(43));
+  self::expect(42, let final core::Object* #t9 = CheckLibraryIsLoaded(prefix) in def::Extension|staticProperty);
+  self::expect(87, let final core::Object* #t10 = CheckLibraryIsLoaded(prefix) in def::Extension|staticProperty = 87);
+  self::expect(87, let final core::Object* #t11 = CheckLibraryIsLoaded(prefix) in def::Extension|staticMethod());
 }
 static method expect(dynamic expected, dynamic actual) → dynamic {
   if(!(expected =={core::Object::==}{(core::Object) → core::bool} actual))
@@ -100,4 +74,4 @@ Extra constant evaluation status:
 Evaluated: VariableGet @ org-dartlang-testcase:///deferred_explicit_access.dart:12:31 -> IntConstant(0)
 Evaluated: VariableGet @ org-dartlang-testcase:///deferred_explicit_access.dart:12:45 -> IntConstant(42)
 Evaluated: VariableGet @ org-dartlang-testcase:///deferred_explicit_access.dart:12:45 -> IntConstant(42)
-Extra constant evaluation: evaluated: 91, effectively constant: 3
+Extra constant evaluation: evaluated: 68, effectively constant: 3

pkg/front_end/testcases/extensions/deferred_import_hidden.dart.weak.transformed.expect

@@ -1,45 +1,19 @@
 library /*isNonNullableByDefault*/;
 import self as self;
-import "dart:async" as asy;
 import "dart:core" as core;
 import "deferred_explicit_access_lib.dart" as def;
 
 import "org-dartlang-testcase:///deferred_explicit_access_lib.dart" deferred as prefix hide Extension;
 
-static method main() → dynamic /* futureValueType= dynamic */ /* originally async */ {
-  final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
-  core::bool* :is_sync = false;
-  dynamic :return_value;
-  (dynamic) → dynamic :async_op_then;
-  (core::Object, core::StackTrace) → dynamic :async_op_error;
-  core::int :await_jump_var = 0;
-  dynamic :await_ctx_var;
-  dynamic :saved_try_context_var0;
-  function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding 
-    try {
-      #L1:
-      {
-        [yield] let dynamic #t1 = asy::_awaitHelper(LoadLibrary(prefix), :async_op_then, :async_op_error) in null;
-        :result_or_exception;
-        self::expect(0, let final core::Object* #t2 = CheckLibraryIsLoaded(prefix) in def::topLevelField);
-        self::expect(42, let final core::Object* #t3 = CheckLibraryIsLoaded(prefix) in def::topLevelField = 42);
-        self::expect(42, let final core::Object* #t4 = CheckLibraryIsLoaded(prefix) in def::topLevelField);
-        self::expect(0, let final core::Object* #t5 = CheckLibraryIsLoaded(prefix) in def::topLevelProperty);
-        self::expect(87, let final core::Object* #t6 = CheckLibraryIsLoaded(prefix) in def::topLevelProperty = 87);
-        self::expect(87, let final core::Object* #t7 = CheckLibraryIsLoaded(prefix) in def::topLevelProperty);
-        self::expect(87, let final core::Object* #t8 = CheckLibraryIsLoaded(prefix) in def::topLevelMethod());
-      }
-      asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
-      return;
-    }
-    on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
-      asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
-    }
-  :async_op_then = asy::_asyncThenWrapperHelper(:async_op);
-  :async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
-  :async_op(null, null){() → dynamic};
-  :is_sync = true;
-  return :async_future;
+static method main() → dynamic async /* futureValueType= dynamic */ {
+  await LoadLibrary(prefix);
+  self::expect(0, let final core::Object* #t1 = CheckLibraryIsLoaded(prefix) in def::topLevelField);
+  self::expect(42, let final core::Object* #t2 = CheckLibraryIsLoaded(prefix) in def::topLevelField = 42);
+  self::expect(42, let final core::Object* #t3 = CheckLibraryIsLoaded(prefix) in def::topLevelField);
+  self::expect(0, let final core::Object* #t4 = CheckLibraryIsLoaded(prefix) in def::topLevelProperty);
+  self::expect(87, let final core::Object* #t5 = CheckLibraryIsLoaded(prefix) in def::topLevelProperty = 87);
+  self::expect(87, let final core::Object* #t6 = CheckLibraryIsLoaded(prefix) in def::topLevelProperty);
+  self::expect(87, let final core::Object* #t7 = CheckLibraryIsLoaded(prefix) in def::topLevelMethod());
 }
 static method expect(dynamic expected, dynamic actual) → dynamic {
   if(!(expected =={core::Object::==}{(core::Object) → core::bool} actual))

pkg/front_end/testcases/general/async_function.dart.weak.transformed.expect

@@ -2,64 +2,15 @@ library /*isNonNullableByDefault*/;
 import self as self;
 import "dart:async" as asy;
 import "dart:core" as core;
-import "dart:_internal" as _in;
 
 import "dart:async";
 
 static field core::List<core::String> stringList = core::_GrowableList::_literal1<core::String>("bar");
-static method asyncString() → asy::Future<core::String> /* futureValueType= core::String */ /* originally async */ {
-  final asy::_Future<core::String> :async_future = new asy::_Future::•<core::String>();
-  core::bool* :is_sync = false;
-  core::String? :return_value;
-  (dynamic) → dynamic :async_op_then;
-  (core::Object, core::StackTrace) → dynamic :async_op_error;
-  core::int :await_jump_var = 0;
-  dynamic :await_ctx_var;
-  function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding 
-    try {
-      #L1:
-      {
-        :return_value = "foo";
-        break #L1;
-      }
-      asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
-      return;
-    }
-    on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
-      asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
-    }
-  :async_op_then = asy::_asyncThenWrapperHelper(:async_op);
-  :async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
-  :async_op(null, null){() → dynamic};
-  :is_sync = true;
-  return :async_future;
+static method asyncString() → asy::Future<core::String> async /* futureValueType= core::String */ {
+  return "foo";
 }
-static method asyncString2() → asy::Future<core::String> /* futureValueType= core::String */ /* originally async */ {
-  final asy::_Future<core::String> :async_future = new asy::_Future::•<core::String>();
-  core::bool* :is_sync = false;
-  FutureOr<core::String>? :return_value;
-  (dynamic) → dynamic :async_op_then;
-  (core::Object, core::StackTrace) → dynamic :async_op_error;
-  core::int :await_jump_var = 0;
-  dynamic :await_ctx_var;
-  function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding 
-    try {
-      #L2:
-      {
-        :return_value = self::asyncString();
-        break #L2;
-      }
-      asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
-      return;
-    }
-    on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
-      asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
-    }
-  :async_op_then = asy::_asyncThenWrapperHelper(:async_op);
-  :async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
-  :async_op(null, null){() → dynamic};
-  :is_sync = true;
-  return :async_future;
+static method asyncString2() → asy::Future<core::String> async /* futureValueType= core::String */ {
+  return self::asyncString();
 }
 static method syncStarString() → core::Iterable<core::String> /* originally sync* */ {
   function :sync_op_gen() → (core::_SyncIterator<dynamic>?, dynamic, dynamic) → core::bool* {
@@ -103,106 +54,14 @@ static method syncStarString2() → core::Iterable<core::String> /* originally s
   }
   return new core::_SyncIterable::•<core::String>(:sync_op_gen);
 }
-static method asyncStarString() → asy::Stream<core::String> /* originally async* */ {
-  asy::_AsyncStarStreamController<core::String>? :controller;
-  dynamic :controller_stream;
-  (dynamic) → dynamic :async_op_then;
-  (core::Object, core::StackTrace) → dynamic :async_op_error;
-  core::int :await_jump_var = 0;
-  dynamic :await_ctx_var;
-  dynamic :saved_try_context_var0;
-  dynamic :saved_try_context_var1;
-  function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding 
-    try
-      try {
-        #L3:
-        {
-          if(:controller.{asy::_AsyncStarStreamController::add}("foo"){(core::String) → core::bool})
-            return null;
-          else
-            [yield] null;
-          :controller.{asy::_AsyncStarStreamController::addStream}(self::asyncStarString2()){(asy::Stream<core::String>) → void};
-          [yield] null;
-          if(_in::unsafeCast<core::bool>(:result_or_exception))
-            return null;
-          [yield] let dynamic #t1 = asy::_awaitHelper(self::asyncString(), :async_op_then, :async_op_error) in null;
-          if(:controller.{asy::_AsyncStarStreamController::add}(_in::unsafeCast<core::String>(:result_or_exception)){(core::String) → core::bool})
-            return null;
-          else
-            [yield] null;
-        }
-        return;
-      }
-      on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
-        :controller.{asy::_AsyncStarStreamController::addError}(exception, stack_trace){(core::Object, core::StackTrace) → void};
-      }
-    finally {
-      :controller.{asy::_AsyncStarStreamController::close}(){() → dynamic};
-    }
-  :async_op_then = asy::_asyncThenWrapperHelper(:async_op);
-  :async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
-  :controller = new asy::_AsyncStarStreamController::•<core::String>(:async_op);
-  :controller_stream = :controller.{asy::_AsyncStarStreamController::stream}{asy::Stream<core::String>};
-  return :controller_stream;
+static method asyncStarString() → asy::Stream<core::String> async* {
+  yield "foo";
+  yield* self::asyncStarString2();
+  yield await self::asyncString();
 }
-static method asyncStarString2() → asy::Stream<core::String> /* originally async* */ {
-  asy::_AsyncStarStreamController<core::String>? :controller;
-  dynamic :controller_stream;
-  (dynamic) → dynamic :async_op_then;
-  (core::Object, core::StackTrace) → dynamic :async_op_error;
-  core::int :await_jump_var = 0;
-  dynamic :await_ctx_var;
-  dynamic :saved_try_context_var0;
-  dynamic :saved_try_context_var1;
-  function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding 
-    try
-      try {
-        #L4:
-        {
-          if(:controller.{asy::_AsyncStarStreamController::add}("bar"){(core::String) → core::bool})
-            return null;
-          else
-            [yield] null;
-        }
-        return;
-      }
-      on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
-        :controller.{asy::_AsyncStarStreamController::addError}(exception, stack_trace){(core::Object, core::StackTrace) → void};
-      }
-    finally {
-      :controller.{asy::_AsyncStarStreamController::close}(){() → dynamic};
-    }
-  :async_op_then = asy::_asyncThenWrapperHelper(:async_op);
-  :async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
-  :controller = new asy::_AsyncStarStreamController::•<core::String>(:async_op);
-  :controller_stream = :controller.{asy::_AsyncStarStreamController::stream}{asy::Stream<core::String>};
-  return :controller_stream;
+static method asyncStarString2() → asy::Stream<core::String> async* {
+  yield "bar";
 }
-static method main() → dynamic /* futureValueType= dynamic */ /* originally async */ {
-  final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
-  core::bool* :is_sync = false;
-  dynamic :return_value;
-  (dynamic) → dynamic :async_op_then;
-  (core::Object, core::StackTrace) → dynamic :async_op_error;
-  core::int :await_jump_var = 0;
-  dynamic :await_ctx_var;
-  dynamic :saved_try_context_var0;
-  function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding 
-    try {
-      #L5:
-      {
-        [yield] let dynamic #t2 = asy::_awaitHelper(self::asyncString(), :async_op_then, :async_op_error) in null;
-        core::String str = _in::unsafeCast<core::String>(:result_or_exception);
-      }
-      asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
-      return;
-    }
-    on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
-      asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
-    }
-  :async_op_then = asy::_asyncThenWrapperHelper(:async_op);
-  :async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
-  :async_op(null, null){() → dynamic};
-  :is_sync = true;
-  return :async_future;
+static method main() → dynamic async /* futureValueType= dynamic */ {
+  core::String str = await self::asyncString();
 }