mirror of
https://github.com/dart-lang/sdk
synced 2024-10-06 14:59:41 +00:00
[SDK] Replaces async's _AsyncAwaitCompleter with _Future.
Run time (less is better) impact: dart: - Calls.AwaitAsyncCall -43.95% ~ -55.50% - Calls.AwaitAsyncCallClosureTargetPolymorphic -40.33% ~ -53.58% - Calls.AwaitAsyncCallInstanceTargetPolymorphic -42.69% ~ -55.65% - Calls.AwaitFutureOrCallInstanceTargetPolymorphicManyAwaits -42.05% ~ -56.14% - Calls.Await... 0% ~ -13% dart-aot: - Calls.AwaitAsyncCall -9.748% ~ -11.13% - Calls.AwaitAsyncCallClosureTargetPolymorphic -8.673% ~ -13.19% - Calls.AwaitAsyncCallInstanceTargetPolymorphic -9.799% ~ -11.74% - Calls.AwaitFutureOrCallInstanceTargetPolymorphicManyAwaits -5.412% ~ -13.43% Code size impact: - flutter_gallery_app_so_brotli_size -0.1237% ~ -0.2410% - flutter_gallery_readonlydata_size 0.1693% ~ 0.2041% - flutter_gallery_instructions_size 0.1157% ~ 0.1779% - flutter_gallery_total_size 0.1021% ~ 0.1413% Bug: https://github.com/dart-lang/sdk/issues/39119 Change-Id: I64d28a8bea078277946d7be43737e265920c8f16 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/126322 Commit-Queue: Clement Skau <cskau@google.com> Reviewed-by: Martin Kustermann <kustermann@google.com>
This commit is contained in:
Clement Skau
commit-bot@chromium.org
parent
7b75bd8ece
commit
27ca552ddb
|
|
@ -1553,7 +1553,9 @@ _asyncThenWrapperHelper(continuation) {}
|
|||
|
||||
_awaitHelper(object, thenCallback, errorCallback, awaiter) {}
|
||||
|
||||
_completeOnAsyncReturn(completer, value) {}
|
||||
_completeOnAsyncReturn(_future, value, async_jump_var) {}
|
||||
|
||||
_completeOnAsyncError(_future, e, st, async_jump_var) {}
|
||||
|
||||
class _AsyncStarStreamController {
|
||||
add(event) {}
|
||||
|
|
@ -1584,14 +1586,10 @@ class Future<T> {
|
|||
class FutureOr {
|
||||
}
|
||||
|
||||
class _AsyncAwaitCompleter implements Completer {
|
||||
get future => null;
|
||||
class _Future {
|
||||
void _completeError(Object error, StackTrace stackTrace) {}
|
||||
|
||||
complete([value]) {}
|
||||
|
||||
completeError(error, [stackTrace]) {}
|
||||
|
||||
void start(void Function() f) {}
|
||||
void _asyncCompleteError(Object error, StackTrace stackTrace) {}
|
||||
}
|
||||
|
||||
class Stream {}
|
||||
|
|
|
|||
|
|
@ -26,7 +26,8 @@ static method Extension|syncStarMethod(final core::int* #this) → dynamic /* or
|
|||
static method Extension|get#syncStarMethod(final core::int* #this) → () →* dynamic
|
||||
return () → dynamic => self::Extension|syncStarMethod(#this);
|
||||
static method Extension|asyncMethod(final core::int* #this) → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -37,17 +38,18 @@ static method Extension|asyncMethod(final core::int* #this) → dynamic /* origi
|
|||
try {
|
||||
#L1:
|
||||
{}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method Extension|get#asyncMethod(final core::int* #this) → () →* dynamic
|
||||
return () → dynamic => self::Extension|asyncMethod(#this);
|
||||
|
|
|
|||
|
|
@ -15,7 +15,8 @@ import "deferred_explicit_access_lib.dart" as def;
|
|||
import "org-dartlang-testcase:///deferred_explicit_access_lib.dart" deferred as prefix;
|
||||
|
||||
static method main() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -38,17 +39,18 @@ static method main() → dynamic /* originally async */ {
|
|||
self::expect(87, let final core::Object* #t11 = CheckLibraryIsLoaded(prefix) in def::Extension|staticProperty = 87);
|
||||
self::expect(87, let final core::Object* #t12 = CheckLibraryIsLoaded(prefix) in def::Extension|staticMethod());
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method expect(dynamic expected, dynamic actual) → dynamic {
|
||||
if(!expected.{core::Object::==}(actual))
|
||||
|
|
@ -100,4 +102,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: 95, effectively constant: 3
|
||||
Extra constant evaluation: evaluated: 96, effectively constant: 3
|
||||
|
|
|
|||
|
|
@ -7,7 +7,8 @@ import "deferred_explicit_access_lib.dart" as def;
|
|||
import "org-dartlang-testcase:///deferred_explicit_access_lib.dart" deferred as prefix hide Extension;
|
||||
|
||||
static method main() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -29,17 +30,18 @@ static method main() → dynamic /* originally async */ {
|
|||
self::expect(87, let final core::Object* #t7 = CheckLibraryIsLoaded(prefix) in def::topLevelProperty);
|
||||
self::expect(87, let final core::Object* #t8 = CheckLibraryIsLoaded(prefix) in def::topLevelMethod());
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method expect(dynamic expected, dynamic actual) → dynamic {
|
||||
if(!expected.{core::Object::==}(actual))
|
||||
|
|
|
|||
|
|
@ -8,7 +8,8 @@ import "dart:async";
|
|||
|
||||
static field core::List<core::String*>* stringList = <core::String*>["bar"];
|
||||
static method asyncString() → asy::Future<core::String*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::String*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::String*>();
|
||||
final asy::_Future<core::String*>* :async_future = new asy::_Future::•<core::String*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::String*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -22,20 +23,22 @@ static method asyncString() → asy::Future<core::String*>* /* originally async
|
|||
:return_value = "foo";
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method asyncString2() → asy::Future<core::String*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::String*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::String*>();
|
||||
final asy::_Future<core::String*>* :async_future = new asy::_Future::•<core::String*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::String*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -49,17 +52,18 @@ static method asyncString2() → asy::Future<core::String*>* /* originally async
|
|||
:return_value = self::asyncString();
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method syncStarString() → core::Iterable<core::String*>* /* originally sync* */ {
|
||||
function :sync_op_gen() → (core::_SyncIterator<dynamic>*, dynamic, dynamic) →* core::bool* {
|
||||
|
|
@ -183,7 +187,8 @@ static method asyncStarString2() → asy::Stream<core::String*>* /* originally a
|
|||
return :controller_stream;
|
||||
}
|
||||
static method main() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -198,15 +203,16 @@ static method main() → dynamic /* originally async */ {
|
|||
[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);
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -28,7 +28,8 @@ class Node extends core::Object {
|
|||
abstract member-signature get runtimeType() → core::Type*; -> core::Object::runtimeType
|
||||
}
|
||||
static method main() → void /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -62,17 +63,18 @@ static method main() → void /* originally async */ {
|
|||
throw "Expected '${expected}' but got '${actual}'";
|
||||
}
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
constants {
|
||||
|
|
|
|||
|
|
@ -5,7 +5,8 @@ import "dart:core" as core;
|
|||
import "dart:_internal" as _in;
|
||||
|
||||
static method main() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -20,15 +21,16 @@ static method main() → dynamic /* originally async */ {
|
|||
[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));
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -57,7 +57,8 @@ static set topLevelSetter(dynamic val) → void {
|
|||
static method dummy() → dynamic
|
||||
return 1;
|
||||
static method staticMembers() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -100,20 +101,22 @@ static method staticMembers() → dynamic /* originally async */ {
|
|||
core::num* e = _in::unsafeCast<core::int*>(:async_temporary_5).{core::num::+}(:result as{TypeError,ForDynamic} core::num);
|
||||
self::expect(5, e);
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method topLevelMembers() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -151,20 +154,22 @@ static method topLevelMembers() → dynamic /* originally async */ {
|
|||
core::num* e = _in::unsafeCast<core::int*>(:async_temporary_4).{core::num::+}(:result as{TypeError,ForDynamic} core::num);
|
||||
self::expect(5, e);
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method instanceMembers() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -203,20 +208,22 @@ static method instanceMembers() → dynamic /* originally async */ {
|
|||
core::num* e = _in::unsafeCast<core::int*>(:async_temporary_4).{core::num::+}(:result as{TypeError,ForDynamic} core::num);
|
||||
self::expect(5, e);
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method others() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -255,20 +262,22 @@ static method others() → dynamic /* originally async */ {
|
|||
core::num* e = _in::unsafeCast<core::int*>(:async_temporary_4).{core::num::+}(:result as{TypeError,ForDynamic} core::num);
|
||||
self::expect(2, e);
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method conditionals() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -327,20 +336,22 @@ static method conditionals() → dynamic /* originally async */ {
|
|||
on dynamic catch(final dynamic e) {
|
||||
}
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method asserts() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -400,20 +411,22 @@ static method asserts() → dynamic /* originally async */ {
|
|||
}
|
||||
}
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method controlFlow() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -546,7 +559,8 @@ static method controlFlow() → dynamic /* originally async */ {
|
|||
}
|
||||
}
|
||||
[yield] let dynamic #t51 = asy::_awaitHelper((() → asy::Future<dynamic>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -562,21 +576,23 @@ static method controlFlow() → dynamic /* originally async */ {
|
|||
:return_value = :result;
|
||||
break #L13;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}).call(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
self::expect(42, :result);
|
||||
[yield] let dynamic #t53 = asy::_awaitHelper((() → asy::Future<dynamic>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -590,17 +606,18 @@ static method controlFlow() → dynamic /* originally async */ {
|
|||
:return_value = func.call<dynamic>(42);
|
||||
break #L14;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}).call(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
self::expect(42, :result);
|
||||
function testStream1() → asy::Stream<core::int*>* /* originally async* */ {
|
||||
|
|
@ -685,20 +702,22 @@ static method controlFlow() → dynamic /* originally async */ {
|
|||
}
|
||||
}
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method future<T extends core::Object* = dynamic>(self::future::T* value) → FutureOr<self::future::T*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<self::future::T*>* :async_completer = new asy::_AsyncAwaitCompleter::•<self::future::T*>();
|
||||
final asy::_Future<self::future::T*>* :async_future = new asy::_Future::•<self::future::T*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<self::future::T*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -712,17 +731,18 @@ static method future<T extends core::Object* = dynamic>(self::future::T* value)
|
|||
:return_value = value;
|
||||
break #L17;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method id<T extends core::Object* = dynamic>(self::id::T* value) → FutureOr<self::id::T*>*
|
||||
return value;
|
||||
|
|
@ -762,7 +782,8 @@ static method intStream() → asy::Stream<core::int*>* /* originally async* */ {
|
|||
return :controller_stream;
|
||||
}
|
||||
static method main() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -791,17 +812,18 @@ static method main() → dynamic /* originally async */ {
|
|||
:result;
|
||||
}
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method expect(dynamic expected, dynamic actual) → dynamic {
|
||||
if(!expected.{core::Object::==}(actual))
|
||||
|
|
|
|||
|
|
@ -11,7 +11,8 @@ class C extends core::Object {
|
|||
: super core::Object::•()
|
||||
;
|
||||
method m() → asy::Future<core::List<core::int*>*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::List<core::int*>*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<core::int*>*>();
|
||||
final asy::_Future<core::List<core::int*>*>* :async_future = new asy::_Future::•<core::List<core::int*>*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::List<core::int*>*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -29,20 +30,22 @@ class C extends core::Object {
|
|||
:return_value = block {} =>#t1;
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
method _m() → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -56,17 +59,18 @@ class C extends core::Object {
|
|||
:return_value = 42;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
abstract member-signature get _identityHashCode() → core::int*; -> core::Object::_identityHashCode
|
||||
abstract member-signature method _instanceOf(dynamic instantiatorTypeArguments, dynamic functionTypeArguments, dynamic type) → core::bool*; -> core::Object::_instanceOf
|
||||
|
|
@ -80,7 +84,8 @@ class C extends core::Object {
|
|||
abstract member-signature get runtimeType() → core::Type*; -> core::Object::runtimeType
|
||||
}
|
||||
static method main() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -95,17 +100,18 @@ static method main() → dynamic /* originally async */ {
|
|||
[yield] let dynamic #t3 = asy::_awaitHelper(new self::C::•().{self::C::m}(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
self::expect(42, _in::unsafeCast<core::List<core::int*>*>(:result).{core::Iterable::first});
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method expect(dynamic expected, dynamic actual) → dynamic {
|
||||
if(!expected.{core::Object::==}(actual))
|
||||
|
|
|
|||
|
|
@ -10,7 +10,8 @@ static method main() → dynamic {
|
|||
core::print(result.{core::Object::runtimeType});
|
||||
}
|
||||
static method returnsString() → FutureOr<core::String*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::String*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::String*>();
|
||||
final asy::_Future<core::String*>* :async_future = new asy::_Future::•<core::String*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::String*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -24,15 +25,16 @@ static method returnsString() → FutureOr<core::String*>* /* originally async *
|
|||
:return_value = "oh no";
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -41,7 +41,8 @@ class Y extends core::Object {
|
|||
abstract member-signature get runtimeType() → core::Type*; -> core::Object::runtimeType
|
||||
}
|
||||
static method f1() → asy::Future<core::List<core::Object*>*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::List<core::Object*>*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<core::Object*>*>();
|
||||
final asy::_Future<core::List<core::Object*>*>* :async_future = new asy::_Future::•<core::List<core::Object*>*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::List<core::Object*>*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -55,22 +56,24 @@ static method f1() → asy::Future<core::List<core::Object*>*>* /* originally as
|
|||
:return_value = <core::Object*>[1];
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method f2() → core::List<core::Object*>*
|
||||
return <core::Object*>[2];
|
||||
static method f3() → asy::Future<core::Object*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::Object*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::Object*>();
|
||||
final asy::_Future<core::Object*>* :async_future = new asy::_Future::•<core::Object*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::Object*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -84,20 +87,22 @@ static method f3() → asy::Future<core::Object*>* /* originally async */ {
|
|||
:return_value = 3;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method foo() → asy::Future<self::X*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<self::X*>* :async_completer = new asy::_AsyncAwaitCompleter::•<self::X*>();
|
||||
final asy::_Future<self::X*>* :async_future = new asy::_Future::•<self::X*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<self::X*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -120,20 +125,22 @@ static method foo() → asy::Future<self::X*>* /* originally async */ {
|
|||
:return_value = new self::X::•(_in::unsafeCast<self::Y*>(:async_temporary_0), _in::unsafeCast<core::Object*>(:result));
|
||||
break #L3;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method main() → asy::Future<void>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<void>* :async_completer = new asy::_AsyncAwaitCompleter::•<void>();
|
||||
final asy::_Future<void>* :async_future = new asy::_Future::•<void>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<void>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -148,15 +155,16 @@ static method main() → asy::Future<void>* /* originally async */ {
|
|||
[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));
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,7 +8,8 @@ import "org-dartlang-testcase:///deferred_lib.dart" deferred as lib;
|
|||
|
||||
static method main() → dynamic {}
|
||||
static method test() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -24,17 +25,18 @@ static method test() → dynamic /* originally async */ {
|
|||
[yield] let dynamic #t2 = asy::_awaitHelper(LoadLibrary(lib), :async_op_then, :async_op_error, :async_op) in null;
|
||||
def::m(:result);
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
library;
|
||||
|
|
|
|||
|
|
@ -2339,7 +2339,8 @@ static method testForElement(dynamic dynVar, core::List<core::int*>* listInt, co
|
|||
} =>#t337;
|
||||
}
|
||||
static method testForElementErrors(core::Map<core::int*, core::int*>* map, core::List<core::int*>* list) → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -2886,17 +2887,18 @@ static method testForElementErrors(core::Map<core::int*, core::int*>* map, core:
|
|||
#t433.{core::Map::[]=}("baz", null);
|
||||
} =>#t433;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method testForElementErrorsNotAsync(asy::Stream<core::int*>* stream) → dynamic {
|
||||
block {
|
||||
|
|
|
|||
|
|
@ -17,7 +17,8 @@ import "dart:core" as core;
|
|||
import "dart:_internal" as _in;
|
||||
|
||||
static method main() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -60,15 +61,16 @@ static method main() → dynamic /* originally async */ {
|
|||
}
|
||||
}
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,7 +6,8 @@ import "dart:_internal" as _in;
|
|||
|
||||
abstract class TestMixin<R extends core::Object* = dynamic, T extends core::Object* = dynamic> extends core::Object /*isMixinDeclaration*/ {
|
||||
method test(generic-covariant-impl asy::Future<self::TestMixin::R*>* fetch) → asy::Future<self::TestMixin::T*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<self::TestMixin::T*>* :async_completer = new asy::_AsyncAwaitCompleter::•<self::TestMixin::T*>();
|
||||
final asy::_Future<self::TestMixin::T*>* :async_future = new asy::_Future::•<self::TestMixin::T*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<self::TestMixin::T*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -38,17 +39,18 @@ abstract class TestMixin<R extends core::Object* = dynamic, T extends core::Obje
|
|||
:return_value = result;
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
abstract member-signature get _identityHashCode() → core::int*; -> core::Object::_identityHashCode
|
||||
abstract member-signature method _instanceOf(dynamic instantiatorTypeArguments, dynamic functionTypeArguments, dynamic type) → core::bool*; -> core::Object::_instanceOf
|
||||
|
|
@ -124,7 +126,8 @@ abstract class _Class1&Object&TestMixin extends core::Object implements self::Te
|
|||
abstract member-signature method noSuchMethod(core::Invocation* invocation) → dynamic; -> core::Object::noSuchMethod
|
||||
abstract member-signature get runtimeType() → core::Type*; -> core::Object::runtimeType
|
||||
method test(generic-covariant-impl asy::Future<self::Response<core::String*>*>* fetch) → asy::Future<core::String*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::String*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::String*>();
|
||||
final asy::_Future<core::String*>* :async_future = new asy::_Future::•<core::String*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::String*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -156,17 +159,18 @@ abstract class _Class1&Object&TestMixin extends core::Object implements self::Te
|
|||
:return_value = result;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
}
|
||||
class Class1 extends self::_Class1&Object&TestMixin {
|
||||
|
|
@ -193,7 +197,8 @@ abstract class _Class2&Object&TestMixin extends core::Object implements self::Te
|
|||
abstract member-signature method noSuchMethod(core::Invocation* invocation) → dynamic; -> core::Object::noSuchMethod
|
||||
abstract member-signature get runtimeType() → core::Type*; -> core::Object::runtimeType
|
||||
method test(generic-covariant-impl asy::Future<self::PagingResponse<core::String*>*>* fetch) → asy::Future<core::String*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::String*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::String*>();
|
||||
final asy::_Future<core::String*>* :async_future = new asy::_Future::•<core::String*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::String*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -225,17 +230,18 @@ abstract class _Class2&Object&TestMixin extends core::Object implements self::Te
|
|||
:return_value = result;
|
||||
break #L3;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
}
|
||||
class Class2 extends self::_Class2&Object&TestMixin {
|
||||
|
|
|
|||
|
|
@ -28,7 +28,8 @@ class B extends core::Object {
|
|||
: super core::Object::•()
|
||||
;
|
||||
method bar() → asy::Future<dynamic>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -42,17 +43,18 @@ class B extends core::Object {
|
|||
:return_value = this.{self::B::a}.{self::A::foo}();
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
abstract member-signature get _identityHashCode() → core::int*; -> core::Object::_identityHashCode
|
||||
abstract member-signature method _instanceOf(dynamic instantiatorTypeArguments, dynamic functionTypeArguments, dynamic type) → core::bool*; -> core::Object::_instanceOf
|
||||
|
|
@ -71,7 +73,8 @@ class C extends core::Object {
|
|||
: super core::Object::•()
|
||||
;
|
||||
method baz() → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -85,17 +88,18 @@ class C extends core::Object {
|
|||
:return_value = this.{self::C::b}.{self::B::bar}() as{TypeError} FutureOr<core::int*>*;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
abstract member-signature get _identityHashCode() → core::int*; -> core::Object::_identityHashCode
|
||||
abstract member-signature method _instanceOf(dynamic instantiatorTypeArguments, dynamic functionTypeArguments, dynamic type) → core::bool*; -> core::Object::_instanceOf
|
||||
|
|
|
|||
|
|
@ -43,7 +43,8 @@ class Class extends core::Object {
|
|||
static method returnDynamic() → dynamic
|
||||
return new self::Class::•();
|
||||
static method returnClass() → self::Class* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -57,20 +58,22 @@ static method returnClass() → self::Class* /* originally async */ {
|
|||
:return_value = new self::Class::•();
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method returnFutureClass() → asy::Future<self::Class*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<self::Class*>* :async_completer = new asy::_AsyncAwaitCompleter::•<self::Class*>();
|
||||
final asy::_Future<self::Class*>* :async_future = new asy::_Future::•<self::Class*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<self::Class*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -84,20 +87,22 @@ static method returnFutureClass() → asy::Future<self::Class*>* /* originally a
|
|||
:return_value = new self::Class::•();
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method returnFutureOrClass() → FutureOr<self::Class*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<self::Class*>* :async_completer = new asy::_AsyncAwaitCompleter::•<self::Class*>();
|
||||
final asy::_Future<self::Class*>* :async_future = new asy::_Future::•<self::Class*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<self::Class*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -111,20 +116,22 @@ static method returnFutureOrClass() → FutureOr<self::Class*>* /* originally as
|
|||
:return_value = new self::Class::•();
|
||||
break #L3;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method returnClassFromDynamic() → self::Class* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -138,20 +145,22 @@ static method returnClassFromDynamic() → self::Class* /* originally async */ {
|
|||
:return_value = self::returnDynamic() as{TypeError} FutureOr<self::Class*>*;
|
||||
break #L4;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method returnFutureClassDynamic() → asy::Future<self::Class*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<self::Class*>* :async_completer = new asy::_AsyncAwaitCompleter::•<self::Class*>();
|
||||
final asy::_Future<self::Class*>* :async_future = new asy::_Future::•<self::Class*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<self::Class*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -165,20 +174,22 @@ static method returnFutureClassDynamic() → asy::Future<self::Class*>* /* origi
|
|||
:return_value = self::returnDynamic() as{TypeError} FutureOr<self::Class*>*;
|
||||
break #L5;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method returnFutureOrClassDynamic() → FutureOr<self::Class*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<self::Class*>* :async_completer = new asy::_AsyncAwaitCompleter::•<self::Class*>();
|
||||
final asy::_Future<self::Class*>* :async_future = new asy::_Future::•<self::Class*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<self::Class*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -192,20 +203,22 @@ static method returnFutureOrClassDynamic() → FutureOr<self::Class*>* /* origin
|
|||
:return_value = self::returnDynamic() as{TypeError} FutureOr<self::Class*>*;
|
||||
break #L6;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method returnClassFromFutureClass() → self::Class* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -219,20 +232,22 @@ static method returnClassFromFutureClass() → self::Class* /* originally async
|
|||
:return_value = self::returnFutureClass();
|
||||
break #L7;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method returnFutureClassFromFutureClass() → asy::Future<self::Class*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<self::Class*>* :async_completer = new asy::_AsyncAwaitCompleter::•<self::Class*>();
|
||||
final asy::_Future<self::Class*>* :async_future = new asy::_Future::•<self::Class*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<self::Class*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -246,20 +261,22 @@ static method returnFutureClassFromFutureClass() → asy::Future<self::Class*>*
|
|||
:return_value = self::returnFutureClass();
|
||||
break #L8;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method returnFutureOrClassFromFutureClass() → FutureOr<self::Class*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<self::Class*>* :async_completer = new asy::_AsyncAwaitCompleter::•<self::Class*>();
|
||||
final asy::_Future<self::Class*>* :async_future = new asy::_Future::•<self::Class*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<self::Class*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -273,20 +290,22 @@ static method returnFutureOrClassFromFutureClass() → FutureOr<self::Class*>* /
|
|||
:return_value = self::returnFutureClass();
|
||||
break #L9;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method returnClassFromFutureOrClass() → self::Class* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -300,20 +319,22 @@ static method returnClassFromFutureOrClass() → self::Class* /* originally asyn
|
|||
:return_value = self::returnFutureOrClass();
|
||||
break #L10;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method returnFutureClassFromFutureOrClass() → asy::Future<self::Class*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<self::Class*>* :async_completer = new asy::_AsyncAwaitCompleter::•<self::Class*>();
|
||||
final asy::_Future<self::Class*>* :async_future = new asy::_Future::•<self::Class*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<self::Class*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -327,20 +348,22 @@ static method returnFutureClassFromFutureOrClass() → asy::Future<self::Class*>
|
|||
:return_value = self::returnFutureOrClass();
|
||||
break #L11;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method returnFutureOrClassFromFutureOrClass() → FutureOr<self::Class*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<self::Class*>* :async_completer = new asy::_AsyncAwaitCompleter::•<self::Class*>();
|
||||
final asy::_Future<self::Class*>* :async_future = new asy::_Future::•<self::Class*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<self::Class*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -354,20 +377,22 @@ static method returnFutureOrClassFromFutureOrClass() → FutureOr<self::Class*>*
|
|||
:return_value = self::returnFutureOrClass();
|
||||
break #L12;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method main() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -404,15 +429,16 @@ static method main() → dynamic /* originally async */ {
|
|||
[yield] let dynamic #t12 = asy::_awaitHelper(self::returnFutureOrClassFromFutureOrClass(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<self::Class*>(:result);
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,7 +9,8 @@ static method bar(core::int* a, core::List<core::int*>* b) → dynamic {
|
|||
self::expect(1.{core::int::unary-}(), b.{core::List::[]}(0).{core::num::-}(2));
|
||||
}
|
||||
static method foo(core::int* x) → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -38,20 +39,22 @@ static method foo(core::int* x) → dynamic /* originally async */ {
|
|||
:return_value = self::bar(_in::unsafeCast<core::int*>(:async_temporary_3), :async_temporary_2);
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method main() → void /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -67,17 +70,18 @@ static method main() → void /* originally async */ {
|
|||
:return_value = :result;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method expect(dynamic expected, dynamic actual) → dynamic {
|
||||
if(!expected.{core::Object::==}(actual))
|
||||
|
|
@ -88,4 +92,4 @@ static method expect(dynamic expected, dynamic actual) → dynamic {
|
|||
Extra constant evaluation status:
|
||||
Evaluated: MethodInvocation @ org-dartlang-testcase:///issue40662.dart:8:10 -> IntConstant(-1)
|
||||
Evaluated: MethodInvocation @ org-dartlang-testcase:///issue40662.dart:9:10 -> IntConstant(-1)
|
||||
Extra constant evaluation: evaluated: 99, effectively constant: 2
|
||||
Extra constant evaluation: evaluated: 101, effectively constant: 2
|
||||
|
|
|
|||
|
|
@ -24,7 +24,8 @@ static method method() → dynamic
|
|||
return null;
|
||||
static method main() → dynamic {
|
||||
new self::Class::•<dynamic>(a: () → FutureOr<core::List<dynamic>*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::List<dynamic>*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<dynamic>*>();
|
||||
final asy::_Future<core::List<dynamic>*>* :async_future = new asy::_Future::•<core::List<dynamic>*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::List<dynamic>*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -38,17 +39,18 @@ static method main() → dynamic {
|
|||
:return_value = self::method() as{TypeError} FutureOr<core::List<dynamic>*>*;
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -9,7 +9,8 @@ class X extends core::Object {
|
|||
: super core::Object::•()
|
||||
;
|
||||
method _foo() → void /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -25,17 +26,18 @@ class X extends core::Object {
|
|||
_in::unsafeCast<core::Null?>(:result);
|
||||
core::print("hello");
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
method foo() → void
|
||||
return this.{self::X::_foo}();
|
||||
|
|
|
|||
|
|
@ -9,7 +9,8 @@ class A extends core::Object {
|
|||
: super core::Object::•()
|
||||
;
|
||||
method foo(dynamic x) → asy::Future<void>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<void>* :async_completer = new asy::_AsyncAwaitCompleter::•<void>();
|
||||
final asy::_Future<void>* :async_future = new asy::_Future::•<void>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<void>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -20,17 +21,18 @@ class A extends core::Object {
|
|||
try {
|
||||
#L1:
|
||||
{}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
abstract member-signature get _identityHashCode() → core::int*; -> core::Object::_identityHashCode
|
||||
abstract member-signature method _instanceOf(dynamic instantiatorTypeArguments, dynamic functionTypeArguments, dynamic type) → core::bool*; -> core::Object::_instanceOf
|
||||
|
|
@ -48,7 +50,8 @@ class B extends core::Object {
|
|||
: super core::Object::•()
|
||||
;
|
||||
method bar(dynamic x) → asy::Future<void>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<void>* :async_completer = new asy::_AsyncAwaitCompleter::•<void>();
|
||||
final asy::_Future<void>* :async_future = new asy::_Future::•<void>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<void>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -59,17 +62,18 @@ class B extends core::Object {
|
|||
try {
|
||||
#L2:
|
||||
{}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
abstract member-signature get _identityHashCode() → core::int*; -> core::Object::_identityHashCode
|
||||
abstract member-signature method _instanceOf(dynamic instantiatorTypeArguments, dynamic functionTypeArguments, dynamic type) → core::bool*; -> core::Object::_instanceOf
|
||||
|
|
@ -83,7 +87,8 @@ class B extends core::Object {
|
|||
abstract member-signature get runtimeType() → core::Type*; -> core::Object::runtimeType
|
||||
}
|
||||
static method main() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -105,15 +110,16 @@ static method main() → dynamic /* originally async */ {
|
|||
:return_value = <asy::Future<void>*>[_in::unsafeCast<asy::Future<void>*>(:async_temporary_1), _in::unsafeCast<self::B*>(:async_temporary_0).{self::B::bar}(_in::unsafeCast<core::Null?>(:result))];
|
||||
break #L3;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -35,7 +35,8 @@ static method returnDynamic() → dynamic
|
|||
static method returnClass() → self::Class*
|
||||
return new self::Class::•();
|
||||
static method returnFutureDynamic() → asy::Future<dynamic>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -49,20 +50,22 @@ static method returnFutureDynamic() → asy::Future<dynamic>* /* originally asyn
|
|||
:return_value = new self::Class::•();
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method returnFutureClass() → asy::Future<self::Class*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<self::Class*>* :async_completer = new asy::_AsyncAwaitCompleter::•<self::Class*>();
|
||||
final asy::_Future<self::Class*>* :async_future = new asy::_Future::•<self::Class*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<self::Class*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -76,17 +79,18 @@ static method returnFutureClass() → asy::Future<self::Class*>* /* originally a
|
|||
:return_value = new self::Class::•();
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method error() → asy::Stream<FutureOr<self::Class*>*>* /* originally async* */ {
|
||||
asy::_AsyncStarStreamController<FutureOr<self::Class*>*>* :controller;
|
||||
|
|
@ -171,7 +175,8 @@ static method stream() → asy::Stream<FutureOr<self::Class*>*>* /* originally a
|
|||
return :controller_stream;
|
||||
}
|
||||
static method main() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -210,15 +215,16 @@ static method main() → dynamic /* originally async */ {
|
|||
}
|
||||
}
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,7 +8,8 @@ import "dart:async";
|
|||
|
||||
static field core::List<core::String*>* stringList = <core::String*>["bar"];
|
||||
static method asyncString() → asy::Future<core::String*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::String*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::String*>();
|
||||
final asy::_Future<core::String*>* :async_future = new asy::_Future::•<core::String*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::String*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -22,20 +23,22 @@ static method asyncString() → asy::Future<core::String*>* /* originally async
|
|||
:return_value = "foo";
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method asyncString2() → asy::Future<core::String*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::String*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::String*>();
|
||||
final asy::_Future<core::String*>* :async_future = new asy::_Future::•<core::String*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::String*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -49,17 +52,18 @@ static method asyncString2() → asy::Future<core::String*>* /* originally async
|
|||
:return_value = self::asyncString();
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method syncStarString() → core::Iterable<core::String*>* /* originally sync* */ {
|
||||
function :sync_op_gen() → (core::_SyncIterator<dynamic>*, dynamic, dynamic) →* core::bool* {
|
||||
|
|
@ -183,7 +187,8 @@ static method asyncStarString2() → asy::Stream<core::String*>* /* originally a
|
|||
return :controller_stream;
|
||||
}
|
||||
static method main() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -198,15 +203,16 @@ static method main() → dynamic /* originally async */ {
|
|||
[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);
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -28,7 +28,8 @@ class Node extends core::Object {
|
|||
abstract member-signature get runtimeType() → core::Type*; -> core::Object::runtimeType
|
||||
}
|
||||
static method main() → void /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -62,17 +63,18 @@ static method main() → void /* originally async */ {
|
|||
throw "Expected '${expected}' but got '${actual}'";
|
||||
}
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
constants {
|
||||
|
|
|
|||
|
|
@ -5,7 +5,8 @@ import "dart:core" as core;
|
|||
import "dart:_internal" as _in;
|
||||
|
||||
static method main() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -20,15 +21,16 @@ static method main() → dynamic /* originally async */ {
|
|||
[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));
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -57,7 +57,8 @@ static set topLevelSetter(dynamic val) → void {
|
|||
static method dummy() → dynamic
|
||||
return 1;
|
||||
static method staticMembers() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -100,20 +101,22 @@ static method staticMembers() → dynamic /* originally async */ {
|
|||
core::num* e = _in::unsafeCast<core::int*>(:async_temporary_5).{core::num::+}(:result as{TypeError,ForDynamic} core::num);
|
||||
self::expect(5, e);
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method topLevelMembers() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -151,20 +154,22 @@ static method topLevelMembers() → dynamic /* originally async */ {
|
|||
core::num* e = _in::unsafeCast<core::int*>(:async_temporary_4).{core::num::+}(:result as{TypeError,ForDynamic} core::num);
|
||||
self::expect(5, e);
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method instanceMembers() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -203,20 +208,22 @@ static method instanceMembers() → dynamic /* originally async */ {
|
|||
core::num* e = _in::unsafeCast<core::int*>(:async_temporary_4).{core::num::+}(:result as{TypeError,ForDynamic} core::num);
|
||||
self::expect(5, e);
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method others() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -255,20 +262,22 @@ static method others() → dynamic /* originally async */ {
|
|||
core::num* e = _in::unsafeCast<core::int*>(:async_temporary_4).{core::num::+}(:result as{TypeError,ForDynamic} core::num);
|
||||
self::expect(2, e);
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method conditionals() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -327,20 +336,22 @@ static method conditionals() → dynamic /* originally async */ {
|
|||
on dynamic catch(final dynamic e) {
|
||||
}
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method asserts() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -400,20 +411,22 @@ static method asserts() → dynamic /* originally async */ {
|
|||
}
|
||||
}
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method controlFlow() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -546,7 +559,8 @@ static method controlFlow() → dynamic /* originally async */ {
|
|||
}
|
||||
}
|
||||
[yield] let dynamic #t51 = asy::_awaitHelper((() → asy::Future<dynamic>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -562,21 +576,23 @@ static method controlFlow() → dynamic /* originally async */ {
|
|||
:return_value = :result;
|
||||
break #L13;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}).call(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
self::expect(42, :result);
|
||||
[yield] let dynamic #t53 = asy::_awaitHelper((() → asy::Future<dynamic>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -590,17 +606,18 @@ static method controlFlow() → dynamic /* originally async */ {
|
|||
:return_value = func.call<dynamic>(42);
|
||||
break #L14;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}).call(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
self::expect(42, :result);
|
||||
function testStream1() → asy::Stream<core::int*>* /* originally async* */ {
|
||||
|
|
@ -685,20 +702,22 @@ static method controlFlow() → dynamic /* originally async */ {
|
|||
}
|
||||
}
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method future<T extends core::Object* = dynamic>(self::future::T* value) → FutureOr<self::future::T*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<self::future::T*>* :async_completer = new asy::_AsyncAwaitCompleter::•<self::future::T*>();
|
||||
final asy::_Future<self::future::T*>* :async_future = new asy::_Future::•<self::future::T*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<self::future::T*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -712,17 +731,18 @@ static method future<T extends core::Object* = dynamic>(self::future::T* value)
|
|||
:return_value = value;
|
||||
break #L17;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method id<T extends core::Object* = dynamic>(self::id::T* value) → FutureOr<self::id::T*>*
|
||||
return value;
|
||||
|
|
@ -762,7 +782,8 @@ static method intStream() → asy::Stream<core::int*>* /* originally async* */ {
|
|||
return :controller_stream;
|
||||
}
|
||||
static method main() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -791,17 +812,18 @@ static method main() → dynamic /* originally async */ {
|
|||
:result;
|
||||
}
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method expect(dynamic expected, dynamic actual) → dynamic {
|
||||
if(!expected.{core::Object::==}(actual))
|
||||
|
|
|
|||
|
|
@ -11,7 +11,8 @@ class C extends core::Object {
|
|||
: super core::Object::•()
|
||||
;
|
||||
method m() → asy::Future<core::List<core::int*>*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::List<core::int*>*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<core::int*>*>();
|
||||
final asy::_Future<core::List<core::int*>*>* :async_future = new asy::_Future::•<core::List<core::int*>*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::List<core::int*>*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -29,20 +30,22 @@ class C extends core::Object {
|
|||
:return_value = block {} =>#t1;
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
method _m() → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -56,17 +59,18 @@ class C extends core::Object {
|
|||
:return_value = 42;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
abstract member-signature get _identityHashCode() → core::int*; -> core::Object::_identityHashCode
|
||||
abstract member-signature method _instanceOf(dynamic instantiatorTypeArguments, dynamic functionTypeArguments, dynamic type) → core::bool*; -> core::Object::_instanceOf
|
||||
|
|
@ -80,7 +84,8 @@ class C extends core::Object {
|
|||
abstract member-signature get runtimeType() → core::Type*; -> core::Object::runtimeType
|
||||
}
|
||||
static method main() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -95,17 +100,18 @@ static method main() → dynamic /* originally async */ {
|
|||
[yield] let dynamic #t3 = asy::_awaitHelper(new self::C::•().{self::C::m}(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
self::expect(42, _in::unsafeCast<core::List<core::int*>*>(:result).{core::Iterable::first});
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method expect(dynamic expected, dynamic actual) → dynamic {
|
||||
if(!expected.{core::Object::==}(actual))
|
||||
|
|
|
|||
|
|
@ -10,7 +10,8 @@ static method main() → dynamic {
|
|||
core::print(result.{core::Object::runtimeType});
|
||||
}
|
||||
static method returnsString() → FutureOr<core::String*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::String*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::String*>();
|
||||
final asy::_Future<core::String*>* :async_future = new asy::_Future::•<core::String*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::String*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -24,15 +25,16 @@ static method returnsString() → FutureOr<core::String*>* /* originally async *
|
|||
:return_value = "oh no";
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -41,7 +41,8 @@ class Y extends core::Object {
|
|||
abstract member-signature get runtimeType() → core::Type*; -> core::Object::runtimeType
|
||||
}
|
||||
static method f1() → asy::Future<core::List<core::Object*>*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::List<core::Object*>*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<core::Object*>*>();
|
||||
final asy::_Future<core::List<core::Object*>*>* :async_future = new asy::_Future::•<core::List<core::Object*>*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::List<core::Object*>*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -55,22 +56,24 @@ static method f1() → asy::Future<core::List<core::Object*>*>* /* originally as
|
|||
:return_value = <core::Object*>[1];
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method f2() → core::List<core::Object*>*
|
||||
return <core::Object*>[2];
|
||||
static method f3() → asy::Future<core::Object*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::Object*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::Object*>();
|
||||
final asy::_Future<core::Object*>* :async_future = new asy::_Future::•<core::Object*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::Object*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -84,20 +87,22 @@ static method f3() → asy::Future<core::Object*>* /* originally async */ {
|
|||
:return_value = 3;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method foo() → asy::Future<self::X*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<self::X*>* :async_completer = new asy::_AsyncAwaitCompleter::•<self::X*>();
|
||||
final asy::_Future<self::X*>* :async_future = new asy::_Future::•<self::X*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<self::X*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -120,20 +125,22 @@ static method foo() → asy::Future<self::X*>* /* originally async */ {
|
|||
:return_value = new self::X::•(_in::unsafeCast<self::Y*>(:async_temporary_0), _in::unsafeCast<core::Object*>(:result));
|
||||
break #L3;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method main() → asy::Future<void>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<void>* :async_completer = new asy::_AsyncAwaitCompleter::•<void>();
|
||||
final asy::_Future<void>* :async_future = new asy::_Future::•<void>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<void>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -148,15 +155,16 @@ static method main() → asy::Future<void>* /* originally async */ {
|
|||
[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));
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,7 +8,8 @@ import "org-dartlang-testcase:///deferred_lib.dart" deferred as lib;
|
|||
|
||||
static method main() → dynamic {}
|
||||
static method test() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -24,17 +25,18 @@ static method test() → dynamic /* originally async */ {
|
|||
[yield] let dynamic #t2 = asy::_awaitHelper(LoadLibrary(lib), :async_op_then, :async_op_error, :async_op) in null;
|
||||
def::m(:result);
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
library;
|
||||
|
|
|
|||
|
|
@ -2339,7 +2339,8 @@ static method testForElement(dynamic dynVar, core::List<core::int*>* listInt, co
|
|||
} =>#t337;
|
||||
}
|
||||
static method testForElementErrors(core::Map<core::int*, core::int*>* map, core::List<core::int*>* list) → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -2886,17 +2887,18 @@ static method testForElementErrors(core::Map<core::int*, core::int*>* map, core:
|
|||
#t433.{core::Map::[]=}("baz", null);
|
||||
} =>#t433;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method testForElementErrorsNotAsync(asy::Stream<core::int*>* stream) → dynamic {
|
||||
block {
|
||||
|
|
|
|||
|
|
@ -28,7 +28,8 @@ class B extends core::Object {
|
|||
: super core::Object::•()
|
||||
;
|
||||
method bar() → asy::Future<dynamic>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -42,17 +43,18 @@ class B extends core::Object {
|
|||
:return_value = this.{self::B::a}.{self::A::foo}();
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
abstract member-signature get _identityHashCode() → core::int*; -> core::Object::_identityHashCode
|
||||
abstract member-signature method _instanceOf(dynamic instantiatorTypeArguments, dynamic functionTypeArguments, dynamic type) → core::bool*; -> core::Object::_instanceOf
|
||||
|
|
@ -71,7 +73,8 @@ class C extends core::Object {
|
|||
: super core::Object::•()
|
||||
;
|
||||
method baz() → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -85,17 +88,18 @@ class C extends core::Object {
|
|||
:return_value = this.{self::C::b}.{self::B::bar}() as{TypeError} FutureOr<core::int*>*;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
abstract member-signature get _identityHashCode() → core::int*; -> core::Object::_identityHashCode
|
||||
abstract member-signature method _instanceOf(dynamic instantiatorTypeArguments, dynamic functionTypeArguments, dynamic type) → core::bool*; -> core::Object::_instanceOf
|
||||
|
|
|
|||
|
|
@ -2,7 +2,8 @@ main = main::main;
|
|||
library from "org-dartlang-test:///libA.dart" as libA {
|
||||
|
||||
static method whatever() → dynamic /* originally async */ {
|
||||
final dart.async::_AsyncAwaitCompleter<dynamic>* :async_completer = new dart.async::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final dart.async::_Future<dynamic>* :async_future = new dart.async::_Future::•<dynamic>();
|
||||
dart.core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -19,17 +20,18 @@ library from "org-dartlang-test:///libA.dart" as libA {
|
|||
:return_value = "hello";
|
||||
break #L1;
|
||||
}
|
||||
dart.async::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
dart.async::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, dart.core::StackTrace* stack_trace) {
|
||||
:async_completer.{dart.async::Completer::completeError}(exception, stack_trace);
|
||||
dart.async::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = dart.async::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = dart.async::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = dart.async::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{dart.async::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{dart.async::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
}
|
||||
library from "org-dartlang-test:///main.dart" as main {
|
||||
|
|
@ -54,7 +56,8 @@ library from "org-dartlang-test:///main.dart" as main {
|
|||
abstract member-signature get runtimeType() → dart.core::Type*; -> dart.core::Object::runtimeType
|
||||
}
|
||||
static method main() → dynamic /* originally async */ {
|
||||
final dart.async::_AsyncAwaitCompleter<dynamic>* :async_completer = new dart.async::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final dart.async::_Future<dynamic>* :async_future = new dart.async::_Future::•<dynamic>();
|
||||
dart.core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -70,17 +73,18 @@ library from "org-dartlang-test:///main.dart" as main {
|
|||
:result;
|
||||
dart.core::print(#C2);
|
||||
}
|
||||
dart.async::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
dart.async::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, dart.core::StackTrace* stack_trace) {
|
||||
:async_completer.{dart.async::Completer::completeError}(exception, stack_trace);
|
||||
dart.async::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = dart.async::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = dart.async::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = dart.async::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{dart.async::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{dart.async::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
}
|
||||
constants {
|
||||
|
|
|
|||
|
|
@ -2,7 +2,8 @@ main = main::main;
|
|||
library from "org-dartlang-test:///libA.dart" as libA {
|
||||
|
||||
static method whatever() → dynamic /* originally async */ {
|
||||
final dart.async::_AsyncAwaitCompleter<dynamic>* :async_completer = new dart.async::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final dart.async::_Future<dynamic>* :async_future = new dart.async::_Future::•<dynamic>();
|
||||
dart.core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -19,17 +20,18 @@ library from "org-dartlang-test:///libA.dart" as libA {
|
|||
:return_value = "hello";
|
||||
break #L1;
|
||||
}
|
||||
dart.async::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
dart.async::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, dart.core::StackTrace* stack_trace) {
|
||||
:async_completer.{dart.async::Completer::completeError}(exception, stack_trace);
|
||||
dart.async::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = dart.async::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = dart.async::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = dart.async::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{dart.async::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{dart.async::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
}
|
||||
library from "org-dartlang-test:///main.dart" as main {
|
||||
|
|
@ -54,7 +56,8 @@ library from "org-dartlang-test:///main.dart" as main {
|
|||
abstract member-signature get runtimeType() → dart.core::Type*; -> dart.core::Object::runtimeType
|
||||
}
|
||||
static method main() → dynamic /* originally async */ {
|
||||
final dart.async::_AsyncAwaitCompleter<dynamic>* :async_completer = new dart.async::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final dart.async::_Future<dynamic>* :async_future = new dart.async::_Future::•<dynamic>();
|
||||
dart.core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -71,17 +74,18 @@ library from "org-dartlang-test:///main.dart" as main {
|
|||
dart.core::print(#C2);
|
||||
dart.core::print("Done");
|
||||
}
|
||||
dart.async::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
dart.async::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, dart.core::StackTrace* stack_trace) {
|
||||
:async_completer.{dart.async::Completer::completeError}(exception, stack_trace);
|
||||
dart.async::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = dart.async::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = dart.async::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = dart.async::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{dart.async::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{dart.async::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
}
|
||||
constants {
|
||||
|
|
|
|||
|
|
@ -20,7 +20,8 @@ library from "org-dartlang-test:///main.dart" as main {
|
|||
abstract member-signature get runtimeType() → dart.core::Type*; -> dart.core::Object::runtimeType
|
||||
}
|
||||
static method main() → dynamic /* originally async */ {
|
||||
final dart.async::_AsyncAwaitCompleter<dynamic>* :async_completer = new dart.async::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final dart.async::_Future<dynamic>* :async_future = new dart.async::_Future::•<dynamic>();
|
||||
dart.core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -36,20 +37,22 @@ library from "org-dartlang-test:///main.dart" as main {
|
|||
:result;
|
||||
dart.core::print(#C2);
|
||||
}
|
||||
dart.async::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
dart.async::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, dart.core::StackTrace* stack_trace) {
|
||||
:async_completer.{dart.async::Completer::completeError}(exception, stack_trace);
|
||||
dart.async::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = dart.async::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = dart.async::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = dart.async::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{dart.async::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{dart.async::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method /* from org-dartlang-test:///myPart.dart */ whatever() → dynamic /* originally async */ {
|
||||
final dart.async::_AsyncAwaitCompleter<dynamic>* :async_completer = new dart.async::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final dart.async::_Future<dynamic>* :async_future = new dart.async::_Future::•<dynamic>();
|
||||
dart.core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -66,17 +69,18 @@ library from "org-dartlang-test:///main.dart" as main {
|
|||
:return_value = "hello";
|
||||
break #L2;
|
||||
}
|
||||
dart.async::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
dart.async::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, dart.core::StackTrace* stack_trace) {
|
||||
:async_completer.{dart.async::Completer::completeError}(exception, stack_trace);
|
||||
dart.async::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = dart.async::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = dart.async::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = dart.async::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{dart.async::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{dart.async::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
}
|
||||
constants {
|
||||
|
|
|
|||
|
|
@ -20,7 +20,8 @@ library from "org-dartlang-test:///main.dart" as main {
|
|||
abstract member-signature get runtimeType() → dart.core::Type*; -> dart.core::Object::runtimeType
|
||||
}
|
||||
static method main() → dynamic /* originally async */ {
|
||||
final dart.async::_AsyncAwaitCompleter<dynamic>* :async_completer = new dart.async::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final dart.async::_Future<dynamic>* :async_future = new dart.async::_Future::•<dynamic>();
|
||||
dart.core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -36,20 +37,22 @@ library from "org-dartlang-test:///main.dart" as main {
|
|||
:result;
|
||||
dart.core::print(#C2);
|
||||
}
|
||||
dart.async::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
dart.async::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, dart.core::StackTrace* stack_trace) {
|
||||
:async_completer.{dart.async::Completer::completeError}(exception, stack_trace);
|
||||
dart.async::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = dart.async::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = dart.async::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = dart.async::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{dart.async::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{dart.async::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method /* from org-dartlang-test:///myPart.dart */ whatever() → dynamic /* originally async */ {
|
||||
final dart.async::_AsyncAwaitCompleter<dynamic>* :async_completer = new dart.async::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final dart.async::_Future<dynamic>* :async_future = new dart.async::_Future::•<dynamic>();
|
||||
dart.core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -66,17 +69,18 @@ library from "org-dartlang-test:///main.dart" as main {
|
|||
:return_value = "hello!!!";
|
||||
break #L2;
|
||||
}
|
||||
dart.async::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
dart.async::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, dart.core::StackTrace* stack_trace) {
|
||||
:async_completer.{dart.async::Completer::completeError}(exception, stack_trace);
|
||||
dart.async::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = dart.async::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = dart.async::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = dart.async::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{dart.async::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{dart.async::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
}
|
||||
constants {
|
||||
|
|
|
|||
|
|
@ -20,7 +20,8 @@ library from "org-dartlang-test:///main.dart" as main {
|
|||
abstract member-signature get runtimeType() → dart.core::Type*; -> dart.core::Object::runtimeType
|
||||
}
|
||||
static method main() → dynamic /* originally async */ {
|
||||
final dart.async::_AsyncAwaitCompleter<dynamic>* :async_completer = new dart.async::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final dart.async::_Future<dynamic>* :async_future = new dart.async::_Future::•<dynamic>();
|
||||
dart.core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -37,20 +38,22 @@ library from "org-dartlang-test:///main.dart" as main {
|
|||
dart.core::print(#C2);
|
||||
dart.core::print("Done!");
|
||||
}
|
||||
dart.async::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
dart.async::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, dart.core::StackTrace* stack_trace) {
|
||||
:async_completer.{dart.async::Completer::completeError}(exception, stack_trace);
|
||||
dart.async::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = dart.async::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = dart.async::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = dart.async::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{dart.async::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{dart.async::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method /* from org-dartlang-test:///myPart.dart */ whatever() → dynamic /* originally async */ {
|
||||
final dart.async::_AsyncAwaitCompleter<dynamic>* :async_completer = new dart.async::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final dart.async::_Future<dynamic>* :async_future = new dart.async::_Future::•<dynamic>();
|
||||
dart.core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -67,17 +70,18 @@ library from "org-dartlang-test:///main.dart" as main {
|
|||
:return_value = "hello!!!";
|
||||
break #L2;
|
||||
}
|
||||
dart.async::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
dart.async::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, dart.core::StackTrace* stack_trace) {
|
||||
:async_completer.{dart.async::Completer::completeError}(exception, stack_trace);
|
||||
dart.async::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = dart.async::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = dart.async::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = dart.async::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{dart.async::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{dart.async::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
}
|
||||
constants {
|
||||
|
|
|
|||
|
|
@ -27,7 +27,8 @@ abstract class MyFuture extends core::Object implements asy::Future<core::int*>
|
|||
abstract member-signature method timeout(core::Duration* timeLimit, {generic-covariant-impl () →* FutureOr<core::int*>* onTimeout = #C1}) → asy::Future<core::int*>*; -> asy::Future::timeout
|
||||
}
|
||||
static method test() → void /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -50,7 +51,8 @@ static method test() → void /* originally async */ {
|
|||
FutureOr<self::MyFuture*>* x8;
|
||||
self::MyFuture* x9;
|
||||
function test0() → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -64,20 +66,22 @@ static method test() → void /* originally async */ {
|
|||
:return_value = x0;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
function test1() → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -91,20 +95,22 @@ static method test() → void /* originally async */ {
|
|||
:return_value = x1;
|
||||
break #L3;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
function test2() → asy::Future<asy::Future<core::int*>*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<asy::Future<core::int*>*>* :async_completer = new asy::_AsyncAwaitCompleter::•<asy::Future<core::int*>*>();
|
||||
final asy::_Future<asy::Future<core::int*>*>* :async_future = new asy::_Future::•<asy::Future<core::int*>*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<asy::Future<core::int*>*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -118,20 +124,22 @@ static method test() → void /* originally async */ {
|
|||
:return_value = x2;
|
||||
break #L4;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
function test3() → asy::Future<FutureOr<core::int*>*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<FutureOr<core::int*>*>* :async_completer = new asy::_AsyncAwaitCompleter::•<FutureOr<core::int*>*>();
|
||||
final asy::_Future<FutureOr<core::int*>*>* :async_future = new asy::_Future::•<FutureOr<core::int*>*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<FutureOr<core::int*>*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -145,20 +153,22 @@ static method test() → void /* originally async */ {
|
|||
:return_value = x3;
|
||||
break #L5;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
function test4() → asy::Future<self::MyFuture*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<self::MyFuture*>* :async_completer = new asy::_AsyncAwaitCompleter::•<self::MyFuture*>();
|
||||
final asy::_Future<self::MyFuture*>* :async_future = new asy::_Future::•<self::MyFuture*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<self::MyFuture*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -172,20 +182,22 @@ static method test() → void /* originally async */ {
|
|||
:return_value = x4;
|
||||
break #L6;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
function test5() → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -199,20 +211,22 @@ static method test() → void /* originally async */ {
|
|||
:return_value = x5;
|
||||
break #L7;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
function test6() → asy::Future<asy::Future<core::int*>*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<asy::Future<core::int*>*>* :async_completer = new asy::_AsyncAwaitCompleter::•<asy::Future<core::int*>*>();
|
||||
final asy::_Future<asy::Future<core::int*>*>* :async_future = new asy::_Future::•<asy::Future<core::int*>*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<asy::Future<core::int*>*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -226,20 +240,22 @@ static method test() → void /* originally async */ {
|
|||
:return_value = x6;
|
||||
break #L8;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
function test7() → asy::Future<FutureOr<core::int*>*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<FutureOr<core::int*>*>* :async_completer = new asy::_AsyncAwaitCompleter::•<FutureOr<core::int*>*>();
|
||||
final asy::_Future<FutureOr<core::int*>*>* :async_future = new asy::_Future::•<FutureOr<core::int*>*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<FutureOr<core::int*>*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -253,20 +269,22 @@ static method test() → void /* originally async */ {
|
|||
:return_value = x7;
|
||||
break #L9;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
function test8() → asy::Future<self::MyFuture*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<self::MyFuture*>* :async_completer = new asy::_AsyncAwaitCompleter::•<self::MyFuture*>();
|
||||
final asy::_Future<self::MyFuture*>* :async_future = new asy::_Future::•<self::MyFuture*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<self::MyFuture*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -280,20 +298,22 @@ static method test() → void /* originally async */ {
|
|||
:return_value = x8;
|
||||
break #L10;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
function test9() → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -307,17 +327,18 @@ static method test() → void /* originally async */ {
|
|||
:return_value = x9;
|
||||
break #L11;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
: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);
|
||||
|
|
@ -340,17 +361,18 @@ static method test() → void /* originally async */ {
|
|||
[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);
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method main() → dynamic {}
|
||||
|
||||
|
|
|
|||
|
|
@ -8,7 +8,8 @@ import "dart:async";
|
|||
static field asy::Future<core::int*>* futureInt = null;
|
||||
static field () →* asy::Future<core::int*>* f = () → asy::Future<core::int*>* => self::futureInt;
|
||||
static field () →* asy::Future<core::int*>* g = () → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -22,17 +23,18 @@ static field () →* asy::Future<core::int*>* g = () → asy::Future<core::int*>
|
|||
:return_value = self::futureInt;
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
static method main() → dynamic {
|
||||
self::f;
|
||||
|
|
|
|||
|
|
@ -4,7 +4,8 @@ import "dart:async" as asy;
|
|||
import "dart:core" as core;
|
||||
|
||||
static field () →* asy::Future<core::int*>* f = () → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -18,17 +19,18 @@ static field () →* asy::Future<core::int*>* f = () → asy::Future<core::int*>
|
|||
:return_value = 0;
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
static method main() → dynamic {
|
||||
self::f;
|
||||
|
|
|
|||
|
|
@ -8,7 +8,8 @@ import "dart:async";
|
|||
static field FutureOr<core::int*>* futureOrInt = null;
|
||||
static field () →* FutureOr<core::int*>* f = () → FutureOr<core::int*>* => self::futureOrInt;
|
||||
static field () →* asy::Future<core::int*>* g = () → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -22,17 +23,18 @@ static field () →* asy::Future<core::int*>* g = () → asy::Future<core::int*>
|
|||
:return_value = self::futureOrInt;
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
static method main() → dynamic {
|
||||
self::f;
|
||||
|
|
|
|||
|
|
@ -9,7 +9,8 @@ import "dart:math" show Random;
|
|||
|
||||
static method test() → dynamic {
|
||||
() →* asy::Future<core::num*>* f = () → asy::Future<core::num*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::num*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::num*>();
|
||||
final asy::_Future<core::num*>* :async_future = new asy::_Future::•<core::num*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::num*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -29,17 +30,18 @@ static method test() → dynamic {
|
|||
break #L1;
|
||||
}
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
asy::Future<core::num*>* g = f.call();
|
||||
asy::Future<core::int*>* h = f.call() as{TypeError} asy::Future<core::int*>*;
|
||||
|
|
|
|||
|
|
@ -9,7 +9,8 @@ import "dart:math" show Random;
|
|||
|
||||
static method test() → dynamic {
|
||||
() →* asy::Future<core::num*>* f = () → asy::Future<core::num*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::num*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::num*>();
|
||||
final asy::_Future<core::num*>* :async_future = new asy::_Future::•<core::num*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::num*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -29,17 +30,18 @@ static method test() → dynamic {
|
|||
break #L1;
|
||||
}
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
asy::Future<core::num*>* g = f.call();
|
||||
asy::Future<core::int*>* h = f.call() as{TypeError} asy::Future<core::int*>*;
|
||||
|
|
|
|||
|
|
@ -9,7 +9,8 @@ import "dart:math" show Random;
|
|||
|
||||
static method test() → dynamic {
|
||||
() →* asy::Future<core::num*>* f = () → asy::Future<core::num*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::num*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::num*>();
|
||||
final asy::_Future<core::num*>* :async_future = new asy::_Future::•<core::num*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::num*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -29,17 +30,18 @@ static method test() → dynamic {
|
|||
break #L1;
|
||||
}
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
asy::Future<core::num*>* g = f.call();
|
||||
asy::Future<core::int*>* h = f.call() as{TypeError} asy::Future<core::int*>*;
|
||||
|
|
|
|||
|
|
@ -7,7 +7,8 @@ import "dart:_internal" as _in;
|
|||
import "dart:async";
|
||||
|
||||
static method main() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -20,7 +21,8 @@ static method main() → dynamic /* originally async */ {
|
|||
#L1:
|
||||
{
|
||||
() →* asy::Future<core::Null?>* f = () → asy::Future<core::Null?>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::Null?>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::Null?>();
|
||||
final asy::_Future<core::Null?>* :async_future = new asy::_Future::•<core::Null?>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::Null?>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -34,32 +36,34 @@ static method main() → dynamic /* originally async */ {
|
|||
:return_value = null;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
asy::Future<dynamic>* y = f.call();
|
||||
asy::Future<core::String*>* z = f.call();
|
||||
[yield] let dynamic #t1 = asy::_awaitHelper(f.call(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::String* s = _in::unsafeCast<core::Null?>(:result);
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,7 +7,8 @@ import "dart:_internal" as _in;
|
|||
import "dart:async";
|
||||
|
||||
static method main() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -59,15 +60,16 @@ static method main() → dynamic /* originally async */ {
|
|||
[yield] let dynamic #t1 = asy::_awaitHelper(f.call().{asy::Stream::first}, :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::String* s = _in::unsafeCast<core::Null?>(:result);
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,7 +7,8 @@ import "dart:_internal" as _in;
|
|||
import "dart:async";
|
||||
|
||||
static method main() → asy::Future<dynamic>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -25,15 +26,16 @@ static method main() → asy::Future<dynamic>* /* originally async */ {
|
|||
[yield] let dynamic #t2 = asy::_awaitHelper(asy::Future::value<core::List<core::int*>*>(<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);
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -60,7 +60,8 @@ abstract class MyStream<T extends core::Object* = dynamic> extends asy::Stream<s
|
|||
static method F<T extends core::Object* = dynamic>() → self::F::T*
|
||||
return null;
|
||||
static method f() → asy::Future<dynamic>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -226,20 +227,22 @@ static method f() → asy::Future<dynamic>* /* originally async */ {
|
|||
}
|
||||
}
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method main() → asy::Future<dynamic>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -318,17 +321,18 @@ static method main() → asy::Future<dynamic>* /* originally async */ {
|
|||
}
|
||||
}
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
||||
constants {
|
||||
|
|
|
|||
|
|
@ -5,7 +5,8 @@ import "dart:core" as core;
|
|||
import "dart:_internal" as _in;
|
||||
|
||||
static method test() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -83,16 +84,17 @@ static method test() → dynamic /* originally async */ {
|
|||
}
|
||||
}
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method main() → dynamic {}
|
||||
|
|
|
|||
|
|
@ -36,7 +36,8 @@ class MyFuture<T extends core::Object* = dynamic> extends core::Object implement
|
|||
static method test() → void {
|
||||
self::MyFuture<dynamic>* f;
|
||||
asy::Future<core::int*>* t1 = f.{self::MyFuture::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -52,20 +53,22 @@ static method test() → void {
|
|||
:return_value = _in::unsafeCast<core::int*>(:result);
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
asy::Future<core::int*>* t2 = f.{self::MyFuture::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -81,20 +84,22 @@ static method test() → void {
|
|||
:return_value = _in::unsafeCast<core::int*>(:result);
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
asy::Future<core::int*>* t3 = f.{self::MyFuture::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -108,20 +113,22 @@ static method test() → void {
|
|||
:return_value = 3;
|
||||
break #L3;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
asy::Future<core::int*>* t4 = f.{self::MyFuture::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -135,24 +142,26 @@ static method test() → void {
|
|||
:return_value = 3;
|
||||
break #L4;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
asy::Future<core::int*>* t5 = f.{self::MyFuture::then}<core::int*>((dynamic _) → asy::Future<core::int*>* => asy::Future::value<core::int*>(3));
|
||||
asy::Future<core::int*>* t6 = f.{self::MyFuture::then}<core::int*>((dynamic _) → asy::Future<core::int*>* {
|
||||
return asy::Future::value<core::int*>(3);
|
||||
});
|
||||
asy::Future<core::int*>* t7 = f.{self::MyFuture::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -166,20 +175,22 @@ static method test() → void {
|
|||
:return_value = asy::Future::value<core::int*>(3);
|
||||
break #L5;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
asy::Future<core::int*>* t8 = f.{self::MyFuture::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -193,17 +204,18 @@ static method test() → void {
|
|||
:return_value = asy::Future::value<core::int*>(3);
|
||||
break #L6;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
}
|
||||
static method main() → dynamic {}
|
||||
|
|
|
|||
|
|
@ -36,7 +36,8 @@ class MyFuture<T extends core::Object* = dynamic> extends core::Object implement
|
|||
static method test() → void {
|
||||
self::MyFuture<dynamic>* f;
|
||||
asy::Future<core::int*>* t1 = f.{self::MyFuture::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -52,20 +53,22 @@ static method test() → void {
|
|||
:return_value = _in::unsafeCast<core::int*>(:result);
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
asy::Future<core::int*>* t2 = f.{self::MyFuture::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -81,20 +84,22 @@ static method test() → void {
|
|||
:return_value = _in::unsafeCast<core::int*>(:result);
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
asy::Future<core::int*>* t3 = f.{self::MyFuture::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -108,20 +113,22 @@ static method test() → void {
|
|||
:return_value = 3;
|
||||
break #L3;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
asy::Future<core::int*>* t4 = f.{self::MyFuture::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -135,24 +142,26 @@ static method test() → void {
|
|||
:return_value = 3;
|
||||
break #L4;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
asy::Future<core::int*>* t5 = f.{self::MyFuture::then}<core::int*>((dynamic _) → self::MyFuture<core::int*>* => new self::MyFuture::value<core::int*>(3));
|
||||
asy::Future<core::int*>* t6 = f.{self::MyFuture::then}<core::int*>((dynamic _) → self::MyFuture<core::int*>* {
|
||||
return new self::MyFuture::value<core::int*>(3);
|
||||
});
|
||||
asy::Future<core::int*>* t7 = f.{self::MyFuture::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -166,20 +175,22 @@ static method test() → void {
|
|||
:return_value = new self::MyFuture::value<core::int*>(3);
|
||||
break #L5;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
asy::Future<core::int*>* t8 = f.{self::MyFuture::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -193,17 +204,18 @@ static method test() → void {
|
|||
:return_value = new self::MyFuture::value<core::int*>(3);
|
||||
break #L6;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
}
|
||||
static method main() → dynamic {}
|
||||
|
|
|
|||
|
|
@ -36,7 +36,8 @@ class MyFuture<T extends core::Object* = dynamic> extends core::Object implement
|
|||
static method test() → void {
|
||||
self::MyFuture<dynamic>* f;
|
||||
self::MyFuture<core::int*>* t1 = f.{self::MyFuture::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -52,20 +53,22 @@ static method test() → void {
|
|||
:return_value = _in::unsafeCast<core::int*>(:result);
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
self::MyFuture<core::int*>* t2 = f.{self::MyFuture::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -81,20 +84,22 @@ static method test() → void {
|
|||
:return_value = _in::unsafeCast<core::int*>(:result);
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
self::MyFuture<core::int*>* t3 = f.{self::MyFuture::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -108,20 +113,22 @@ static method test() → void {
|
|||
:return_value = 3;
|
||||
break #L3;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
self::MyFuture<core::int*>* t4 = f.{self::MyFuture::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -135,24 +142,26 @@ static method test() → void {
|
|||
:return_value = 3;
|
||||
break #L4;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
self::MyFuture<core::int*>* t5 = f.{self::MyFuture::then}<core::int*>((dynamic _) → asy::Future<core::int*>* => asy::Future::value<core::int*>(3));
|
||||
self::MyFuture<core::int*>* t6 = f.{self::MyFuture::then}<core::int*>((dynamic _) → asy::Future<core::int*>* {
|
||||
return asy::Future::value<core::int*>(3);
|
||||
});
|
||||
self::MyFuture<core::int*>* t7 = f.{self::MyFuture::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -166,20 +175,22 @@ static method test() → void {
|
|||
:return_value = asy::Future::value<core::int*>(3);
|
||||
break #L5;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
self::MyFuture<core::int*>* t8 = f.{self::MyFuture::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -193,17 +204,18 @@ static method test() → void {
|
|||
:return_value = asy::Future::value<core::int*>(3);
|
||||
break #L6;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
}
|
||||
static method main() → dynamic {}
|
||||
|
|
|
|||
|
|
@ -36,7 +36,8 @@ class MyFuture<T extends core::Object* = dynamic> extends core::Object implement
|
|||
static method test() → void {
|
||||
self::MyFuture<dynamic>* f;
|
||||
self::MyFuture<core::int*>* t1 = f.{self::MyFuture::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -52,20 +53,22 @@ static method test() → void {
|
|||
:return_value = _in::unsafeCast<core::int*>(:result);
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
self::MyFuture<core::int*>* t2 = f.{self::MyFuture::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -81,20 +84,22 @@ static method test() → void {
|
|||
:return_value = _in::unsafeCast<core::int*>(:result);
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
self::MyFuture<core::int*>* t3 = f.{self::MyFuture::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -108,20 +113,22 @@ static method test() → void {
|
|||
:return_value = 3;
|
||||
break #L3;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
self::MyFuture<core::int*>* t4 = f.{self::MyFuture::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -135,24 +142,26 @@ static method test() → void {
|
|||
:return_value = 3;
|
||||
break #L4;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
self::MyFuture<core::int*>* t5 = f.{self::MyFuture::then}<core::int*>((dynamic _) → self::MyFuture<core::int*>* => new self::MyFuture::value<core::int*>(3));
|
||||
self::MyFuture<core::int*>* t6 = f.{self::MyFuture::then}<core::int*>((dynamic _) → self::MyFuture<core::int*>* {
|
||||
return new self::MyFuture::value<core::int*>(3);
|
||||
});
|
||||
self::MyFuture<core::int*>* t7 = f.{self::MyFuture::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -166,20 +175,22 @@ static method test() → void {
|
|||
:return_value = new self::MyFuture::value<core::int*>(3);
|
||||
break #L5;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
self::MyFuture<core::int*>* t8 = f.{self::MyFuture::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -193,17 +204,18 @@ static method test() → void {
|
|||
:return_value = new self::MyFuture::value<core::int*>(3);
|
||||
break #L6;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
}
|
||||
static method main() → dynamic {}
|
||||
|
|
|
|||
|
|
@ -36,7 +36,8 @@ class MyFuture<T extends core::Object* = dynamic> extends core::Object implement
|
|||
static method test() → void {
|
||||
asy::Future<dynamic>* f;
|
||||
asy::Future<core::int*>* t1 = f.{asy::Future::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -52,20 +53,22 @@ static method test() → void {
|
|||
:return_value = _in::unsafeCast<core::int*>(:result);
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
asy::Future<core::int*>* t2 = f.{asy::Future::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -81,20 +84,22 @@ static method test() → void {
|
|||
:return_value = _in::unsafeCast<core::int*>(:result);
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
asy::Future<core::int*>* t3 = f.{asy::Future::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -108,20 +113,22 @@ static method test() → void {
|
|||
:return_value = 3;
|
||||
break #L3;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
asy::Future<core::int*>* t4 = f.{asy::Future::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -135,24 +142,26 @@ static method test() → void {
|
|||
:return_value = 3;
|
||||
break #L4;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
asy::Future<core::int*>* t5 = f.{asy::Future::then}<core::int*>((dynamic _) → self::MyFuture<core::int*>* => new self::MyFuture::value<core::int*>(3));
|
||||
asy::Future<core::int*>* t6 = f.{asy::Future::then}<core::int*>((dynamic _) → self::MyFuture<core::int*>* {
|
||||
return new self::MyFuture::value<core::int*>(3);
|
||||
});
|
||||
asy::Future<core::int*>* t7 = f.{asy::Future::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -166,20 +175,22 @@ static method test() → void {
|
|||
:return_value = new self::MyFuture::value<core::int*>(3);
|
||||
break #L5;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
asy::Future<core::int*>* t8 = f.{asy::Future::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -193,17 +204,18 @@ static method test() → void {
|
|||
:return_value = new self::MyFuture::value<core::int*>(3);
|
||||
break #L6;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
}
|
||||
static method main() → dynamic {}
|
||||
|
|
|
|||
|
|
@ -36,7 +36,8 @@ class MyFuture<T extends core::Object* = dynamic> extends core::Object implement
|
|||
static method test() → void {
|
||||
asy::Future<dynamic>* f;
|
||||
asy::Future<core::int*>* t1 = f.{asy::Future::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -52,20 +53,22 @@ static method test() → void {
|
|||
:return_value = _in::unsafeCast<core::int*>(:result);
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
asy::Future<core::int*>* t2 = f.{asy::Future::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -81,20 +84,22 @@ static method test() → void {
|
|||
:return_value = _in::unsafeCast<core::int*>(:result);
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
asy::Future<core::int*>* t3 = f.{asy::Future::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -108,20 +113,22 @@ static method test() → void {
|
|||
:return_value = 3;
|
||||
break #L3;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
asy::Future<core::int*>* t4 = f.{asy::Future::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -135,24 +142,26 @@ static method test() → void {
|
|||
:return_value = 3;
|
||||
break #L4;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
asy::Future<core::int*>* t5 = f.{asy::Future::then}<core::int*>((dynamic _) → asy::Future<core::int*>* => asy::Future::value<core::int*>(3));
|
||||
asy::Future<core::int*>* t6 = f.{asy::Future::then}<core::int*>((dynamic _) → asy::Future<core::int*>* {
|
||||
return asy::Future::value<core::int*>(3);
|
||||
});
|
||||
asy::Future<core::int*>* t7 = f.{asy::Future::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -166,20 +175,22 @@ static method test() → void {
|
|||
:return_value = asy::Future::value<core::int*>(3);
|
||||
break #L5;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
asy::Future<core::int*>* t8 = f.{asy::Future::then}<core::int*>((dynamic _) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -193,17 +204,18 @@ static method test() → void {
|
|||
:return_value = asy::Future::value<core::int*>(3);
|
||||
break #L6;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
}
|
||||
static method main() → dynamic {}
|
||||
|
|
|
|||
|
|
@ -36,7 +36,8 @@ class MyFuture<T extends core::Object* = dynamic> extends core::Object implement
|
|||
static method test() → void {
|
||||
self::MyFuture<core::bool*>* f;
|
||||
asy::Future<core::int*>* t1 = f.{self::MyFuture::then}<core::int*>((core::bool* x) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -59,20 +60,22 @@ static method test() → void {
|
|||
:return_value = :async_temporary_0;
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
asy::Future<core::int*>* t2 = f.{self::MyFuture::then}<core::int*>((core::bool* x) → FutureOr<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -88,17 +91,18 @@ static method test() → void {
|
|||
:return_value = (_in::unsafeCast<core::bool*>(:result) ?{core::Object*} 2 : asy::Future::value<core::int*>(3)) as{TypeError} FutureOr<core::int*>*;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
asy::Future<core::int*>* t5 = f.{self::MyFuture::then}<core::int*>((core::bool* x) → FutureOr<core::int*>* => (x ?{core::Object*} 2 : asy::Future::value<core::int*>(3)) as{TypeError} FutureOr<core::int*>*);
|
||||
asy::Future<core::int*>* t6 = f.{self::MyFuture::then}<core::int*>((core::bool* x) → FutureOr<core::int*>* {
|
||||
|
|
|
|||
|
|
@ -36,7 +36,8 @@ class MyFuture<T extends core::Object* = dynamic> extends core::Object implement
|
|||
static method test() → void {
|
||||
self::MyFuture<core::bool*>* f;
|
||||
asy::Future<core::int*>* t1 = f.{self::MyFuture::then}<core::int*>((core::bool* x) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -59,20 +60,22 @@ static method test() → void {
|
|||
:return_value = :async_temporary_0;
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
asy::Future<core::int*>* t2 = f.{self::MyFuture::then}<core::int*>((core::bool* x) → FutureOr<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -88,17 +91,18 @@ static method test() → void {
|
|||
:return_value = (_in::unsafeCast<core::bool*>(:result) ?{core::Object*} 2 : new self::MyFuture::value<core::int*>(3)) as{TypeError} FutureOr<core::int*>*;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
asy::Future<core::int*>* t5 = f.{self::MyFuture::then}<core::int*>((core::bool* x) → FutureOr<core::int*>* => (x ?{core::Object*} 2 : new self::MyFuture::value<core::int*>(3)) as{TypeError} FutureOr<core::int*>*);
|
||||
asy::Future<core::int*>* t6 = f.{self::MyFuture::then}<core::int*>((core::bool* x) → FutureOr<core::int*>* {
|
||||
|
|
|
|||
|
|
@ -36,7 +36,8 @@ class MyFuture<T extends core::Object* = dynamic> extends core::Object implement
|
|||
static method test() → void {
|
||||
self::MyFuture<core::bool*>* f;
|
||||
self::MyFuture<core::int*>* t1 = f.{self::MyFuture::then}<core::int*>((core::bool* x) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -59,20 +60,22 @@ static method test() → void {
|
|||
:return_value = :async_temporary_0;
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
self::MyFuture<core::int*>* t2 = f.{self::MyFuture::then}<core::int*>((core::bool* x) → FutureOr<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -88,17 +91,18 @@ static method test() → void {
|
|||
:return_value = (_in::unsafeCast<core::bool*>(:result) ?{core::Object*} 2 : asy::Future::value<core::int*>(3)) as{TypeError} FutureOr<core::int*>*;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
self::MyFuture<core::int*>* t5 = f.{self::MyFuture::then}<core::int*>((core::bool* x) → FutureOr<core::int*>* => (x ?{core::Object*} 2 : asy::Future::value<core::int*>(3)) as{TypeError} FutureOr<core::int*>*);
|
||||
self::MyFuture<core::int*>* t6 = f.{self::MyFuture::then}<core::int*>((core::bool* x) → FutureOr<core::int*>* {
|
||||
|
|
|
|||
|
|
@ -36,7 +36,8 @@ class MyFuture<T extends core::Object* = dynamic> extends core::Object implement
|
|||
static method test() → void {
|
||||
self::MyFuture<core::bool*>* f;
|
||||
self::MyFuture<core::int*>* t1 = f.{self::MyFuture::then}<core::int*>((core::bool* x) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -59,20 +60,22 @@ static method test() → void {
|
|||
:return_value = :async_temporary_0;
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
self::MyFuture<core::int*>* t2 = f.{self::MyFuture::then}<core::int*>((core::bool* x) → FutureOr<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -88,17 +91,18 @@ static method test() → void {
|
|||
:return_value = (_in::unsafeCast<core::bool*>(:result) ?{core::Object*} 2 : new self::MyFuture::value<core::int*>(3)) as{TypeError} FutureOr<core::int*>*;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
self::MyFuture<core::int*>* t5 = f.{self::MyFuture::then}<core::int*>((core::bool* x) → FutureOr<core::int*>* => (x ?{core::Object*} 2 : new self::MyFuture::value<core::int*>(3)) as{TypeError} FutureOr<core::int*>*);
|
||||
self::MyFuture<core::int*>* t6 = f.{self::MyFuture::then}<core::int*>((core::bool* x) → FutureOr<core::int*>* {
|
||||
|
|
|
|||
|
|
@ -36,7 +36,8 @@ class MyFuture<T extends core::Object* = dynamic> extends core::Object implement
|
|||
static method test() → void {
|
||||
asy::Future<core::bool*>* f;
|
||||
asy::Future<core::int*>* t1 = f.{asy::Future::then}<core::int*>((core::bool* x) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -59,20 +60,22 @@ static method test() → void {
|
|||
:return_value = :async_temporary_0;
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
asy::Future<core::int*>* t2 = f.{asy::Future::then}<core::int*>((core::bool* x) → FutureOr<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -88,17 +91,18 @@ static method test() → void {
|
|||
:return_value = (_in::unsafeCast<core::bool*>(:result) ?{core::Object*} 2 : new self::MyFuture::value<core::int*>(3)) as{TypeError} FutureOr<core::int*>*;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
asy::Future<core::int*>* t5 = f.{asy::Future::then}<core::int*>((core::bool* x) → FutureOr<core::int*>* => (x ?{core::Object*} 2 : new self::MyFuture::value<core::int*>(3)) as{TypeError} FutureOr<core::int*>*);
|
||||
asy::Future<core::int*>* t6 = f.{asy::Future::then}<core::int*>((core::bool* x) → FutureOr<core::int*>* {
|
||||
|
|
|
|||
|
|
@ -36,7 +36,8 @@ class MyFuture<T extends core::Object* = dynamic> extends core::Object implement
|
|||
static method test() → void {
|
||||
asy::Future<core::bool*>* f;
|
||||
asy::Future<core::int*>* t1 = f.{asy::Future::then}<core::int*>((core::bool* x) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -59,20 +60,22 @@ static method test() → void {
|
|||
:return_value = :async_temporary_0;
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
asy::Future<core::int*>* t2 = f.{asy::Future::then}<core::int*>((core::bool* x) → FutureOr<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -88,17 +91,18 @@ static method test() → void {
|
|||
:return_value = (_in::unsafeCast<core::bool*>(:result) ?{core::Object*} 2 : asy::Future::value<core::int*>(3)) as{TypeError} FutureOr<core::int*>*;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
asy::Future<core::int*>* t5 = f.{asy::Future::then}<core::int*>((core::bool* x) → FutureOr<core::int*>* => (x ?{core::Object*} 2 : asy::Future::value<core::int*>(3)) as{TypeError} FutureOr<core::int*>*);
|
||||
asy::Future<core::int*>* t6 = f.{asy::Future::then}<core::int*>((core::bool* x) → FutureOr<core::int*>* {
|
||||
|
|
|
|||
|
|
@ -36,7 +36,8 @@ class MyFuture<T extends core::Object* = dynamic> extends core::Object implement
|
|||
static method test() → void {
|
||||
self::MyFuture<core::int*>* f;
|
||||
asy::Future<core::int*>* t1 = f.{self::MyFuture::then}<core::int*>((core::int* x) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -60,20 +61,22 @@ static method test() → void {
|
|||
:return_value = :async_temporary_0;
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
asy::Future<core::int*>* t2 = f.{self::MyFuture::then}<core::int*>((core::int* x) → FutureOr<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -89,17 +92,18 @@ static method test() → void {
|
|||
:return_value = (let final core::int* #t4 = _in::unsafeCast<core::int*>(:result) in #t4.{core::num::==}(null) ?{core::Object*} asy::Future::value<core::int*>(3) : #t4) as{TypeError} FutureOr<core::int*>*;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
});
|
||||
asy::Future<core::int*>* t5 = f.{self::MyFuture::then}<core::int*>((core::int* x) → FutureOr<core::int*>* => (let final core::int* #t5 = x in #t5.{core::num::==}(null) ?{core::Object*} asy::Future::value<core::int*>(3) : #t5) as{TypeError} FutureOr<core::int*>*);
|
||||
asy::Future<core::int*>* t6 = f.{self::MyFuture::then}<core::int*>((core::int* x) → FutureOr<core::int*>* {
|
||||
|
|
|
|||
|
|
@ -33,7 +33,8 @@ class MyFuture<T extends core::Object* = dynamic> extends core::Object implement
|
|||
return this.{self::MyFuture::noSuchMethod}(new core::_InvocationMirror::_withType(#C9, 0, #C3, core::List::unmodifiable<dynamic>(<dynamic>[timeLimit]), core::Map::unmodifiable<core::Symbol*, dynamic>(<core::Symbol*, dynamic>{#C10: onTimeout}))) as{TypeError,ForDynamic} asy::Future<self::MyFuture::T*>*;
|
||||
}
|
||||
static method g1(core::bool* x) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -47,20 +48,22 @@ static method g1(core::bool* x) → asy::Future<core::int*>* /* originally async
|
|||
:return_value = (x ?{core::Object*} 42 : asy::Future::value<core::int*>(42)) as{TypeError} FutureOr<core::int*>*;
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method g2(core::bool* x) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -74,20 +77,22 @@ static method g2(core::bool* x) → asy::Future<core::int*>* /* originally async
|
|||
:return_value = (x ?{core::Object*} 42 : asy::Future::value<core::int*>(42)) as{TypeError} FutureOr<core::int*>*;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method g3(core::bool* x) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -102,17 +107,18 @@ static method g3(core::bool* x) → asy::Future<core::int*>* /* originally async
|
|||
:return_value = y as{TypeError} FutureOr<core::int*>*;
|
||||
break #L3;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method main() → dynamic {}
|
||||
|
||||
|
|
|
|||
|
|
@ -33,7 +33,8 @@ class MyFuture<T extends core::Object* = dynamic> extends core::Object implement
|
|||
return this.{self::MyFuture::noSuchMethod}(new core::_InvocationMirror::_withType(#C9, 0, #C3, core::List::unmodifiable<dynamic>(<dynamic>[timeLimit]), core::Map::unmodifiable<core::Symbol*, dynamic>(<core::Symbol*, dynamic>{#C10: onTimeout}))) as{TypeError,ForDynamic} asy::Future<self::MyFuture::T*>*;
|
||||
}
|
||||
static method g1(core::bool* x) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -47,20 +48,22 @@ static method g1(core::bool* x) → asy::Future<core::int*>* /* originally async
|
|||
:return_value = (x ?{core::Object*} 42 : new self::MyFuture::value<core::int*>(42)) as{TypeError} FutureOr<core::int*>*;
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method g2(core::bool* x) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -74,20 +77,22 @@ static method g2(core::bool* x) → asy::Future<core::int*>* /* originally async
|
|||
:return_value = (x ?{core::Object*} 42 : new self::MyFuture::value<core::int*>(42)) as{TypeError} FutureOr<core::int*>*;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method g3(core::bool* x) → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -102,17 +107,18 @@ static method g3(core::bool* x) → asy::Future<core::int*>* /* originally async
|
|||
:return_value = y as{TypeError} FutureOr<core::int*>*;
|
||||
break #L3;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method main() → dynamic {}
|
||||
|
||||
|
|
|
|||
|
|
@ -45,7 +45,8 @@ static field asy::Future<core::int*>* t1 = self::f.{self::MyFuture::then}<core::
|
|||
^" in "hi" as{TypeError} FutureOr<core::int*>?));
|
||||
static field asy::Future<core::List<core::int*>*>* t2 = self::f.{self::MyFuture::then}<core::List<core::int*>*>((dynamic _) → core::List<core::int*>* => <core::int*>[3]);
|
||||
static method g2() → asy::Future<core::List<core::int*>*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::List<core::int*>*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<core::int*>*>();
|
||||
final asy::_Future<core::List<core::int*>*>* :async_future = new asy::_Future::•<core::List<core::int*>*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::List<core::int*>*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -59,20 +60,22 @@ static method g2() → asy::Future<core::List<core::int*>*>* /* originally async
|
|||
:return_value = <core::int*>[3];
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method g3() → asy::Future<core::List<core::int*>*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::List<core::int*>*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<core::int*>*>();
|
||||
final asy::_Future<core::List<core::int*>*>* :async_future = new asy::_Future::•<core::List<core::int*>*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::List<core::int*>*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -86,17 +89,18 @@ static method g3() → asy::Future<core::List<core::int*>*>* /* originally async
|
|||
:return_value = asy::Future::value<core::List<core::int*>*>(<core::int*>[3]);
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method main() → dynamic {}
|
||||
|
||||
|
|
|
|||
|
|
@ -36,7 +36,8 @@ static field self::MyFuture<dynamic>* f;
|
|||
static field asy::Future<core::int*>* t1 = self::f.{self::MyFuture::then}<core::int*>((dynamic _) → self::MyFuture<core::int*>* => new self::MyFuture::value<core::int*>("hi"));
|
||||
static field asy::Future<core::List<core::int*>*>* t2 = self::f.{self::MyFuture::then}<core::List<core::int*>*>((dynamic _) → core::List<core::int*>* => <core::int*>[3]);
|
||||
static method g2() → asy::Future<core::List<core::int*>*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::List<core::int*>*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<core::int*>*>();
|
||||
final asy::_Future<core::List<core::int*>*>* :async_future = new asy::_Future::•<core::List<core::int*>*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::List<core::int*>*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -50,20 +51,22 @@ static method g2() → asy::Future<core::List<core::int*>*>* /* originally async
|
|||
:return_value = <core::int*>[3];
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method g3() → asy::Future<core::List<core::int*>*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::List<core::int*>*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<core::int*>*>();
|
||||
final asy::_Future<core::List<core::int*>*>* :async_future = new asy::_Future::•<core::List<core::int*>*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::List<core::int*>*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -77,17 +80,18 @@ static method g3() → asy::Future<core::List<core::int*>*>* /* originally async
|
|||
:return_value = new self::MyFuture::value<core::List<core::int*>*>(<core::int*>[3]);
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method main() → dynamic {}
|
||||
|
||||
|
|
|
|||
|
|
@ -45,7 +45,8 @@ static field asy::Future<core::int*>* t1 = self::f.{asy::Future::then}<core::int
|
|||
^" in "hi" as{TypeError} FutureOr<core::int*>?));
|
||||
static field asy::Future<core::List<core::int*>*>* t2 = self::f.{asy::Future::then}<core::List<core::int*>*>((dynamic _) → core::List<core::int*>* => <core::int*>[3]);
|
||||
static method g2() → asy::Future<core::List<core::int*>*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::List<core::int*>*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<core::int*>*>();
|
||||
final asy::_Future<core::List<core::int*>*>* :async_future = new asy::_Future::•<core::List<core::int*>*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::List<core::int*>*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -59,20 +60,22 @@ static method g2() → asy::Future<core::List<core::int*>*>* /* originally async
|
|||
:return_value = <core::int*>[3];
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method g3() → asy::Future<core::List<core::int*>*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::List<core::int*>*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<core::int*>*>();
|
||||
final asy::_Future<core::List<core::int*>*>* :async_future = new asy::_Future::•<core::List<core::int*>*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::List<core::int*>*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -86,17 +89,18 @@ static method g3() → asy::Future<core::List<core::int*>*>* /* originally async
|
|||
:return_value = asy::Future::value<core::List<core::int*>*>(<core::int*>[3]);
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method main() → dynamic {}
|
||||
|
||||
|
|
|
|||
|
|
@ -36,7 +36,8 @@ static field asy::Future<dynamic>* f;
|
|||
static field asy::Future<core::int*>* t1 = self::f.{asy::Future::then}<core::int*>((dynamic _) → self::MyFuture<core::int*>* => new self::MyFuture::value<core::int*>("hi"));
|
||||
static field asy::Future<core::List<core::int*>*>* t2 = self::f.{asy::Future::then}<core::List<core::int*>*>((dynamic _) → core::List<core::int*>* => <core::int*>[3]);
|
||||
static method g2() → asy::Future<core::List<core::int*>*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::List<core::int*>*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<core::int*>*>();
|
||||
final asy::_Future<core::List<core::int*>*>* :async_future = new asy::_Future::•<core::List<core::int*>*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::List<core::int*>*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -50,20 +51,22 @@ static method g2() → asy::Future<core::List<core::int*>*>* /* originally async
|
|||
:return_value = <core::int*>[3];
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method g3() → asy::Future<core::List<core::int*>*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::List<core::int*>*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<core::int*>*>();
|
||||
final asy::_Future<core::List<core::int*>*>* :async_future = new asy::_Future::•<core::List<core::int*>*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::List<core::int*>*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -77,17 +80,18 @@ static method g3() → asy::Future<core::List<core::int*>*>* /* originally async
|
|||
:return_value = new self::MyFuture::value<core::List<core::int*>*>(<core::int*>[3]);
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method main() → dynamic {}
|
||||
|
||||
|
|
|
|||
|
|
@ -22,7 +22,8 @@ class A extends core::Object {
|
|||
abstract member-signature get runtimeType() → core::Type*; -> core::Object::runtimeType
|
||||
}
|
||||
static method foo() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -39,16 +40,17 @@ static method foo() → dynamic /* originally async */ {
|
|||
[yield] let dynamic #t1 = asy::_awaitHelper(asy::Future::wait<core::List<self::A*>*>(<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);
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method main() → dynamic {}
|
||||
|
|
|
|||
|
|
@ -9,7 +9,8 @@ import "dart:async";
|
|||
static method id<T extends core::Object* = dynamic>(self::id::T* x) → self::id::T*
|
||||
return x;
|
||||
static method test() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -25,16 +26,17 @@ static method test() → dynamic /* originally async */ {
|
|||
[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);
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method main() → dynamic {}
|
||||
|
|
|
|||
|
|
@ -32,7 +32,8 @@ class C extends self::A {
|
|||
;
|
||||
}
|
||||
static method main() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -54,15 +55,16 @@ static method main() → dynamic /* originally async */ {
|
|||
core::List<self::A*>* list = result;
|
||||
list = result2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,7 +7,8 @@ static method test() → dynamic {
|
|||
function f0() → core::int*
|
||||
return 42;
|
||||
function f1() → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -21,23 +22,25 @@ static method test() → dynamic {
|
|||
:return_value = 42;
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
function f2() → core::int* {
|
||||
return 42;
|
||||
}
|
||||
function f3() → asy::Future<core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<core::int*>();
|
||||
final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -51,17 +54,18 @@ static method test() → dynamic {
|
|||
:return_value = 42;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
function f4() → core::Iterable<core::int*>* /* originally sync* */ {
|
||||
function :sync_op_gen() → (core::_SyncIterator<dynamic>*, dynamic, dynamic) →* core::bool* {
|
||||
|
|
|
|||
|
|
@ -56,7 +56,8 @@ class Bar<T extends asy::Stream<core::String*>* = asy::Stream<core::String*>*> e
|
|||
: super core::Object::•()
|
||||
;
|
||||
method foo(generic-covariant-impl self::Bar::T* t) → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -97,17 +98,18 @@ class Bar<T extends asy::Stream<core::String*>* = asy::Stream<core::String*>*> e
|
|||
}
|
||||
}
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
abstract member-signature get _identityHashCode() → core::int*; -> core::Object::_identityHashCode
|
||||
abstract member-signature method _instanceOf(dynamic instantiatorTypeArguments, dynamic functionTypeArguments, dynamic type) → core::bool*; -> core::Object::_instanceOf
|
||||
|
|
@ -125,7 +127,8 @@ class Baz<T extends core::Object* = dynamic, E extends asy::Stream<self::Baz::T*
|
|||
: super core::Object::•()
|
||||
;
|
||||
method foo(generic-covariant-impl self::Baz::S* t) → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -167,17 +170,18 @@ class Baz<T extends core::Object* = dynamic, E extends asy::Stream<self::Baz::T*
|
|||
}
|
||||
}
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
abstract member-signature get _identityHashCode() → core::int*; -> core::Object::_identityHashCode
|
||||
abstract member-signature method _instanceOf(dynamic instantiatorTypeArguments, dynamic functionTypeArguments, dynamic type) → core::bool*; -> core::Object::_instanceOf
|
||||
|
|
@ -242,7 +246,8 @@ abstract class MyStream<T extends core::Object* = dynamic> extends asy::Stream<s
|
|||
abstract member-signature get runtimeType() → core::Type*; -> core::Object::runtimeType
|
||||
}
|
||||
static method test() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -440,17 +445,18 @@ Try changing the type of the variable.
|
|||
}
|
||||
}
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method main() → dynamic {}
|
||||
|
||||
|
|
|
|||
|
|
@ -19,7 +19,8 @@ static method main() → dynamic {
|
|||
return (core::int* x) → core::int* => x;
|
||||
}
|
||||
function b() → asy::Future<(core::int*) →* core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<(core::int*) →* core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<(core::int*) →* core::int*>();
|
||||
final asy::_Future<(core::int*) →* core::int*>* :async_future = new asy::_Future::•<(core::int*) →* core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<(core::int*) →* core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -36,17 +37,18 @@ static method main() → dynamic {
|
|||
^" in ((dynamic x) → dynamic => x) as{TypeError} FutureOr<(core::int*) →* core::int*>*;
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
function c() → core::Iterable<(core::int*) →* core::int*>* /* originally sync* */ {
|
||||
function :sync_op_gen() → (core::_SyncIterator<dynamic>*, dynamic, dynamic) →* core::bool* {
|
||||
|
|
|
|||
|
|
@ -18,7 +18,8 @@ static method a() → (core::int*) →* core::int* {
|
|||
return (core::int* x) → core::int* => x;
|
||||
}
|
||||
static method b() → asy::Future<(core::int*) →* core::int*>* /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<(core::int*) →* core::int*>* :async_completer = new asy::_AsyncAwaitCompleter::•<(core::int*) →* core::int*>();
|
||||
final asy::_Future<(core::int*) →* core::int*>* :async_future = new asy::_Future::•<(core::int*) →* core::int*>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<(core::int*) →* core::int*>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -35,17 +36,18 @@ static method b() → asy::Future<(core::int*) →* core::int*>* /* originally a
|
|||
^" in ((dynamic x) → dynamic => x) as{TypeError} FutureOr<(core::int*) →* core::int*>*;
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method c() → core::Iterable<(core::int*) →* core::int*>* /* originally sync* */ {
|
||||
function :sync_op_gen() → (core::_SyncIterator<dynamic>*, dynamic, dynamic) →* core::bool* {
|
||||
|
|
|
|||
|
|
@ -28,7 +28,8 @@ import "dart:core" as core;
|
|||
import "dart:_internal" as _in;
|
||||
|
||||
static method test() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -122,16 +123,17 @@ static method test() → dynamic /* originally async */ {
|
|||
}
|
||||
}
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method main() → dynamic {}
|
||||
|
|
|
|||
|
|
@ -44,7 +44,8 @@ class B extends self::A {
|
|||
static method f<T extends core::Object* = dynamic>() → self::f::T*
|
||||
return null;
|
||||
static method test() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic>* :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>* :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) →* dynamic :async_op_then;
|
||||
|
|
@ -201,16 +202,17 @@ Try changing the type of the variable.
|
|||
}
|
||||
}
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method main() → dynamic {}
|
||||
|
|
|
|||
|
|
@ -137,7 +137,8 @@ No types are needed, the first is given by 'on', the second is always 'StackTrac
|
|||
} =>#t7;
|
||||
}
|
||||
static method hest() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -178,20 +179,22 @@ static method hest() → dynamic /* originally async */ {
|
|||
:return_value = "hest";
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method fisk() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -219,7 +222,8 @@ static method fisk() → dynamic /* originally async */ {
|
|||
core::Function? f;
|
||||
function #f#get() → core::Function
|
||||
return let final core::Function? #t15 = f in #t15.==(null) ?{core::Function} f = () → asy::Future<dynamic> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -235,32 +239,34 @@ static method fisk() → dynamic /* originally async */ {
|
|||
:return_value = :result;
|
||||
break #L4;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
} : #t15{core::Function};
|
||||
function #f#set(core::Function #t17) → dynamic
|
||||
return f = #t17;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method main() → dynamic {}
|
||||
|
||||
|
|
@ -270,4 +276,4 @@ constants {
|
|||
|
||||
Extra constant evaluation status:
|
||||
Evaluated: VariableGet @ org-dartlang-testcase:///later.dart:46:18 -> IntConstant(42)
|
||||
Extra constant evaluation: evaluated: 213, effectively constant: 1
|
||||
Extra constant evaluation: evaluated: 216, effectively constant: 1
|
||||
|
|
|
|||
|
|
@ -157,7 +157,8 @@ No types are needed, the first is given by 'on', the second is always 'StackTrac
|
|||
} =>#t7;
|
||||
}
|
||||
static method hest() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -198,20 +199,22 @@ static method hest() → dynamic /* originally async */ {
|
|||
:return_value = "hest";
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method fisk() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -257,7 +260,8 @@ static method fisk() → dynamic /* originally async */ {
|
|||
function #f#get() → core::Function {
|
||||
if(!#f#isSet) {
|
||||
f = () → asy::Future<dynamic> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -273,17 +277,18 @@ static method fisk() → dynamic /* originally async */ {
|
|||
:return_value = :result;
|
||||
break #L4;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
#f#isSet = true;
|
||||
}
|
||||
|
|
@ -294,17 +299,18 @@ static method fisk() → dynamic /* originally async */ {
|
|||
return f = #t14;
|
||||
}
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method main() → dynamic {}
|
||||
|
||||
|
|
|
|||
|
|
@ -6,7 +6,8 @@ import "dart:_internal" as _in;
|
|||
|
||||
abstract class TestMixin<R extends core::Object? = dynamic, T extends core::Object? = dynamic> extends core::Object /*isMixinDeclaration*/ {
|
||||
method test(generic-covariant-impl asy::Future<self::TestMixin::R%> fetch) → asy::Future<self::TestMixin::T%> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<self::TestMixin::T%> :async_completer = new asy::_AsyncAwaitCompleter::•<self::TestMixin::T%>();
|
||||
final asy::_Future<self::TestMixin::T%> :async_future = new asy::_Future::•<self::TestMixin::T%>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<self::TestMixin::T%>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -38,17 +39,18 @@ abstract class TestMixin<R extends core::Object? = dynamic, T extends core::Obje
|
|||
:return_value = result;
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
}
|
||||
class PagingResponse<T extends core::Object? = dynamic> extends core::Object {
|
||||
|
|
@ -74,7 +76,8 @@ abstract class _Class1&Object&TestMixin extends core::Object implements self::Te
|
|||
: super core::Object::•()
|
||||
;
|
||||
method test(generic-covariant-impl asy::Future<self::Response<core::String>> fetch) → asy::Future<core::String> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::String> :async_completer = new asy::_AsyncAwaitCompleter::•<core::String>();
|
||||
final asy::_Future<core::String> :async_future = new asy::_Future::•<core::String>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::String>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -106,17 +109,18 @@ abstract class _Class1&Object&TestMixin extends core::Object implements self::Te
|
|||
:return_value = result;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
}
|
||||
class Class1 extends self::_Class1&Object&TestMixin {
|
||||
|
|
@ -133,7 +137,8 @@ abstract class _Class2&Object&TestMixin extends core::Object implements self::Te
|
|||
: super core::Object::•()
|
||||
;
|
||||
method test(generic-covariant-impl asy::Future<self::PagingResponse<core::String>> fetch) → asy::Future<core::String> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::String> :async_completer = new asy::_AsyncAwaitCompleter::•<core::String>();
|
||||
final asy::_Future<core::String> :async_future = new asy::_Future::•<core::String>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::String>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -165,17 +170,18 @@ abstract class _Class2&Object&TestMixin extends core::Object implements self::Te
|
|||
:return_value = result;
|
||||
break #L3;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
}
|
||||
class Class2 extends self::_Class2&Object&TestMixin {
|
||||
|
|
|
|||
|
|
@ -6,7 +6,8 @@ import "dart:_internal" as _in;
|
|||
|
||||
abstract class TestMixin<R extends core::Object? = dynamic, T extends core::Object? = dynamic> extends core::Object /*isMixinDeclaration*/ {
|
||||
method test(generic-covariant-impl asy::Future<self::TestMixin::R%> fetch) → asy::Future<self::TestMixin::T%> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<self::TestMixin::T%> :async_completer = new asy::_AsyncAwaitCompleter::•<self::TestMixin::T%>();
|
||||
final asy::_Future<self::TestMixin::T%> :async_future = new asy::_Future::•<self::TestMixin::T%>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<self::TestMixin::T%>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -38,17 +39,18 @@ abstract class TestMixin<R extends core::Object? = dynamic, T extends core::Obje
|
|||
:return_value = result;
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
}
|
||||
class PagingResponse<T extends core::Object? = dynamic> extends core::Object {
|
||||
|
|
@ -74,7 +76,8 @@ abstract class _Class1&Object&TestMixin extends core::Object implements self::Te
|
|||
: super core::Object::•()
|
||||
;
|
||||
method test(generic-covariant-impl asy::Future<self::Response<core::String>> fetch) → asy::Future<core::String> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::String> :async_completer = new asy::_AsyncAwaitCompleter::•<core::String>();
|
||||
final asy::_Future<core::String> :async_future = new asy::_Future::•<core::String>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::String>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -106,17 +109,18 @@ abstract class _Class1&Object&TestMixin extends core::Object implements self::Te
|
|||
:return_value = result;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
}
|
||||
class Class1 extends self::_Class1&Object&TestMixin {
|
||||
|
|
@ -133,7 +137,8 @@ abstract class _Class2&Object&TestMixin extends core::Object implements self::Te
|
|||
: super core::Object::•()
|
||||
;
|
||||
method test(generic-covariant-impl asy::Future<self::PagingResponse<core::String>> fetch) → asy::Future<core::String> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::String> :async_completer = new asy::_AsyncAwaitCompleter::•<core::String>();
|
||||
final asy::_Future<core::String> :async_future = new asy::_Future::•<core::String>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::String>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -165,17 +170,18 @@ abstract class _Class2&Object&TestMixin extends core::Object implements self::Te
|
|||
:return_value = result;
|
||||
break #L3;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
}
|
||||
class Class2 extends self::_Class2&Object&TestMixin {
|
||||
|
|
|
|||
|
|
@ -13,7 +13,8 @@ import "dart:core" as core;
|
|||
import "dart:_internal" as _in;
|
||||
|
||||
static method test() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -32,17 +33,18 @@ static method test() → dynamic /* originally async */ {
|
|||
[yield] let dynamic #t2 = asy::_awaitHelper(self::l(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::List<dynamic> y = let core::List<dynamic>? #t3 = _in::unsafeCast<core::List<dynamic>?>(:result) in #t3.==(null) ?{core::List<dynamic>} #t3 as{TypeError,ForNonNullableByDefault} core::List<dynamic> : #t3{core::List<dynamic>};
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method l() → asy::Future<core::List<dynamic>>?
|
||||
return null;
|
||||
|
|
|
|||
|
|
@ -13,7 +13,8 @@ import "dart:core" as core;
|
|||
import "dart:_internal" as _in;
|
||||
|
||||
static method test() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -32,17 +33,18 @@ static method test() → dynamic /* originally async */ {
|
|||
[yield] let dynamic #t2 = asy::_awaitHelper(self::l(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
core::List<dynamic> y = _in::unsafeCast<core::List<dynamic>?>(:result);
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method l() → asy::Future<core::List<dynamic>>?
|
||||
return null;
|
||||
|
|
|
|||
|
|
@ -4,7 +4,8 @@ import "dart:async" as asy;
|
|||
import "dart:core" as core;
|
||||
|
||||
static method main() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -20,15 +21,16 @@ static method main() → dynamic /* originally async */ {
|
|||
core::Iterable<core::String>? i = let final core::Iterable<core::String>? #t2 = b in #t2.{core::Object::==}(null) ?{core::Iterable<core::String>?} a : #t2{core::Iterable<core::String>};
|
||||
core::print(i);
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,7 +4,8 @@ import "dart:async" as asy;
|
|||
import "dart:core" as core;
|
||||
|
||||
static method main() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -20,15 +21,16 @@ static method main() → dynamic /* originally async */ {
|
|||
core::Iterable<core::String>? i = let final core::Iterable<core::String>? #t2 = b in #t2.{core::Object::==}(null) ?{core::Iterable<core::String>?} a : #t2{core::Iterable<core::String>};
|
||||
core::print(i);
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -56,7 +56,8 @@ static method main() → void {
|
|||
return self::throwing();
|
||||
};
|
||||
(core::int) → asy::Future<core::String> y1 = (core::int v) → asy::Future<Never> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<Never> :async_completer = new asy::_AsyncAwaitCompleter::•<Never>();
|
||||
final asy::_Future<Never> :async_future = new asy::_Future::•<Never>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<Never>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -70,20 +71,22 @@ static method main() → void {
|
|||
:return_value = throw v;
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
(core::int) → asy::Future<core::String> y2 = (core::int v) → asy::Future<Never> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<Never> :async_completer = new asy::_AsyncAwaitCompleter::•<Never>();
|
||||
final asy::_Future<Never> :async_future = new asy::_Future::•<Never>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<Never>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -96,20 +99,22 @@ static method main() → void {
|
|||
{
|
||||
throw v;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
(core::int) → asy::Future<core::String> y3 = (core::int v) → asy::Future<Never> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<Never> :async_completer = new asy::_AsyncAwaitCompleter::•<Never>();
|
||||
final asy::_Future<Never> :async_future = new asy::_Future::•<Never>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<Never>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -123,20 +128,22 @@ static method main() → void {
|
|||
:return_value = throw v;
|
||||
break #L3;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
(core::int) → asy::Future<core::String> y4 = (core::int v) → asy::Future<Never> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<Never> :async_completer = new asy::_AsyncAwaitCompleter::•<Never>();
|
||||
final asy::_Future<Never> :async_future = new asy::_Future::•<Never>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<Never>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -150,20 +157,22 @@ static method main() → void {
|
|||
:return_value = self::throwing();
|
||||
break #L4;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
(core::int) → asy::Future<core::String> y5 = (core::int v) → asy::Future<Never> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<Never> :async_completer = new asy::_AsyncAwaitCompleter::•<Never>();
|
||||
final asy::_Future<Never> :async_future = new asy::_Future::•<Never>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<Never>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -176,20 +185,22 @@ static method main() → void {
|
|||
{
|
||||
self::throwing();
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
(core::int) → asy::Future<core::String> y6 = (core::int v) → asy::Future<Never> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<Never> :async_completer = new asy::_AsyncAwaitCompleter::•<Never>();
|
||||
final asy::_Future<Never> :async_future = new asy::_Future::•<Never>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<Never>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -203,21 +214,23 @@ static method main() → void {
|
|||
:return_value = self::throwing();
|
||||
break #L6;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
}
|
||||
static method errors() → void /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -269,7 +282,8 @@ static method errors() → void /* originally async */ {
|
|||
^" in null;
|
||||
};
|
||||
(core::int) → asy::Future<core::String> y2 = (core::int v) → asy::Future<core::String> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::String> :async_completer = new asy::_AsyncAwaitCompleter::•<core::String>();
|
||||
final asy::_Future<core::String> :async_future = new asy::_Future::•<core::String>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::String>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -290,20 +304,22 @@ static method errors() → void /* originally async */ {
|
|||
^" in null;
|
||||
break #L8;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
(core::int) → asy::Future<core::String> y3 = (core::int v) → asy::Future<core::String> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::String> :async_completer = new asy::_AsyncAwaitCompleter::•<core::String>();
|
||||
final asy::_Future<core::String> :async_future = new asy::_Future::•<core::String>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::String>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -325,20 +341,22 @@ static method errors() → void /* originally async */ {
|
|||
^" in null;
|
||||
break #L9;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
(core::int) → asy::Future<core::String> y5 = (core::int v) → asy::Future<core::String> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::String> :async_completer = new asy::_AsyncAwaitCompleter::•<core::String>();
|
||||
final asy::_Future<core::String> :async_future = new asy::_Future::•<core::String>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::String>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -359,20 +377,22 @@ static method errors() → void /* originally async */ {
|
|||
^" in null;
|
||||
break #L10;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
(core::int) → asy::Future<core::String> y6 = (core::int v) → asy::Future<core::String> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::String> :async_completer = new asy::_AsyncAwaitCompleter::•<core::String>();
|
||||
final asy::_Future<core::String> :async_future = new asy::_Future::•<core::String>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::String>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -394,28 +414,30 @@ static method errors() → void /* originally async */ {
|
|||
^" in null;
|
||||
break #L11;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -57,7 +57,8 @@ static method main() → void {
|
|||
return let final Never #t3 = self::throwing() in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.");
|
||||
};
|
||||
(core::int) → asy::Future<core::String> y1 = (core::int v) → asy::Future<Never> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<Never> :async_completer = new asy::_AsyncAwaitCompleter::•<Never>();
|
||||
final asy::_Future<Never> :async_future = new asy::_Future::•<Never>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<Never>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -71,20 +72,22 @@ static method main() → void {
|
|||
:return_value = throw v;
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
(core::int) → asy::Future<core::String> y2 = (core::int v) → asy::Future<Never> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<Never> :async_completer = new asy::_AsyncAwaitCompleter::•<Never>();
|
||||
final asy::_Future<Never> :async_future = new asy::_Future::•<Never>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<Never>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -97,20 +100,22 @@ static method main() → void {
|
|||
{
|
||||
throw v;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
(core::int) → asy::Future<core::String> y3 = (core::int v) → asy::Future<Never> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<Never> :async_completer = new asy::_AsyncAwaitCompleter::•<Never>();
|
||||
final asy::_Future<Never> :async_future = new asy::_Future::•<Never>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<Never>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -124,20 +129,22 @@ static method main() → void {
|
|||
:return_value = throw v;
|
||||
break #L3;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
(core::int) → asy::Future<core::String> y4 = (core::int v) → asy::Future<Never> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<Never> :async_completer = new asy::_AsyncAwaitCompleter::•<Never>();
|
||||
final asy::_Future<Never> :async_future = new asy::_Future::•<Never>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<Never>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -151,20 +158,22 @@ static method main() → void {
|
|||
:return_value = let final Never #t4 = self::throwing() in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.");
|
||||
break #L4;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
(core::int) → asy::Future<core::String> y5 = (core::int v) → asy::Future<Never> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<Never> :async_completer = new asy::_AsyncAwaitCompleter::•<Never>();
|
||||
final asy::_Future<Never> :async_future = new asy::_Future::•<Never>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<Never>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -177,20 +186,22 @@ static method main() → void {
|
|||
{
|
||||
let final Never #t5 = self::throwing() in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.");
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
(core::int) → asy::Future<core::String> y6 = (core::int v) → asy::Future<Never> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<Never> :async_completer = new asy::_AsyncAwaitCompleter::•<Never>();
|
||||
final asy::_Future<Never> :async_future = new asy::_Future::•<Never>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<Never>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -204,21 +215,23 @@ static method main() → void {
|
|||
:return_value = let final Never #t6 = self::throwing() in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.");
|
||||
break #L6;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
}
|
||||
static method errors() → void /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -270,7 +283,8 @@ static method errors() → void /* originally async */ {
|
|||
^" in null;
|
||||
};
|
||||
(core::int) → asy::Future<core::String> y2 = (core::int v) → asy::Future<core::String> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::String> :async_completer = new asy::_AsyncAwaitCompleter::•<core::String>();
|
||||
final asy::_Future<core::String> :async_future = new asy::_Future::•<core::String>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::String>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -291,20 +305,22 @@ static method errors() → void /* originally async */ {
|
|||
^" in null;
|
||||
break #L8;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
(core::int) → asy::Future<core::String> y3 = (core::int v) → asy::Future<core::String> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::String> :async_completer = new asy::_AsyncAwaitCompleter::•<core::String>();
|
||||
final asy::_Future<core::String> :async_future = new asy::_Future::•<core::String>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::String>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -326,20 +342,22 @@ static method errors() → void /* originally async */ {
|
|||
^" in null;
|
||||
break #L9;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
(core::int) → asy::Future<core::String> y5 = (core::int v) → asy::Future<core::String> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::String> :async_completer = new asy::_AsyncAwaitCompleter::•<core::String>();
|
||||
final asy::_Future<core::String> :async_future = new asy::_Future::•<core::String>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::String>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -360,20 +378,22 @@ static method errors() → void /* originally async */ {
|
|||
^" in null;
|
||||
break #L10;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
(core::int) → asy::Future<core::String> y6 = (core::int v) → asy::Future<core::String> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::String> :async_completer = new asy::_AsyncAwaitCompleter::•<core::String>();
|
||||
final asy::_Future<core::String> :async_future = new asy::_Future::•<core::String>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::String>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -395,28 +415,30 @@ static method errors() → void /* originally async */ {
|
|||
^" in null;
|
||||
break #L11;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -34,7 +34,8 @@ import "dart:core" as core;
|
|||
static method getNull() → dynamic
|
||||
return null;
|
||||
static method getFutureNull() → asy::Future<dynamic> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -48,20 +49,22 @@ static method getFutureNull() → asy::Future<dynamic> /* originally async */ {
|
|||
:return_value = null;
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method getFutureBool() → asy::Future<core::bool> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::bool> :async_completer = new asy::_AsyncAwaitCompleter::•<core::bool>();
|
||||
final asy::_Future<core::bool> :async_future = new asy::_Future::•<core::bool>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::bool>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -75,20 +78,22 @@ static method getFutureBool() → asy::Future<core::bool> /* originally async */
|
|||
:return_value = true;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method test1() → asy::Future<core::bool> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::bool> :async_completer = new asy::_AsyncAwaitCompleter::•<core::bool>();
|
||||
final asy::_Future<core::bool> :async_future = new asy::_Future::•<core::bool>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::bool>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -104,24 +109,26 @@ static method test1() → asy::Future<core::bool> /* originally async */ {
|
|||
:return_value = :result as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<core::bool>;
|
||||
break #L3;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method test2() → asy::Future<core::bool>
|
||||
return self::getNull() as{TypeError,ForDynamic,ForNonNullableByDefault} asy::Future<core::bool>;
|
||||
static method test3() → core::bool
|
||||
return self::getNull() as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool;
|
||||
static method test4() → asy::Future<core::bool> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::bool> :async_completer = new asy::_AsyncAwaitCompleter::•<core::bool>();
|
||||
final asy::_Future<core::bool> :async_future = new asy::_Future::•<core::bool>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::bool>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -137,17 +144,18 @@ static method test4() → asy::Future<core::bool> /* originally async */ {
|
|||
:return_value = :result as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<core::bool>;
|
||||
break #L4;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method test5() → asy::Future<core::bool>
|
||||
return let final<BottomType> #t3 = invalid-expression "pkg/front_end/testcases/nnbd/issue41437a.dart:18:25: Error: A value of type 'Future<dynamic>' can't be returned from a function with return type 'Future<bool>'.
|
||||
|
|
@ -157,7 +165,8 @@ Future<bool> test5() => getFutureNull(); // error
|
|||
static method test6() → asy::Future<core::bool>
|
||||
return self::getFutureBool();
|
||||
static method test7() → asy::Future<core::bool> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::bool> :async_completer = new asy::_AsyncAwaitCompleter::•<core::bool>();
|
||||
final asy::_Future<core::bool> :async_future = new asy::_Future::•<core::bool>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::bool>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -171,20 +180,22 @@ static method test7() → asy::Future<core::bool> /* originally async */ {
|
|||
:return_value = self::getFutureBool();
|
||||
break #L5;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method test() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -196,7 +207,8 @@ static method test() → dynamic /* originally async */ {
|
|||
#L6:
|
||||
{
|
||||
function test1() → asy::Future<core::bool> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::bool> :async_completer = new asy::_AsyncAwaitCompleter::•<core::bool>();
|
||||
final asy::_Future<core::bool> :async_future = new asy::_Future::•<core::bool>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::bool>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -212,24 +224,26 @@ static method test() → dynamic /* originally async */ {
|
|||
:return_value = :result as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<core::bool>;
|
||||
break #L7;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
function test2() → asy::Future<core::bool>
|
||||
return self::getNull() as{TypeError,ForDynamic,ForNonNullableByDefault} asy::Future<core::bool>;
|
||||
function test3() → core::bool
|
||||
return self::getNull() as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool;
|
||||
function test4() → asy::Future<core::bool> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::bool> :async_completer = new asy::_AsyncAwaitCompleter::•<core::bool>();
|
||||
final asy::_Future<core::bool> :async_future = new asy::_Future::•<core::bool>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::bool>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -245,17 +259,18 @@ static method test() → dynamic /* originally async */ {
|
|||
:return_value = :result as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<core::bool>;
|
||||
break #L8;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
function test5() → asy::Future<core::bool>
|
||||
return let final<BottomType> #t6 = invalid-expression "pkg/front_end/testcases/nnbd/issue41437a.dart:27:27: Error: A value of type 'Future<dynamic>' can't be returned from a function with return type 'Future<bool>'.
|
||||
|
|
@ -265,7 +280,8 @@ static method test() → dynamic /* originally async */ {
|
|||
function test6() → asy::Future<core::bool>
|
||||
return self::getFutureBool();
|
||||
function test7() → asy::Future<core::bool> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::bool> :async_completer = new asy::_AsyncAwaitCompleter::•<core::bool>();
|
||||
final asy::_Future<core::bool> :async_future = new asy::_Future::•<core::bool>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::bool>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -279,23 +295,25 @@ static method test() → dynamic /* originally async */ {
|
|||
:return_value = self::getFutureBool();
|
||||
break #L9;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
asy::Future<core::bool> var1 = let final<BottomType> #t7 = invalid-expression "pkg/front_end/testcases/nnbd/issue41437a.dart:31:52: Error: A value of type 'Future<dynamic>' can't be assigned to a variable of type 'Future<bool>'.
|
||||
- 'Future' is from 'dart:async'.
|
||||
Future<bool> var1 = (() async => await getNull())(); // error
|
||||
^" in (() → asy::Future<dynamic> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -311,17 +329,18 @@ static method test() → dynamic /* originally async */ {
|
|||
:return_value = :result;
|
||||
break #L10;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}).call() as{TypeError,ForNonNullableByDefault} asy::Future<core::bool>;
|
||||
asy::Future<core::bool> var2 = (() → dynamic => self::getNull()).call() as{TypeError,ForDynamic,ForNonNullableByDefault} asy::Future<core::bool>;
|
||||
core::bool var3 = (() → dynamic => self::getNull()).call() as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool;
|
||||
|
|
@ -329,7 +348,8 @@ static method test() → dynamic /* originally async */ {
|
|||
- 'Future' is from 'dart:async'.
|
||||
Future<bool> var4 = (() async => await getFutureNull())(); // error
|
||||
^" in (() → asy::Future<dynamic> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -345,17 +365,18 @@ static method test() → dynamic /* originally async */ {
|
|||
:return_value = :result;
|
||||
break #L11;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}).call() as{TypeError,ForNonNullableByDefault} asy::Future<core::bool>;
|
||||
asy::Future<core::bool> var5 = let final<BottomType> #t11 = invalid-expression "pkg/front_end/testcases/nnbd/issue41437a.dart:35:46: Error: A value of type 'Future<dynamic>' can't be assigned to a variable of type 'Future<bool>'.
|
||||
- 'Future' is from 'dart:async'.
|
||||
|
|
@ -363,7 +384,8 @@ static method test() → dynamic /* originally async */ {
|
|||
^" in (() → asy::Future<dynamic> => self::getFutureNull()).call() as{TypeError,ForNonNullableByDefault} asy::Future<core::bool>;
|
||||
asy::Future<core::bool> var6 = (() → asy::Future<core::bool> => self::getFutureBool()).call();
|
||||
asy::Future<core::bool> var7 = (() → asy::Future<core::bool> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::bool> :async_completer = new asy::_AsyncAwaitCompleter::•<core::bool>();
|
||||
final asy::_Future<core::bool> :async_future = new asy::_Future::•<core::bool>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::bool>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -377,29 +399,31 @@ static method test() → dynamic /* originally async */ {
|
|||
:return_value = self::getFutureBool();
|
||||
break #L12;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}).call();
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method main() → dynamic {}
|
||||
|
|
|
|||
|
|
@ -34,7 +34,8 @@ import "dart:core" as core;
|
|||
static method getNull() → dynamic
|
||||
return null;
|
||||
static method getFutureNull() → asy::Future<dynamic> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -48,20 +49,22 @@ static method getFutureNull() → asy::Future<dynamic> /* originally async */ {
|
|||
:return_value = null;
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method getFutureBool() → asy::Future<core::bool> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::bool> :async_completer = new asy::_AsyncAwaitCompleter::•<core::bool>();
|
||||
final asy::_Future<core::bool> :async_future = new asy::_Future::•<core::bool>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::bool>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -75,20 +78,22 @@ static method getFutureBool() → asy::Future<core::bool> /* originally async */
|
|||
:return_value = true;
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method test1() → asy::Future<core::bool> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::bool> :async_completer = new asy::_AsyncAwaitCompleter::•<core::bool>();
|
||||
final asy::_Future<core::bool> :async_future = new asy::_Future::•<core::bool>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::bool>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -104,24 +109,26 @@ static method test1() → asy::Future<core::bool> /* originally async */ {
|
|||
:return_value = :result as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<core::bool>;
|
||||
break #L3;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method test2() → asy::Future<core::bool>
|
||||
return self::getNull() as{TypeError,ForDynamic,ForNonNullableByDefault} asy::Future<core::bool>;
|
||||
static method test3() → core::bool
|
||||
return self::getNull() as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool;
|
||||
static method test4() → asy::Future<core::bool> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::bool> :async_completer = new asy::_AsyncAwaitCompleter::•<core::bool>();
|
||||
final asy::_Future<core::bool> :async_future = new asy::_Future::•<core::bool>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::bool>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -137,17 +144,18 @@ static method test4() → asy::Future<core::bool> /* originally async */ {
|
|||
:return_value = :result as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<core::bool>;
|
||||
break #L4;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method test5() → asy::Future<core::bool>
|
||||
return let final<BottomType> #t3 = invalid-expression "pkg/front_end/testcases/nnbd/issue41437a.dart:18:25: Error: A value of type 'Future<dynamic>' can't be returned from a function with return type 'Future<bool>'.
|
||||
|
|
@ -157,7 +165,8 @@ Future<bool> test5() => getFutureNull(); // error
|
|||
static method test6() → asy::Future<core::bool>
|
||||
return self::getFutureBool();
|
||||
static method test7() → asy::Future<core::bool> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::bool> :async_completer = new asy::_AsyncAwaitCompleter::•<core::bool>();
|
||||
final asy::_Future<core::bool> :async_future = new asy::_Future::•<core::bool>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::bool>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -171,20 +180,22 @@ static method test7() → asy::Future<core::bool> /* originally async */ {
|
|||
:return_value = self::getFutureBool();
|
||||
break #L5;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method test() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -196,7 +207,8 @@ static method test() → dynamic /* originally async */ {
|
|||
#L6:
|
||||
{
|
||||
function test1() → asy::Future<core::bool> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::bool> :async_completer = new asy::_AsyncAwaitCompleter::•<core::bool>();
|
||||
final asy::_Future<core::bool> :async_future = new asy::_Future::•<core::bool>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::bool>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -212,24 +224,26 @@ static method test() → dynamic /* originally async */ {
|
|||
:return_value = :result as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<core::bool>;
|
||||
break #L7;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
function test2() → asy::Future<core::bool>
|
||||
return self::getNull() as{TypeError,ForDynamic,ForNonNullableByDefault} asy::Future<core::bool>;
|
||||
function test3() → core::bool
|
||||
return self::getNull() as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool;
|
||||
function test4() → asy::Future<core::bool> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::bool> :async_completer = new asy::_AsyncAwaitCompleter::•<core::bool>();
|
||||
final asy::_Future<core::bool> :async_future = new asy::_Future::•<core::bool>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::bool>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -245,17 +259,18 @@ static method test() → dynamic /* originally async */ {
|
|||
:return_value = :result as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<core::bool>;
|
||||
break #L8;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
function test5() → asy::Future<core::bool>
|
||||
return let final<BottomType> #t6 = invalid-expression "pkg/front_end/testcases/nnbd/issue41437a.dart:27:27: Error: A value of type 'Future<dynamic>' can't be returned from a function with return type 'Future<bool>'.
|
||||
|
|
@ -265,7 +280,8 @@ static method test() → dynamic /* originally async */ {
|
|||
function test6() → asy::Future<core::bool>
|
||||
return self::getFutureBool();
|
||||
function test7() → asy::Future<core::bool> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::bool> :async_completer = new asy::_AsyncAwaitCompleter::•<core::bool>();
|
||||
final asy::_Future<core::bool> :async_future = new asy::_Future::•<core::bool>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::bool>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -279,23 +295,25 @@ static method test() → dynamic /* originally async */ {
|
|||
:return_value = self::getFutureBool();
|
||||
break #L9;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
asy::Future<core::bool> var1 = let final<BottomType> #t7 = invalid-expression "pkg/front_end/testcases/nnbd/issue41437a.dart:31:52: Error: A value of type 'Future<dynamic>' can't be assigned to a variable of type 'Future<bool>'.
|
||||
- 'Future' is from 'dart:async'.
|
||||
Future<bool> var1 = (() async => await getNull())(); // error
|
||||
^" in (() → asy::Future<dynamic> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -311,17 +329,18 @@ static method test() → dynamic /* originally async */ {
|
|||
:return_value = :result;
|
||||
break #L10;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}).call() as{TypeError,ForNonNullableByDefault} asy::Future<core::bool>;
|
||||
asy::Future<core::bool> var2 = (() → dynamic => self::getNull()).call() as{TypeError,ForDynamic,ForNonNullableByDefault} asy::Future<core::bool>;
|
||||
core::bool var3 = (() → dynamic => self::getNull()).call() as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool;
|
||||
|
|
@ -329,7 +348,8 @@ static method test() → dynamic /* originally async */ {
|
|||
- 'Future' is from 'dart:async'.
|
||||
Future<bool> var4 = (() async => await getFutureNull())(); // error
|
||||
^" in (() → asy::Future<dynamic> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -345,17 +365,18 @@ static method test() → dynamic /* originally async */ {
|
|||
:return_value = :result;
|
||||
break #L11;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}).call() as{TypeError,ForNonNullableByDefault} asy::Future<core::bool>;
|
||||
asy::Future<core::bool> var5 = let final<BottomType> #t11 = invalid-expression "pkg/front_end/testcases/nnbd/issue41437a.dart:35:46: Error: A value of type 'Future<dynamic>' can't be assigned to a variable of type 'Future<bool>'.
|
||||
- 'Future' is from 'dart:async'.
|
||||
|
|
@ -363,7 +384,8 @@ static method test() → dynamic /* originally async */ {
|
|||
^" in (() → asy::Future<dynamic> => self::getFutureNull()).call() as{TypeError,ForNonNullableByDefault} asy::Future<core::bool>;
|
||||
asy::Future<core::bool> var6 = (() → asy::Future<core::bool> => self::getFutureBool()).call();
|
||||
asy::Future<core::bool> var7 = (() → asy::Future<core::bool> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::bool> :async_completer = new asy::_AsyncAwaitCompleter::•<core::bool>();
|
||||
final asy::_Future<core::bool> :async_future = new asy::_Future::•<core::bool>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::bool>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -377,29 +399,31 @@ static method test() → dynamic /* originally async */ {
|
|||
:return_value = self::getFutureBool();
|
||||
break #L12;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}).call();
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method main() → dynamic {}
|
||||
|
|
|
|||
|
|
@ -143,7 +143,8 @@ static method test7() → core::Iterable<core::bool> /* originally sync* */ {
|
|||
return new core::_SyncIterable::•<core::bool>(:sync_op_gen);
|
||||
}
|
||||
static method test() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -284,16 +285,17 @@ static method test() → dynamic /* originally async */ {
|
|||
return new core::_SyncIterable::•<core::bool>(:sync_op_gen);
|
||||
}).call();
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method main() → dynamic {}
|
||||
|
|
|
|||
|
|
@ -143,7 +143,8 @@ static method test7() → core::Iterable<core::bool> /* originally sync* */ {
|
|||
return new core::_SyncIterable::•<core::bool>(:sync_op_gen);
|
||||
}
|
||||
static method test() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -284,16 +285,17 @@ static method test() → dynamic /* originally async */ {
|
|||
return new core::_SyncIterable::•<core::bool>(:sync_op_gen);
|
||||
}).call();
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method main() → dynamic {}
|
||||
|
|
|
|||
|
|
@ -233,7 +233,8 @@ static method test7() → asy::Stream<core::bool> /* originally async* */ {
|
|||
return :controller_stream;
|
||||
}
|
||||
static method test() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -482,16 +483,17 @@ static method test() → dynamic /* originally async */ {
|
|||
return :controller_stream;
|
||||
}).call();
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method main() → dynamic {}
|
||||
|
|
|
|||
|
|
@ -233,7 +233,8 @@ static method test7() → asy::Stream<core::bool> /* originally async* */ {
|
|||
return :controller_stream;
|
||||
}
|
||||
static method test() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -482,16 +483,17 @@ static method test() → dynamic /* originally async */ {
|
|||
return :controller_stream;
|
||||
}).call();
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method main() → dynamic {}
|
||||
|
|
|
|||
|
|
@ -16,7 +16,8 @@ import "dart:core" as core;
|
|||
import "dart:_internal" as _in;
|
||||
|
||||
static method returnFutureOfVoid() → asy::Future<void> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<void> :async_completer = new asy::_AsyncAwaitCompleter::•<void>();
|
||||
final asy::_Future<void> :async_future = new asy::_Future::•<void>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<void>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -27,21 +28,23 @@ static method returnFutureOfVoid() → asy::Future<void> /* originally async */
|
|||
try {
|
||||
#L1:
|
||||
{}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method returnVoid() → void {}
|
||||
static method returnVoidAsync() → void /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -52,20 +55,22 @@ static method returnVoidAsync() → void /* originally async */ {
|
|||
try {
|
||||
#L2:
|
||||
{}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method test() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -82,20 +87,22 @@ static method test() → dynamic /* originally async */ {
|
|||
[yield] let dynamic #t2 = asy::_awaitHelper(self::returnVoidAsync(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<void>(:result);
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method main() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -110,15 +117,16 @@ static method main() → dynamic /* originally async */ {
|
|||
[yield] let dynamic #t3 = asy::_awaitHelper(self::returnFutureOfVoid(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<void>(:result);
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,7 +16,8 @@ import "dart:core" as core;
|
|||
import "dart:_internal" as _in;
|
||||
|
||||
static method returnFutureOfVoid() → asy::Future<void> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<void> :async_completer = new asy::_AsyncAwaitCompleter::•<void>();
|
||||
final asy::_Future<void> :async_future = new asy::_Future::•<void>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<void>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -27,21 +28,23 @@ static method returnFutureOfVoid() → asy::Future<void> /* originally async */
|
|||
try {
|
||||
#L1:
|
||||
{}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method returnVoid() → void {}
|
||||
static method returnVoidAsync() → void /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -52,20 +55,22 @@ static method returnVoidAsync() → void /* originally async */ {
|
|||
try {
|
||||
#L2:
|
||||
{}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method test() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -82,20 +87,22 @@ static method test() → dynamic /* originally async */ {
|
|||
[yield] let dynamic #t2 = asy::_awaitHelper(self::returnVoidAsync(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<void>(:result);
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method main() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -110,15 +117,16 @@ static method main() → dynamic /* originally async */ {
|
|||
[yield] let dynamic #t3 = asy::_awaitHelper(self::returnFutureOfVoid(), :async_op_then, :async_op_error, :async_op) in null;
|
||||
_in::unsafeCast<void>(:result);
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -35,7 +35,8 @@ static method test1(self::C<core::num> c) → dynamic {
|
|||
return s.{core::num::+}(1);
|
||||
};
|
||||
<S extends FutureOr<core::num> = FutureOr<core::num>>(S, FutureOr<core::num>) → asy::Future<core::num> f2 = c.{self::C::field2} = <S extends FutureOr<core::num> = FutureOr<core::num>>(S s, FutureOr<core::num>t) → asy::Future<core::num> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::num> :async_completer = new asy::_AsyncAwaitCompleter::•<core::num>();
|
||||
final asy::_Future<core::num> :async_future = new asy::_Future::•<core::num>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::num>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -51,17 +52,18 @@ static method test1(self::C<core::num> c) → dynamic {
|
|||
:return_value = _in::unsafeCast<core::num>(:result).{core::num::+}(1);
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
}
|
||||
static method test2(self::C<core::num?> c) → dynamic {
|
||||
|
|
@ -71,7 +73,8 @@ static method test2(self::C<core::num?> c) → dynamic {
|
|||
^" in s.{core::num::+}(1);
|
||||
};
|
||||
<S extends FutureOr<core::num?> = FutureOr<core::num?>>(S%, FutureOr<core::num?>) → asy::Future<core::num> f2 = c.{self::C::field2} = <S extends FutureOr<core::num?> = FutureOr<core::num?>>(S% s, FutureOr<core::num?>t) → asy::Future<core::num> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::num> :async_completer = new asy::_AsyncAwaitCompleter::•<core::num>();
|
||||
final asy::_Future<core::num> :async_future = new asy::_Future::•<core::num>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::num>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -90,17 +93,18 @@ static method test2(self::C<core::num?> c) → dynamic {
|
|||
:return_value = _in::unsafeCast<core::num?>(:result).{core::num::+}(1);
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
}
|
||||
static method test3<S extends core::num? = core::num?>(self::test3::S% s) → dynamic
|
||||
|
|
|
|||
|
|
@ -35,7 +35,8 @@ static method test1(self::C<core::num> c) → dynamic {
|
|||
return s.{core::num::+}(1);
|
||||
};
|
||||
<S extends FutureOr<core::num> = FutureOr<core::num>>(S, FutureOr<core::num>) → asy::Future<core::num> f2 = c.{self::C::field2} = <S extends FutureOr<core::num> = FutureOr<core::num>>(S s, FutureOr<core::num>t) → asy::Future<core::num> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::num> :async_completer = new asy::_AsyncAwaitCompleter::•<core::num>();
|
||||
final asy::_Future<core::num> :async_future = new asy::_Future::•<core::num>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::num>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -51,17 +52,18 @@ static method test1(self::C<core::num> c) → dynamic {
|
|||
:return_value = _in::unsafeCast<core::num>(:result).{core::num::+}(1);
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
}
|
||||
static method test2(self::C<core::num?> c) → dynamic {
|
||||
|
|
@ -71,7 +73,8 @@ static method test2(self::C<core::num?> c) → dynamic {
|
|||
^" in s.{core::num::+}(1);
|
||||
};
|
||||
<S extends FutureOr<core::num?> = FutureOr<core::num?>>(S%, FutureOr<core::num?>) → asy::Future<core::num> f2 = c.{self::C::field2} = <S extends FutureOr<core::num?> = FutureOr<core::num?>>(S% s, FutureOr<core::num?>t) → asy::Future<core::num> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::num> :async_completer = new asy::_AsyncAwaitCompleter::•<core::num>();
|
||||
final asy::_Future<core::num> :async_future = new asy::_Future::•<core::num>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::num>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -90,17 +93,18 @@ static method test2(self::C<core::num?> c) → dynamic {
|
|||
:return_value = _in::unsafeCast<core::num?>(:result).{core::num::+}(1);
|
||||
break #L2;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
}
|
||||
static method test3<S extends core::num? = core::num?>(self::test3::S% s) → dynamic
|
||||
|
|
|
|||
|
|
@ -6,7 +6,8 @@ import "dart:core" as core;
|
|||
static method getNull() → dynamic
|
||||
return null;
|
||||
static method fn() → asy::Future<core::Object> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::Object> :async_completer = new asy::_AsyncAwaitCompleter::•<core::Object>();
|
||||
final asy::_Future<core::Object> :async_future = new asy::_Future::•<core::Object>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::Object>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -24,16 +25,17 @@ static method fn() → asy::Future<core::Object> /* originally async */ {
|
|||
:return_value = let dynamic #t4 = :result in #t4.==(null) ?{FutureOr<core::Object>} #t4 as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<core::Object> : #t4{FutureOr<core::Object>};
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method main() → dynamic {}
|
||||
|
|
|
|||
|
|
@ -6,7 +6,8 @@ import "dart:core" as core;
|
|||
static method getNull() → dynamic
|
||||
return null;
|
||||
static method fn() → asy::Future<core::Object> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::Object> :async_completer = new asy::_AsyncAwaitCompleter::•<core::Object>();
|
||||
final asy::_Future<core::Object> :async_future = new asy::_Future::•<core::Object>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::Object>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -24,16 +25,17 @@ static method fn() → asy::Future<core::Object> /* originally async */ {
|
|||
:return_value = :result;
|
||||
break #L1;
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
static method main() → dynamic {}
|
||||
|
|
|
|||
|
|
@ -4,7 +4,8 @@ import "dart:async" as asy;
|
|||
import "dart:core" as core;
|
||||
|
||||
static method main() → dynamic /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
|
||||
final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<dynamic>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -21,7 +22,8 @@ static method main() → dynamic /* originally async */ {
|
|||
return 42;
|
||||
};
|
||||
(dynamic _) → asy::Future<core::int?> /* originally async */ {
|
||||
final asy::_AsyncAwaitCompleter<core::int?> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int?>();
|
||||
final asy::_Future<core::int?> :async_future = new asy::_Future::•<core::int?>();
|
||||
core::bool* :is_sync = false;
|
||||
FutureOr<core::int?>? :return_value;
|
||||
dynamic :async_stack_trace;
|
||||
(dynamic) → dynamic :async_op_then;
|
||||
|
|
@ -37,28 +39,30 @@ static method main() → dynamic /* originally async */ {
|
|||
break #L2;
|
||||
}
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
};
|
||||
}
|
||||
asy::_completeOnAsyncReturn(:async_completer, :return_value);
|
||||
asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
|
||||
return;
|
||||
}
|
||||
on dynamic catch(dynamic exception, core::StackTrace stack_trace) {
|
||||
:async_completer.{asy::Completer::completeError}(exception, stack_trace);
|
||||
asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
|
||||
}
|
||||
:async_stack_trace = asy::_asyncStackTraceHelper(:async_op);
|
||||
:async_op_then = asy::_asyncThenWrapperHelper(:async_op);
|
||||
:async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
|
||||
:async_completer.{asy::_AsyncAwaitCompleter::start}(:async_op);
|
||||
return :async_completer.{asy::Completer::future};
|
||||
:async_op.call();
|
||||
:is_sync = true;
|
||||
return :async_future;
|
||||
}
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue