pkg/front_end/testcases/dart2wasm/yield.dart.strong.transformed.expect

library;
import self as self;
import "dart:core" as core;
import "dart:async" as asy;

static method method(final core::Iterable<core::int> iterable) → core::Iterable<core::int> sync* /* emittedValueType= core::int */ {
  yield 1;
  yield 2;
  yield* iterable;
}
static method asyncMethod(final asy::Stream<core::int> stream) → asy::Stream<core::int> {
  final synthesized asy::StreamController<core::int> #controller = asy::StreamController::•<core::int>(sync: #C1);
  final synthesized () → asy::Future<void> #body = () → asy::Future<void> async /* emittedValueType= void */ {
    void :async_temporary_0;
    void :async_temporary_1;
    dynamic :async_temporary_2;
    synthesized asy::Completer<void>? #paused;
    final dynamic #onCancelCallback = () → void {
      if(#paused == null) {
      }
      else {
        #paused.{asy::Completer::complete}(#C2){([FutureOr<void>?]) → void};
        #paused = #C2;
      }
    };
    #controller.{asy::StreamController::onResume} = #onCancelCallback;
    #controller.{asy::StreamController::onCancel} = #onCancelCallback;
    {
      core::int #t1 = 0;
      core::Object #t2;
      core::StackTrace #t3;
      try
        try {
          {
            #controller.{asy::StreamController::add}(1){(core::Object?) → void};
            if(#controller.{asy::StreamController::isPaused}{core::bool}) {
              :async_temporary_0 = await(#paused = asy::Completer::•<void>()).{asy::Completer::future}{asy::Future<void>};
              :async_temporary_0 as dynamic;
            }
            if(#controller.{asy::StreamController::hasListener}{core::bool}) {
            }
            else
              return;
          }
          {
            #controller.{asy::StreamController::add}(2){(core::Object?) → void};
            if(#controller.{asy::StreamController::isPaused}{core::bool}) {
              :async_temporary_1 = await(#paused = asy::Completer::•<void>()).{asy::Completer::future}{asy::Future<void>};
              :async_temporary_1 as dynamic;
            }
            if(#controller.{asy::StreamController::hasListener}{core::bool}) {
            }
            else
              return;
          }
          {
            :async_temporary_2 = await #controller.{asy::StreamController::addStream}(stream){(asy::Stream<core::int>, {cancelOnError: core::bool?}) → asy::Future<dynamic>};
            :async_temporary_2;
            if(#controller.{asy::StreamController::hasListener}{core::bool}) {
            }
            else
              return;
          }
        }
        on dynamic catch(final dynamic #t4, final core::StackTrace #t5) {
          #controller.{asy::StreamController::addError}(#t4, #t5){(core::Object, [core::StackTrace?]) → void};
          #t4;
          #t5;
        }
      finally {
        #controller.{asy::StreamController::close}(){() → asy::Future<dynamic>};
        #t1;
        #t2;
        #t3;
      }
    }
  };
  #controller.{asy::StreamController::onListen} = () → dynamic
    asy::scheduleMicrotask(#body);
;
  return #controller.{asy::StreamController::stream}{asy::Stream<core::int>};
}

constants  {
  #C1 = true
  #C2 = null
}