sdk/pkg/front_end/testcases/general/stream_future.dart.weak.transformed.expect

library;
//
// 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::•()
    ;
  abstract member-signature get _identityHashCode() → core::int*; -> core::Object::_identityHashCode
  abstract member-signature method _instanceOf(dynamic instantiatorTypeArguments, dynamic functionTypeArguments, dynamic type) → core::bool*; -> core::Object::_instanceOf
  abstract member-signature method _simpleInstanceOf(dynamic type) → core::bool*; -> core::Object::_simpleInstanceOf
  abstract member-signature method _simpleInstanceOfTrue(dynamic type) → core::bool*; -> core::Object::_simpleInstanceOfTrue
  abstract member-signature method _simpleInstanceOfFalse(dynamic type) → core::bool*; -> core::Object::_simpleInstanceOfFalse
  abstract member-signature operator ==(dynamic other) → core::bool*; -> core::Object::==
  abstract member-signature get hashCode() → core::int*; -> core::Object::hashCode
  abstract member-signature method toString() → core::String*; -> core::Object::toString
  abstract member-signature method noSuchMethod(core::Invocation* invocation) → dynamic; -> core::Object::noSuchMethod
  abstract member-signature get runtimeType() → core::Type*; -> core::Object::runtimeType
}
static method returnDynamic() → dynamic
  return new self::Class::•();
static method returnClass() → self::Class*
  return new self::Class::•();
static method returnFutureDynamic() → asy::Future<dynamic>* /* originally async */ {
  final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
  core::bool* :is_sync = false;
  FutureOr<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 {
      #L1:
      {
        :return_value = new self::Class::•();
        break #L1;
      }
      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.call();
  :is_sync = true;
  return :async_future;
}
static method returnFutureClass() → asy::Future<self::Class*>* /* originally async */ {
  final asy::_Future<self::Class*>* :async_future = new asy::_Future::•<self::Class*>();
  core::bool* :is_sync = false;
  FutureOr<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, dynamic :exception, dynamic :stack_trace]) → dynamic yielding 
    try {
      #L2:
      {
        :return_value = new self::Class::•();
        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.call();
  :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, dynamic :exception, dynamic :stack_trace]) → dynamic yielding 
    try
      try {
        #L3:
        {
          if(:controller.{asy::_AsyncStarStreamController::add}(let final Never* #t1 = 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} FutureOr<self::Class*>*))
            return null;
          else
            [yield] null;
        }
        return;
      }
      on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
        :controller.{asy::_AsyncStarStreamController::addError}(exception, stack_trace);
      }
    finally {
      :controller.{asy::_AsyncStarStreamController::close}();
    }
  :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};
  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, dynamic :exception, dynamic :stack_trace]) → dynamic yielding 
    try
      try {
        #L4:
        {
          if(:controller.{asy::_AsyncStarStreamController::add}(self::returnDynamic() as{TypeError,ForDynamic} FutureOr<self::Class*>*))
            return null;
          else
            [yield] null;
          if(:controller.{asy::_AsyncStarStreamController::add}(self::returnClass()))
            return null;
          else
            [yield] null;
          if(:controller.{asy::_AsyncStarStreamController::add}(self::returnFutureClass()))
            return null;
          else
            [yield] null;
        }
        return;
      }
      on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
        :controller.{asy::_AsyncStarStreamController::addError}(exception, stack_trace);
      }
    finally {
      :controller.{asy::_AsyncStarStreamController::close}();
    }
  :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};
  return :controller_stream;
}
static method main() → dynamic /* originally async */ {
  final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
  core::bool* :is_sync = false;
  FutureOr<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 {
      #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 #t2 = asy::_asyncStarMoveNextHelper(:stream);
              [yield] let dynamic #t3 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::moveNext}(), :async_op_then, :async_op_error, :async_op) in null;
              if(_in::unsafeCast<core::bool>(:result)) {
                FutureOr<self::Class*>* cls = :for-iterator.{asy::_StreamIterator::current};
                {
                  core::print(cls);
                }
              }
              else
                break #L6;
            }
          finally
            if(!:for-iterator.{asy::_StreamIterator::_subscription}.{core::Object::==}(null)) {
              [yield] let dynamic #t4 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(), :async_op_then, :async_op_error, :async_op) in null;
              :result;
            }
        }
      }
      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.call();
  :is_sync = true;
  return :async_future;
}