Apply transformations after comparing to golden files.

pkg/front_end/testcases/inference/downwards_inference_yield_yield_star.dart.strong.expect

 library test;
 import self as self;
 import "dart:core" as core;
 import "dart:async" as asy;
 
 abstract class MyStream<T extends core::Object> extends asy::Stream<self::MyStream::T> {
   static factory •<T extends core::Object>() → self::MyStream<self::MyStream::•::T>
     return null;
 }
-static method foo() → asy::Stream<core::List<core::int>> /* originally async* */ {
-  dynamic :controller;
-  dynamic :async_op_then;
-  dynamic :async_op_error;
-  dynamic :await_jump_var = 0;
-  dynamic :await_ctx_var;
-  dynamic :saved_try_context_var0;
-  dynamic :saved_try_context_var1;
-  function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding 
-    try
-      try {
-        #L1:
-        {
-          if(:controller.add(<core::int>[]))
-            return null;
-          else
-            [yield] null;
-          if(:controller.add(self::MyStream::•<dynamic>()))
-            return null;
-          else
-            [yield] null;
-          if(:controller.addStream(<dynamic>[]))
-            return null;
-          else
-            [yield] null;
-          if(:controller.addStream(self::MyStream::•<core::List<core::int>>()))
-            return null;
-          else
-            [yield] null;
-        }
-        return;
-      }
-      on dynamic catch(dynamic :exception, dynamic :stack_trace) {
-        :controller.addError(:exception, :stack_trace);
-      }
-    finally {
-      :controller.close();
-    }
-  :async_op_then = asy::_asyncThenWrapperHelper(:async_op);
-  :async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
-  :controller = new asy::_AsyncStarStreamController::•(:async_op);
-  return :controller.stream;
+static method foo() → asy::Stream<core::List<core::int>> async* {
+  yield<core::int>[];
+  yield self::MyStream::•<dynamic>();
+  yield*<dynamic>[];
+  yield* self::MyStream::•<core::List<core::int>>();
 }
-static method bar() → core::Iterable<core::Map<core::int, core::int>> /* originally sync* */ {
-  dynamic :await_jump_var = 0;
-  dynamic :await_ctx_var;
-  function :sync_op(core::Iterator<dynamic> :iterator) → core::bool yielding {
-    {
-      {
-        :iterator._current = <core::int, core::int>{};
-        [yield] true;
-      }
-      {
-        :iterator._current = core::List::_internal<dynamic>();
-        [yield] true;
-      }
-      {
-        :iterator.isYieldEach = true;
-        :iterator._current = <dynamic, dynamic>{};
-        [yield] true;
-      }
-      {
-        :iterator.isYieldEach = true;
-        :iterator._current = core::List::_internal<core::Map<core::int, core::int>>();
-        [yield] true;
-      }
-    }
-    return false;
-  }
-  return new core::_SyncIterable::•(:sync_op);
+static method bar() → core::Iterable<core::Map<core::int, core::int>> sync* {
+  yield<core::int, core::int>{};
+  yield core::List::_internal<dynamic>();
+  yield*<dynamic, dynamic>{};
+  yield* core::List::_internal<core::Map<core::int, core::int>>();
 }
 static method main() → dynamic {}