[vm] Make async lowering no longer use optional parameters
This CL
* Makes :async_op only have two parameters: We take advantage
of the fact that errors not only have exception != null but
also stacktrace != null.
* Makes :async_op have no optional parameters. This reduces
code size significantly.
* Removes unused parameter in _awaitHelper calls
* Wrap the then callback instead of the error callback. (needed
to make optional parameters required)
This results in 2% code savings on a big g3 app.
The size of :async_op shrinks on average by 11%
TEST=ci
Change-Id: I38d5fba4ebebc780b48dac5aa6a250d2c7952bfd
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/233362
Reviewed-by: Slava Egorov <vegorov@google.com>
Reviewed-by: Alexander Markov <alexmarkov@google.com>
Commit-Queue: Martin Kustermann <kustermann@google.com>
This commit is contained in:
Martin Kustermann
committed by
Commit Bot
Commit Bot
parent
7611d9167b
commit
f50b3a52e4
@@ -2588,7 +2588,7 @@ void _asyncStarMoveNextHelper(var stream) {}
|
||||
|
||||
_asyncThenWrapperHelper(continuation) {}
|
||||
|
||||
_awaitHelper(object, thenCallback, errorCallback, awaiter) {}
|
||||
_awaitHelper(object, thenCallback, errorCallback) {}
|
||||
|
||||
_completeOnAsyncReturn(_future, value, async_jump_var) {}
|
||||
|
||||
|
||||
@@ -33,7 +33,7 @@ static method Extension|asyncMethod(lowered final core::int* #this) → dynamic
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{}
|
||||
@@ -45,7 +45,7 @@ static method Extension|asyncMethod(lowered final core::int* #this) → dynamic
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -58,7 +58,7 @@ static method Extension|asyncStarMethod(lowered final core::int* #this) → dyna
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L2:
|
||||
|
||||
+5
-5
@@ -23,12 +23,12 @@ static method main() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(LoadLibrary(prefix), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(LoadLibrary(prefix), :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
self::expect(0, let final core::Object* #t2 = CheckLibraryIsLoaded(prefix) in def::Extension|staticField);
|
||||
self::expect(0, let final core::Object* #t3 = CheckLibraryIsLoaded(prefix) in def::Extension|get#property(0));
|
||||
self::expect(42, let final core::Object* #t4 = CheckLibraryIsLoaded(prefix) in let final core::int* #t5 = 0 in let final core::int* #t6 = 42 in let final void #t7 = def::Extension|set#property(#t5, #t6) in #t6);
|
||||
@@ -46,7 +46,7 @@ static method main() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -100,4 +100,4 @@ Extra constant evaluation status:
|
||||
Evaluated: VariableGet @ org-dartlang-testcase:///deferred_explicit_access.dart:12:31 -> IntConstant(0)
|
||||
Evaluated: VariableGet @ org-dartlang-testcase:///deferred_explicit_access.dart:12:45 -> IntConstant(42)
|
||||
Evaluated: VariableGet @ org-dartlang-testcase:///deferred_explicit_access.dart:12:45 -> IntConstant(42)
|
||||
Extra constant evaluation: evaluated: 92, effectively constant: 3
|
||||
Extra constant evaluation: evaluated: 91, effectively constant: 3
|
||||
|
||||
+4
-4
@@ -15,12 +15,12 @@ static method main() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(LoadLibrary(prefix), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(LoadLibrary(prefix), :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
self::expect(0, let final core::Object* #t2 = CheckLibraryIsLoaded(prefix) in def::topLevelField);
|
||||
self::expect(42, let final core::Object* #t3 = CheckLibraryIsLoaded(prefix) in def::topLevelField = 42);
|
||||
self::expect(42, let final core::Object* #t4 = CheckLibraryIsLoaded(prefix) in def::topLevelField);
|
||||
@@ -37,7 +37,7 @@ static method main() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -15,7 +15,7 @@ static method asyncString() → asy::Future<core::String*>* /* originally async
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -30,7 +30,7 @@ static method asyncString() → asy::Future<core::String*>* /* originally async
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -42,7 +42,7 @@ static method asyncString2() → asy::Future<core::String*>* /* originally async
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
@@ -57,7 +57,7 @@ static method asyncString2() → asy::Future<core::String*>* /* originally async
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -112,7 +112,7 @@ static method asyncStarString() → asy::Stream<core::String*>* /* originally as
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L3:
|
||||
@@ -125,8 +125,8 @@ static method asyncStarString() → asy::Stream<core::String*>* /* originally as
|
||||
return null;
|
||||
else
|
||||
[yield] null;
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(self::asyncString(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
if(:controller.{asy::_AsyncStarStreamController::add}(_in::unsafeCast<core::String*>(:result)){(core::String*) → core::bool})
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(self::asyncString(), :async_op_then, :async_op_error) in null;
|
||||
if(:controller.{asy::_AsyncStarStreamController::add}(_in::unsafeCast<core::String*>(:result_or_exception)){(core::String*) → core::bool})
|
||||
return null;
|
||||
else
|
||||
[yield] null;
|
||||
@@ -154,7 +154,7 @@ static method asyncStarString2() → asy::Stream<core::String*>* /* originally a
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L4:
|
||||
@@ -187,12 +187,12 @@ static method main() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L5:
|
||||
{
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(self::asyncString(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::String* str = _in::unsafeCast<core::String*>(:result);
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(self::asyncString(), :async_op_then, :async_op_error) in null;
|
||||
core::String* str = _in::unsafeCast<core::String*>(:result_or_exception);
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
@@ -202,7 +202,7 @@ static method main() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
+54
-54
@@ -15,30 +15,30 @@ static method main() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(self::returnsString(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<core::String>(:result);
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(self::returnsFutureOrString(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<core::String>(:result);
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(self::returnsAwaitFutureOrString(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<core::String>(:result);
|
||||
[yield] let dynamic #t4 = asy::_awaitHelper(self::returnsFutureString(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<core::String>(:result);
|
||||
[yield] let dynamic #t5 = asy::_awaitHelper(self::returnsAwaitFutureString(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<core::String>(:result);
|
||||
[yield] let dynamic #t6 = asy::_awaitHelper(self::returnsObject(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<core::Object>(:result);
|
||||
[yield] let dynamic #t7 = asy::_awaitHelper(self::returnsFutureOrObject(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<core::Object>(:result);
|
||||
[yield] let dynamic #t8 = asy::_awaitHelper(self::returnsAwaitFutureOrObject(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<core::Object>(:result);
|
||||
[yield] let dynamic #t9 = asy::_awaitHelper(self::returnsFutureObject(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<core::Object>(:result);
|
||||
[yield] let dynamic #t10 = asy::_awaitHelper(self::returnsAwaitFutureObject(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<core::Object>(:result);
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(self::returnsString(), :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<core::String>(:result_or_exception);
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(self::returnsFutureOrString(), :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<core::String>(:result_or_exception);
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(self::returnsAwaitFutureOrString(), :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<core::String>(:result_or_exception);
|
||||
[yield] let dynamic #t4 = asy::_awaitHelper(self::returnsFutureString(), :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<core::String>(:result_or_exception);
|
||||
[yield] let dynamic #t5 = asy::_awaitHelper(self::returnsAwaitFutureString(), :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<core::String>(:result_or_exception);
|
||||
[yield] let dynamic #t6 = asy::_awaitHelper(self::returnsObject(), :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<core::Object>(:result_or_exception);
|
||||
[yield] let dynamic #t7 = asy::_awaitHelper(self::returnsFutureOrObject(), :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<core::Object>(:result_or_exception);
|
||||
[yield] let dynamic #t8 = asy::_awaitHelper(self::returnsAwaitFutureOrObject(), :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<core::Object>(:result_or_exception);
|
||||
[yield] let dynamic #t9 = asy::_awaitHelper(self::returnsFutureObject(), :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<core::Object>(:result_or_exception);
|
||||
[yield] let dynamic #t10 = asy::_awaitHelper(self::returnsAwaitFutureObject(), :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<core::Object>(:result_or_exception);
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
@@ -48,7 +48,7 @@ static method main() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -60,7 +60,7 @@ static method returnsString() → asy::Future<core::String> /* originally async
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
@@ -75,7 +75,7 @@ static method returnsString() → asy::Future<core::String> /* originally async
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -87,7 +87,7 @@ static method returnsFutureOrString() → asy::Future<core::String> /* originall
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L3:
|
||||
{
|
||||
@@ -102,7 +102,7 @@ static method returnsFutureOrString() → asy::Future<core::String> /* originall
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -115,12 +115,12 @@ static method returnsAwaitFutureOrString() → asy::Future<core::String> /* orig
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L4:
|
||||
{
|
||||
[yield] let dynamic #t11 = asy::_awaitHelper(self::getFutureOr<core::String>("a"), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = _in::unsafeCast<core::String>(:result);
|
||||
[yield] let dynamic #t11 = asy::_awaitHelper(self::getFutureOr<core::String>("a"), :async_op_then, :async_op_error) in null;
|
||||
:return_value = _in::unsafeCast<core::String>(:result_or_exception);
|
||||
break #L4;
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -131,7 +131,7 @@ static method returnsAwaitFutureOrString() → asy::Future<core::String> /* orig
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -143,7 +143,7 @@ static method returnsFutureString() → asy::Future<core::String> /* originally
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L5:
|
||||
{
|
||||
@@ -158,7 +158,7 @@ static method returnsFutureString() → asy::Future<core::String> /* originally
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -171,12 +171,12 @@ static method returnsAwaitFutureString() → FutureOr<core::String> /* originall
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L6:
|
||||
{
|
||||
[yield] let dynamic #t12 = asy::_awaitHelper(self::getFuture<core::String>("a"), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = _in::unsafeCast<core::String>(:result);
|
||||
[yield] let dynamic #t12 = asy::_awaitHelper(self::getFuture<core::String>("a"), :async_op_then, :async_op_error) in null;
|
||||
:return_value = _in::unsafeCast<core::String>(:result_or_exception);
|
||||
break #L6;
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -187,7 +187,7 @@ static method returnsAwaitFutureString() → FutureOr<core::String> /* originall
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -199,7 +199,7 @@ static method returnsObject() → asy::Future<core::Object> /* originally async
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L7:
|
||||
{
|
||||
@@ -214,7 +214,7 @@ static method returnsObject() → asy::Future<core::Object> /* originally async
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -226,7 +226,7 @@ static method returnsFutureOrObject() → asy::Future<core::Object> /* originall
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L8:
|
||||
{
|
||||
@@ -241,7 +241,7 @@ static method returnsFutureOrObject() → asy::Future<core::Object> /* originall
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -254,12 +254,12 @@ static method returnsAwaitFutureOrObject() → asy::Future<core::Object> /* orig
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L9:
|
||||
{
|
||||
[yield] let dynamic #t13 = asy::_awaitHelper(self::getFutureOr<core::Object>(new core::Object::•()), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = _in::unsafeCast<core::Object>(:result);
|
||||
[yield] let dynamic #t13 = asy::_awaitHelper(self::getFutureOr<core::Object>(new core::Object::•()), :async_op_then, :async_op_error) in null;
|
||||
:return_value = _in::unsafeCast<core::Object>(:result_or_exception);
|
||||
break #L9;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -270,7 +270,7 @@ static method returnsAwaitFutureOrObject() → asy::Future<core::Object> /* orig
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -282,7 +282,7 @@ static method returnsFutureObject() → asy::Future<core::Object> /* originally
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L10:
|
||||
{
|
||||
@@ -297,7 +297,7 @@ static method returnsFutureObject() → asy::Future<core::Object> /* originally
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -310,12 +310,12 @@ static method returnsAwaitFutureObject() → FutureOr<core::Object> /* originall
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L11:
|
||||
{
|
||||
[yield] let dynamic #t14 = asy::_awaitHelper(self::getFuture<core::Object>(new core::Object::•()), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = _in::unsafeCast<core::Object>(:result);
|
||||
[yield] let dynamic #t14 = asy::_awaitHelper(self::getFuture<core::Object>(new core::Object::•()), :async_op_then, :async_op_error) in null;
|
||||
:return_value = _in::unsafeCast<core::Object>(:result_or_exception);
|
||||
break #L11;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -326,7 +326,7 @@ static method returnsAwaitFutureObject() → FutureOr<core::Object> /* originall
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -338,7 +338,7 @@ static method getFutureOr<T extends core::Object? = dynamic>(self::getFutureOr::
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L12:
|
||||
{
|
||||
@@ -353,7 +353,7 @@ static method getFutureOr<T extends core::Object? = dynamic>(self::getFutureOr::
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -365,7 +365,7 @@ static method getFuture<T extends core::Object? = dynamic>(self::getFuture::T% v
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L13:
|
||||
{
|
||||
@@ -380,7 +380,7 @@ static method getFuture<T extends core::Object? = dynamic>(self::getFuture::T% v
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
+2
-2
@@ -18,7 +18,7 @@ static method foo() → dynamic /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -32,7 +32,7 @@ static method foo() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -39,23 +39,23 @@ static method main() → void /* originally async */ {
|
||||
self::Node* :async_temporary_0;
|
||||
self::Node* :async_temporary_1;
|
||||
self::Node* :async_temporary_2;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
core::String* expected = "1 2 3 4 5 6 7 8 9 10";
|
||||
:async_temporary_2 = new self::Node::•("2", core::_GrowableList::•<self::Node*>(0));
|
||||
[yield] let dynamic #t4 = asy::_awaitHelper(asy::Future::value<self::Node*>(new self::Node::•("7", core::_GrowableList::•<self::Node*>(0))), :async_op_then, :async_op_error, :async_op) in null;
|
||||
[yield] let dynamic #t5 = asy::_awaitHelper(asy::Future::value<self::Node*>(new self::Node::•("6", core::_GrowableList::_literal1<self::Node*>(_in::unsafeCast<self::Node*>(:result)))), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:async_temporary_1 = _in::unsafeCast<self::Node*>(:result);
|
||||
[yield] let dynamic #t6 = asy::_awaitHelper(asy::Future::value<self::Node*>(new self::Node::•("8", core::_GrowableList::•<self::Node*>(0))), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:async_temporary_0 = _in::unsafeCast<self::Node*>(:result);
|
||||
[yield] let dynamic #t7 = asy::_awaitHelper(asy::Future::value<self::Node*>(new self::Node::•("9", core::_GrowableList::•<self::Node*>(0))), :async_op_then, :async_op_error, :async_op) in null;
|
||||
[yield] let dynamic #t8 = asy::_awaitHelper(asy::Future::value<self::Node*>(new self::Node::•("4", core::_GrowableList::_literal1<self::Node*>(new self::Node::•("5", core::_GrowableList::_literal3<self::Node*>(_in::unsafeCast<self::Node*>(:async_temporary_1), _in::unsafeCast<self::Node*>(:async_temporary_0), _in::unsafeCast<self::Node*>(:result)))))), :async_op_then, :async_op_error, :async_op) in null;
|
||||
[yield] let dynamic #t9 = asy::_awaitHelper(asy::Future::value<self::Node*>(new self::Node::•("3", core::_GrowableList::_literal1<self::Node*>(_in::unsafeCast<self::Node*>(:result)))), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:async_temporary_0 = _in::unsafeCast<self::Node*>(:result);
|
||||
[yield] let dynamic #t10 = asy::_awaitHelper(asy::Future::value<self::Node*>(new self::Node::•("10", core::_GrowableList::•<self::Node*>(0))), :async_op_then, :async_op_error, :async_op) in null;
|
||||
self::Node* node = new self::Node::•("1", core::_GrowableList::_literal3<self::Node*>(_in::unsafeCast<self::Node*>(:async_temporary_2), _in::unsafeCast<self::Node*>(:async_temporary_0), _in::unsafeCast<self::Node*>(:result)));
|
||||
[yield] let dynamic #t4 = asy::_awaitHelper(asy::Future::value<self::Node*>(new self::Node::•("7", core::_GrowableList::•<self::Node*>(0))), :async_op_then, :async_op_error) in null;
|
||||
[yield] let dynamic #t5 = asy::_awaitHelper(asy::Future::value<self::Node*>(new self::Node::•("6", core::_GrowableList::_literal1<self::Node*>(_in::unsafeCast<self::Node*>(:result_or_exception)))), :async_op_then, :async_op_error) in null;
|
||||
:async_temporary_1 = _in::unsafeCast<self::Node*>(:result_or_exception);
|
||||
[yield] let dynamic #t6 = asy::_awaitHelper(asy::Future::value<self::Node*>(new self::Node::•("8", core::_GrowableList::•<self::Node*>(0))), :async_op_then, :async_op_error) in null;
|
||||
:async_temporary_0 = _in::unsafeCast<self::Node*>(:result_or_exception);
|
||||
[yield] let dynamic #t7 = asy::_awaitHelper(asy::Future::value<self::Node*>(new self::Node::•("9", core::_GrowableList::•<self::Node*>(0))), :async_op_then, :async_op_error) in null;
|
||||
[yield] let dynamic #t8 = asy::_awaitHelper(asy::Future::value<self::Node*>(new self::Node::•("4", core::_GrowableList::_literal1<self::Node*>(new self::Node::•("5", core::_GrowableList::_literal3<self::Node*>(_in::unsafeCast<self::Node*>(:async_temporary_1), _in::unsafeCast<self::Node*>(:async_temporary_0), _in::unsafeCast<self::Node*>(:result_or_exception)))))), :async_op_then, :async_op_error) in null;
|
||||
[yield] let dynamic #t9 = asy::_awaitHelper(asy::Future::value<self::Node*>(new self::Node::•("3", core::_GrowableList::_literal1<self::Node*>(_in::unsafeCast<self::Node*>(:result_or_exception)))), :async_op_then, :async_op_error) in null;
|
||||
:async_temporary_0 = _in::unsafeCast<self::Node*>(:result_or_exception);
|
||||
[yield] let dynamic #t10 = asy::_awaitHelper(asy::Future::value<self::Node*>(new self::Node::•("10", core::_GrowableList::•<self::Node*>(0))), :async_op_then, :async_op_error) in null;
|
||||
self::Node* node = new self::Node::•("1", core::_GrowableList::_literal3<self::Node*>(_in::unsafeCast<self::Node*>(:async_temporary_2), _in::unsafeCast<self::Node*>(:async_temporary_0), _in::unsafeCast<self::Node*>(:result_or_exception)));
|
||||
core::String* actual = node.{self::Node::toSimpleString}(){() →* dynamic} as{TypeError,ForDynamic} core::String*;
|
||||
core::print(actual);
|
||||
if(!(actual =={core::String::==}{(core::Object*) →* core::bool*} expected)) {
|
||||
@@ -70,7 +70,7 @@ static method main() → void /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -13,12 +13,12 @@ static method main() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper("Hello, World!", :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::print(_in::unsafeCast<core::String*>(:result));
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper("Hello, World!", :async_op_then, :async_op_error) in null;
|
||||
core::print(_in::unsafeCast<core::String*>(:result_or_exception));
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
@@ -28,7 +28,7 @@ static method main() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -71,33 +71,33 @@ static method staticMembers() → dynamic /* originally async */ {
|
||||
core::int* :async_temporary_3;
|
||||
core::int* :async_temporary_4;
|
||||
core::int* :async_temporary_5;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
:async_temporary_0 = self::C::staticField;
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::num* a = _in::unsafeCast<core::int*>(:async_temporary_0).{core::num::+}(:result as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null;
|
||||
core::num* a = _in::unsafeCast<core::int*>(:async_temporary_0).{core::num::+}(:result_or_exception as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
self::expect(2, a);
|
||||
:async_temporary_1 = self::C::staticField = 1;
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::num* f = _in::unsafeCast<core::int*>(:async_temporary_1).{core::num::+}(:result as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null;
|
||||
core::num* f = _in::unsafeCast<core::int*>(:async_temporary_1).{core::num::+}(:result_or_exception as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
self::expect(2, f);
|
||||
:async_temporary_2 = self::C::staticGetter;
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::num* b = _in::unsafeCast<core::int*>(:async_temporary_2).{core::num::+}(:result as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null;
|
||||
core::num* b = _in::unsafeCast<core::int*>(:async_temporary_2).{core::num::+}(:result_or_exception as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
self::expect(2, b);
|
||||
:async_temporary_3 = self::C::staticSetter = 1;
|
||||
[yield] let dynamic #t4 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::num* c = _in::unsafeCast<core::int*>(:async_temporary_3).{core::num::+}(:result as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
[yield] let dynamic #t4 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null;
|
||||
core::num* c = _in::unsafeCast<core::int*>(:async_temporary_3).{core::num::+}(:result_or_exception as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
self::expect(2, c);
|
||||
:async_temporary_4 = self::C::staticFoo(2);
|
||||
[yield] let dynamic #t5 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::num* d = _in::unsafeCast<core::int*>(:async_temporary_4).{core::num::+}(:result as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
[yield] let dynamic #t5 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null;
|
||||
core::num* d = _in::unsafeCast<core::int*>(:async_temporary_4).{core::num::+}(:result_or_exception as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
self::expect(3, d);
|
||||
:async_temporary_5 = self::C::staticField.{core::num::+}(self::C::staticGetter){(core::num*) →* core::int*}.{core::num::+}(self::C::staticSetter = 1){(core::num*) →* core::int*}.{core::num::+}(self::C::staticFoo(1)){(core::num*) →* core::int*};
|
||||
[yield] let dynamic #t6 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::num* e = _in::unsafeCast<core::int*>(:async_temporary_5).{core::num::+}(:result as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
[yield] let dynamic #t6 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null;
|
||||
core::num* e = _in::unsafeCast<core::int*>(:async_temporary_5).{core::num::+}(:result_or_exception as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
self::expect(5, e);
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -108,7 +108,7 @@ static method staticMembers() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -126,29 +126,29 @@ static method topLevelMembers() → dynamic /* originally async */ {
|
||||
core::int* :async_temporary_2;
|
||||
core::int* :async_temporary_3;
|
||||
core::int* :async_temporary_4;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
:async_temporary_0 = self::globalVariable;
|
||||
[yield] let dynamic #t7 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::num* a = _in::unsafeCast<core::int*>(:async_temporary_0).{core::num::+}(:result as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
[yield] let dynamic #t7 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null;
|
||||
core::num* a = _in::unsafeCast<core::int*>(:async_temporary_0).{core::num::+}(:result_or_exception as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
self::expect(2, a);
|
||||
:async_temporary_1 = self::topLevelGetter;
|
||||
[yield] let dynamic #t8 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::num* b = _in::unsafeCast<core::int*>(:async_temporary_1).{core::num::+}(:result as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
[yield] let dynamic #t8 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null;
|
||||
core::num* b = _in::unsafeCast<core::int*>(:async_temporary_1).{core::num::+}(:result_or_exception as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
self::expect(2, b);
|
||||
:async_temporary_2 = self::topLevelSetter = 1;
|
||||
[yield] let dynamic #t9 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::num* c = _in::unsafeCast<core::int*>(:async_temporary_2).{core::num::+}(:result as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
[yield] let dynamic #t9 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null;
|
||||
core::num* c = _in::unsafeCast<core::int*>(:async_temporary_2).{core::num::+}(:result_or_exception as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
self::expect(2, c);
|
||||
:async_temporary_3 = self::topLevelFoo(1);
|
||||
[yield] let dynamic #t10 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::num* d = _in::unsafeCast<core::int*>(:async_temporary_3).{core::num::+}(:result as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
[yield] let dynamic #t10 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null;
|
||||
core::num* d = _in::unsafeCast<core::int*>(:async_temporary_3).{core::num::+}(:result_or_exception as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
self::expect(2, d);
|
||||
:async_temporary_4 = self::globalVariable.{core::num::+}(self::topLevelGetter){(core::num*) →* core::int*}.{core::num::+}(self::topLevelSetter = 1){(core::num*) →* core::int*}.{core::num::+}(self::topLevelFoo(1)){(core::num*) →* core::int*};
|
||||
[yield] let dynamic #t11 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::num* e = _in::unsafeCast<core::int*>(:async_temporary_4).{core::num::+}(:result as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
[yield] let dynamic #t11 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null;
|
||||
core::num* e = _in::unsafeCast<core::int*>(:async_temporary_4).{core::num::+}(:result_or_exception as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
self::expect(5, e);
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -159,7 +159,7 @@ static method topLevelMembers() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -177,30 +177,30 @@ static method instanceMembers() → dynamic /* originally async */ {
|
||||
core::int* :async_temporary_2;
|
||||
core::int* :async_temporary_3;
|
||||
core::int* :async_temporary_4;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L3:
|
||||
{
|
||||
self::C* inst = new self::C::•();
|
||||
:async_temporary_0 = inst.{self::C::field}{core::int*};
|
||||
[yield] let dynamic #t12 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::num* a = _in::unsafeCast<core::int*>(:async_temporary_0).{core::num::+}(:result as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
[yield] let dynamic #t12 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null;
|
||||
core::num* a = _in::unsafeCast<core::int*>(:async_temporary_0).{core::num::+}(:result_or_exception as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
self::expect(2, a);
|
||||
:async_temporary_1 = inst.{self::C::getter}{core::int*};
|
||||
[yield] let dynamic #t13 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::num* b = _in::unsafeCast<core::int*>(:async_temporary_1).{core::num::+}(:result as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
[yield] let dynamic #t13 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null;
|
||||
core::num* b = _in::unsafeCast<core::int*>(:async_temporary_1).{core::num::+}(:result_or_exception as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
self::expect(2, b);
|
||||
:async_temporary_2 = inst.{self::C::setter} = 1;
|
||||
[yield] let dynamic #t14 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::num* c = _in::unsafeCast<core::int*>(:async_temporary_2).{core::num::+}(:result as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
[yield] let dynamic #t14 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null;
|
||||
core::num* c = _in::unsafeCast<core::int*>(:async_temporary_2).{core::num::+}(:result_or_exception as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
self::expect(2, c);
|
||||
:async_temporary_3 = inst.{self::C::foo}(1){(core::int*) →* core::int*};
|
||||
[yield] let dynamic #t15 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::num* d = _in::unsafeCast<core::int*>(:async_temporary_3).{core::num::+}(:result as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
[yield] let dynamic #t15 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null;
|
||||
core::num* d = _in::unsafeCast<core::int*>(:async_temporary_3).{core::num::+}(:result_or_exception as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
self::expect(2, d);
|
||||
:async_temporary_4 = inst.{self::C::field}{core::int*}.{core::num::+}(inst.{self::C::getter}{core::int*}){(core::num*) →* core::int*}.{core::num::+}(inst.{self::C::setter} = 1){(core::num*) →* core::int*}.{core::num::+}(inst.{self::C::foo}(1){(core::int*) →* core::int*}){(core::num*) →* core::int*};
|
||||
[yield] let dynamic #t16 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::num* e = _in::unsafeCast<core::int*>(:async_temporary_4).{core::num::+}(:result as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
[yield] let dynamic #t16 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null;
|
||||
core::num* e = _in::unsafeCast<core::int*>(:async_temporary_4).{core::num::+}(:result_or_exception as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
self::expect(5, e);
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -211,7 +211,7 @@ static method instanceMembers() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -229,30 +229,30 @@ static method others() → dynamic /* originally async */ {
|
||||
core::int* :async_temporary_2;
|
||||
core::List<core::int*>* :async_temporary_3;
|
||||
core::int* :async_temporary_4;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L4:
|
||||
{
|
||||
:async_temporary_0 = self::globalVariable;
|
||||
[yield] let dynamic #t17 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:async_temporary_0 = "${_in::unsafeCast<core::int*>(:async_temporary_0)} ${:result} ";
|
||||
[yield] let dynamic #t18 = asy::_awaitHelper("someString", :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::String* a = _in::unsafeCast<core::String*>(:async_temporary_0).{core::String::+}(_in::unsafeCast<core::String*>(:result)){(core::String*) →* core::String*};
|
||||
[yield] let dynamic #t17 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null;
|
||||
:async_temporary_0 = "${_in::unsafeCast<core::int*>(:async_temporary_0)} ${:result_or_exception} ";
|
||||
[yield] let dynamic #t18 = asy::_awaitHelper("someString", :async_op_then, :async_op_error) in null;
|
||||
core::String* a = _in::unsafeCast<core::String*>(:async_temporary_0).{core::String::+}(_in::unsafeCast<core::String*>(:result_or_exception)){(core::String*) →* core::String*};
|
||||
self::expect("1 1 someString", a);
|
||||
self::C* c = new self::C::•();
|
||||
:async_temporary_1 = c.{self::C::field}{core::int*};
|
||||
[yield] let dynamic #t19 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::num* d = _in::unsafeCast<core::int*>(:async_temporary_1).{core::num::+}(:result as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
[yield] let dynamic #t19 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null;
|
||||
core::num* d = _in::unsafeCast<core::int*>(:async_temporary_1).{core::num::+}(:result_or_exception as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
core::int* cnt = 2;
|
||||
core::List<core::int*>* b = core::_GrowableList::_literal3<core::int*>(1, 2, 3);
|
||||
:async_temporary_3 = b;
|
||||
:async_temporary_2 = cnt;
|
||||
[yield] let dynamic #t20 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<core::List<core::int*>*>(:async_temporary_3).{core::List::[]=}(_in::unsafeCast<core::int*>(:async_temporary_2), :result as{TypeError,ForDynamic} core::int*){(core::int*, core::int*) →* void};
|
||||
[yield] let dynamic #t20 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<core::List<core::int*>*>(:async_temporary_3).{core::List::[]=}(_in::unsafeCast<core::int*>(:async_temporary_2), :result_or_exception as{TypeError,ForDynamic} core::int*){(core::int*, core::int*) →* void};
|
||||
self::expect(1, b.{core::List::[]}(cnt){(core::int*) →* core::int*});
|
||||
:async_temporary_4 = b.{core::List::[]}(0){(core::int*) →* core::int*};
|
||||
[yield] let dynamic #t21 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::num* e = _in::unsafeCast<core::int*>(:async_temporary_4).{core::num::+}(:result as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
[yield] let dynamic #t21 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null;
|
||||
core::num* e = _in::unsafeCast<core::int*>(:async_temporary_4).{core::num::+}(:result_or_exception as{TypeError,ForDynamic} core::num*){(core::num*) →* core::num*};
|
||||
self::expect(2, e);
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -263,7 +263,7 @@ static method others() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -281,7 +281,7 @@ static method conditionals() → dynamic /* originally async */ {
|
||||
dynamic :async_temporary_1;
|
||||
dynamic :async_temporary_2;
|
||||
dynamic :async_temporary_3;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L5:
|
||||
{
|
||||
@@ -291,8 +291,8 @@ static method conditionals() → dynamic /* originally async */ {
|
||||
if(_in::unsafeCast<core::bool*>(:async_temporary_0))
|
||||
;
|
||||
else {
|
||||
[yield] let dynamic #t22 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:async_temporary_0 = :result as{TypeError,ForDynamic} core::bool* =={core::Object::==}{(core::Object) → core::bool} true;
|
||||
[yield] let dynamic #t22 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null;
|
||||
:async_temporary_0 = :result_or_exception as{TypeError,ForDynamic} core::bool* =={core::Object::==}{(core::Object) → core::bool} true;
|
||||
}
|
||||
core::bool* c = _in::unsafeCast<core::bool*>(:async_temporary_0);
|
||||
self::expect(true, c);
|
||||
@@ -300,14 +300,14 @@ static method conditionals() → dynamic /* originally async */ {
|
||||
:async_temporary_1 = a;
|
||||
}
|
||||
else {
|
||||
[yield] let dynamic #t23 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:async_temporary_1 = :result;
|
||||
[yield] let dynamic #t23 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null;
|
||||
:async_temporary_1 = :result_or_exception;
|
||||
}
|
||||
dynamic d = :async_temporary_1;
|
||||
self::expect(false, d);
|
||||
if(a is core::int*) {
|
||||
[yield] let dynamic #t24 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:async_temporary_2 = :result;
|
||||
[yield] let dynamic #t24 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null;
|
||||
:async_temporary_2 = :result_or_exception;
|
||||
}
|
||||
else {
|
||||
:async_temporary_2 = 2;
|
||||
@@ -316,8 +316,8 @@ static method conditionals() → dynamic /* originally async */ {
|
||||
self::expect(2, e);
|
||||
try {
|
||||
if(a is core::int*) {
|
||||
[yield] let dynamic #t25 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:async_temporary_3 = :result;
|
||||
[yield] let dynamic #t25 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null;
|
||||
:async_temporary_3 = :result_or_exception;
|
||||
}
|
||||
else {
|
||||
:async_temporary_3 = 2;
|
||||
@@ -335,7 +335,7 @@ static method conditionals() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -349,7 +349,7 @@ static method asserts() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L6:
|
||||
{
|
||||
@@ -360,34 +360,34 @@ static method asserts() → dynamic /* originally async */ {
|
||||
{
|
||||
final <T extends core::Object* = dynamic>(T*) →* FutureOr<T*>* func = #t26 as{TypeError} <T extends core::Object* = dynamic>(T*) →* FutureOr<T*>*;
|
||||
assert {
|
||||
[yield] let dynamic #t27 = asy::_awaitHelper(func<core::bool*>(true){(core::bool*) →* FutureOr<core::bool*>*}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
assert(_in::unsafeCast<core::bool*>(:result));
|
||||
[yield] let dynamic #t27 = asy::_awaitHelper(func<core::bool*>(true){(core::bool*) →* FutureOr<core::bool*>*}, :async_op_then, :async_op_error) in null;
|
||||
assert(_in::unsafeCast<core::bool*>(:result_or_exception));
|
||||
}
|
||||
assert {
|
||||
if(self::id<core::bool*>(true) as{TypeError} core::bool*)
|
||||
;
|
||||
else {
|
||||
[yield] let dynamic #t28 = asy::_awaitHelper(func<core::String*>("message"){(core::String*) →* FutureOr<core::String*>*}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
assert(false, _in::unsafeCast<core::String*>(:result));
|
||||
[yield] let dynamic #t28 = asy::_awaitHelper(func<core::String*>("message"){(core::String*) →* FutureOr<core::String*>*}, :async_op_then, :async_op_error) in null;
|
||||
assert(false, _in::unsafeCast<core::String*>(:result_or_exception));
|
||||
}
|
||||
}
|
||||
assert {
|
||||
[yield] let dynamic #t29 = asy::_awaitHelper(func<core::bool*>(true){(core::bool*) →* FutureOr<core::bool*>*}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
if(_in::unsafeCast<core::bool*>(:result))
|
||||
[yield] let dynamic #t29 = asy::_awaitHelper(func<core::bool*>(true){(core::bool*) →* FutureOr<core::bool*>*}, :async_op_then, :async_op_error) in null;
|
||||
if(_in::unsafeCast<core::bool*>(:result_or_exception))
|
||||
;
|
||||
else {
|
||||
[yield] let dynamic #t30 = asy::_awaitHelper(func<core::String*>("message"){(core::String*) →* FutureOr<core::String*>*}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
assert(false, _in::unsafeCast<core::String*>(:result));
|
||||
[yield] let dynamic #t30 = asy::_awaitHelper(func<core::String*>("message"){(core::String*) →* FutureOr<core::String*>*}, :async_op_then, :async_op_error) in null;
|
||||
assert(false, _in::unsafeCast<core::String*>(:result_or_exception));
|
||||
}
|
||||
}
|
||||
try {
|
||||
assert {
|
||||
[yield] let dynamic #t31 = asy::_awaitHelper(func<core::bool*>(false){(core::bool*) →* FutureOr<core::bool*>*}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
if(_in::unsafeCast<core::bool*>(:result))
|
||||
[yield] let dynamic #t31 = asy::_awaitHelper(func<core::bool*>(false){(core::bool*) →* FutureOr<core::bool*>*}, :async_op_then, :async_op_error) in null;
|
||||
if(_in::unsafeCast<core::bool*>(:result_or_exception))
|
||||
;
|
||||
else {
|
||||
[yield] let dynamic #t32 = asy::_awaitHelper(func<core::String*>("message"){(core::String*) →* FutureOr<core::String*>*}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
assert(false, _in::unsafeCast<core::String*>(:result));
|
||||
[yield] let dynamic #t32 = asy::_awaitHelper(func<core::String*>("message"){(core::String*) →* FutureOr<core::String*>*}, :async_op_then, :async_op_error) in null;
|
||||
assert(false, _in::unsafeCast<core::String*>(:result_or_exception));
|
||||
}
|
||||
}
|
||||
if(self::assertStatementsEnabled)
|
||||
@@ -408,7 +408,7 @@ static method asserts() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -428,7 +428,7 @@ static method controlFlow() → dynamic /* originally async */ {
|
||||
dynamic :stack_trace0;
|
||||
core::List<dynamic>* :async_temporary_0;
|
||||
core::List<dynamic>* :async_temporary_1;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L7:
|
||||
{
|
||||
@@ -447,16 +447,16 @@ static method controlFlow() → dynamic /* originally async */ {
|
||||
core::int* i;
|
||||
if(#t34) {
|
||||
#t34 = false;
|
||||
[yield] let dynamic #t36 = asy::_awaitHelper(func<core::int*>(0){(core::int*) →* FutureOr<core::int*>*}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
i = _in::unsafeCast<core::int*>(:result);
|
||||
[yield] let dynamic #t36 = asy::_awaitHelper(func<core::int*>(0){(core::int*) →* FutureOr<core::int*>*}, :async_op_then, :async_op_error) in null;
|
||||
i = _in::unsafeCast<core::int*>(:result_or_exception);
|
||||
}
|
||||
else {
|
||||
i = #t35;
|
||||
[yield] let dynamic #t37 = asy::_awaitHelper(func<core::int*>(let final core::int* #t38 = i in let final core::int* #t39 = i = #t38.{core::num::+}(1){(core::num*) →* core::int*} in #t38){(core::int*) →* FutureOr<core::int*>*}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<core::int*>(:result);
|
||||
[yield] let dynamic #t37 = asy::_awaitHelper(func<core::int*>(let final core::int* #t38 = i in let final core::int* #t39 = i = #t38.{core::num::+}(1){(core::num*) →* core::int*} in #t38){(core::int*) →* FutureOr<core::int*>*}, :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<core::int*>(:result_or_exception);
|
||||
}
|
||||
[yield] let dynamic #t40 = asy::_awaitHelper(func<core::bool*>(i.{core::num::<}(5){(core::num*) →* core::bool*}){(core::bool*) →* FutureOr<core::bool*>*}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
if(_in::unsafeCast<core::bool*>(:result)) {
|
||||
[yield] let dynamic #t40 = asy::_awaitHelper(func<core::bool*>(i.{core::num::<}(5){(core::num*) →* core::bool*}){(core::bool*) →* FutureOr<core::bool*>*}, :async_op_then, :async_op_error) in null;
|
||||
if(_in::unsafeCast<core::bool*>(:result_or_exception)) {
|
||||
{
|
||||
c = c.{core::num::+}(1){(core::num*) →* core::int*};
|
||||
}
|
||||
@@ -470,8 +470,8 @@ static method controlFlow() → dynamic /* originally async */ {
|
||||
c = 0;
|
||||
#L9:
|
||||
while (true) {
|
||||
[yield] let dynamic #t41 = asy::_awaitHelper(func<core::bool*>(c.{core::num::<}(5){(core::num*) →* core::bool*}){(core::bool*) →* FutureOr<core::bool*>*}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
if(_in::unsafeCast<core::bool*>(:result))
|
||||
[yield] let dynamic #t41 = asy::_awaitHelper(func<core::bool*>(c.{core::num::<}(5){(core::num*) →* core::bool*}){(core::bool*) →* FutureOr<core::bool*>*}, :async_op_then, :async_op_error) in null;
|
||||
if(_in::unsafeCast<core::bool*>(:result_or_exception))
|
||||
c = c.{core::num::+}(1){(core::num*) →* core::int*};
|
||||
else
|
||||
break #L9;
|
||||
@@ -480,26 +480,26 @@ static method controlFlow() → dynamic /* originally async */ {
|
||||
c = 0;
|
||||
do {
|
||||
c = c.{core::num::+}(1){(core::num*) →* core::int*};
|
||||
[yield] let dynamic #t42 = asy::_awaitHelper(func<core::bool*>(c.{core::num::<}(5){(core::num*) →* core::bool*}){(core::bool*) →* FutureOr<core::bool*>*}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
[yield] let dynamic #t42 = asy::_awaitHelper(func<core::bool*>(c.{core::num::<}(5){(core::num*) →* core::bool*}){(core::bool*) →* FutureOr<core::bool*>*}, :async_op_then, :async_op_error) in null;
|
||||
}
|
||||
while (_in::unsafeCast<core::bool*>(:result))
|
||||
while (_in::unsafeCast<core::bool*>(:result_or_exception))
|
||||
self::expect(5, c);
|
||||
[yield] let dynamic #t43 = asy::_awaitHelper(func<core::bool*>(c =={core::num::==}{(core::Object*) →* core::bool*} 5){(core::bool*) →* FutureOr<core::bool*>*}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
if(_in::unsafeCast<core::bool*>(:result)) {
|
||||
[yield] let dynamic #t43 = asy::_awaitHelper(func<core::bool*>(c =={core::num::==}{(core::Object*) →* core::bool*} 5){(core::bool*) →* FutureOr<core::bool*>*}, :async_op_then, :async_op_error) in null;
|
||||
if(_in::unsafeCast<core::bool*>(:result_or_exception)) {
|
||||
self::expect(5, c);
|
||||
}
|
||||
else {
|
||||
throw "unreachable";
|
||||
}
|
||||
try {
|
||||
[yield] let dynamic #t44 = asy::_awaitHelper(func<core::String*>("string"){(core::String*) →* FutureOr<core::String*>*}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
throw _in::unsafeCast<core::String*>(:result);
|
||||
[yield] let dynamic #t44 = asy::_awaitHelper(func<core::String*>("string"){(core::String*) →* FutureOr<core::String*>*}, :async_op_then, :async_op_error) in null;
|
||||
throw _in::unsafeCast<core::String*>(:result_or_exception);
|
||||
}
|
||||
on core::String* catch(no-exception-var) {
|
||||
}
|
||||
try {
|
||||
[yield] let dynamic #t45 = asy::_awaitHelper(throw "string", :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<Never*>(:result);
|
||||
[yield] let dynamic #t45 = asy::_awaitHelper(throw "string", :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<Never*>(:result_or_exception);
|
||||
}
|
||||
on core::String* catch(no-exception-var) {
|
||||
}
|
||||
@@ -511,28 +511,28 @@ static method controlFlow() → dynamic /* originally async */ {
|
||||
}
|
||||
on dynamic catch(final dynamic e) {
|
||||
self::expect("string", e);
|
||||
[yield] let dynamic #t46 = asy::_awaitHelper(func<core::int*>(0){(core::int*) →* FutureOr<core::int*>*}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
self::expect(0, _in::unsafeCast<core::int*>(:result));
|
||||
[yield] let dynamic #t46 = asy::_awaitHelper(func<core::int*>(0){(core::int*) →* FutureOr<core::int*>*}, :async_op_then, :async_op_error) in null;
|
||||
self::expect(0, _in::unsafeCast<core::int*>(:result_or_exception));
|
||||
rethrow;
|
||||
}
|
||||
finally {
|
||||
[yield] let dynamic #t47 = asy::_awaitHelper(func<core::int*>(0){(core::int*) →* FutureOr<core::int*>*}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
self::expect(0, _in::unsafeCast<core::int*>(:result));
|
||||
[yield] let dynamic #t47 = asy::_awaitHelper(func<core::int*>(0){(core::int*) →* FutureOr<core::int*>*}, :async_op_then, :async_op_error) in null;
|
||||
self::expect(0, _in::unsafeCast<core::int*>(:result_or_exception));
|
||||
}
|
||||
}
|
||||
on dynamic catch(final dynamic e) {
|
||||
[yield] let dynamic #t48 = asy::_awaitHelper(func<core::int*>(0){(core::int*) →* FutureOr<core::int*>*}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
self::expect(0, _in::unsafeCast<core::int*>(:result));
|
||||
[yield] let dynamic #t48 = asy::_awaitHelper(func<core::int*>(0){(core::int*) →* FutureOr<core::int*>*}, :async_op_then, :async_op_error) in null;
|
||||
self::expect(0, _in::unsafeCast<core::int*>(:result_or_exception));
|
||||
self::expect("string", e);
|
||||
}
|
||||
finally {
|
||||
[yield] let dynamic #t49 = asy::_awaitHelper(func<core::int*>(0){(core::int*) →* FutureOr<core::int*>*}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
self::expect(0, _in::unsafeCast<core::int*>(:result));
|
||||
[yield] let dynamic #t49 = asy::_awaitHelper(func<core::int*>(0){(core::int*) →* FutureOr<core::int*>*}, :async_op_then, :async_op_error) in null;
|
||||
self::expect(0, _in::unsafeCast<core::int*>(:result_or_exception));
|
||||
}
|
||||
#L10:
|
||||
{
|
||||
[yield] let dynamic #t50 = asy::_awaitHelper(func<core::int*>(2){(core::int*) →* FutureOr<core::int*>*}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
switch(_in::unsafeCast<core::int*>(:result)) {
|
||||
[yield] let dynamic #t50 = asy::_awaitHelper(func<core::int*>(2){(core::int*) →* FutureOr<core::int*>*}, :async_op_then, :async_op_error) in null;
|
||||
switch(_in::unsafeCast<core::int*>(:result_or_exception)) {
|
||||
#L11:
|
||||
case #C3:
|
||||
{
|
||||
@@ -554,12 +554,12 @@ static method controlFlow() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L13:
|
||||
{
|
||||
[yield] let dynamic #t52 = asy::_awaitHelper(func<dynamic>(42){(dynamic) →* FutureOr<dynamic>*}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = :result;
|
||||
[yield] let dynamic #t52 = asy::_awaitHelper(func<dynamic>(42){(dynamic) →* FutureOr<dynamic>*}, :async_op_then, :async_op_error) in null;
|
||||
:return_value = :result_or_exception;
|
||||
break #L13;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -570,11 +570,11 @@ static method controlFlow() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
})(){() →* asy::Future<dynamic>*}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
self::expect(42, :result);
|
||||
})(){() →* asy::Future<dynamic>*}, :async_op_then, :async_op_error) in null;
|
||||
self::expect(42, :result_or_exception);
|
||||
[yield] let dynamic #t53 = asy::_awaitHelper((() → asy::Future<dynamic>* /* originally async */ {
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
@@ -583,7 +583,7 @@ static method controlFlow() → dynamic /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L14:
|
||||
{
|
||||
@@ -598,11 +598,11 @@ static method controlFlow() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
})(){() →* asy::Future<dynamic>*}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
self::expect(42, :result);
|
||||
})(){() →* asy::Future<dynamic>*}, :async_op_then, :async_op_error) in null;
|
||||
self::expect(42, :result_or_exception);
|
||||
function testStream1() → asy::Stream<core::int*>* /* originally async* */ {
|
||||
asy::_AsyncStarStreamController<core::int*>* :controller;
|
||||
dynamic :controller_stream;
|
||||
@@ -612,13 +612,13 @@ static method controlFlow() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L15:
|
||||
{
|
||||
[yield] let dynamic #t54 = asy::_awaitHelper(func<core::int*>(42){(core::int*) →* FutureOr<core::int*>*}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
if(:controller.{asy::_AsyncStarStreamController::add}(_in::unsafeCast<core::int*>(:result)){(core::int*) → core::bool})
|
||||
[yield] let dynamic #t54 = asy::_awaitHelper(func<core::int*>(42){(core::int*) →* FutureOr<core::int*>*}, :async_op_then, :async_op_error) in null;
|
||||
if(:controller.{asy::_AsyncStarStreamController::add}(_in::unsafeCast<core::int*>(:result_or_exception)){(core::int*) → core::bool})
|
||||
return null;
|
||||
else
|
||||
[yield] null;
|
||||
@@ -638,8 +638,8 @@ static method controlFlow() → dynamic /* originally async */ {
|
||||
return :controller_stream;
|
||||
}
|
||||
:async_temporary_0 = core::_GrowableList::_literal1<dynamic>(42);
|
||||
[yield] let dynamic #t55 = asy::_awaitHelper(testStream1(){() →* asy::Stream<core::int*>*}.{asy::Stream::toList}(){() →* asy::Future<core::List<core::int*>*>*}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
self::expectList(_in::unsafeCast<core::List<dynamic>*>(:async_temporary_0), _in::unsafeCast<core::List<core::int*>*>(:result));
|
||||
[yield] let dynamic #t55 = asy::_awaitHelper(testStream1(){() →* asy::Stream<core::int*>*}.{asy::Stream::toList}(){() →* asy::Future<core::List<core::int*>*>*}, :async_op_then, :async_op_error) in null;
|
||||
self::expectList(_in::unsafeCast<core::List<dynamic>*>(:async_temporary_0), _in::unsafeCast<core::List<core::int*>*>(:result_or_exception));
|
||||
function testStream2() → asy::Stream<core::int*>* /* originally async* */ {
|
||||
asy::_AsyncStarStreamController<core::int*>* :controller;
|
||||
dynamic :controller_stream;
|
||||
@@ -649,13 +649,13 @@ static method controlFlow() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L16:
|
||||
{
|
||||
[yield] let dynamic #t56 = asy::_awaitHelper(func<asy::Stream<core::int*>*>(self::intStream()){(asy::Stream<core::int*>*) →* FutureOr<asy::Stream<core::int*>*>*}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
if(:controller.{asy::_AsyncStarStreamController::addStream}(_in::unsafeCast<asy::Stream<core::int*>*>(:result)){(asy::Stream<core::int*>) → core::bool})
|
||||
[yield] let dynamic #t56 = asy::_awaitHelper(func<asy::Stream<core::int*>*>(self::intStream()){(asy::Stream<core::int*>*) →* FutureOr<asy::Stream<core::int*>*>*}, :async_op_then, :async_op_error) in null;
|
||||
if(:controller.{asy::_AsyncStarStreamController::addStream}(_in::unsafeCast<asy::Stream<core::int*>*>(:result_or_exception)){(asy::Stream<core::int*>) → core::bool})
|
||||
return null;
|
||||
else
|
||||
[yield] null;
|
||||
@@ -675,8 +675,8 @@ static method controlFlow() → dynamic /* originally async */ {
|
||||
return :controller_stream;
|
||||
}
|
||||
:async_temporary_1 = core::_GrowableList::_literal1<dynamic>(42);
|
||||
[yield] let dynamic #t57 = asy::_awaitHelper(testStream2(){() →* asy::Stream<core::int*>*}.{asy::Stream::toList}(){() →* asy::Future<core::List<core::int*>*>*}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
self::expectList(_in::unsafeCast<core::List<dynamic>*>(:async_temporary_1), _in::unsafeCast<core::List<core::int*>*>(:result));
|
||||
[yield] let dynamic #t57 = asy::_awaitHelper(testStream2(){() →* asy::Stream<core::int*>*}.{asy::Stream::toList}(){() →* asy::Future<core::List<core::int*>*>*}, :async_op_then, :async_op_error) in null;
|
||||
self::expectList(_in::unsafeCast<core::List<dynamic>*>(:async_temporary_1), _in::unsafeCast<core::List<core::int*>*>(:result_or_exception));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -689,7 +689,7 @@ static method controlFlow() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -701,7 +701,7 @@ static method future<T extends core::Object* = dynamic>(self::future::T* value)
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L17:
|
||||
{
|
||||
@@ -716,7 +716,7 @@ static method future<T extends core::Object* = dynamic>(self::future::T* value)
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -731,7 +731,7 @@ static method intStream() → asy::Stream<core::int*>* /* originally async* */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L18:
|
||||
@@ -764,25 +764,25 @@ static method main() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L19:
|
||||
{
|
||||
for (core::int* i = 0; i.{core::num::<}(11){(core::num*) →* core::bool*}; i = i.{core::num::+}(1){(core::num*) →* core::int*}) {
|
||||
[yield] let dynamic #t58 = asy::_awaitHelper(self::staticMembers(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t59 = asy::_awaitHelper(self::topLevelMembers(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t60 = asy::_awaitHelper(self::instanceMembers(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t61 = asy::_awaitHelper(self::conditionals(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t62 = asy::_awaitHelper(self::others(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t63 = asy::_awaitHelper(self::asserts(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t64 = asy::_awaitHelper(self::controlFlow(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t58 = asy::_awaitHelper(self::staticMembers(), :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
[yield] let dynamic #t59 = asy::_awaitHelper(self::topLevelMembers(), :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
[yield] let dynamic #t60 = asy::_awaitHelper(self::instanceMembers(), :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
[yield] let dynamic #t61 = asy::_awaitHelper(self::conditionals(), :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
[yield] let dynamic #t62 = asy::_awaitHelper(self::others(), :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
[yield] let dynamic #t63 = asy::_awaitHelper(self::asserts(), :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
[yield] let dynamic #t64 = asy::_awaitHelper(self::controlFlow(), :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -793,7 +793,7 @@ static method main() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -19,13 +19,13 @@ class C extends core::Object {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
final core::List<core::int*>* #t1 = core::_GrowableList::•<core::int*>(0);
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(this.{self::C::_m}(){() →* asy::Future<core::int*>*}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
#t1.{core::List::add}(_in::unsafeCast<core::int*>(:result)){(core::int*) →* void};
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(this.{self::C::_m}(){() →* asy::Future<core::int*>*}, :async_op_then, :async_op_error) in null;
|
||||
#t1.{core::List::add}(_in::unsafeCast<core::int*>(:result_or_exception)){(core::int*) →* void};
|
||||
:return_value = block {} =>#t1;
|
||||
break #L1;
|
||||
}
|
||||
@@ -37,7 +37,7 @@ class C extends core::Object {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -49,7 +49,7 @@ class C extends core::Object {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
@@ -64,7 +64,7 @@ class C extends core::Object {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -88,12 +88,12 @@ static method main() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L3:
|
||||
{
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(new self::C::•().{self::C::m}(){() →* asy::Future<core::List<core::int*>*>*}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
self::expect(42, _in::unsafeCast<core::List<core::int*>*>(:result).{core::Iterable::first}{core::int*});
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(new self::C::•().{self::C::m}(){() →* asy::Future<core::List<core::int*>*>*}, :async_op_then, :async_op_error) in null;
|
||||
self::expect(42, _in::unsafeCast<core::List<core::int*>*>(:result_or_exception).{core::Iterable::first}{core::int*});
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
@@ -103,7 +103,7 @@ static method main() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -17,7 +17,7 @@ static method returnsString() → FutureOr<core::String*>* /* originally async *
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -32,7 +32,7 @@ static method returnsString() → FutureOr<core::String*>* /* originally async *
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -48,7 +48,7 @@ static method f1() → asy::Future<core::List<core::Object*>*>* /* originally as
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -63,7 +63,7 @@ static method f1() → asy::Future<core::List<core::Object*>*>* /* originally as
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -77,7 +77,7 @@ static method f3() → asy::Future<core::Object*>* /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
@@ -92,7 +92,7 @@ static method f3() → asy::Future<core::Object*>* /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -106,18 +106,18 @@ static method foo() → asy::Future<self::X*>* /* originally async */ {
|
||||
dynamic :await_ctx_var;
|
||||
dynamic :saved_try_context_var0;
|
||||
self::Y* :async_temporary_0;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L3:
|
||||
{
|
||||
final self::Y* #t1 = new self::Y::•();
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(self::f1(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
#t1.{self::Y::f}(_in::unsafeCast<core::List<core::Object*>*>(:result)){(dynamic) →* dynamic};
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(self::f1(), :async_op_then, :async_op_error) in null;
|
||||
#t1.{self::Y::f}(_in::unsafeCast<core::List<core::Object*>*>(:result_or_exception)){(dynamic) →* dynamic};
|
||||
:async_temporary_0 = block {
|
||||
#t1.{self::Y::f}(self::f2()){(dynamic) →* dynamic};
|
||||
} =>#t1;
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(self::f3(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = new self::X::•(_in::unsafeCast<self::Y*>(:async_temporary_0), _in::unsafeCast<core::Object*>(:result));
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(self::f3(), :async_op_then, :async_op_error) in null;
|
||||
:return_value = new self::X::•(_in::unsafeCast<self::Y*>(:async_temporary_0), _in::unsafeCast<core::Object*>(:result_or_exception));
|
||||
break #L3;
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -128,7 +128,7 @@ static method foo() → asy::Future<self::X*>* /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -141,12 +141,12 @@ static method main() → asy::Future<void>* /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L4:
|
||||
{
|
||||
[yield] let dynamic #t4 = asy::_awaitHelper(self::foo(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::print(_in::unsafeCast<self::X*>(:result));
|
||||
[yield] let dynamic #t4 = asy::_awaitHelper(self::foo(), :async_op_then, :async_op_error) in null;
|
||||
core::print(_in::unsafeCast<self::X*>(:result_or_exception));
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
@@ -156,7 +156,7 @@ static method main() → asy::Future<void>* /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
+4
-4
@@ -16,13 +16,13 @@ static method test() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
final core::Object* #t1 = CheckLibraryIsLoaded(lib);
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(LoadLibrary(lib), :async_op_then, :async_op_error, :async_op) in null;
|
||||
def::m(:result);
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(LoadLibrary(lib), :async_op_then, :async_op_error) in null;
|
||||
def::m(:result_or_exception);
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
@@ -32,7 +32,7 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
+26
-26
@@ -1955,7 +1955,7 @@ static method testForElementErrors(core::Map<core::int*, core::int*>* map, core:
|
||||
dynamic :saved_try_context_var1;
|
||||
dynamic :exception0;
|
||||
dynamic :stack_trace0;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -2284,8 +2284,8 @@ static method testForElementErrors(core::Map<core::int*, core::int*>* map, core:
|
||||
#L2:
|
||||
while (true) {
|
||||
dynamic #t265 = asy::_asyncStarMoveNextHelper(:stream);
|
||||
[yield] let dynamic #t266 = 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)) {
|
||||
[yield] let dynamic #t266 = 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)) {
|
||||
dynamic i = :for-iterator.{asy::_StreamIterator::current}{dynamic};
|
||||
#t264.{core::List::add}{Invariant}(i){(dynamic) →* void};
|
||||
}
|
||||
@@ -2294,8 +2294,8 @@ static method testForElementErrors(core::Map<core::int*, core::int*>* map, core:
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<dynamic>?} == null)) {
|
||||
[yield] let dynamic #t267 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t267 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
core::List<dynamic>* list30 = block {} =>#t264;
|
||||
@@ -2310,8 +2310,8 @@ static method testForElementErrors(core::Map<core::int*, core::int*>* map, core:
|
||||
#L3:
|
||||
while (true) {
|
||||
dynamic #t269 = asy::_asyncStarMoveNextHelper(:stream);
|
||||
[yield] let dynamic #t270 = 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)) {
|
||||
[yield] let dynamic #t270 = 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)) {
|
||||
dynamic i = :for-iterator.{asy::_StreamIterator::current}{dynamic};
|
||||
#t268.{core::Set::add}{Invariant}(i){(dynamic) →* core::bool*};
|
||||
}
|
||||
@@ -2320,8 +2320,8 @@ static method testForElementErrors(core::Map<core::int*, core::int*>* map, core:
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<dynamic>?} == null)) {
|
||||
[yield] let dynamic #t271 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t271 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
core::Set<dynamic>* set30 = block {
|
||||
@@ -2338,8 +2338,8 @@ static method testForElementErrors(core::Map<core::int*, core::int*>* map, core:
|
||||
#L4:
|
||||
while (true) {
|
||||
dynamic #t273 = asy::_asyncStarMoveNextHelper(:stream);
|
||||
[yield] let dynamic #t274 = 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)) {
|
||||
[yield] let dynamic #t274 = 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)) {
|
||||
dynamic i = :for-iterator.{asy::_StreamIterator::current}{dynamic};
|
||||
#t272.{core::Map::[]=}{Invariant}("bar", i){(core::String*, dynamic) →* void};
|
||||
}
|
||||
@@ -2348,8 +2348,8 @@ static method testForElementErrors(core::Map<core::int*, core::int*>* map, core:
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<dynamic>?} == null)) {
|
||||
[yield] let dynamic #t275 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t275 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
core::Map<core::String*, dynamic>* map30 = block {
|
||||
@@ -2367,8 +2367,8 @@ static method testForElementErrors(core::Map<core::int*, core::int*>* map, core:
|
||||
#L5:
|
||||
while (true) {
|
||||
dynamic #t277 = asy::_asyncStarMoveNextHelper(:stream);
|
||||
[yield] let dynamic #t278 = 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)) {
|
||||
[yield] let dynamic #t278 = 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)) {
|
||||
core::int* i = :for-iterator.{asy::_StreamIterator::current}{core::int*};
|
||||
#t276.{core::List::add}{Invariant}(i){(core::int*) →* void};
|
||||
}
|
||||
@@ -2377,8 +2377,8 @@ static method testForElementErrors(core::Map<core::int*, core::int*>* map, core:
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<core::int*>?} == null)) {
|
||||
[yield] let dynamic #t279 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t279 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
core::List<core::int*>* list40 = block {} =>#t276;
|
||||
@@ -2394,8 +2394,8 @@ static method testForElementErrors(core::Map<core::int*, core::int*>* map, core:
|
||||
#L6:
|
||||
while (true) {
|
||||
dynamic #t281 = asy::_asyncStarMoveNextHelper(:stream);
|
||||
[yield] let dynamic #t282 = 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)) {
|
||||
[yield] let dynamic #t282 = 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)) {
|
||||
core::int* i = :for-iterator.{asy::_StreamIterator::current}{core::int*};
|
||||
#t280.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
|
||||
}
|
||||
@@ -2404,8 +2404,8 @@ static method testForElementErrors(core::Map<core::int*, core::int*>* map, core:
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<core::int*>?} == null)) {
|
||||
[yield] let dynamic #t283 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t283 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
core::Set<core::int*>* set40 = block {
|
||||
@@ -2423,8 +2423,8 @@ static method testForElementErrors(core::Map<core::int*, core::int*>* map, core:
|
||||
#L7:
|
||||
while (true) {
|
||||
dynamic #t285 = asy::_asyncStarMoveNextHelper(:stream);
|
||||
[yield] let dynamic #t286 = 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)) {
|
||||
[yield] let dynamic #t286 = 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)) {
|
||||
core::int* i = :for-iterator.{asy::_StreamIterator::current}{core::int*};
|
||||
#t284.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
|
||||
}
|
||||
@@ -2433,8 +2433,8 @@ static method testForElementErrors(core::Map<core::int*, core::int*>* map, core:
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<core::int*>?} == null)) {
|
||||
[yield] let dynamic #t287 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t287 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
core::Map<core::String*, core::int*>* map40 = block {
|
||||
@@ -2489,7 +2489,7 @@ static method testForElementErrors(core::Map<core::int*, core::int*>* map, core:
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
+6
-6
@@ -28,7 +28,7 @@ static method main() → dynamic /* originally async */ {
|
||||
dynamic :saved_try_context_var1;
|
||||
dynamic :exception0;
|
||||
dynamic :stack_trace0;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -41,8 +41,8 @@ static method main() → dynamic /* originally async */ {
|
||||
#L2:
|
||||
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, :async_op) in null;
|
||||
if(_in::unsafeCast<core::bool>(:result)) {
|
||||
[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)) {
|
||||
final dynamic #t3 = :for-iterator.{asy::_StreamIterator::current}{dynamic};
|
||||
{
|
||||
invalid-expression "pkg/front_end/testcases/general/error_recovery/empty_await_for.dart:3:14: Error: This couldn't be parsed.
|
||||
@@ -55,8 +55,8 @@ static method main() → dynamic /* originally async */ {
|
||||
}
|
||||
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;
|
||||
[yield] let dynamic #t4 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -68,7 +68,7 @@ static method main() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -14,12 +14,12 @@ abstract class TestMixin<R extends core::Object* = dynamic, T extends core::Obje
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(fetch, :async_op_then, :async_op_error, :async_op) in null;
|
||||
final self::TestMixin::R* response = _in::unsafeCast<self::TestMixin::R*>(:result);
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(fetch, :async_op_then, :async_op_error) in null;
|
||||
final self::TestMixin::R* response = _in::unsafeCast<self::TestMixin::R*>(:result_or_exception);
|
||||
self::TestMixin::T* result;
|
||||
if(response is self::Response<dynamic>*) {
|
||||
result = response{self::TestMixin::R* & self::Response<dynamic>* /* '*' & '*' = '*' */}.{self::Response::data}{dynamic} as{TypeError,ForDynamic} self::TestMixin::T*;
|
||||
@@ -46,7 +46,7 @@ abstract class TestMixin<R extends core::Object* = dynamic, T extends core::Obje
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -122,12 +122,12 @@ abstract class _Class1&Object&TestMixin extends core::Object implements self::Te
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(fetch, :async_op_then, :async_op_error, :async_op) in null;
|
||||
final self::Response<core::String*>* response = _in::unsafeCast<self::Response<core::String*>*>(:result);
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(fetch, :async_op_then, :async_op_error) in null;
|
||||
final self::Response<core::String*>* response = _in::unsafeCast<self::Response<core::String*>*>(:result_or_exception);
|
||||
core::String* result;
|
||||
if(response is self::Response<dynamic>*) {
|
||||
result = response{self::Response<core::String*>*}.{self::Response::data}{dynamic} as{TypeError,ForDynamic} core::String*;
|
||||
@@ -154,7 +154,7 @@ abstract class _Class1&Object&TestMixin extends core::Object implements self::Te
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -191,12 +191,12 @@ abstract class _Class2&Object&TestMixin extends core::Object implements self::Te
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L3:
|
||||
{
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(fetch, :async_op_then, :async_op_error, :async_op) in null;
|
||||
final self::PagingResponse<core::String*>* response = _in::unsafeCast<self::PagingResponse<core::String*>*>(:result);
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(fetch, :async_op_then, :async_op_error) in null;
|
||||
final self::PagingResponse<core::String*>* response = _in::unsafeCast<self::PagingResponse<core::String*>*>(:result_or_exception);
|
||||
core::String* result;
|
||||
if(response is self::Response<dynamic>*) {
|
||||
result = response{self::PagingResponse<core::String*>*}.{self::Response::data}{dynamic} as{TypeError,ForDynamic} core::String*;
|
||||
@@ -223,7 +223,7 @@ abstract class _Class2&Object&TestMixin extends core::Object implements self::Te
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -35,7 +35,7 @@ class B extends core::Object {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -50,7 +50,7 @@ class B extends core::Object {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -78,7 +78,7 @@ class C extends core::Object {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
@@ -93,7 +93,7 @@ class C extends core::Object {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -50,7 +50,7 @@ static method returnClass() → self::Class* /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -65,7 +65,7 @@ static method returnClass() → self::Class* /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -77,7 +77,7 @@ static method returnFutureClass() → asy::Future<self::Class*>* /* originally a
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
@@ -92,7 +92,7 @@ static method returnFutureClass() → asy::Future<self::Class*>* /* originally a
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -104,7 +104,7 @@ static method returnFutureOrClass() → FutureOr<self::Class*>* /* originally as
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L3:
|
||||
{
|
||||
@@ -119,7 +119,7 @@ static method returnFutureOrClass() → FutureOr<self::Class*>* /* originally as
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -131,7 +131,7 @@ static method returnClassFromDynamic() → self::Class* /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L4:
|
||||
{
|
||||
@@ -146,7 +146,7 @@ static method returnClassFromDynamic() → self::Class* /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -158,7 +158,7 @@ static method returnFutureClassDynamic() → asy::Future<self::Class*>* /* origi
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L5:
|
||||
{
|
||||
@@ -173,7 +173,7 @@ static method returnFutureClassDynamic() → asy::Future<self::Class*>* /* origi
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -185,7 +185,7 @@ static method returnFutureOrClassDynamic() → FutureOr<self::Class*>* /* origin
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L6:
|
||||
{
|
||||
@@ -200,7 +200,7 @@ static method returnFutureOrClassDynamic() → FutureOr<self::Class*>* /* origin
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -212,7 +212,7 @@ static method returnClassFromFutureClass() → self::Class* /* originally async
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L7:
|
||||
{
|
||||
@@ -227,7 +227,7 @@ static method returnClassFromFutureClass() → self::Class* /* originally async
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -239,7 +239,7 @@ static method returnFutureClassFromFutureClass() → asy::Future<self::Class*>*
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L8:
|
||||
{
|
||||
@@ -254,7 +254,7 @@ static method returnFutureClassFromFutureClass() → asy::Future<self::Class*>*
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -266,7 +266,7 @@ static method returnFutureOrClassFromFutureClass() → FutureOr<self::Class*>* /
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L9:
|
||||
{
|
||||
@@ -281,7 +281,7 @@ static method returnFutureOrClassFromFutureClass() → FutureOr<self::Class*>* /
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -293,7 +293,7 @@ static method returnClassFromFutureOrClass() → self::Class* /* originally asyn
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L10:
|
||||
{
|
||||
@@ -308,7 +308,7 @@ static method returnClassFromFutureOrClass() → self::Class* /* originally asyn
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -320,7 +320,7 @@ static method returnFutureClassFromFutureOrClass() → asy::Future<self::Class*>
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L11:
|
||||
{
|
||||
@@ -335,7 +335,7 @@ static method returnFutureClassFromFutureOrClass() → asy::Future<self::Class*>
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -347,7 +347,7 @@ static method returnFutureOrClassFromFutureOrClass() → FutureOr<self::Class*>*
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L12:
|
||||
{
|
||||
@@ -362,7 +362,7 @@ static method returnFutureOrClassFromFutureOrClass() → FutureOr<self::Class*>*
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -375,34 +375,34 @@ static method main() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L13:
|
||||
{
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(self::returnClass(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<self::Class*>(:result);
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(self::returnFutureClass(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<self::Class*>(:result);
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(self::returnFutureOrClass(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<self::Class*>(:result);
|
||||
[yield] let dynamic #t4 = asy::_awaitHelper(self::returnClassFromDynamic(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<self::Class*>(:result);
|
||||
[yield] let dynamic #t5 = asy::_awaitHelper(self::returnFutureClassDynamic(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<self::Class*>(:result);
|
||||
[yield] let dynamic #t6 = asy::_awaitHelper(self::returnFutureOrClassDynamic(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<self::Class*>(:result);
|
||||
[yield] let dynamic #t7 = asy::_awaitHelper(self::returnClassFromFutureClass(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<self::Class*>(:result);
|
||||
[yield] let dynamic #t8 = asy::_awaitHelper(self::returnFutureClassFromFutureClass(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<self::Class*>(:result);
|
||||
[yield] let dynamic #t9 = asy::_awaitHelper(self::returnFutureOrClassFromFutureClass(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<self::Class*>(:result);
|
||||
[yield] let dynamic #t10 = asy::_awaitHelper(self::returnClassFromFutureOrClass(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<self::Class*>(:result);
|
||||
[yield] let dynamic #t11 = asy::_awaitHelper(self::returnFutureClassFromFutureOrClass(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<self::Class*>(:result);
|
||||
[yield] let dynamic #t12 = asy::_awaitHelper(self::returnFutureOrClassFromFutureOrClass(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<self::Class*>(:result);
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(self::returnClass(), :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<self::Class*>(:result_or_exception);
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(self::returnFutureClass(), :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<self::Class*>(:result_or_exception);
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(self::returnFutureOrClass(), :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<self::Class*>(:result_or_exception);
|
||||
[yield] let dynamic #t4 = asy::_awaitHelper(self::returnClassFromDynamic(), :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<self::Class*>(:result_or_exception);
|
||||
[yield] let dynamic #t5 = asy::_awaitHelper(self::returnFutureClassDynamic(), :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<self::Class*>(:result_or_exception);
|
||||
[yield] let dynamic #t6 = asy::_awaitHelper(self::returnFutureOrClassDynamic(), :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<self::Class*>(:result_or_exception);
|
||||
[yield] let dynamic #t7 = asy::_awaitHelper(self::returnClassFromFutureClass(), :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<self::Class*>(:result_or_exception);
|
||||
[yield] let dynamic #t8 = asy::_awaitHelper(self::returnFutureClassFromFutureClass(), :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<self::Class*>(:result_or_exception);
|
||||
[yield] let dynamic #t9 = asy::_awaitHelper(self::returnFutureOrClassFromFutureClass(), :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<self::Class*>(:result_or_exception);
|
||||
[yield] let dynamic #t10 = asy::_awaitHelper(self::returnClassFromFutureOrClass(), :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<self::Class*>(:result_or_exception);
|
||||
[yield] let dynamic #t11 = asy::_awaitHelper(self::returnFutureClassFromFutureOrClass(), :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<self::Class*>(:result_or_exception);
|
||||
[yield] let dynamic #t12 = asy::_awaitHelper(self::returnFutureOrClassFromFutureOrClass(), :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<self::Class*>(:result_or_exception);
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
@@ -412,7 +412,7 @@ static method main() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -21,7 +21,7 @@ static method test(core::Iterable<void> iterable, asy::Stream<void> stream) →
|
||||
dynamic :saved_try_context_var1;
|
||||
dynamic :exception0;
|
||||
dynamic :stack_trace0;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -48,8 +48,8 @@ static method test(core::Iterable<void> iterable, asy::Stream<void> stream) →
|
||||
#L2:
|
||||
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, :async_op) in null;
|
||||
if(_in::unsafeCast<core::bool>(:result)) {
|
||||
[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)) {
|
||||
void v5 = :for-iterator.{asy::_StreamIterator::current}{void};
|
||||
{}
|
||||
}
|
||||
@@ -58,8 +58,8 @@ static method test(core::Iterable<void> iterable, asy::Stream<void> stream) →
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<void>?} == null)) {
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[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;
|
||||
}
|
||||
}
|
||||
{
|
||||
@@ -69,8 +69,8 @@ static method test(core::Iterable<void> iterable, asy::Stream<void> stream) →
|
||||
#L3:
|
||||
while (true) {
|
||||
dynamic #t4 = asy::_asyncStarMoveNextHelper(:stream);
|
||||
[yield] let dynamic #t5 = 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)) {
|
||||
[yield] let dynamic #t5 = 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)) {
|
||||
void v6 = :for-iterator.{asy::_StreamIterator::current}{void};
|
||||
{}
|
||||
}
|
||||
@@ -79,8 +79,8 @@ static method test(core::Iterable<void> iterable, asy::Stream<void> stream) →
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<void>?} == null)) {
|
||||
[yield] let dynamic #t6 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t6 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
core::List<void> l1 = core::_GrowableList::_literal1<void>(self::method());
|
||||
@@ -94,7 +94,7 @@ static method test(core::Iterable<void> iterable, asy::Stream<void> stream) →
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -36,7 +36,7 @@ static field () → Null a = () → Null {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -53,7 +53,7 @@ static field () → Null a = () → Null {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -32,7 +32,7 @@ static field () → Null a = () → Null {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{}
|
||||
@@ -44,7 +44,7 @@ static field () → Null a = () → Null {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -61,7 +61,7 @@ static field () → Null a = () → Null {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
@@ -78,7 +78,7 @@ static field () → Null a = () → Null {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -92,12 +92,12 @@ static field (dynamic) → asy::Future<dynamic> b = (dynamic f) → asy::Future<
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L3:
|
||||
{
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(f, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = :result;
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(f, :async_op_then, :async_op_error) in null;
|
||||
:return_value = :result_or_exception;
|
||||
break #L3;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -108,7 +108,7 @@ static field (dynamic) → asy::Future<dynamic> b = (dynamic f) → asy::Future<
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
|
||||
@@ -21,7 +21,7 @@ static method foo(core::int* x) → dynamic /* originally async */ {
|
||||
core::int* :async_temporary_1;
|
||||
core::List<core::int*>* :async_temporary_2;
|
||||
core::int* :async_temporary_3;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -29,8 +29,8 @@ static method foo(core::int* x) → dynamic /* originally async */ {
|
||||
if(!(x == null)) {
|
||||
:async_temporary_1 = x.{core::num::+}(1){(core::num*) →* core::int*};
|
||||
:async_temporary_0 = x.{core::num::+}(2){(core::num*) →* core::int*};
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(null, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:async_temporary_2 = core::_GrowableList::_literal3<core::int*>(_in::unsafeCast<core::int*>(:async_temporary_1), _in::unsafeCast<core::int*>(:async_temporary_0), _in::unsafeCast<Null>(:result));
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(null, :async_op_then, :async_op_error) in null;
|
||||
:async_temporary_2 = core::_GrowableList::_literal3<core::int*>(_in::unsafeCast<core::int*>(:async_temporary_1), _in::unsafeCast<core::int*>(:async_temporary_0), _in::unsafeCast<Null>(:result_or_exception));
|
||||
}
|
||||
else {
|
||||
:async_temporary_2 = null;
|
||||
@@ -46,7 +46,7 @@ static method foo(core::int* x) → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -59,12 +59,12 @@ static method main() → void /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(self::foo(0), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = :result;
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(self::foo(0), :async_op_then, :async_op_error) in null;
|
||||
:return_value = :result_or_exception;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -75,7 +75,7 @@ static method main() → void /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -88,4 +88,4 @@ static method expect(dynamic expected, dynamic actual) → dynamic {
|
||||
Extra constant evaluation status:
|
||||
Evaluated: InstanceInvocation @ org-dartlang-testcase:///issue40662.dart:10:10 -> IntConstant(-1)
|
||||
Evaluated: InstanceInvocation @ org-dartlang-testcase:///issue40662.dart:11:10 -> IntConstant(-1)
|
||||
Extra constant evaluation: evaluated: 94, effectively constant: 2
|
||||
Extra constant evaluation: evaluated: 92, effectively constant: 2
|
||||
|
||||
@@ -31,7 +31,7 @@ static method main() → dynamic {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -46,7 +46,7 @@ static method main() → dynamic {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
|
||||
@@ -23,7 +23,7 @@ static method test(self::A<core::String> a) → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -35,7 +35,7 @@ static method test(self::A<core::String> a) → dynamic /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
@@ -50,11 +50,11 @@ static method test(self::A<core::String> a) → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
})(){() → asy::Future<core::String?>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
final core::String? x = _in::unsafeCast<core::String?>(:result);
|
||||
})(){() → asy::Future<core::String?>}, :async_op_then, :async_op_error) in null;
|
||||
final core::String? x = _in::unsafeCast<core::String?>(:result_or_exception);
|
||||
self::bar(x);
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -65,7 +65,7 @@ static method test(self::A<core::String> a) → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -77,7 +77,7 @@ static method test2(self::A<core::String> a) → dynamic /* originally async */
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L3:
|
||||
{
|
||||
@@ -92,7 +92,7 @@ static method test2(self::A<core::String> a) → dynamic /* originally async */
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -13,7 +13,7 @@ static method foo<X extends core::Object?>(self::foo::X% x) → asy::Future<core
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -33,7 +33,7 @@ static method foo<X extends core::Object?>(self::foo::X% x) → asy::Future<core
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -18,7 +18,7 @@ static method test(asy::StreamController<void> _eventStreamController) → dynam
|
||||
dynamic :saved_try_context_var1;
|
||||
dynamic :exception0;
|
||||
dynamic :stack_trace0;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -29,8 +29,8 @@ static method test(asy::StreamController<void> _eventStreamController) → dynam
|
||||
#L2:
|
||||
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, :async_op) in null;
|
||||
if(_in::unsafeCast<core::bool>(:result)) {
|
||||
[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)) {
|
||||
final void _ = :for-iterator.{asy::_StreamIterator::current}{void};
|
||||
{}
|
||||
}
|
||||
@@ -39,8 +39,8 @@ static method test(asy::StreamController<void> _eventStreamController) → dynam
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<void>?} == null)) {
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[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;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -52,7 +52,7 @@ static method test(asy::StreamController<void> _eventStreamController) → dynam
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
+4
-4
@@ -17,12 +17,12 @@ class X extends core::Object {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(null, :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<Null>(:result);
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(null, :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<Null>(:result_or_exception);
|
||||
core::print("hello");
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -33,7 +33,7 @@ class X extends core::Object {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
+10
-10
@@ -16,7 +16,7 @@ class A extends core::Object {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{}
|
||||
@@ -28,7 +28,7 @@ class A extends core::Object {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -55,7 +55,7 @@ class B extends core::Object {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{}
|
||||
@@ -67,7 +67,7 @@ class B extends core::Object {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -93,16 +93,16 @@ static method main() → dynamic /* originally async */ {
|
||||
dynamic :saved_try_context_var0;
|
||||
self::B* :async_temporary_0;
|
||||
dynamic :async_temporary_1;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L3:
|
||||
{
|
||||
:async_temporary_1 = new self::A::•();
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(null, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:async_temporary_1 = _in::unsafeCast<self::A*>(:async_temporary_1).{self::A::foo}(_in::unsafeCast<Null>(:result)){(dynamic) →* asy::Future<void>*};
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(null, :async_op_then, :async_op_error) in null;
|
||||
:async_temporary_1 = _in::unsafeCast<self::A*>(:async_temporary_1).{self::A::foo}(_in::unsafeCast<Null>(:result_or_exception)){(dynamic) →* asy::Future<void>*};
|
||||
:async_temporary_0 = new self::B::•();
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(null, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = core::_GrowableList::_literal2<asy::Future<void>*>(_in::unsafeCast<asy::Future<void>*>(:async_temporary_1), _in::unsafeCast<self::B*>(:async_temporary_0).{self::B::bar}(_in::unsafeCast<Null>(:result)){(dynamic) →* asy::Future<void>*});
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(null, :async_op_then, :async_op_error) in null;
|
||||
:return_value = core::_GrowableList::_literal2<asy::Future<void>*>(_in::unsafeCast<asy::Future<void>*>(:async_temporary_1), _in::unsafeCast<self::B*>(:async_temporary_0).{self::B::bar}(_in::unsafeCast<Null>(:result_or_exception)){(dynamic) →* asy::Future<void>*});
|
||||
break #L3;
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -113,7 +113,7 @@ static method main() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -24,7 +24,7 @@ static method bar(dynamic d) → dynamic /* originally async* */ {
|
||||
dynamic :saved_try_context_var2;
|
||||
dynamic :exception0;
|
||||
dynamic :stack_trace0;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L1:
|
||||
@@ -36,8 +36,8 @@ static method bar(dynamic d) → dynamic /* originally async* */ {
|
||||
#L2:
|
||||
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, :async_op) in null;
|
||||
if(_in::unsafeCast<core::bool>(:result)) {
|
||||
[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)) {
|
||||
dynamic x = :for-iterator.{asy::_StreamIterator::current}{dynamic};
|
||||
{
|
||||
if(:controller.{asy::_AsyncStarStreamController::add}(x){(dynamic) → core::bool})
|
||||
@@ -55,8 +55,8 @@ static method bar(dynamic d) → dynamic /* originally async* */ {
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<dynamic>?} == null)) {
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[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;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -42,7 +42,7 @@ static method returnFutureDynamic() → asy::Future<dynamic>* /* originally asyn
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -57,7 +57,7 @@ static method returnFutureDynamic() → asy::Future<dynamic>* /* originally asyn
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -69,7 +69,7 @@ static method returnFutureClass() → asy::Future<self::Class*>* /* originally a
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
@@ -84,7 +84,7 @@ static method returnFutureClass() → asy::Future<self::Class*>* /* originally a
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -97,7 +97,7 @@ static method error() → asy::Stream<FutureOr<self::Class*>*>* /* originally as
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L3:
|
||||
@@ -134,7 +134,7 @@ static method stream() → asy::Stream<FutureOr<self::Class*>*>* /* originally a
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L4:
|
||||
@@ -178,7 +178,7 @@ static method main() → dynamic /* originally async */ {
|
||||
dynamic :saved_try_context_var1;
|
||||
dynamic :exception0;
|
||||
dynamic :stack_trace0;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L5:
|
||||
{
|
||||
@@ -189,8 +189,8 @@ static method main() → dynamic /* originally async */ {
|
||||
#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, :async_op) in null;
|
||||
if(_in::unsafeCast<core::bool>(:result)) {
|
||||
[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);
|
||||
@@ -201,8 +201,8 @@ static method main() → dynamic /* originally async */ {
|
||||
}
|
||||
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, :async_op) in null;
|
||||
:result;
|
||||
[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;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -214,7 +214,7 @@ static method main() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -10,12 +10,12 @@ library from "org-dartlang-test:///libA.dart" as libA {
|
||||
dart.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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
[yield] let dynamic #t1 = dart.async::_awaitHelper(null, :async_op_then, :async_op_error, :async_op) in null;
|
||||
dart._internal::unsafeCast<Null>(:result);
|
||||
[yield] let dynamic #t1 = dart.async::_awaitHelper(null, :async_op_then, :async_op_error) in null;
|
||||
dart._internal::unsafeCast<Null>(:result_or_exception);
|
||||
:return_value = "hello";
|
||||
break #L1;
|
||||
}
|
||||
@@ -27,7 +27,7 @@ library from "org-dartlang-test:///libA.dart" as libA {
|
||||
}
|
||||
:async_op_then = dart.async::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = dart.async::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -62,12 +62,12 @@ library from "org-dartlang-test:///main.dart" as main {
|
||||
dart.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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
[yield] let dynamic #t2 = dart.async::_awaitHelper(libA::whatever(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t2 = dart.async::_awaitHelper(libA::whatever(), :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
dart.core::print(#C2);
|
||||
}
|
||||
dart.async::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -78,7 +78,7 @@ library from "org-dartlang-test:///main.dart" as main {
|
||||
}
|
||||
:async_op_then = dart.async::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = dart.async::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -10,12 +10,12 @@ library from "org-dartlang-test:///libA.dart" as libA {
|
||||
dart.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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
[yield] let dynamic #t1 = dart.async::_awaitHelper(null, :async_op_then, :async_op_error, :async_op) in null;
|
||||
dart._internal::unsafeCast<Null>(:result);
|
||||
[yield] let dynamic #t1 = dart.async::_awaitHelper(null, :async_op_then, :async_op_error) in null;
|
||||
dart._internal::unsafeCast<Null>(:result_or_exception);
|
||||
:return_value = "hello";
|
||||
break #L1;
|
||||
}
|
||||
@@ -27,7 +27,7 @@ library from "org-dartlang-test:///libA.dart" as libA {
|
||||
}
|
||||
:async_op_then = dart.async::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = dart.async::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -62,12 +62,12 @@ library from "org-dartlang-test:///main.dart" as main {
|
||||
dart.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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
[yield] let dynamic #t2 = dart.async::_awaitHelper(libA::whatever(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t2 = dart.async::_awaitHelper(libA::whatever(), :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
dart.core::print(#C2);
|
||||
dart.core::print("Done");
|
||||
}
|
||||
@@ -79,7 +79,7 @@ library from "org-dartlang-test:///main.dart" as main {
|
||||
}
|
||||
:async_op_then = dart.async::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = dart.async::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -28,12 +28,12 @@ library from "org-dartlang-test:///main.dart" as main {
|
||||
dart.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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
[yield] let dynamic #t1 = dart.async::_awaitHelper(main::whatever(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t1 = dart.async::_awaitHelper(main::whatever(), :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
dart.core::print(#C2);
|
||||
}
|
||||
dart.async::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -44,7 +44,7 @@ library from "org-dartlang-test:///main.dart" as main {
|
||||
}
|
||||
:async_op_then = dart.async::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = dart.async::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -57,12 +57,12 @@ library from "org-dartlang-test:///main.dart" as main {
|
||||
dart.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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
[yield] let dynamic #t2 = dart.async::_awaitHelper(null, :async_op_then, :async_op_error, :async_op) in null;
|
||||
dart._internal::unsafeCast<Null>(:result);
|
||||
[yield] let dynamic #t2 = dart.async::_awaitHelper(null, :async_op_then, :async_op_error) in null;
|
||||
dart._internal::unsafeCast<Null>(:result_or_exception);
|
||||
:return_value = "hello";
|
||||
break #L2;
|
||||
}
|
||||
@@ -74,7 +74,7 @@ library from "org-dartlang-test:///main.dart" as main {
|
||||
}
|
||||
:async_op_then = dart.async::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = dart.async::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -28,12 +28,12 @@ library from "org-dartlang-test:///main.dart" as main {
|
||||
dart.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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
[yield] let dynamic #t1 = dart.async::_awaitHelper(main::whatever(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t1 = dart.async::_awaitHelper(main::whatever(), :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
dart.core::print(#C2);
|
||||
}
|
||||
dart.async::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -44,7 +44,7 @@ library from "org-dartlang-test:///main.dart" as main {
|
||||
}
|
||||
:async_op_then = dart.async::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = dart.async::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -57,12 +57,12 @@ library from "org-dartlang-test:///main.dart" as main {
|
||||
dart.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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
[yield] let dynamic #t2 = dart.async::_awaitHelper(null, :async_op_then, :async_op_error, :async_op) in null;
|
||||
dart._internal::unsafeCast<Null>(:result);
|
||||
[yield] let dynamic #t2 = dart.async::_awaitHelper(null, :async_op_then, :async_op_error) in null;
|
||||
dart._internal::unsafeCast<Null>(:result_or_exception);
|
||||
:return_value = "hello!!!";
|
||||
break #L2;
|
||||
}
|
||||
@@ -74,7 +74,7 @@ library from "org-dartlang-test:///main.dart" as main {
|
||||
}
|
||||
:async_op_then = dart.async::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = dart.async::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -28,12 +28,12 @@ library from "org-dartlang-test:///main.dart" as main {
|
||||
dart.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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
[yield] let dynamic #t1 = dart.async::_awaitHelper(main::whatever(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t1 = dart.async::_awaitHelper(main::whatever(), :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
dart.core::print(#C2);
|
||||
dart.core::print("Done!");
|
||||
}
|
||||
@@ -45,7 +45,7 @@ library from "org-dartlang-test:///main.dart" as main {
|
||||
}
|
||||
:async_op_then = dart.async::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = dart.async::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -58,12 +58,12 @@ library from "org-dartlang-test:///main.dart" as main {
|
||||
dart.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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
[yield] let dynamic #t2 = dart.async::_awaitHelper(null, :async_op_then, :async_op_error, :async_op) in null;
|
||||
dart._internal::unsafeCast<Null>(:result);
|
||||
[yield] let dynamic #t2 = dart.async::_awaitHelper(null, :async_op_then, :async_op_error) in null;
|
||||
dart._internal::unsafeCast<Null>(:result_or_exception);
|
||||
:return_value = "hello!!!";
|
||||
break #L2;
|
||||
}
|
||||
@@ -75,7 +75,7 @@ library from "org-dartlang-test:///main.dart" as main {
|
||||
}
|
||||
:async_op_then = dart.async::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = dart.async::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -35,7 +35,7 @@ static method test() → void /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -57,7 +57,7 @@ static method test() → void /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
@@ -72,7 +72,7 @@ static method test() → void /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -84,7 +84,7 @@ static method test() → void /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L3:
|
||||
{
|
||||
@@ -99,7 +99,7 @@ static method test() → void /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -111,7 +111,7 @@ static method test() → void /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L4:
|
||||
{
|
||||
@@ -126,7 +126,7 @@ static method test() → void /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -138,7 +138,7 @@ static method test() → void /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L5:
|
||||
{
|
||||
@@ -153,7 +153,7 @@ static method test() → void /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -165,7 +165,7 @@ static method test() → void /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L6:
|
||||
{
|
||||
@@ -180,7 +180,7 @@ static method test() → void /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -192,7 +192,7 @@ static method test() → void /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L7:
|
||||
{
|
||||
@@ -207,7 +207,7 @@ static method test() → void /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -219,7 +219,7 @@ static method test() → void /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L8:
|
||||
{
|
||||
@@ -234,7 +234,7 @@ static method test() → void /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -246,7 +246,7 @@ static method test() → void /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L9:
|
||||
{
|
||||
@@ -261,7 +261,7 @@ static method test() → void /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -273,7 +273,7 @@ static method test() → void /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L10:
|
||||
{
|
||||
@@ -288,7 +288,7 @@ static method test() → void /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -300,7 +300,7 @@ static method test() → void /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L11:
|
||||
{
|
||||
@@ -315,30 +315,30 @@ static method test() → void /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(x0, :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::int* y0 = _in::unsafeCast<core::int*>(:result);
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(x1, :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::int* y1 = _in::unsafeCast<core::int*>(:result);
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(x2, :async_op_then, :async_op_error, :async_op) in null;
|
||||
asy::Future<core::int*>* y2 = _in::unsafeCast<asy::Future<core::int*>*>(:result);
|
||||
[yield] let dynamic #t4 = asy::_awaitHelper(x3, :async_op_then, :async_op_error, :async_op) in null;
|
||||
FutureOr<core::int*>* y3 = _in::unsafeCast<FutureOr<core::int*>*>(:result);
|
||||
[yield] let dynamic #t5 = asy::_awaitHelper(x4, :async_op_then, :async_op_error, :async_op) in null;
|
||||
self::MyFuture* y4 = _in::unsafeCast<self::MyFuture*>(:result);
|
||||
[yield] let dynamic #t6 = asy::_awaitHelper(x5, :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::int* y5 = _in::unsafeCast<core::int*>(:result);
|
||||
[yield] let dynamic #t7 = asy::_awaitHelper(x6, :async_op_then, :async_op_error, :async_op) in null;
|
||||
asy::Future<core::int*>* y6 = _in::unsafeCast<asy::Future<core::int*>*>(:result);
|
||||
[yield] let dynamic #t8 = asy::_awaitHelper(x7, :async_op_then, :async_op_error, :async_op) in null;
|
||||
FutureOr<core::int*>* y7 = _in::unsafeCast<FutureOr<core::int*>*>(:result);
|
||||
[yield] let dynamic #t9 = asy::_awaitHelper(x8, :async_op_then, :async_op_error, :async_op) in null;
|
||||
self::MyFuture* y8 = _in::unsafeCast<self::MyFuture*>(:result);
|
||||
[yield] let dynamic #t10 = asy::_awaitHelper(x9, :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::int* y9 = _in::unsafeCast<core::int*>(:result);
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(x0, :async_op_then, :async_op_error) in null;
|
||||
core::int* y0 = _in::unsafeCast<core::int*>(:result_or_exception);
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(x1, :async_op_then, :async_op_error) in null;
|
||||
core::int* y1 = _in::unsafeCast<core::int*>(:result_or_exception);
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(x2, :async_op_then, :async_op_error) in null;
|
||||
asy::Future<core::int*>* y2 = _in::unsafeCast<asy::Future<core::int*>*>(:result_or_exception);
|
||||
[yield] let dynamic #t4 = asy::_awaitHelper(x3, :async_op_then, :async_op_error) in null;
|
||||
FutureOr<core::int*>* y3 = _in::unsafeCast<FutureOr<core::int*>*>(:result_or_exception);
|
||||
[yield] let dynamic #t5 = asy::_awaitHelper(x4, :async_op_then, :async_op_error) in null;
|
||||
self::MyFuture* y4 = _in::unsafeCast<self::MyFuture*>(:result_or_exception);
|
||||
[yield] let dynamic #t6 = asy::_awaitHelper(x5, :async_op_then, :async_op_error) in null;
|
||||
core::int* y5 = _in::unsafeCast<core::int*>(:result_or_exception);
|
||||
[yield] let dynamic #t7 = asy::_awaitHelper(x6, :async_op_then, :async_op_error) in null;
|
||||
asy::Future<core::int*>* y6 = _in::unsafeCast<asy::Future<core::int*>*>(:result_or_exception);
|
||||
[yield] let dynamic #t8 = asy::_awaitHelper(x7, :async_op_then, :async_op_error) in null;
|
||||
FutureOr<core::int*>* y7 = _in::unsafeCast<FutureOr<core::int*>*>(:result_or_exception);
|
||||
[yield] let dynamic #t9 = asy::_awaitHelper(x8, :async_op_then, :async_op_error) in null;
|
||||
self::MyFuture* y8 = _in::unsafeCast<self::MyFuture*>(:result_or_exception);
|
||||
[yield] let dynamic #t10 = asy::_awaitHelper(x9, :async_op_then, :async_op_error) in null;
|
||||
core::int* y9 = _in::unsafeCast<core::int*>(:result_or_exception);
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
@@ -348,7 +348,7 @@ static method test() → void /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
+2
-2
@@ -15,7 +15,7 @@ static field () →* asy::Future<core::int*>* g = () → asy::Future<core::int*>
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -30,7 +30,7 @@ static field () →* asy::Future<core::int*>* g = () → asy::Future<core::int*>
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
|
||||
+2
-2
@@ -11,7 +11,7 @@ static field () →* asy::Future<core::int*>* f = () → asy::Future<core::int*>
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -26,7 +26,7 @@ static field () →* asy::Future<core::int*>* f = () → asy::Future<core::int*>
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
|
||||
+2
-2
@@ -15,7 +15,7 @@ static field () →* asy::Future<core::int*>* g = () → asy::Future<core::int*>
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -30,7 +30,7 @@ static field () →* asy::Future<core::int*>* g = () → asy::Future<core::int*>
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
|
||||
+2
-2
@@ -16,7 +16,7 @@ static method test() → dynamic {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -37,7 +37,7 @@ static method test() → dynamic {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
|
||||
+2
-2
@@ -16,7 +16,7 @@ static method test() → dynamic {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -37,7 +37,7 @@ static method test() → dynamic {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
|
||||
+2
-2
@@ -16,7 +16,7 @@ static method test() → dynamic {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -37,7 +37,7 @@ static method test() → dynamic {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
|
||||
+1
-1
@@ -15,7 +15,7 @@ static method test() → dynamic {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L1:
|
||||
|
||||
+6
-6
@@ -15,7 +15,7 @@ static method main() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -27,7 +27,7 @@ static method main() → dynamic /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
@@ -42,14 +42,14 @@ static method main() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
asy::Future<dynamic>* y = f(){() →* asy::Future<Null>*};
|
||||
asy::Future<core::String*>* z = f(){() →* asy::Future<Null>*};
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(f(){() →* asy::Future<Null>*}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::String* s = _in::unsafeCast<Null>(:result);
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(f(){() →* asy::Future<Null>*}, :async_op_then, :async_op_error) in null;
|
||||
core::String* s = _in::unsafeCast<Null>(:result_or_exception);
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
@@ -59,7 +59,7 @@ static method main() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
+5
-5
@@ -15,7 +15,7 @@ static method main() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -28,7 +28,7 @@ static method main() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L2:
|
||||
@@ -54,8 +54,8 @@ static method main() → dynamic /* originally async */ {
|
||||
};
|
||||
asy::Stream<dynamic>* y = f(){() →* asy::Stream<Null>*};
|
||||
asy::Stream<core::String*>* z = f(){() →* asy::Stream<Null>*};
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(f(){() →* asy::Stream<Null>*}.{asy::Stream::first}{asy::Future<Null>*}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::String* s = _in::unsafeCast<Null>(:result);
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(f(){() →* asy::Stream<Null>*}.{asy::Stream::first}{asy::Future<Null>*}, :async_op_then, :async_op_error) in null;
|
||||
core::String* s = _in::unsafeCast<Null>(:result_or_exception);
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
@@ -65,7 +65,7 @@ static method main() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
+6
-6
@@ -15,15 +15,15 @@ static method main() → asy::Future<dynamic>* /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
dynamic d;
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(core::_GrowableList::_literal1<core::int*>(d as{TypeError,ForDynamic} core::int*), :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::List<core::int*>* l0 = _in::unsafeCast<core::List<core::int*>*>(:result);
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(asy::Future::value<core::List<core::int*>*>(core::_GrowableList::_literal1<core::int*>(d as{TypeError,ForDynamic} core::int*)), :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::List<core::int*>* l1 = _in::unsafeCast<core::List<core::int*>*>(:result);
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(core::_GrowableList::_literal1<core::int*>(d as{TypeError,ForDynamic} core::int*), :async_op_then, :async_op_error) in null;
|
||||
core::List<core::int*>* l0 = _in::unsafeCast<core::List<core::int*>*>(:result_or_exception);
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(asy::Future::value<core::List<core::int*>*>(core::_GrowableList::_literal1<core::int*>(d as{TypeError,ForDynamic} core::int*)), :async_op_then, :async_op_error) in null;
|
||||
core::List<core::int*>* l1 = _in::unsafeCast<core::List<core::int*>*>(:result_or_exception);
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
@@ -33,7 +33,7 @@ static method main() → asy::Future<dynamic>* /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
+32
-32
@@ -71,7 +71,7 @@ static method f() → asy::Future<dynamic>* /* originally async */ {
|
||||
dynamic :saved_try_context_var1;
|
||||
dynamic :exception0;
|
||||
dynamic :stack_trace0;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -123,8 +123,8 @@ static method f() → asy::Future<dynamic>* /* originally async */ {
|
||||
#L2:
|
||||
while (true) {
|
||||
dynamic #t3 = asy::_asyncStarMoveNextHelper(:stream);
|
||||
[yield] let dynamic #t4 = 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)) {
|
||||
[yield] let dynamic #t4 = 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)) {
|
||||
dynamic x = :for-iterator.{asy::_StreamIterator::current}{dynamic};
|
||||
{}
|
||||
}
|
||||
@@ -133,8 +133,8 @@ static method f() → asy::Future<dynamic>* /* originally async */ {
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<dynamic>?} == null)) {
|
||||
[yield] let dynamic #t5 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t5 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
{
|
||||
@@ -144,8 +144,8 @@ static method f() → asy::Future<dynamic>* /* originally async */ {
|
||||
#L3:
|
||||
while (true) {
|
||||
dynamic #t6 = asy::_asyncStarMoveNextHelper(:stream);
|
||||
[yield] let dynamic #t7 = 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)) {
|
||||
[yield] let dynamic #t7 = 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)) {
|
||||
dynamic x = :for-iterator.{asy::_StreamIterator::current}{dynamic};
|
||||
{}
|
||||
}
|
||||
@@ -154,8 +154,8 @@ static method f() → asy::Future<dynamic>* /* originally async */ {
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<dynamic>?} == null)) {
|
||||
[yield] let dynamic #t8 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t8 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
{
|
||||
@@ -165,8 +165,8 @@ static method f() → asy::Future<dynamic>* /* originally async */ {
|
||||
#L4:
|
||||
while (true) {
|
||||
dynamic #t9 = asy::_asyncStarMoveNextHelper(:stream);
|
||||
[yield] let dynamic #t10 = 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)) {
|
||||
[yield] let dynamic #t10 = 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)) {
|
||||
core::Object* x = :for-iterator.{asy::_StreamIterator::current}{core::Object*};
|
||||
{}
|
||||
}
|
||||
@@ -175,8 +175,8 @@ static method f() → asy::Future<dynamic>* /* originally async */ {
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<core::Object*>?} == null)) {
|
||||
[yield] let dynamic #t11 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t11 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
{
|
||||
@@ -186,8 +186,8 @@ static method f() → asy::Future<dynamic>* /* originally async */ {
|
||||
#L5:
|
||||
while (true) {
|
||||
dynamic #t12 = asy::_asyncStarMoveNextHelper(:stream);
|
||||
[yield] let dynamic #t13 = 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)) {
|
||||
[yield] let dynamic #t13 = 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)) {
|
||||
final dynamic #t14 = :for-iterator.{asy::_StreamIterator::current}{dynamic};
|
||||
{
|
||||
d = #t14;
|
||||
@@ -198,8 +198,8 @@ static method f() → asy::Future<dynamic>* /* originally async */ {
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<dynamic>?} == null)) {
|
||||
[yield] let dynamic #t15 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t15 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
{
|
||||
@@ -209,8 +209,8 @@ static method f() → asy::Future<dynamic>* /* originally async */ {
|
||||
#L6:
|
||||
while (true) {
|
||||
dynamic #t16 = asy::_asyncStarMoveNextHelper(:stream);
|
||||
[yield] let dynamic #t17 = 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)) {
|
||||
[yield] let dynamic #t17 = 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)) {
|
||||
final core::Object* #t18 = :for-iterator.{asy::_StreamIterator::current}{core::Object*};
|
||||
{
|
||||
o = #t18;
|
||||
@@ -221,8 +221,8 @@ static method f() → asy::Future<dynamic>* /* originally async */ {
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<core::Object*>?} == null)) {
|
||||
[yield] let dynamic #t19 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t19 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -234,7 +234,7 @@ static method f() → asy::Future<dynamic>* /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -250,7 +250,7 @@ static method main() → asy::Future<dynamic>* /* originally async */ {
|
||||
dynamic :saved_try_context_var1;
|
||||
dynamic :exception0;
|
||||
dynamic :stack_trace0;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L7:
|
||||
{
|
||||
@@ -282,8 +282,8 @@ static method main() → asy::Future<dynamic>* /* originally async */ {
|
||||
#L8:
|
||||
while (true) {
|
||||
dynamic #t20 = asy::_asyncStarMoveNextHelper(:stream);
|
||||
[yield] let dynamic #t21 = 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)) {
|
||||
[yield] let dynamic #t21 = 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)) {
|
||||
core::int* x = :for-iterator.{asy::_StreamIterator::current}{core::int*};
|
||||
{}
|
||||
}
|
||||
@@ -292,8 +292,8 @@ static method main() → asy::Future<dynamic>* /* originally async */ {
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<core::int*>?} == null)) {
|
||||
[yield] let dynamic #t22 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t22 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
{
|
||||
@@ -303,8 +303,8 @@ static method main() → asy::Future<dynamic>* /* originally async */ {
|
||||
#L9:
|
||||
while (true) {
|
||||
dynamic #t23 = asy::_asyncStarMoveNextHelper(:stream);
|
||||
[yield] let dynamic #t24 = 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)) {
|
||||
[yield] let dynamic #t24 = 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)) {
|
||||
core::int* x = :for-iterator.{asy::_StreamIterator::current}{core::int*};
|
||||
{}
|
||||
}
|
||||
@@ -313,8 +313,8 @@ static method main() → asy::Future<dynamic>* /* originally async */ {
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<core::int*>?} == null)) {
|
||||
[yield] let dynamic #t25 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t25 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -326,7 +326,7 @@ static method main() → asy::Future<dynamic>* /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
+1
-1
@@ -92,7 +92,7 @@ static method foo() → asy::Stream<core::List<core::int*>*>* /* originally asyn
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L1:
|
||||
|
||||
+10
-10
@@ -16,7 +16,7 @@ static method test() → dynamic /* originally async */ {
|
||||
dynamic :saved_try_context_var1;
|
||||
dynamic :exception0;
|
||||
dynamic :stack_trace0;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -35,8 +35,8 @@ static method test() → dynamic /* originally async */ {
|
||||
#L2:
|
||||
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, :async_op) in null;
|
||||
if(_in::unsafeCast<core::bool>(:result)) {
|
||||
[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)) {
|
||||
dynamic x = :for-iterator.{asy::_StreamIterator::current}{dynamic};
|
||||
{}
|
||||
}
|
||||
@@ -45,8 +45,8 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<dynamic>?} == null)) {
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[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;
|
||||
}
|
||||
}
|
||||
core::int* y;
|
||||
@@ -66,8 +66,8 @@ static method test() → dynamic /* originally async */ {
|
||||
#L3:
|
||||
while (true) {
|
||||
dynamic #t5 = asy::_asyncStarMoveNextHelper(:stream);
|
||||
[yield] let dynamic #t6 = 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)) {
|
||||
[yield] let dynamic #t6 = 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)) {
|
||||
final dynamic #t7 = :for-iterator.{asy::_StreamIterator::current}{dynamic};
|
||||
{
|
||||
y = #t7 as{TypeError,ForDynamic} core::int*;
|
||||
@@ -78,8 +78,8 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<dynamic>?} == null)) {
|
||||
[yield] let dynamic #t8 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t8 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -91,7 +91,7 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -44,12 +44,12 @@ static method test() → void {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(asy::Future::value<core::int*>(3), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = _in::unsafeCast<core::int*>(:result);
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(asy::Future::value<core::int*>(3), :async_op_then, :async_op_error) in null;
|
||||
:return_value = _in::unsafeCast<core::int*>(:result_or_exception);
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -60,7 +60,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
@@ -73,12 +73,12 @@ static method test() → void {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(asy::Future::value<core::int*>(3), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = _in::unsafeCast<core::int*>(:result);
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(asy::Future::value<core::int*>(3), :async_op_then, :async_op_error) in null;
|
||||
:return_value = _in::unsafeCast<core::int*>(:result_or_exception);
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -89,7 +89,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
@@ -101,7 +101,7 @@ static method test() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L3:
|
||||
{
|
||||
@@ -116,7 +116,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
@@ -128,7 +128,7 @@ static method test() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L4:
|
||||
{
|
||||
@@ -143,7 +143,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
@@ -159,7 +159,7 @@ static method test() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L5:
|
||||
{
|
||||
@@ -174,7 +174,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
@@ -186,7 +186,7 @@ static method test() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L6:
|
||||
{
|
||||
@@ -201,7 +201,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
|
||||
@@ -44,12 +44,12 @@ static method test() → void {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(new self::MyFuture::value<core::int*>(3), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = _in::unsafeCast<core::int*>(:result);
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(new self::MyFuture::value<core::int*>(3), :async_op_then, :async_op_error) in null;
|
||||
:return_value = _in::unsafeCast<core::int*>(:result_or_exception);
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -60,7 +60,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
@@ -73,12 +73,12 @@ static method test() → void {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(new self::MyFuture::value<core::int*>(3), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = _in::unsafeCast<core::int*>(:result);
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(new self::MyFuture::value<core::int*>(3), :async_op_then, :async_op_error) in null;
|
||||
:return_value = _in::unsafeCast<core::int*>(:result_or_exception);
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -89,7 +89,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
@@ -101,7 +101,7 @@ static method test() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L3:
|
||||
{
|
||||
@@ -116,7 +116,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
@@ -128,7 +128,7 @@ static method test() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L4:
|
||||
{
|
||||
@@ -143,7 +143,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
@@ -159,7 +159,7 @@ static method test() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L5:
|
||||
{
|
||||
@@ -174,7 +174,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
@@ -186,7 +186,7 @@ static method test() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L6:
|
||||
{
|
||||
@@ -201,7 +201,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
|
||||
@@ -44,12 +44,12 @@ static method test() → void {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(asy::Future::value<core::int*>(3), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = _in::unsafeCast<core::int*>(:result);
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(asy::Future::value<core::int*>(3), :async_op_then, :async_op_error) in null;
|
||||
:return_value = _in::unsafeCast<core::int*>(:result_or_exception);
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -60,7 +60,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
@@ -73,12 +73,12 @@ static method test() → void {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(asy::Future::value<core::int*>(3), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = _in::unsafeCast<core::int*>(:result);
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(asy::Future::value<core::int*>(3), :async_op_then, :async_op_error) in null;
|
||||
:return_value = _in::unsafeCast<core::int*>(:result_or_exception);
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -89,7 +89,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
@@ -101,7 +101,7 @@ static method test() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L3:
|
||||
{
|
||||
@@ -116,7 +116,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
@@ -128,7 +128,7 @@ static method test() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L4:
|
||||
{
|
||||
@@ -143,7 +143,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
@@ -159,7 +159,7 @@ static method test() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L5:
|
||||
{
|
||||
@@ -174,7 +174,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
@@ -186,7 +186,7 @@ static method test() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L6:
|
||||
{
|
||||
@@ -201,7 +201,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
|
||||
@@ -44,12 +44,12 @@ static method test() → void {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(new self::MyFuture::value<core::int*>(3), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = _in::unsafeCast<core::int*>(:result);
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(new self::MyFuture::value<core::int*>(3), :async_op_then, :async_op_error) in null;
|
||||
:return_value = _in::unsafeCast<core::int*>(:result_or_exception);
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -60,7 +60,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
@@ -73,12 +73,12 @@ static method test() → void {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(new self::MyFuture::value<core::int*>(3), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = _in::unsafeCast<core::int*>(:result);
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(new self::MyFuture::value<core::int*>(3), :async_op_then, :async_op_error) in null;
|
||||
:return_value = _in::unsafeCast<core::int*>(:result_or_exception);
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -89,7 +89,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
@@ -101,7 +101,7 @@ static method test() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L3:
|
||||
{
|
||||
@@ -116,7 +116,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
@@ -128,7 +128,7 @@ static method test() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L4:
|
||||
{
|
||||
@@ -143,7 +143,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
@@ -159,7 +159,7 @@ static method test() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L5:
|
||||
{
|
||||
@@ -174,7 +174,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
@@ -186,7 +186,7 @@ static method test() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L6:
|
||||
{
|
||||
@@ -201,7 +201,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
|
||||
@@ -44,12 +44,12 @@ static method test() → void {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(new self::MyFuture::value<core::int*>(3), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = _in::unsafeCast<core::int*>(:result);
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(new self::MyFuture::value<core::int*>(3), :async_op_then, :async_op_error) in null;
|
||||
:return_value = _in::unsafeCast<core::int*>(:result_or_exception);
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -60,7 +60,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* asy::Future<core::int*>*};
|
||||
@@ -73,12 +73,12 @@ static method test() → void {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(new self::MyFuture::value<core::int*>(3), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = _in::unsafeCast<core::int*>(:result);
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(new self::MyFuture::value<core::int*>(3), :async_op_then, :async_op_error) in null;
|
||||
:return_value = _in::unsafeCast<core::int*>(:result_or_exception);
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -89,7 +89,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* asy::Future<core::int*>*};
|
||||
@@ -101,7 +101,7 @@ static method test() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L3:
|
||||
{
|
||||
@@ -116,7 +116,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* asy::Future<core::int*>*};
|
||||
@@ -128,7 +128,7 @@ static method test() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L4:
|
||||
{
|
||||
@@ -143,7 +143,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* asy::Future<core::int*>*};
|
||||
@@ -159,7 +159,7 @@ static method test() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L5:
|
||||
{
|
||||
@@ -174,7 +174,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* asy::Future<core::int*>*};
|
||||
@@ -186,7 +186,7 @@ static method test() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L6:
|
||||
{
|
||||
@@ -201,7 +201,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* asy::Future<core::int*>*};
|
||||
|
||||
@@ -44,12 +44,12 @@ static method test() → void {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(asy::Future::value<core::int*>(3), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = _in::unsafeCast<core::int*>(:result);
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(asy::Future::value<core::int*>(3), :async_op_then, :async_op_error) in null;
|
||||
:return_value = _in::unsafeCast<core::int*>(:result_or_exception);
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -60,7 +60,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* asy::Future<core::int*>*};
|
||||
@@ -73,12 +73,12 @@ static method test() → void {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(asy::Future::value<core::int*>(3), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = _in::unsafeCast<core::int*>(:result);
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(asy::Future::value<core::int*>(3), :async_op_then, :async_op_error) in null;
|
||||
:return_value = _in::unsafeCast<core::int*>(:result_or_exception);
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -89,7 +89,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* asy::Future<core::int*>*};
|
||||
@@ -101,7 +101,7 @@ static method test() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L3:
|
||||
{
|
||||
@@ -116,7 +116,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* asy::Future<core::int*>*};
|
||||
@@ -128,7 +128,7 @@ static method test() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L4:
|
||||
{
|
||||
@@ -143,7 +143,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* asy::Future<core::int*>*};
|
||||
@@ -159,7 +159,7 @@ static method test() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L5:
|
||||
{
|
||||
@@ -174,7 +174,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* asy::Future<core::int*>*};
|
||||
@@ -186,7 +186,7 @@ static method test() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L6:
|
||||
{
|
||||
@@ -201,7 +201,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((dynamic) →* FutureOr<core::int*>*, {onError: core::Function*}) →* asy::Future<core::int*>*};
|
||||
|
||||
+8
-8
@@ -45,7 +45,7 @@ static method test() → void {
|
||||
dynamic :await_ctx_var;
|
||||
dynamic :saved_try_context_var0;
|
||||
core::int* :async_temporary_0;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -53,8 +53,8 @@ static method test() → void {
|
||||
:async_temporary_0 = 2;
|
||||
}
|
||||
else {
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(asy::Future::value<core::int*>(3), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:async_temporary_0 = _in::unsafeCast<core::int*>(:result);
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(asy::Future::value<core::int*>(3), :async_op_then, :async_op_error) in null;
|
||||
:async_temporary_0 = _in::unsafeCast<core::int*>(:result_or_exception);
|
||||
}
|
||||
:return_value = _in::unsafeCast<core::int*>(:async_temporary_0);
|
||||
break #L1;
|
||||
@@ -67,7 +67,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((core::bool*) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
@@ -80,12 +80,12 @@ static method test() → void {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(x, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = (_in::unsafeCast<core::bool*>(:result) ?{core::Object*} 2 : asy::Future::value<core::int*>(3)) as{TypeError} FutureOr<core::int*>*;
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(x, :async_op_then, :async_op_error) in null;
|
||||
:return_value = (_in::unsafeCast<core::bool*>(:result_or_exception) ?{core::Object*} 2 : asy::Future::value<core::int*>(3)) as{TypeError} FutureOr<core::int*>*;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -96,7 +96,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((core::bool*) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
|
||||
+8
-8
@@ -45,7 +45,7 @@ static method test() → void {
|
||||
dynamic :await_ctx_var;
|
||||
dynamic :saved_try_context_var0;
|
||||
core::int* :async_temporary_0;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -53,8 +53,8 @@ static method test() → void {
|
||||
:async_temporary_0 = 2;
|
||||
}
|
||||
else {
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(new self::MyFuture::value<core::int*>(3), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:async_temporary_0 = _in::unsafeCast<core::int*>(:result);
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(new self::MyFuture::value<core::int*>(3), :async_op_then, :async_op_error) in null;
|
||||
:async_temporary_0 = _in::unsafeCast<core::int*>(:result_or_exception);
|
||||
}
|
||||
:return_value = _in::unsafeCast<core::int*>(:async_temporary_0);
|
||||
break #L1;
|
||||
@@ -67,7 +67,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((core::bool*) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
@@ -80,12 +80,12 @@ static method test() → void {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(x, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = (_in::unsafeCast<core::bool*>(:result) ?{core::Object*} 2 : new self::MyFuture::value<core::int*>(3)) as{TypeError} FutureOr<core::int*>*;
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(x, :async_op_then, :async_op_error) in null;
|
||||
:return_value = (_in::unsafeCast<core::bool*>(:result_or_exception) ?{core::Object*} 2 : new self::MyFuture::value<core::int*>(3)) as{TypeError} FutureOr<core::int*>*;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -96,7 +96,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((core::bool*) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
|
||||
+8
-8
@@ -45,7 +45,7 @@ static method test() → void {
|
||||
dynamic :await_ctx_var;
|
||||
dynamic :saved_try_context_var0;
|
||||
core::int* :async_temporary_0;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -53,8 +53,8 @@ static method test() → void {
|
||||
:async_temporary_0 = 2;
|
||||
}
|
||||
else {
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(asy::Future::value<core::int*>(3), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:async_temporary_0 = _in::unsafeCast<core::int*>(:result);
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(asy::Future::value<core::int*>(3), :async_op_then, :async_op_error) in null;
|
||||
:async_temporary_0 = _in::unsafeCast<core::int*>(:result_or_exception);
|
||||
}
|
||||
:return_value = _in::unsafeCast<core::int*>(:async_temporary_0);
|
||||
break #L1;
|
||||
@@ -67,7 +67,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((core::bool*) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
@@ -80,12 +80,12 @@ static method test() → void {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(x, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = (_in::unsafeCast<core::bool*>(:result) ?{core::Object*} 2 : asy::Future::value<core::int*>(3)) as{TypeError} FutureOr<core::int*>*;
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(x, :async_op_then, :async_op_error) in null;
|
||||
:return_value = (_in::unsafeCast<core::bool*>(:result_or_exception) ?{core::Object*} 2 : asy::Future::value<core::int*>(3)) as{TypeError} FutureOr<core::int*>*;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -96,7 +96,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((core::bool*) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
|
||||
+8
-8
@@ -45,7 +45,7 @@ static method test() → void {
|
||||
dynamic :await_ctx_var;
|
||||
dynamic :saved_try_context_var0;
|
||||
core::int* :async_temporary_0;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -53,8 +53,8 @@ static method test() → void {
|
||||
:async_temporary_0 = 2;
|
||||
}
|
||||
else {
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(new self::MyFuture::value<core::int*>(3), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:async_temporary_0 = _in::unsafeCast<core::int*>(:result);
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(new self::MyFuture::value<core::int*>(3), :async_op_then, :async_op_error) in null;
|
||||
:async_temporary_0 = _in::unsafeCast<core::int*>(:result_or_exception);
|
||||
}
|
||||
:return_value = _in::unsafeCast<core::int*>(:async_temporary_0);
|
||||
break #L1;
|
||||
@@ -67,7 +67,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((core::bool*) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
@@ -80,12 +80,12 @@ static method test() → void {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(x, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = (_in::unsafeCast<core::bool*>(:result) ?{core::Object*} 2 : new self::MyFuture::value<core::int*>(3)) as{TypeError} FutureOr<core::int*>*;
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(x, :async_op_then, :async_op_error) in null;
|
||||
:return_value = (_in::unsafeCast<core::bool*>(:result_or_exception) ?{core::Object*} 2 : new self::MyFuture::value<core::int*>(3)) as{TypeError} FutureOr<core::int*>*;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -96,7 +96,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((core::bool*) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
|
||||
+8
-8
@@ -45,7 +45,7 @@ static method test() → void {
|
||||
dynamic :await_ctx_var;
|
||||
dynamic :saved_try_context_var0;
|
||||
core::int* :async_temporary_0;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -53,8 +53,8 @@ static method test() → void {
|
||||
:async_temporary_0 = 2;
|
||||
}
|
||||
else {
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(new self::MyFuture::value<core::int*>(3), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:async_temporary_0 = _in::unsafeCast<core::int*>(:result);
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(new self::MyFuture::value<core::int*>(3), :async_op_then, :async_op_error) in null;
|
||||
:async_temporary_0 = _in::unsafeCast<core::int*>(:result_or_exception);
|
||||
}
|
||||
:return_value = _in::unsafeCast<core::int*>(:async_temporary_0);
|
||||
break #L1;
|
||||
@@ -67,7 +67,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((core::bool*) →* FutureOr<core::int*>*, {onError: core::Function*}) →* asy::Future<core::int*>*};
|
||||
@@ -80,12 +80,12 @@ static method test() → void {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(x, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = (_in::unsafeCast<core::bool*>(:result) ?{core::Object*} 2 : new self::MyFuture::value<core::int*>(3)) as{TypeError} FutureOr<core::int*>*;
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(x, :async_op_then, :async_op_error) in null;
|
||||
:return_value = (_in::unsafeCast<core::bool*>(:result_or_exception) ?{core::Object*} 2 : new self::MyFuture::value<core::int*>(3)) as{TypeError} FutureOr<core::int*>*;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -96,7 +96,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((core::bool*) →* FutureOr<core::int*>*, {onError: core::Function*}) →* asy::Future<core::int*>*};
|
||||
|
||||
+8
-8
@@ -45,7 +45,7 @@ static method test() → void {
|
||||
dynamic :await_ctx_var;
|
||||
dynamic :saved_try_context_var0;
|
||||
core::int* :async_temporary_0;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -53,8 +53,8 @@ static method test() → void {
|
||||
:async_temporary_0 = 2;
|
||||
}
|
||||
else {
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(asy::Future::value<core::int*>(3), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:async_temporary_0 = _in::unsafeCast<core::int*>(:result);
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(asy::Future::value<core::int*>(3), :async_op_then, :async_op_error) in null;
|
||||
:async_temporary_0 = _in::unsafeCast<core::int*>(:result_or_exception);
|
||||
}
|
||||
:return_value = _in::unsafeCast<core::int*>(:async_temporary_0);
|
||||
break #L1;
|
||||
@@ -67,7 +67,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((core::bool*) →* FutureOr<core::int*>*, {onError: core::Function*}) →* asy::Future<core::int*>*};
|
||||
@@ -80,12 +80,12 @@ static method test() → void {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(x, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = (_in::unsafeCast<core::bool*>(:result) ?{core::Object*} 2 : asy::Future::value<core::int*>(3)) as{TypeError} FutureOr<core::int*>*;
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(x, :async_op_then, :async_op_error) in null;
|
||||
:return_value = (_in::unsafeCast<core::bool*>(:result_or_exception) ?{core::Object*} 2 : asy::Future::value<core::int*>(3)) as{TypeError} FutureOr<core::int*>*;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -96,7 +96,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((core::bool*) →* FutureOr<core::int*>*, {onError: core::Function*}) →* asy::Future<core::int*>*};
|
||||
|
||||
@@ -45,14 +45,14 @@ static method test() → void {
|
||||
dynamic :await_ctx_var;
|
||||
dynamic :saved_try_context_var0;
|
||||
core::int* :async_temporary_0;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
final core::int* #t1 = x;
|
||||
if(#t1 == null) {
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(asy::Future::value<core::int*>(3), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:async_temporary_0 = _in::unsafeCast<core::int*>(:result);
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(asy::Future::value<core::int*>(3), :async_op_then, :async_op_error) in null;
|
||||
:async_temporary_0 = _in::unsafeCast<core::int*>(:result_or_exception);
|
||||
}
|
||||
else {
|
||||
:async_temporary_0 = #t1;
|
||||
@@ -68,7 +68,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((core::int*) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
@@ -81,12 +81,12 @@ static method test() → void {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(x, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = (let final core::int* #t4 = _in::unsafeCast<core::int*>(:result) in #t4 == null ?{core::Object*} asy::Future::value<core::int*>(3) : #t4) as{TypeError} FutureOr<core::int*>*;
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(x, :async_op_then, :async_op_error) in null;
|
||||
:return_value = (let final core::int* #t4 = _in::unsafeCast<core::int*>(:result_or_exception) in #t4 == null ?{core::Object*} asy::Future::value<core::int*>(3) : #t4) as{TypeError} FutureOr<core::int*>*;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -97,7 +97,7 @@ static method test() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}){((core::int*) →* FutureOr<core::int*>*, {onError: core::Function*}) →* self::MyFuture<core::int*>*};
|
||||
|
||||
+6
-6
@@ -40,7 +40,7 @@ static method g1(core::bool* x) → asy::Future<core::int*>* /* originally async
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -55,7 +55,7 @@ static method g1(core::bool* x) → asy::Future<core::int*>* /* originally async
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -67,7 +67,7 @@ static method g2(core::bool* x) → asy::Future<core::int*>* /* originally async
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
@@ -82,7 +82,7 @@ static method g2(core::bool* x) → asy::Future<core::int*>* /* originally async
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -94,7 +94,7 @@ static method g3(core::bool* x) → asy::Future<core::int*>* /* originally async
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L3:
|
||||
{
|
||||
@@ -110,7 +110,7 @@ static method g3(core::bool* x) → asy::Future<core::int*>* /* originally async
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
+6
-6
@@ -40,7 +40,7 @@ static method g1(core::bool* x) → asy::Future<core::int*>* /* originally async
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -55,7 +55,7 @@ static method g1(core::bool* x) → asy::Future<core::int*>* /* originally async
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -67,7 +67,7 @@ static method g2(core::bool* x) → asy::Future<core::int*>* /* originally async
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
@@ -82,7 +82,7 @@ static method g2(core::bool* x) → asy::Future<core::int*>* /* originally async
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -94,7 +94,7 @@ static method g3(core::bool* x) → asy::Future<core::int*>* /* originally async
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L3:
|
||||
{
|
||||
@@ -110,7 +110,7 @@ static method g3(core::bool* x) → asy::Future<core::int*>* /* originally async
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
+4
-4
@@ -52,7 +52,7 @@ static method g2() → asy::Future<core::List<core::int*>*>* /* originally async
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -67,7 +67,7 @@ static method g2() → asy::Future<core::List<core::int*>*>* /* originally async
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -79,7 +79,7 @@ static method g3() → asy::Future<core::List<core::int*>*>* /* originally async
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
@@ -94,7 +94,7 @@ static method g3() → asy::Future<core::List<core::int*>*>* /* originally async
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
+4
-4
@@ -43,7 +43,7 @@ static method g2() → asy::Future<core::List<core::int*>*>* /* originally async
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -58,7 +58,7 @@ static method g2() → asy::Future<core::List<core::int*>*>* /* originally async
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -70,7 +70,7 @@ static method g3() → asy::Future<core::List<core::int*>*>* /* originally async
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
@@ -85,7 +85,7 @@ static method g3() → asy::Future<core::List<core::int*>*>* /* originally async
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
+4
-4
@@ -52,7 +52,7 @@ static method g2() → asy::Future<core::List<core::int*>*>* /* originally async
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -67,7 +67,7 @@ static method g2() → asy::Future<core::List<core::int*>*>* /* originally async
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -79,7 +79,7 @@ static method g3() → asy::Future<core::List<core::int*>*>* /* originally async
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
@@ -94,7 +94,7 @@ static method g3() → asy::Future<core::List<core::int*>*>* /* originally async
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
+4
-4
@@ -43,7 +43,7 @@ static method g2() → asy::Future<core::List<core::int*>*>* /* originally async
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -58,7 +58,7 @@ static method g2() → asy::Future<core::List<core::int*>*>* /* originally async
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -70,7 +70,7 @@ static method g3() → asy::Future<core::List<core::int*>*>* /* originally async
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
@@ -85,7 +85,7 @@ static method g3() → asy::Future<core::List<core::int*>*>* /* originally async
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
+4
-4
@@ -30,14 +30,14 @@ static method foo() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
asy::Future<core::List<self::A*>*>* f1 = null;
|
||||
asy::Future<core::List<self::A*>*>* f2 = null;
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(asy::Future::wait<core::List<self::A*>*>(core::_GrowableList::_literal2<asy::Future<core::List<self::A*>*>*>(f1, f2)), :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::List<core::List<self::A*>*>* merged = _in::unsafeCast<core::List<core::List<self::A*>*>>(:result);
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(asy::Future::wait<core::List<self::A*>*>(core::_GrowableList::_literal2<asy::Future<core::List<self::A*>*>*>(f1, f2)), :async_op_then, :async_op_error) in null;
|
||||
core::List<core::List<self::A*>*>* merged = _in::unsafeCast<core::List<core::List<self::A*>*>>(:result_or_exception);
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
@@ -47,7 +47,7 @@ static method foo() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
+4
-4
@@ -17,13 +17,13 @@ static method test() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
asy::Future<core::String*>* f;
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(self::id<FutureOr<core::String*>*>(f), :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::String* s = _in::unsafeCast<core::String*>(:result);
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(self::id<FutureOr<core::String*>*>(f), :async_op_then, :async_op_error) in null;
|
||||
core::String* s = _in::unsafeCast<core::String*>(:result_or_exception);
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
@@ -33,7 +33,7 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
+6
-6
@@ -40,17 +40,17 @@ static method main() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
asy::Future<self::B*>* b = asy::Future::value<self::B*>(new self::B::•());
|
||||
asy::Future<self::C*>* c = asy::Future::value<self::C*>(new self::C::•());
|
||||
core::List<asy::Future<self::A*>*>* lll = core::_GrowableList::_literal2<asy::Future<self::A*>*>(b, c);
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(asy::Future::wait<self::A*>(lll), :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::List<self::A*>* result = _in::unsafeCast<core::List<self::A*>>(:result);
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(asy::Future::wait<self::A*>(core::_GrowableList::_literal2<asy::Future<self::A*>*>(b, c)), :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::List<self::A*>* result2 = _in::unsafeCast<core::List<self::A*>>(:result);
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(asy::Future::wait<self::A*>(lll), :async_op_then, :async_op_error) in null;
|
||||
core::List<self::A*>* result = _in::unsafeCast<core::List<self::A*>>(:result_or_exception);
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(asy::Future::wait<self::A*>(core::_GrowableList::_literal2<asy::Future<self::A*>*>(b, c)), :async_op_then, :async_op_error) in null;
|
||||
core::List<self::A*>* result2 = _in::unsafeCast<core::List<self::A*>>(:result_or_exception);
|
||||
core::List<self::A*>* list = result;
|
||||
list = result2;
|
||||
}
|
||||
@@ -62,7 +62,7 @@ static method main() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -16,7 +16,7 @@ static method main() → void {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L1:
|
||||
|
||||
+5
-5
@@ -14,7 +14,7 @@ static method test() → dynamic {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -29,7 +29,7 @@ static method test() → dynamic {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -44,7 +44,7 @@ static method test() → dynamic {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
@@ -59,7 +59,7 @@ static method test() → dynamic {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -89,7 +89,7 @@ static method test() → dynamic {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L3:
|
||||
|
||||
+42
-42
@@ -67,7 +67,7 @@ class Bar<T extends asy::Stream<core::String*>*> extends core::Object {
|
||||
dynamic :saved_try_context_var1;
|
||||
dynamic :exception0;
|
||||
dynamic :stack_trace0;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -78,8 +78,8 @@ class Bar<T extends asy::Stream<core::String*>*> extends core::Object {
|
||||
#L2:
|
||||
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, :async_op) in null;
|
||||
if(_in::unsafeCast<core::bool>(:result)) {
|
||||
[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)) {
|
||||
core::String* i = :for-iterator.{asy::_StreamIterator::current}{core::String*};
|
||||
{
|
||||
core::int* x = invalid-expression "pkg/front_end/testcases/inference/infer_types_on_loop_indices_for_each_loop_async.dart:17:44: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
|
||||
@@ -92,8 +92,8 @@ class Bar<T extends asy::Stream<core::String*>*> extends core::Object {
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<core::String*>?} == null)) {
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[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;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -105,7 +105,7 @@ class Bar<T extends asy::Stream<core::String*>*> extends core::Object {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -136,7 +136,7 @@ class Baz<T extends core::Object* = dynamic, E extends asy::Stream<self::Baz::T*
|
||||
dynamic :saved_try_context_var1;
|
||||
dynamic :exception0;
|
||||
dynamic :stack_trace0;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L3:
|
||||
{
|
||||
@@ -147,8 +147,8 @@ class Baz<T extends core::Object* = dynamic, E extends asy::Stream<self::Baz::T*
|
||||
#L4:
|
||||
while (true) {
|
||||
dynamic #t4 = asy::_asyncStarMoveNextHelper(:stream);
|
||||
[yield] let dynamic #t5 = 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)) {
|
||||
[yield] let dynamic #t5 = 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)) {
|
||||
self::Baz::T* i = :for-iterator.{asy::_StreamIterator::current}{self::Baz::T*};
|
||||
{
|
||||
core::int* x = invalid-expression "pkg/front_end/testcases/inference/infer_types_on_loop_indices_for_each_loop_async.dart:25:44: Error: A value of type 'T' can't be assigned to a variable of type 'int'.
|
||||
@@ -162,8 +162,8 @@ class Baz<T extends core::Object* = dynamic, E extends asy::Stream<self::Baz::T*
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<self::Baz::T*>?} == null)) {
|
||||
[yield] let dynamic #t6 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t6 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -175,7 +175,7 @@ class Baz<T extends core::Object* = dynamic, E extends asy::Stream<self::Baz::T*
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -253,7 +253,7 @@ static method test() → dynamic /* originally async */ {
|
||||
dynamic :saved_try_context_var1;
|
||||
dynamic :exception0;
|
||||
dynamic :stack_trace0;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L5:
|
||||
{
|
||||
@@ -265,8 +265,8 @@ static method test() → dynamic /* originally async */ {
|
||||
#L6:
|
||||
while (true) {
|
||||
dynamic #t7 = asy::_asyncStarMoveNextHelper(:stream);
|
||||
[yield] let dynamic #t8 = 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)) {
|
||||
[yield] let dynamic #t8 = 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)) {
|
||||
self::Foo* x = :for-iterator.{asy::_StreamIterator::current}{self::Foo*};
|
||||
{
|
||||
core::String* y = invalid-expression "pkg/front_end/testcases/inference/infer_types_on_loop_indices_for_each_loop_async.dart:38:45: Error: A value of type 'Foo' can't be assigned to a variable of type 'String'.
|
||||
@@ -280,8 +280,8 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<self::Foo*>?} == null)) {
|
||||
[yield] let dynamic #t9 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t9 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
{
|
||||
@@ -291,8 +291,8 @@ static method test() → dynamic /* originally async */ {
|
||||
#L7:
|
||||
while (true) {
|
||||
dynamic #t10 = asy::_asyncStarMoveNextHelper(:stream);
|
||||
[yield] let dynamic #t11 = 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)) {
|
||||
[yield] let dynamic #t11 = 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)) {
|
||||
dynamic x = :for-iterator.{asy::_StreamIterator::current}{dynamic};
|
||||
{
|
||||
core::String* y = x as{TypeError,ForDynamic} core::String*;
|
||||
@@ -303,8 +303,8 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<dynamic>?} == null)) {
|
||||
[yield] let dynamic #t12 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t12 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
{
|
||||
@@ -314,8 +314,8 @@ static method test() → dynamic /* originally async */ {
|
||||
#L8:
|
||||
while (true) {
|
||||
dynamic #t13 = asy::_asyncStarMoveNextHelper(:stream);
|
||||
[yield] let dynamic #t14 = 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)) {
|
||||
[yield] let dynamic #t14 = 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)) {
|
||||
final self::Foo* #t15 = :for-iterator.{asy::_StreamIterator::current}{self::Foo*};
|
||||
{
|
||||
core::String* x = invalid-expression "pkg/front_end/testcases/inference/infer_types_on_loop_indices_for_each_loop_async.dart:45:21: Error: A value of type 'Foo' can't be assigned to a variable of type 'String'.
|
||||
@@ -331,8 +331,8 @@ Try changing the type of the variable.
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<self::Foo*>?} == null)) {
|
||||
[yield] let dynamic #t16 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t16 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
dynamic z;
|
||||
@@ -343,8 +343,8 @@ Try changing the type of the variable.
|
||||
#L9:
|
||||
while (true) {
|
||||
dynamic #t17 = asy::_asyncStarMoveNextHelper(:stream);
|
||||
[yield] let dynamic #t18 = 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)) {
|
||||
[yield] let dynamic #t18 = 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)) {
|
||||
final self::Foo* #t19 = :for-iterator.{asy::_StreamIterator::current}{self::Foo*};
|
||||
{
|
||||
z = #t19;
|
||||
@@ -356,8 +356,8 @@ Try changing the type of the variable.
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<self::Foo*>?} == null)) {
|
||||
[yield] let dynamic #t20 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t20 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
asy::Stream<dynamic>* stream = myStream;
|
||||
@@ -368,8 +368,8 @@ Try changing the type of the variable.
|
||||
#L10:
|
||||
while (true) {
|
||||
dynamic #t21 = asy::_asyncStarMoveNextHelper(:stream);
|
||||
[yield] let dynamic #t22 = 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)) {
|
||||
[yield] let dynamic #t22 = 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)) {
|
||||
final dynamic #t23 = :for-iterator.{asy::_StreamIterator::current}{dynamic};
|
||||
{
|
||||
self::Foo* x = #t23 as{TypeError,ForDynamic} self::Foo*;
|
||||
@@ -381,8 +381,8 @@ Try changing the type of the variable.
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<dynamic>?} == null)) {
|
||||
[yield] let dynamic #t24 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t24 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
dynamic stream2 = myStream;
|
||||
@@ -393,8 +393,8 @@ Try changing the type of the variable.
|
||||
#L11:
|
||||
while (true) {
|
||||
dynamic #t25 = asy::_asyncStarMoveNextHelper(:stream);
|
||||
[yield] let dynamic #t26 = 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)) {
|
||||
[yield] let dynamic #t26 = 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)) {
|
||||
final dynamic #t27 = :for-iterator.{asy::_StreamIterator::current}{dynamic};
|
||||
{
|
||||
self::Foo* x = #t27 as{TypeError,ForDynamic} self::Foo*;
|
||||
@@ -406,8 +406,8 @@ Try changing the type of the variable.
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<dynamic>?} == null)) {
|
||||
[yield] let dynamic #t28 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t28 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
core::Map<core::String*, self::Foo*>* map = <core::String*, self::Foo*>{};
|
||||
@@ -423,8 +423,8 @@ Try changing the type of the variable.
|
||||
#L12:
|
||||
while (true) {
|
||||
dynamic #t29 = asy::_asyncStarMoveNextHelper(:stream);
|
||||
[yield] let dynamic #t30 = 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)) {
|
||||
[yield] let dynamic #t30 = 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)) {
|
||||
dynamic x = :for-iterator.{asy::_StreamIterator::current}{dynamic};
|
||||
{
|
||||
core::String* y = x as{TypeError,ForDynamic} core::String*;
|
||||
@@ -435,8 +435,8 @@ Try changing the type of the variable.
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<dynamic>?} == null)) {
|
||||
[yield] let dynamic #t31 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t31 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -448,7 +448,7 @@ Try changing the type of the variable.
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
+4
-4
@@ -26,7 +26,7 @@ static method main() → dynamic {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -44,7 +44,7 @@ static method main() → dynamic {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -91,7 +91,7 @@ static method main() → dynamic {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L2:
|
||||
@@ -124,7 +124,7 @@ static method main() → dynamic {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L3:
|
||||
|
||||
+4
-4
@@ -25,7 +25,7 @@ static method b() → asy::Future<(core::int*) →* core::int*>* /* originally a
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -43,7 +43,7 @@ static method b() → asy::Future<(core::int*) →* core::int*>* /* originally a
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -90,7 +90,7 @@ static method e() → asy::Stream<(core::int*) →* core::int*>* /* originally a
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L2:
|
||||
@@ -123,7 +123,7 @@ static method f() → asy::Stream<(core::int*) →* core::int*>* /* originally a
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L3:
|
||||
|
||||
+10
-10
@@ -39,7 +39,7 @@ static method test() → dynamic /* originally async */ {
|
||||
dynamic :saved_try_context_var1;
|
||||
dynamic :exception0;
|
||||
dynamic :stack_trace0;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -66,8 +66,8 @@ static method test() → dynamic /* originally async */ {
|
||||
#L2:
|
||||
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)) {
|
||||
[yield] let dynamic #t3 = 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)) {
|
||||
final dynamic #t4 = :for-iterator.{asy::_StreamIterator::current}{dynamic};
|
||||
{
|
||||
core::int* x = #t4 as{TypeError,ForDynamic} core::int*;
|
||||
@@ -78,8 +78,8 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<dynamic>?} == null)) {
|
||||
[yield] let dynamic #t5 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t5 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
core::int* y;
|
||||
@@ -105,8 +105,8 @@ static method test() → dynamic /* originally async */ {
|
||||
#L3:
|
||||
while (true) {
|
||||
dynamic #t7 = asy::_asyncStarMoveNextHelper(:stream);
|
||||
[yield] let dynamic #t8 = 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)) {
|
||||
[yield] let dynamic #t8 = 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)) {
|
||||
final dynamic #t9 = :for-iterator.{asy::_StreamIterator::current}{dynamic};
|
||||
{
|
||||
y = #t9 as{TypeError,ForDynamic} core::int*;
|
||||
@@ -117,8 +117,8 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<dynamic>?} == null)) {
|
||||
[yield] let dynamic #t10 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t10 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -130,7 +130,7 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
+18
-18
@@ -55,7 +55,7 @@ static method test() → dynamic /* originally async */ {
|
||||
dynamic :saved_try_context_var1;
|
||||
dynamic :exception0;
|
||||
dynamic :stack_trace0;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -80,8 +80,8 @@ static method test() → dynamic /* originally async */ {
|
||||
#L2:
|
||||
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)) {
|
||||
[yield] let dynamic #t3 = 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)) {
|
||||
final self::A* #t4 = :for-iterator.{asy::_StreamIterator::current}{self::A*};
|
||||
{
|
||||
a = #t4;
|
||||
@@ -92,8 +92,8 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<self::A*>?} == null)) {
|
||||
[yield] let dynamic #t5 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t5 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
{
|
||||
@@ -112,8 +112,8 @@ static method test() → dynamic /* originally async */ {
|
||||
#L3:
|
||||
while (true) {
|
||||
dynamic #t7 = asy::_asyncStarMoveNextHelper(:stream);
|
||||
[yield] let dynamic #t8 = 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)) {
|
||||
[yield] let dynamic #t8 = 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)) {
|
||||
final self::A* #t9 = :for-iterator.{asy::_StreamIterator::current}{self::A*};
|
||||
{
|
||||
b = #t9 as{TypeError} self::B*;
|
||||
@@ -124,8 +124,8 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<self::A*>?} == null)) {
|
||||
[yield] let dynamic #t10 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t10 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
{
|
||||
@@ -148,8 +148,8 @@ Try changing the type of the variable.
|
||||
#L4:
|
||||
while (true) {
|
||||
dynamic #t12 = asy::_asyncStarMoveNextHelper(:stream);
|
||||
[yield] let dynamic #t13 = 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)) {
|
||||
[yield] let dynamic #t13 = 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)) {
|
||||
final self::A* #t14 = :for-iterator.{asy::_StreamIterator::current}{self::A*};
|
||||
{
|
||||
i = invalid-expression "pkg/front_end/testcases/inference_new/for_each_outer_var_type.dart:27:16: Error: A value of type 'A' can't be assigned to a variable of type 'int'.
|
||||
@@ -164,8 +164,8 @@ Try changing the type of the variable.
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<self::A*>?} == null)) {
|
||||
[yield] let dynamic #t15 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t15 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
{
|
||||
@@ -184,8 +184,8 @@ Try changing the type of the variable.
|
||||
#L5:
|
||||
while (true) {
|
||||
dynamic #t17 = asy::_asyncStarMoveNextHelper(:stream);
|
||||
[yield] let dynamic #t18 = 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)) {
|
||||
[yield] let dynamic #t18 = 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)) {
|
||||
final self::A* #t19 = :for-iterator.{asy::_StreamIterator::current}{self::A*};
|
||||
{
|
||||
a = #t19;
|
||||
@@ -196,8 +196,8 @@ Try changing the type of the variable.
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<self::A*>?} == null)) {
|
||||
[yield] let dynamic #t20 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t20 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -209,7 +209,7 @@ Try changing the type of the variable.
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() →* dynamic};
|
||||
:async_op(null, null){() →* dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -148,7 +148,7 @@ static method hest() → dynamic /* originally async */ {
|
||||
dynamic :saved_try_context_var1;
|
||||
dynamic :exception0;
|
||||
dynamic :stack_trace0;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -159,8 +159,8 @@ static method hest() → dynamic /* originally async */ {
|
||||
#L2:
|
||||
while (true) {
|
||||
dynamic #t6 = asy::_asyncStarMoveNextHelper(:stream);
|
||||
[yield] let dynamic #t7 = 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)) {
|
||||
[yield] let dynamic #t7 = 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)) {
|
||||
core::String s = :for-iterator.{asy::_StreamIterator::current}{core::String};
|
||||
{
|
||||
core::print(s);
|
||||
@@ -171,8 +171,8 @@ static method hest() → dynamic /* originally async */ {
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<core::String>?} == null)) {
|
||||
[yield] let dynamic #t8 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t8 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
:return_value = "hest";
|
||||
@@ -186,7 +186,7 @@ static method hest() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -198,7 +198,7 @@ static method fisk() → dynamic /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L3:
|
||||
{
|
||||
@@ -227,12 +227,12 @@ static method fisk() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L4:
|
||||
{
|
||||
[yield] let dynamic #t12 = asy::_awaitHelper(self::hest(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = :result;
|
||||
[yield] let dynamic #t12 = asy::_awaitHelper(self::hest(), :async_op_then, :async_op_error) in null;
|
||||
:return_value = :result_or_exception;
|
||||
break #L4;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -243,7 +243,7 @@ static method fisk() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
} : #t11{core::Function};
|
||||
@@ -258,7 +258,7 @@ static method fisk() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -270,4 +270,4 @@ constants {
|
||||
|
||||
Extra constant evaluation status:
|
||||
Evaluated: VariableGet @ org-dartlang-testcase:///later.dart:46:18 -> IntConstant(42)
|
||||
Extra constant evaluation: evaluated: 204, effectively constant: 1
|
||||
Extra constant evaluation: evaluated: 201, effectively constant: 1
|
||||
|
||||
@@ -168,7 +168,7 @@ static method hest() → dynamic /* originally async */ {
|
||||
dynamic :saved_try_context_var1;
|
||||
dynamic :exception0;
|
||||
dynamic :stack_trace0;
|
||||
function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -179,8 +179,8 @@ static method hest() → dynamic /* originally async */ {
|
||||
#L2:
|
||||
while (true) {
|
||||
dynamic #t6 = asy::_asyncStarMoveNextHelper(:stream);
|
||||
[yield] let dynamic #t7 = 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)) {
|
||||
[yield] let dynamic #t7 = 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)) {
|
||||
core::String s = :for-iterator.{asy::_StreamIterator::current}{core::String};
|
||||
{
|
||||
core::print(s);
|
||||
@@ -191,8 +191,8 @@ static method hest() → dynamic /* originally async */ {
|
||||
}
|
||||
finally
|
||||
if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<core::String>?} == null)) {
|
||||
[yield] let dynamic #t8 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:result;
|
||||
[yield] let dynamic #t8 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>}, :async_op_then, :async_op_error) in null;
|
||||
:result_or_exception;
|
||||
}
|
||||
}
|
||||
:return_value = "hest";
|
||||
@@ -206,7 +206,7 @@ static method hest() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -218,7 +218,7 @@ static method fisk() → dynamic /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L3:
|
||||
{
|
||||
@@ -265,12 +265,12 @@ static method fisk() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L4:
|
||||
{
|
||||
[yield] let dynamic #t9 = asy::_awaitHelper(self::hest(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = :result;
|
||||
[yield] let dynamic #t9 = asy::_awaitHelper(self::hest(), :async_op_then, :async_op_error) in null;
|
||||
:return_value = :result_or_exception;
|
||||
break #L4;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -281,7 +281,7 @@ static method fisk() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
@@ -302,7 +302,7 @@ static method fisk() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
+4
-4
@@ -280,7 +280,7 @@ Try changing the type of the variable.
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L4:
|
||||
{
|
||||
@@ -310,7 +310,7 @@ Try changing the type of the variable.
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -414,7 +414,7 @@ static method boz(Null x) → self::A {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L5:
|
||||
{
|
||||
@@ -442,7 +442,7 @@ static method boz(Null x) → self::A {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
+4
-4
@@ -280,7 +280,7 @@ Try changing the type of the variable.
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L4:
|
||||
{
|
||||
@@ -310,7 +310,7 @@ Try changing the type of the variable.
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -414,7 +414,7 @@ static method boz(Null x) → self::A {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L5:
|
||||
{
|
||||
@@ -442,7 +442,7 @@ static method boz(Null x) → self::A {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -14,12 +14,12 @@ abstract class TestMixin<R extends core::Object? = dynamic, T extends core::Obje
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(fetch, :async_op_then, :async_op_error, :async_op) in null;
|
||||
final self::TestMixin::R% response = _in::unsafeCast<self::TestMixin::R%>(:result);
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(fetch, :async_op_then, :async_op_error) in null;
|
||||
final self::TestMixin::R% response = _in::unsafeCast<self::TestMixin::R%>(:result_or_exception);
|
||||
self::TestMixin::T% result;
|
||||
if(response is{ForNonNullableByDefault} self::Response<dynamic>) {
|
||||
result = response{self::TestMixin::R% & self::Response<dynamic> /* '%' & '!' = '!' */}.{self::Response::data}{dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} self::TestMixin::T%;
|
||||
@@ -46,7 +46,7 @@ abstract class TestMixin<R extends core::Object? = dynamic, T extends core::Obje
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -82,12 +82,12 @@ abstract class _Class1&Object&TestMixin extends core::Object implements self::Te
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(fetch, :async_op_then, :async_op_error, :async_op) in null;
|
||||
final self::Response<core::String> response = _in::unsafeCast<self::Response<core::String>>(:result);
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(fetch, :async_op_then, :async_op_error) in null;
|
||||
final self::Response<core::String> response = _in::unsafeCast<self::Response<core::String>>(:result_or_exception);
|
||||
core::String result;
|
||||
if(response is{ForNonNullableByDefault} self::Response<dynamic>) {
|
||||
result = response{self::Response<core::String>}.{self::Response::data}{dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} core::String;
|
||||
@@ -114,7 +114,7 @@ abstract class _Class1&Object&TestMixin extends core::Object implements self::Te
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -141,12 +141,12 @@ abstract class _Class2&Object&TestMixin extends core::Object implements self::Te
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L3:
|
||||
{
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(fetch, :async_op_then, :async_op_error, :async_op) in null;
|
||||
final self::PagingResponse<core::String> response = _in::unsafeCast<self::PagingResponse<core::String>>(:result);
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(fetch, :async_op_then, :async_op_error) in null;
|
||||
final self::PagingResponse<core::String> response = _in::unsafeCast<self::PagingResponse<core::String>>(:result_or_exception);
|
||||
core::String result;
|
||||
if(response is{ForNonNullableByDefault} self::Response<dynamic>) {
|
||||
result = response{self::PagingResponse<core::String>}.{self::Response::data}{dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} core::String;
|
||||
@@ -173,7 +173,7 @@ abstract class _Class2&Object&TestMixin extends core::Object implements self::Te
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -14,12 +14,12 @@ abstract class TestMixin<R extends core::Object? = dynamic, T extends core::Obje
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(fetch, :async_op_then, :async_op_error, :async_op) in null;
|
||||
final self::TestMixin::R% response = _in::unsafeCast<self::TestMixin::R%>(:result);
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(fetch, :async_op_then, :async_op_error) in null;
|
||||
final self::TestMixin::R% response = _in::unsafeCast<self::TestMixin::R%>(:result_or_exception);
|
||||
self::TestMixin::T% result;
|
||||
if(response is{ForNonNullableByDefault} self::Response<dynamic>) {
|
||||
result = response{self::TestMixin::R% & self::Response<dynamic> /* '%' & '!' = '!' */}.{self::Response::data}{dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} self::TestMixin::T%;
|
||||
@@ -46,7 +46,7 @@ abstract class TestMixin<R extends core::Object? = dynamic, T extends core::Obje
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -82,12 +82,12 @@ abstract class _Class1&Object&TestMixin extends core::Object implements self::Te
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(fetch, :async_op_then, :async_op_error, :async_op) in null;
|
||||
final self::Response<core::String> response = _in::unsafeCast<self::Response<core::String>>(:result);
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(fetch, :async_op_then, :async_op_error) in null;
|
||||
final self::Response<core::String> response = _in::unsafeCast<self::Response<core::String>>(:result_or_exception);
|
||||
core::String result;
|
||||
if(response is{ForNonNullableByDefault} self::Response<dynamic>) {
|
||||
result = response{self::Response<core::String>}.{self::Response::data}{dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} core::String;
|
||||
@@ -114,7 +114,7 @@ abstract class _Class1&Object&TestMixin extends core::Object implements self::Te
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -141,12 +141,12 @@ abstract class _Class2&Object&TestMixin extends core::Object implements self::Te
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L3:
|
||||
{
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(fetch, :async_op_then, :async_op_error, :async_op) in null;
|
||||
final self::PagingResponse<core::String> response = _in::unsafeCast<self::PagingResponse<core::String>>(:result);
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(fetch, :async_op_then, :async_op_error) in null;
|
||||
final self::PagingResponse<core::String> response = _in::unsafeCast<self::PagingResponse<core::String>>(:result_or_exception);
|
||||
core::String result;
|
||||
if(response is{ForNonNullableByDefault} self::Response<dynamic>) {
|
||||
result = response{self::PagingResponse<core::String>}.{self::Response::data}{dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} core::String;
|
||||
@@ -173,7 +173,7 @@ abstract class _Class2&Object&TestMixin extends core::Object implements self::Te
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -21,15 +21,15 @@ static method test() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(self::l(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(self::l(), :async_op_then, :async_op_error) in null;
|
||||
core::List<dynamic> y = invalid-expression "pkg/front_end/testcases/nnbd/issue41108.dart:6:12: Error: A value of type 'List<dynamic>?' can't be assigned to a variable of type 'List<dynamic>' because 'List<dynamic>?' is nullable and 'List<dynamic>' isn't.
|
||||
- 'List' is from 'dart:core'.
|
||||
List y = await l(); // should be a List?
|
||||
^" in let core::List<dynamic>? #t2 = _in::unsafeCast<core::List<dynamic>?>(:result) in #t2 == null ?{core::List<dynamic>} #t2 as{TypeError,ForNonNullableByDefault} core::List<dynamic> : #t2{core::List<dynamic>};
|
||||
^" in let core::List<dynamic>? #t2 = _in::unsafeCast<core::List<dynamic>?>(:result_or_exception) in #t2 == null ?{core::List<dynamic>} #t2 as{TypeError,ForNonNullableByDefault} core::List<dynamic> : #t2{core::List<dynamic>};
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
@@ -39,7 +39,7 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -21,15 +21,15 @@ static method test() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(self::l(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(self::l(), :async_op_then, :async_op_error) in null;
|
||||
core::List<dynamic> y = invalid-expression "pkg/front_end/testcases/nnbd/issue41108.dart:6:12: Error: A value of type 'List<dynamic>?' can't be assigned to a variable of type 'List<dynamic>' because 'List<dynamic>?' is nullable and 'List<dynamic>' isn't.
|
||||
- 'List' is from 'dart:core'.
|
||||
List y = await l(); // should be a List?
|
||||
^" in _in::unsafeCast<core::List<dynamic>?>(:result);
|
||||
^" in _in::unsafeCast<core::List<dynamic>?>(:result_or_exception);
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
@@ -39,7 +39,7 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -11,7 +11,7 @@ static method main() → dynamic /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -28,7 +28,7 @@ static method main() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -11,7 +11,7 @@ static method main() → dynamic /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -28,7 +28,7 @@ static method main() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -63,7 +63,7 @@ static method main() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -78,7 +78,7 @@ static method main() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
@@ -90,7 +90,7 @@ static method main() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
@@ -104,7 +104,7 @@ static method main() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
@@ -116,7 +116,7 @@ static method main() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L3:
|
||||
{
|
||||
@@ -131,7 +131,7 @@ static method main() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
@@ -143,7 +143,7 @@ static method main() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L4:
|
||||
{
|
||||
@@ -158,7 +158,7 @@ static method main() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
@@ -170,7 +170,7 @@ static method main() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L5:
|
||||
{
|
||||
@@ -184,7 +184,7 @@ static method main() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
@@ -196,7 +196,7 @@ static method main() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L6:
|
||||
{
|
||||
@@ -211,7 +211,7 @@ static method main() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
@@ -224,7 +224,7 @@ static method errors() → void /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L7:
|
||||
{
|
||||
@@ -276,7 +276,7 @@ static method errors() → void /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L8:
|
||||
{
|
||||
@@ -298,7 +298,7 @@ static method errors() → void /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
@@ -310,7 +310,7 @@ static method errors() → void /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L9:
|
||||
{
|
||||
@@ -333,7 +333,7 @@ static method errors() → void /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
@@ -345,7 +345,7 @@ static method errors() → void /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L10:
|
||||
{
|
||||
@@ -367,7 +367,7 @@ static method errors() → void /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
@@ -379,7 +379,7 @@ static method errors() → void /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L11:
|
||||
{
|
||||
@@ -402,7 +402,7 @@ static method errors() → void /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
@@ -415,7 +415,7 @@ static method errors() → void /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -64,7 +64,7 @@ static method main() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -79,7 +79,7 @@ static method main() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
@@ -91,7 +91,7 @@ static method main() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
@@ -105,7 +105,7 @@ static method main() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
@@ -117,7 +117,7 @@ static method main() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L3:
|
||||
{
|
||||
@@ -132,7 +132,7 @@ static method main() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
@@ -144,7 +144,7 @@ static method main() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L4:
|
||||
{
|
||||
@@ -159,7 +159,7 @@ static method main() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
@@ -171,7 +171,7 @@ static method main() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L5:
|
||||
{
|
||||
@@ -185,7 +185,7 @@ static method main() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
@@ -197,7 +197,7 @@ static method main() → void {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L6:
|
||||
{
|
||||
@@ -212,7 +212,7 @@ static method main() → void {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
@@ -225,7 +225,7 @@ static method errors() → void /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L7:
|
||||
{
|
||||
@@ -277,7 +277,7 @@ static method errors() → void /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L8:
|
||||
{
|
||||
@@ -299,7 +299,7 @@ static method errors() → void /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
@@ -311,7 +311,7 @@ static method errors() → void /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L9:
|
||||
{
|
||||
@@ -334,7 +334,7 @@ static method errors() → void /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
@@ -346,7 +346,7 @@ static method errors() → void /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L10:
|
||||
{
|
||||
@@ -368,7 +368,7 @@ static method errors() → void /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
@@ -380,7 +380,7 @@ static method errors() → void /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L11:
|
||||
{
|
||||
@@ -403,7 +403,7 @@ static method errors() → void /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
@@ -416,7 +416,7 @@ static method errors() → void /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -41,7 +41,7 @@ static method getFutureNull() → asy::Future<dynamic> /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -56,7 +56,7 @@ static method getFutureNull() → asy::Future<dynamic> /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -68,7 +68,7 @@ static method getFutureBool() → asy::Future<core::bool> /* originally async */
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
@@ -83,7 +83,7 @@ static method getFutureBool() → asy::Future<core::bool> /* originally async */
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -96,12 +96,12 @@ static method test1() → asy::Future<core::bool> /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L3:
|
||||
{
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(self::getNull(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = :result as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<core::bool>;
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(self::getNull(), :async_op_then, :async_op_error) in null;
|
||||
:return_value = :result_or_exception as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<core::bool>;
|
||||
break #L3;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -112,7 +112,7 @@ static method test1() → asy::Future<core::bool> /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -129,12 +129,12 @@ static method test4() → asy::Future<core::bool> /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L4:
|
||||
{
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(self::getFutureNull(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = :result as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<core::bool>;
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(self::getFutureNull(), :async_op_then, :async_op_error) in null;
|
||||
:return_value = :result_or_exception as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<core::bool>;
|
||||
break #L4;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -145,7 +145,7 @@ static method test4() → asy::Future<core::bool> /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -164,7 +164,7 @@ static method test7() → asy::Future<core::bool> /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L5:
|
||||
{
|
||||
@@ -179,7 +179,7 @@ static method test7() → asy::Future<core::bool> /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -191,7 +191,7 @@ static method test() → dynamic /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L6:
|
||||
{
|
||||
@@ -204,12 +204,12 @@ static method test() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L7:
|
||||
{
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(self::getNull(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = :result as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<core::bool>;
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(self::getNull(), :async_op_then, :async_op_error) in null;
|
||||
:return_value = :result_or_exception as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<core::bool>;
|
||||
break #L7;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -220,7 +220,7 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -237,12 +237,12 @@ static method test() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L8:
|
||||
{
|
||||
[yield] let dynamic #t4 = asy::_awaitHelper(self::getFutureNull(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = :result as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<core::bool>;
|
||||
[yield] let dynamic #t4 = asy::_awaitHelper(self::getFutureNull(), :async_op_then, :async_op_error) in null;
|
||||
:return_value = :result_or_exception as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<core::bool>;
|
||||
break #L8;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -253,7 +253,7 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -272,7 +272,7 @@ static method test() → dynamic /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L9:
|
||||
{
|
||||
@@ -287,7 +287,7 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -303,12 +303,12 @@ static method test() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L10:
|
||||
{
|
||||
[yield] let dynamic #t5 = asy::_awaitHelper(self::getNull(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = :result;
|
||||
[yield] let dynamic #t5 = asy::_awaitHelper(self::getNull(), :async_op_then, :async_op_error) in null;
|
||||
:return_value = :result_or_exception;
|
||||
break #L10;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -319,7 +319,7 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
})(){() → asy::Future<dynamic>} as{TypeError,ForNonNullableByDefault} asy::Future<core::bool>;
|
||||
@@ -337,12 +337,12 @@ static method test() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L11:
|
||||
{
|
||||
[yield] let dynamic #t6 = asy::_awaitHelper(self::getFutureNull(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = :result;
|
||||
[yield] let dynamic #t6 = asy::_awaitHelper(self::getFutureNull(), :async_op_then, :async_op_error) in null;
|
||||
:return_value = :result_or_exception;
|
||||
break #L11;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -353,7 +353,7 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
})(){() → asy::Future<dynamic>} as{TypeError,ForNonNullableByDefault} asy::Future<core::bool>;
|
||||
@@ -370,7 +370,7 @@ static method test() → dynamic /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L12:
|
||||
{
|
||||
@@ -385,7 +385,7 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
})(){() → asy::Future<core::bool>};
|
||||
@@ -398,7 +398,7 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -41,7 +41,7 @@ static method getFutureNull() → asy::Future<dynamic> /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -56,7 +56,7 @@ static method getFutureNull() → asy::Future<dynamic> /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -68,7 +68,7 @@ static method getFutureBool() → asy::Future<core::bool> /* originally async */
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
@@ -83,7 +83,7 @@ static method getFutureBool() → asy::Future<core::bool> /* originally async */
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -96,12 +96,12 @@ static method test1() → asy::Future<core::bool> /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L3:
|
||||
{
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(self::getNull(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = :result as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<core::bool>;
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(self::getNull(), :async_op_then, :async_op_error) in null;
|
||||
:return_value = :result_or_exception as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<core::bool>;
|
||||
break #L3;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -112,7 +112,7 @@ static method test1() → asy::Future<core::bool> /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -129,12 +129,12 @@ static method test4() → asy::Future<core::bool> /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L4:
|
||||
{
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(self::getFutureNull(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = :result as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<core::bool>;
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(self::getFutureNull(), :async_op_then, :async_op_error) in null;
|
||||
:return_value = :result_or_exception as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<core::bool>;
|
||||
break #L4;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -145,7 +145,7 @@ static method test4() → asy::Future<core::bool> /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -164,7 +164,7 @@ static method test7() → asy::Future<core::bool> /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L5:
|
||||
{
|
||||
@@ -179,7 +179,7 @@ static method test7() → asy::Future<core::bool> /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -191,7 +191,7 @@ static method test() → dynamic /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L6:
|
||||
{
|
||||
@@ -204,12 +204,12 @@ static method test() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L7:
|
||||
{
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(self::getNull(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = :result as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<core::bool>;
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(self::getNull(), :async_op_then, :async_op_error) in null;
|
||||
:return_value = :result_or_exception as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<core::bool>;
|
||||
break #L7;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -220,7 +220,7 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -237,12 +237,12 @@ static method test() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L8:
|
||||
{
|
||||
[yield] let dynamic #t4 = asy::_awaitHelper(self::getFutureNull(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = :result as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<core::bool>;
|
||||
[yield] let dynamic #t4 = asy::_awaitHelper(self::getFutureNull(), :async_op_then, :async_op_error) in null;
|
||||
:return_value = :result_or_exception as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<core::bool>;
|
||||
break #L8;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -253,7 +253,7 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -272,7 +272,7 @@ static method test() → dynamic /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L9:
|
||||
{
|
||||
@@ -287,7 +287,7 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -303,12 +303,12 @@ static method test() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L10:
|
||||
{
|
||||
[yield] let dynamic #t5 = asy::_awaitHelper(self::getNull(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = :result;
|
||||
[yield] let dynamic #t5 = asy::_awaitHelper(self::getNull(), :async_op_then, :async_op_error) in null;
|
||||
:return_value = :result_or_exception;
|
||||
break #L10;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -319,7 +319,7 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
})(){() → asy::Future<dynamic>} as{TypeError,ForNonNullableByDefault} asy::Future<core::bool>;
|
||||
@@ -337,12 +337,12 @@ static method test() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L11:
|
||||
{
|
||||
[yield] let dynamic #t6 = asy::_awaitHelper(self::getFutureNull(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = :result;
|
||||
[yield] let dynamic #t6 = asy::_awaitHelper(self::getFutureNull(), :async_op_then, :async_op_error) in null;
|
||||
:return_value = :result_or_exception;
|
||||
break #L11;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -353,7 +353,7 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
})(){() → asy::Future<dynamic>} as{TypeError,ForNonNullableByDefault} asy::Future<core::bool>;
|
||||
@@ -370,7 +370,7 @@ static method test() → dynamic /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L12:
|
||||
{
|
||||
@@ -385,7 +385,7 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
})(){() → asy::Future<core::bool>};
|
||||
@@ -398,7 +398,7 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -150,7 +150,7 @@ static method test() → dynamic /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -292,7 +292,7 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -150,7 +150,7 @@ static method test() → dynamic /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
@@ -292,7 +292,7 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -52,7 +52,7 @@ static method getStreamNull() → asy::Stream<dynamic> /* originally async* */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L1:
|
||||
@@ -85,7 +85,7 @@ static method getStreamBool() → asy::Stream<core::bool> /* originally async* *
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L2:
|
||||
@@ -118,7 +118,7 @@ static method test1() → asy::Stream<core::bool> /* originally async* */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L3:
|
||||
@@ -155,7 +155,7 @@ static method test4() → asy::Stream<core::bool> /* originally async* */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L4:
|
||||
@@ -198,7 +198,7 @@ static method test7() → asy::Stream<core::bool> /* originally async* */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L5:
|
||||
@@ -230,7 +230,7 @@ static method test() → dynamic /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L6:
|
||||
{
|
||||
@@ -243,7 +243,7 @@ static method test() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L7:
|
||||
@@ -280,7 +280,7 @@ static method test() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L8:
|
||||
@@ -323,7 +323,7 @@ static method test() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L9:
|
||||
@@ -359,7 +359,7 @@ static method test() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L10:
|
||||
@@ -397,7 +397,7 @@ static method test() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L11:
|
||||
@@ -435,7 +435,7 @@ static method test() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L12:
|
||||
@@ -468,7 +468,7 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -52,7 +52,7 @@ static method getStreamNull() → asy::Stream<dynamic> /* originally async* */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L1:
|
||||
@@ -85,7 +85,7 @@ static method getStreamBool() → asy::Stream<core::bool> /* originally async* *
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L2:
|
||||
@@ -118,7 +118,7 @@ static method test1() → asy::Stream<core::bool> /* originally async* */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L3:
|
||||
@@ -155,7 +155,7 @@ static method test4() → asy::Stream<core::bool> /* originally async* */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L4:
|
||||
@@ -198,7 +198,7 @@ static method test7() → asy::Stream<core::bool> /* originally async* */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L5:
|
||||
@@ -230,7 +230,7 @@ static method test() → dynamic /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L6:
|
||||
{
|
||||
@@ -243,7 +243,7 @@ static method test() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L7:
|
||||
@@ -280,7 +280,7 @@ static method test() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L8:
|
||||
@@ -323,7 +323,7 @@ static method test() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L9:
|
||||
@@ -359,7 +359,7 @@ static method test() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L10:
|
||||
@@ -397,7 +397,7 @@ static method test() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L11:
|
||||
@@ -435,7 +435,7 @@ static method test() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try
|
||||
try {
|
||||
#L12:
|
||||
@@ -468,7 +468,7 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -23,7 +23,7 @@ static method returnFutureOfVoid() → asy::Future<void> /* originally async */
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{}
|
||||
@@ -35,7 +35,7 @@ static method returnFutureOfVoid() → asy::Future<void> /* originally async */
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -48,7 +48,7 @@ static method returnVoidAsync() → void /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{}
|
||||
@@ -60,7 +60,7 @@ static method returnVoidAsync() → void /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -73,14 +73,14 @@ static method test() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L3:
|
||||
{
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(self::returnVoid(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<void>(:result);
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(self::returnVoidAsync(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<void>(:result);
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(self::returnVoid(), :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<void>(:result_or_exception);
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(self::returnVoidAsync(), :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<void>(:result_or_exception);
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
@@ -90,7 +90,7 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -103,12 +103,12 @@ static method main() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L4:
|
||||
{
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(self::returnFutureOfVoid(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<void>(:result);
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(self::returnFutureOfVoid(), :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<void>(:result_or_exception);
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
@@ -118,7 +118,7 @@ static method main() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -23,7 +23,7 @@ static method returnFutureOfVoid() → asy::Future<void> /* originally async */
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{}
|
||||
@@ -35,7 +35,7 @@ static method returnFutureOfVoid() → asy::Future<void> /* originally async */
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -48,7 +48,7 @@ static method returnVoidAsync() → void /* originally async */ {
|
||||
(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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{}
|
||||
@@ -60,7 +60,7 @@ static method returnVoidAsync() → void /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -73,14 +73,14 @@ static method test() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L3:
|
||||
{
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(self::returnVoid(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<void>(:result);
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(self::returnVoidAsync(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<void>(:result);
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(self::returnVoid(), :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<void>(:result_or_exception);
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(self::returnVoidAsync(), :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<void>(:result_or_exception);
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
@@ -90,7 +90,7 @@ static method test() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
@@ -103,12 +103,12 @@ static method main() → dynamic /* originally async */ {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L4:
|
||||
{
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(self::returnFutureOfVoid(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<void>(:result);
|
||||
[yield] let dynamic #t3 = asy::_awaitHelper(self::returnFutureOfVoid(), :async_op_then, :async_op_error) in null;
|
||||
_in::unsafeCast<void>(:result_or_exception);
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
@@ -118,7 +118,7 @@ static method main() → dynamic /* originally async */ {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
@@ -43,12 +43,12 @@ static method test1(self::C<core::num> c) → dynamic {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L1:
|
||||
{
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(t, :async_op_then, :async_op_error, :async_op) in null;
|
||||
:return_value = _in::unsafeCast<core::num>(:result).{core::num::+}(1){(core::num) → core::num};
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(t, :async_op_then, :async_op_error) in null;
|
||||
:return_value = _in::unsafeCast<core::num>(:result_or_exception).{core::num::+}(1){(core::num) → core::num};
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -59,7 +59,7 @@ static method test1(self::C<core::num> c) → dynamic {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
@@ -79,14 +79,14 @@ static method test2(self::C<core::num?> c) → dynamic {
|
||||
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
|
||||
function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding
|
||||
try {
|
||||
#L2:
|
||||
{
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(t, :async_op_then, :async_op_error, :async_op) in null;
|
||||
[yield] let dynamic #t2 = asy::_awaitHelper(t, :async_op_then, :async_op_error) in null;
|
||||
:return_value = invalid-expression "pkg/front_end/testcases/nnbd/issue41697.dart:36:22: Error: Operator '+' cannot be called on 'num?' because it is potentially null.
|
||||
return (await t) + 1; // error
|
||||
^" in _in::unsafeCast<core::num?>(:result).{core::num::+}(1){(core::num) → core::num};
|
||||
^" in _in::unsafeCast<core::num?>(:result_or_exception).{core::num::+}(1){(core::num) → core::num};
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
@@ -97,7 +97,7 @@ static method test2(self::C<core::num?> c) → dynamic {
|
||||
}
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_op(){() → dynamic};
|
||||
:async_op(null, null){() → dynamic};
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user