library /*isNonNullableByDefault*/;
//
// Problems in library:
//
// pkg/front_end/testcases/general/stream_future.dart:18:9: Error: A value of type 'Future<dynamic>' can't be assigned to a variable of type 'FutureOr<Class>'.
//  - 'Future' is from 'dart:async'.
//  - 'Class' is from 'pkg/front_end/testcases/general/stream_future.dart'.
//   yield returnFutureDynamic();
//         ^
//
import self as self;
import "dart:core" as core;
import "dart:async" as asy;
import "dart:_internal" as _in;

import "dart:async";

class Class extends core::Object {
  synthetic constructor •() → self::Class
    : super core::Object::•()
    ;
}
static method returnDynamic() → dynamic
  return new self::Class::•();
static method returnClass() → self::Class
  return new self::Class::•();
static method returnFutureDynamic() → asy::Future<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:
      {
        :return_value = new self::Class::•();
        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 returnFutureClass() → asy::Future<self::Class> /* futureValueType= self::Class */ /* originally async */ {
  final asy::_Future<self::Class> :async_future = new asy::_Future::•<self::Class>();
  core::bool* :is_sync = false;
  self::Class? :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 = new self::Class::•();
        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(null, null){() → dynamic};
  :is_sync = true;
  return :async_future;
}
static method error() → asy::Stream<FutureOr<self::Class>> /* originally async* */ {
  asy::_AsyncStarStreamController<FutureOr<self::Class>>? :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}(invalid-expression "pkg/front_end/testcases/general/stream_future.dart:18:9: Error: A value of type 'Future<dynamic>' can't be assigned to a variable of type 'FutureOr<Class>'.
 - 'Future' is from 'dart:async'.
 - 'Class' is from 'pkg/front_end/testcases/general/stream_future.dart'.
  yield returnFutureDynamic();
        ^" in self::returnFutureDynamic() as{TypeError,ForNonNullableByDefault} FutureOr<self::Class>){(FutureOr<self::Class>) → 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::•<FutureOr<self::Class>>(:async_op);
  :controller_stream = :controller.{asy::_AsyncStarStreamController::stream}{asy::Stream<FutureOr<self::Class>>};
  return :controller_stream;
}
static method stream() → asy::Stream<FutureOr<self::Class>> /* originally async* */ {
  asy::_AsyncStarStreamController<FutureOr<self::Class>>? :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}(self::returnDynamic() as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<self::Class>){(FutureOr<self::Class>) → core::bool})
            return null;
          else
            [yield] null;
          if(:controller.{asy::_AsyncStarStreamController::add}(self::returnClass()){(FutureOr<self::Class>) → core::bool})
            return null;
          else
            [yield] null;
          if(:controller.{asy::_AsyncStarStreamController::add}(self::returnFutureClass()){(FutureOr<self::Class>) → 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::•<FutureOr<self::Class>>(:async_op);
  :controller_stream = :controller.{asy::_AsyncStarStreamController::stream}{asy::Stream<FutureOr<self::Class>>};
  return :controller_stream;
}
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;
  dynamic :saved_try_context_var1;
  dynamic :exception0;
  dynamic :stack_trace0;
  function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding 
    try {
      #L5:
      {
        {
          asy::Stream<FutureOr<self::Class>> :stream = self::stream();
          asy::_StreamIterator<FutureOr<self::Class>>? :for-iterator = new asy::_StreamIterator::•<FutureOr<self::Class>>(:stream);
          try
            #L6:
            while (true) {
              dynamic #t1 = asy::_asyncStarMoveNextHelper(:stream);
              [yield] let dynamic #t2 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::moveNext}(){() → asy::Future<core::bool>}, :async_op_then, :async_op_error) in null;
              if(_in::unsafeCast<core::bool>(:result_or_exception)) {
                FutureOr<self::Class>cls = :for-iterator.{asy::_StreamIterator::current}{FutureOr<self::Class>};
                {
                  core::print(cls);
                }
              }
              else
                break #L6;
            }
          finally
            if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<FutureOr<self::Class>>?} == null)) {
              [yield] let dynamic #t3 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
              :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;
}