library;
//
// Problems in library:
//
// pkg/front_end/testcases/regress/issue_37681.dart:6:7: Error: Functions marked 'async' must have a return type assignable to 'Future'.
//   int f_async() async { return 42; }
//       ^^^^^^^
//
// pkg/front_end/testcases/regress/issue_37681.dart:9:7: Error: Functions marked 'async*' must have a return type assignable to 'Stream'.
//   int f_async_star() async* { yield 42; }
//       ^^^^^^^^^^^^
//
// pkg/front_end/testcases/regress/issue_37681.dart:14:7: Error: Functions marked 'sync*' must have a return type assignable to 'Iterable'.
//   int f_sync_star() sync* { yield 42; }
//       ^^^^^^^^^^^
//
import self as self;
import "dart:async" as asy;
import "dart:core" as core;
import "dart:_internal" as _in;

static method main() → 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;
  dynamic :saved_try_context_var1;
  dynamic :exception0;
  dynamic :stack_trace0;
  function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding 
    try {
      #L1:
      {
        function f_async() → core::int* /* 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, dynamic :exception, dynamic :stack_trace]) → dynamic yielding 
            try {
              #L2:
              {
                :return_value = 42;
                break #L2;
              }
              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(){() →* dynamic};
          :is_sync = true;
          return :async_future;
        }
        [yield] let dynamic #t1 = asy::_awaitHelper(f_async(){() →* core::int*}, :async_op_then, :async_op_error, :async_op) in null;
        core::print(_in::unsafeCast<core::int*>(:result));
        function f_async_star() → core::int* /* 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;
          dynamic :saved_try_context_var0;
          dynamic :saved_try_context_var1;
          function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding 
            try
              try {
                #L3:
                {
                  if(:controller.{asy::_AsyncStarStreamController::add}(42){(dynamic) → 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::•<dynamic>(:async_op);
          :controller_stream = :controller.{asy::_AsyncStarStreamController::stream}{asy::Stream<dynamic>};
          return :controller_stream;
        }
        {
          asy::Stream<dynamic>* :stream = (f_async_star(){() →* core::int*} as dynamic) as{TypeError,ForDynamic} asy::Stream<dynamic>*;
          asy::_StreamIterator<dynamic>* :for-iterator = new asy::_StreamIterator::•<dynamic>(:stream);
          try
            #L4:
            while (true) {
              dynamic #t2 = asy::_asyncStarMoveNextHelper(:stream);
              [yield] let dynamic #t3 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::moveNext}(){() → asy::Future<core::bool>}, :async_op_then, :async_op_error, :async_op) in null;
              if(_in::unsafeCast<core::bool>(:result)) {
                dynamic x = :for-iterator.{asy::_StreamIterator::current}{dynamic};
                {
                  core::print(x);
                }
              }
              else
                break #L4;
            }
          finally
            if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<dynamic>?} == null)) {
              [yield] let dynamic #t4 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
              :result;
            }
        }
        function f_sync_star() → core::int* /* originally sync* */ {
          function :sync_op_gen() → (core::_SyncIterator<dynamic>*, dynamic, dynamic) →* core::bool* {
            core::int* :await_jump_var = 0;
            dynamic :await_ctx_var;
            function :sync_op(core::_SyncIterator<dynamic>* :iterator, dynamic :exception, dynamic :stack_trace) → core::bool* yielding {
              {
                {
                  :iterator.{core::_SyncIterator::_current} = 42;
                  [yield] true;
                }
              }
              return false;
            }
            return :sync_op;
          }
          return new core::_SyncIterable::•<dynamic>(:sync_op_gen);
        }
        {
          core::Iterator<dynamic>* :sync-for-iterator = ((f_sync_star(){() →* core::int*} as dynamic) as{TypeError,ForDynamic} core::Iterable<dynamic>*).{core::Iterable::iterator}{core::Iterator<dynamic>*};
          for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
            dynamic x = :sync-for-iterator.{core::Iterator::current}{dynamic};
            {
              core::print(x);
            }
          }
        }
      }
      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(){() →* dynamic};
  :is_sync = true;
  return :async_future;
}