pkg/front_end/testcases/nnbd_mixed/return_from_async.dart.weak.transformed.expect

library /*isNonNullableByDefault*/;
import self as self;
import "dart:core" as core;
import "dart:async" as asy;
import "dart:_internal" as _in;
import "return_from_async_lib.dart" as ret;

import "dart:async";
import "org-dartlang-testcase:///return_from_async_lib.dart";

abstract class Class extends core::Object {
  synthetic constructor •() → self::Class
    : super core::Object::•()
    ;
  abstract method throwFutureOrInt() → FutureOr<core::int>;
  abstract method throwInt() → core::int;
  abstract method throwFutureInt() → asy::Future<core::int>;
  abstract method throwDynamic() → dynamic;
  abstract method throwFutureNum() → asy::Future<core::num>;
}
static field core::bool caughtFutureOrInt = false;
static field core::bool caughtInt = false;
static field core::bool caughtFutureInt = false;
static field core::bool caughtDynamic = false;
static field core::bool caughtFutureNum = false;
static method callFutureOrInt(self::Class c) → asy::Future<core::int> /* originally async */ {
  final asy::_Future<core::int> :async_future = new asy::_Future::•<core::int>();
  core::bool* :is_sync = false;
  FutureOr<core::int>? :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;
  FutureOr<core::int>:async_temporary_0;
  FutureOr<core::int>:async_temporary_1;
  FutureOr<core::int>:async_temporary_2;
  function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding 
    try {
      #L1:
      {
        try {
          final FutureOr<core::int>#t1 = c.{self::Class::throwFutureOrInt}();
          if(#t1 is asy::Future<core::int>) {
            [yield] let dynamic #t2 = asy::_awaitHelper(#t1, :async_op_then, :async_op_error, :async_op) in null;
            :async_temporary_0 = _in::unsafeCast<core::int>(:result);
          }
          else {
            :async_temporary_0 = #t1;
          }
          :return_value = :async_temporary_0;
          break #L1;
        }
        on core::Object catch(final core::Object e) {
          core::print("Caught \"${e}\"");
          self::caughtFutureOrInt = true;
          final core::int #t3 = 0;
          if(#t3 is asy::Future<core::int>) {
            [yield] let dynamic #t4 = asy::_awaitHelper(#t3, :async_op_then, :async_op_error, :async_op) in null;
            :async_temporary_2 = _in::unsafeCast<core::int>(:result);
          }
          else {
            :async_temporary_2 = #t3;
          }
          :return_value = :async_temporary_2;
          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 callInt(self::Class c) → asy::Future<core::int> /* originally async */ {
  final asy::_Future<core::int> :async_future = new asy::_Future::•<core::int>();
  core::bool* :is_sync = false;
  FutureOr<core::int>? :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;
  FutureOr<core::int>:async_temporary_0;
  FutureOr<core::int>:async_temporary_1;
  FutureOr<core::int>:async_temporary_2;
  function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding 
    try {
      #L2:
      {
        try {
          final core::int #t5 = c.{self::Class::throwInt}();
          if(#t5 is asy::Future<core::int>) {
            [yield] let dynamic #t6 = asy::_awaitHelper(#t5, :async_op_then, :async_op_error, :async_op) in null;
            :async_temporary_0 = _in::unsafeCast<core::int>(:result);
          }
          else {
            :async_temporary_0 = #t5;
          }
          :return_value = :async_temporary_0;
          break #L2;
        }
        on core::Object catch(final core::Object e) {
          core::print("Caught \"${e}\"");
          self::caughtInt = true;
          final core::int #t7 = 0;
          if(#t7 is asy::Future<core::int>) {
            [yield] let dynamic #t8 = asy::_awaitHelper(#t7, :async_op_then, :async_op_error, :async_op) in null;
            :async_temporary_2 = _in::unsafeCast<core::int>(:result);
          }
          else {
            :async_temporary_2 = #t7;
          }
          :return_value = :async_temporary_2;
          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 callFutureInt(self::Class c) → asy::Future<core::int> /* originally async */ {
  final asy::_Future<core::int> :async_future = new asy::_Future::•<core::int>();
  core::bool* :is_sync = false;
  FutureOr<core::int>? :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;
  FutureOr<core::int>:async_temporary_0;
  FutureOr<core::int>:async_temporary_1;
  FutureOr<core::int>:async_temporary_2;
  function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding 
    try {
      #L3:
      {
        try {
          final asy::Future<core::int> #t9 = c.{self::Class::throwFutureInt}();
          if(#t9 is asy::Future<core::int>) {
            [yield] let dynamic #t10 = asy::_awaitHelper(#t9, :async_op_then, :async_op_error, :async_op) in null;
            :async_temporary_0 = _in::unsafeCast<core::int>(:result);
          }
          else {
            :async_temporary_0 = #t9;
          }
          :return_value = :async_temporary_0;
          break #L3;
        }
        on core::Object catch(final core::Object e) {
          core::print("Caught \"${e}\"");
          self::caughtFutureInt = true;
          final core::int #t11 = 0;
          if(#t11 is asy::Future<core::int>) {
            [yield] let dynamic #t12 = asy::_awaitHelper(#t11, :async_op_then, :async_op_error, :async_op) in null;
            :async_temporary_2 = _in::unsafeCast<core::int>(:result);
          }
          else {
            :async_temporary_2 = #t11;
          }
          :return_value = :async_temporary_2;
          break #L3;
        }
      }
      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 callDynamic(self::Class c) → asy::Future<core::int> /* originally async */ {
  final asy::_Future<core::int> :async_future = new asy::_Future::•<core::int>();
  core::bool* :is_sync = false;
  FutureOr<core::int>? :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;
  FutureOr<core::int>:async_temporary_0;
  FutureOr<core::int>:async_temporary_1;
  FutureOr<core::int>:async_temporary_2;
  function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding 
    try {
      #L4:
      {
        try {
          final FutureOr<core::int>#t13 = c.{self::Class::throwDynamic}() as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<core::int>;
          if(#t13 is asy::Future<core::int>) {
            [yield] let dynamic #t14 = asy::_awaitHelper(#t13, :async_op_then, :async_op_error, :async_op) in null;
            :async_temporary_0 = _in::unsafeCast<core::int>(:result);
          }
          else {
            :async_temporary_0 = #t13;
          }
          :return_value = :async_temporary_0;
          break #L4;
        }
        on core::Object catch(final core::Object e) {
          core::print("Caught \"${e}\"");
          self::caughtDynamic = true;
          final core::int #t15 = 0;
          if(#t15 is asy::Future<core::int>) {
            [yield] let dynamic #t16 = asy::_awaitHelper(#t15, :async_op_then, :async_op_error, :async_op) in null;
            :async_temporary_2 = _in::unsafeCast<core::int>(:result);
          }
          else {
            :async_temporary_2 = #t15;
          }
          :return_value = :async_temporary_2;
          break #L4;
        }
      }
      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 callFutureNum(self::Class c) → asy::Future<core::num> /* originally async */ {
  final asy::_Future<core::num> :async_future = new asy::_Future::•<core::num>();
  core::bool* :is_sync = false;
  FutureOr<core::num>? :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;
  FutureOr<core::num>:async_temporary_0;
  FutureOr<core::num>:async_temporary_1;
  FutureOr<core::num>:async_temporary_2;
  function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding 
    try {
      #L5:
      {
        try {
          final asy::Future<core::num> #t17 = c.{self::Class::throwFutureNum}();
          if(#t17 is asy::Future<core::num>) {
            [yield] let dynamic #t18 = asy::_awaitHelper(#t17, :async_op_then, :async_op_error, :async_op) in null;
            :async_temporary_0 = _in::unsafeCast<core::num>(:result);
          }
          else {
            :async_temporary_0 = #t17;
          }
          :return_value = :async_temporary_0;
          break #L5;
        }
        on core::Object catch(final core::Object e) {
          core::print("Caught \"${e}\"");
          self::caughtFutureNum = true;
          final core::int #t19 = 0;
          if(#t19 is asy::Future<core::num>) {
            [yield] let dynamic #t20 = asy::_awaitHelper(#t19, :async_op_then, :async_op_error, :async_op) in null;
            :async_temporary_2 = _in::unsafeCast<core::int>(:result);
          }
          else {
            :async_temporary_2 = #t19;
          }
          :return_value = :async_temporary_2;
          break #L5;
        }
      }
      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 main() → void /* 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;
  function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding 
    try {
      #L6:
      {
        self::Class c = new ret::Subclass::•();
        [yield] let dynamic #t21 = asy::_awaitHelper(self::callFutureOrInt(c), :async_op_then, :async_op_error, :async_op) in null;
        _in::unsafeCast<core::int>(:result);
        if(!self::caughtFutureOrInt)
          throw "Uncaught async return";
        [yield] let dynamic #t22 = asy::_awaitHelper(self::callInt(c), :async_op_then, :async_op_error, :async_op) in null;
        _in::unsafeCast<core::int>(:result);
        if(!self::caughtInt)
          throw "Uncaught async return";
        [yield] let dynamic #t23 = asy::_awaitHelper(self::callFutureInt(c), :async_op_then, :async_op_error, :async_op) in null;
        _in::unsafeCast<core::int>(:result);
        if(!self::caughtFutureInt)
          throw "Uncaught async return";
        [yield] let dynamic #t24 = asy::_awaitHelper(self::callDynamic(c), :async_op_then, :async_op_error, :async_op) in null;
        _in::unsafeCast<core::int>(:result);
        if(!self::caughtDynamic)
          throw "Uncaught async return";
        [yield] let dynamic #t25 = asy::_awaitHelper(self::callFutureNum(c), :async_op_then, :async_op_error, :async_op) in null;
        _in::unsafeCast<core::num>(:result);
        if(!self::caughtFutureNum)
          throw "Uncaught async return";
      }
      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;
}

library /*isNonNullableByDefault*/;
import self as ret;
import "dart:core" as core;
import "return_from_async.dart" as self;
import "dart:async" as asy;

import "dart:async";
import "org-dartlang-testcase:///return_from_async.dart";

class Subclass extends core::Object implements self::Class {
  synthetic constructor •() → ret::Subclass
    : super core::Object::•()
    ;
  method throwFutureOrInt() → FutureOr<core::int> /* originally async */ {
    final asy::_Future<core::int> :async_future = new asy::_Future::•<core::int>();
    core::bool* :is_sync = false;
    FutureOr<core::int>? :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 {
        #L7:
        {
          throw "FutureOr<int>";
        }
        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;
  }
  method throwInt() → core::int {
    throw "int";
  }
  method throwFutureInt() → asy::Future<core::int> /* originally async */ {
    final asy::_Future<core::int> :async_future = new asy::_Future::•<core::int>();
    core::bool* :is_sync = false;
    FutureOr<core::int>? :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 {
        #L8:
        {
          throw "Future<int>";
        }
        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;
  }
  method throwDynamic() → dynamic {
    throw "dynamic";
  }
  method throwFutureNum() → asy::Future<core::num> /* originally async */ {
    final asy::_Future<core::num> :async_future = new asy::_Future::•<core::num>();
    core::bool* :is_sync = false;
    FutureOr<core::num>? :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 {
        #L9:
        {
          throw "Future<num>";
        }
        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;
  }
}