| library /*isNonNullableByDefault*/; |
| import self as self; |
| import "dart:core" as core; |
| import "dart:async" as asy; |
| import "dart:_internal" as _in; |
| |
| import "dart:async"; |
| |
| 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 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 { |
| #L1: |
| { |
| 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; |
| } |
| static method callFutureOrInt() → 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 FutureOr<core::int>#t1 = self::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 #L2; |
| } |
| 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 #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 throwInt() → core::int { |
| throw "int"; |
| } |
| static method callInt() → 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 core::int #t5 = self::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 #L3; |
| } |
| 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 #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 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 { |
| #L4: |
| { |
| 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; |
| } |
| static method callFutureInt() → 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 { |
| #L5: |
| { |
| try { |
| final asy::Future<core::int> #t9 = self::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 #L5; |
| } |
| 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 #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 throwDynamic() → dynamic { |
| throw "dynamic"; |
| } |
| static method callDynamic() → 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 { |
| #L6: |
| { |
| try { |
| final FutureOr<core::int>#t13 = self::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 #L6; |
| } |
| 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 #L6; |
| } |
| } |
| 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 throwFutureNum() → 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 { |
| #L7: |
| { |
| 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; |
| } |
| static method callFutureNum() → 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 { |
| #L8: |
| { |
| try { |
| final asy::Future<core::int> #t17 = self::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::int>(:result); |
| } |
| else { |
| :async_temporary_0 = #t17; |
| } |
| :return_value = :async_temporary_0; |
| break #L8; |
| } |
| 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 #L8; |
| } |
| } |
| 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 { |
| #L9: |
| { |
| [yield] let dynamic #t21 = asy::_awaitHelper(self::callFutureOrInt(), :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(), :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(), :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(), :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(), :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; |
| } |