diff --git a/pkg/front_end/testcases/async_function.dart.direct.transformed.expect b/pkg/front_end/testcases/async_function.dart.direct.transformed.expect index 6d5759c1b45..86b51976c32 100644 --- a/pkg/front_end/testcases/async_function.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/async_function.dart.direct.transformed.expect @@ -5,7 +5,7 @@ import "dart:core" as core; static field core::List stringList = ["bar"]; static method asyncString() → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -19,20 +19,20 @@ static method asyncString() → asy::Future /* originally async */ :return_value = "foo"; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method asyncString2() → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -46,17 +46,17 @@ static method asyncString2() → asy::Future /* originally async * :return_value = self::asyncString(); break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method syncStarString() → core::Iterable /* originally sync* */ { dynamic :await_jump_var = 0; @@ -170,7 +170,7 @@ static method asyncStarString2() → asy::Stream /* originally asy return :controller.{asy::_AsyncStarStreamController::stream}; } static method main() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -185,15 +185,15 @@ 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 = :result; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } diff --git a/pkg/front_end/testcases/await.dart.direct.transformed.expect b/pkg/front_end/testcases/await.dart.direct.transformed.expect index 7a120848728..c0f0f71c0ac 100644 --- a/pkg/front_end/testcases/await.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/await.dart.direct.transformed.expect @@ -4,7 +4,7 @@ import "dart:async" as asy; import "dart:core" as core; static method main() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -19,15 +19,15 @@ 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(:result); } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } diff --git a/pkg/front_end/testcases/check_deferred_before_args2.dart.direct.transformed.expect b/pkg/front_end/testcases/check_deferred_before_args2.dart.direct.transformed.expect index 87168186f07..b8cd3f7331b 100644 --- a/pkg/front_end/testcases/check_deferred_before_args2.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/check_deferred_before_args2.dart.direct.transformed.expect @@ -5,7 +5,7 @@ import "./deferred_lib.dart" as def; static method main() → dynamic {} static method test() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -21,15 +21,15 @@ 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); } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } diff --git a/pkg/front_end/testcases/check_deferred_before_args2.dart.strong.transformed.expect b/pkg/front_end/testcases/check_deferred_before_args2.dart.strong.transformed.expect index 342fff755a1..57fd26347c0 100644 --- a/pkg/front_end/testcases/check_deferred_before_args2.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/check_deferred_before_args2.dart.strong.transformed.expect @@ -6,7 +6,7 @@ import "./deferred_lib.dart" as def; static method main() → dynamic {} static method test() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -22,15 +22,15 @@ 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); } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } diff --git a/pkg/front_end/testcases/future_or_test.dart.direct.transformed.expect b/pkg/front_end/testcases/future_or_test.dart.direct.transformed.expect index dbae52182fe..359d991010c 100644 --- a/pkg/front_end/testcases/future_or_test.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/future_or_test.dart.direct.transformed.expect @@ -16,7 +16,7 @@ class B extends core::Object { : super core::Object::•() ; method bar() → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -30,17 +30,17 @@ class B extends core::Object { :return_value = this.{self::B::a}.foo(); break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } } class C extends core::Object { @@ -49,7 +49,7 @@ class C extends core::Object { : super core::Object::•() ; method baz() → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -63,17 +63,17 @@ class C extends core::Object { :return_value = this.{self::C::b}.bar(); break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/future_or_test.dart.strong.transformed.expect b/pkg/front_end/testcases/future_or_test.dart.strong.transformed.expect index b18f9fb0287..fa7b7ac4c27 100644 --- a/pkg/front_end/testcases/future_or_test.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/future_or_test.dart.strong.transformed.expect @@ -16,7 +16,7 @@ class B extends core::Object { : super core::Object::•() ; method bar() → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -30,17 +30,17 @@ class B extends core::Object { :return_value = this.{self::B::a}.{self::A::foo}(); break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } } class C extends core::Object { @@ -49,7 +49,7 @@ class C extends core::Object { : super core::Object::•() ; method baz() → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -63,17 +63,17 @@ class C extends core::Object { :return_value = this.{self::C::b}.{self::B::bar}() as{TypeError} asy::FutureOr; break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/async_await.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/async_await.dart.direct.transformed.expect index 40299a9a284..839f1dddc79 100644 --- a/pkg/front_end/testcases/inference/async_await.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/async_await.dart.direct.transformed.expect @@ -9,7 +9,7 @@ abstract class MyFuture extends core::Object implements asy::Future { ; } static method test() → void /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -32,7 +32,7 @@ static method test() → void /* originally async */ { asy::FutureOr x8; self::MyFuture x9; function test0() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -46,20 +46,20 @@ static method test() → void /* originally async */ { :return_value = x0; break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } function test1() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -73,20 +73,20 @@ static method test() → void /* originally async */ { :return_value = x1; break #L3; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } function test2() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -100,20 +100,20 @@ static method test() → void /* originally async */ { :return_value = x2; break #L4; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } function test3() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -127,20 +127,20 @@ static method test() → void /* originally async */ { :return_value = x3; break #L5; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } function test4() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -154,20 +154,20 @@ static method test() → void /* originally async */ { :return_value = x4; break #L6; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } function test5() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -181,20 +181,20 @@ static method test() → void /* originally async */ { :return_value = x5; break #L7; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } function test6() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -208,20 +208,20 @@ static method test() → void /* originally async */ { :return_value = x6; break #L8; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } function test7() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -235,20 +235,20 @@ static method test() → void /* originally async */ { :return_value = x7; break #L9; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } function test8() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -262,20 +262,20 @@ static method test() → void /* originally async */ { :return_value = x8; break #L10; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } function test9() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -289,17 +289,17 @@ static method test() → void /* originally async */ { :return_value = x9; break #L11; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } [yield] let dynamic #t1 = asy::_awaitHelper(x0, :async_op_then, :async_op_error, :async_op) in null; dynamic y0 = :result; @@ -322,16 +322,16 @@ static method test() → void /* originally async */ { [yield] let dynamic #t10 = asy::_awaitHelper(x9, :async_op_then, :async_op_error, :async_op) in null; dynamic y9 = :result; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/async_await.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/async_await.dart.strong.transformed.expect index 2e07d8f638d..d0c0e68742e 100644 --- a/pkg/front_end/testcases/inference/async_await.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/async_await.dart.strong.transformed.expect @@ -9,7 +9,7 @@ abstract class MyFuture extends core::Object implements asy::Future { ; } static method test() → void /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -32,7 +32,7 @@ static method test() → void /* originally async */ { asy::FutureOr x8; self::MyFuture x9; function test0() → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -46,20 +46,20 @@ static method test() → void /* originally async */ { :return_value = x0; break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } function test1() → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -73,20 +73,20 @@ static method test() → void /* originally async */ { :return_value = x1; break #L3; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } function test2() → asy::Future> /* originally async */ { - final asy::Completer> :completer = asy::Completer::sync>(); + final asy::Completer> :async_completer = asy::Completer::sync>(); asy::FutureOr> :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -100,20 +100,20 @@ static method test() → void /* originally async */ { :return_value = x2; break #L4; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } function test3() → asy::Future> /* originally async */ { - final asy::Completer> :completer = asy::Completer::sync>(); + final asy::Completer> :async_completer = asy::Completer::sync>(); asy::FutureOr> :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -127,20 +127,20 @@ static method test() → void /* originally async */ { :return_value = x3; break #L5; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } function test4() → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -154,20 +154,20 @@ static method test() → void /* originally async */ { :return_value = x4; break #L6; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } function test5() → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -181,20 +181,20 @@ static method test() → void /* originally async */ { :return_value = x5; break #L7; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } function test6() → asy::Future> /* originally async */ { - final asy::Completer> :completer = asy::Completer::sync>(); + final asy::Completer> :async_completer = asy::Completer::sync>(); asy::FutureOr> :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -208,20 +208,20 @@ static method test() → void /* originally async */ { :return_value = x6; break #L8; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } function test7() → asy::Future> /* originally async */ { - final asy::Completer> :completer = asy::Completer::sync>(); + final asy::Completer> :async_completer = asy::Completer::sync>(); asy::FutureOr> :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -235,20 +235,20 @@ static method test() → void /* originally async */ { :return_value = x7; break #L9; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } function test8() → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -262,20 +262,20 @@ static method test() → void /* originally async */ { :return_value = x8; break #L10; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } function test9() → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -289,17 +289,17 @@ static method test() → void /* originally async */ { :return_value = x9; break #L11; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } [yield] let dynamic #t1 = asy::_awaitHelper(x0, :async_op_then, :async_op_error, :async_op) in null; core::int y0 = :result; @@ -322,16 +322,16 @@ 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 = :result; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/async_closure_return_type_flatten.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/async_closure_return_type_flatten.dart.direct.transformed.expect index a1115198cea..cdfa0e5eea8 100644 --- a/pkg/front_end/testcases/inference/async_closure_return_type_flatten.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/async_closure_return_type_flatten.dart.direct.transformed.expect @@ -6,7 +6,7 @@ import "dart:core" as core; static field asy::Future futureInt = null; static field dynamic f = () → dynamic => self::futureInt; static field dynamic g = () → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -20,17 +20,17 @@ static field dynamic g = () → asy::Future /* originally async */ { :return_value = self::futureInt; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }; static method main() → dynamic { self::f; diff --git a/pkg/front_end/testcases/inference/async_closure_return_type_flatten.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/async_closure_return_type_flatten.dart.strong.transformed.expect index a6aca806b76..e35517f5bc7 100644 --- a/pkg/front_end/testcases/inference/async_closure_return_type_flatten.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/async_closure_return_type_flatten.dart.strong.transformed.expect @@ -6,7 +6,7 @@ import "dart:core" as core; static field asy::Future futureInt = null; static field () → asy::Future f = () → asy::Future => self::futureInt; static field () → asy::Future g = () → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -20,17 +20,17 @@ static field () → asy::Future g = () → asy::Future /* :return_value = self::futureInt; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }; static method main() → dynamic { self::f; diff --git a/pkg/front_end/testcases/inference/async_closure_return_type_future.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/async_closure_return_type_future.dart.direct.transformed.expect index 4bf2eb0dd1d..92ac89618b3 100644 --- a/pkg/front_end/testcases/inference/async_closure_return_type_future.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/async_closure_return_type_future.dart.direct.transformed.expect @@ -3,7 +3,7 @@ import self as self; import "dart:async" as asy; static field dynamic f = () → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -17,17 +17,17 @@ static field dynamic f = () → asy::Future /* originally async */ { :return_value = 0; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }; static method main() → dynamic { self::f; diff --git a/pkg/front_end/testcases/inference/async_closure_return_type_future.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/async_closure_return_type_future.dart.strong.transformed.expect index 5af95467ed0..d7fa5b60a35 100644 --- a/pkg/front_end/testcases/inference/async_closure_return_type_future.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/async_closure_return_type_future.dart.strong.transformed.expect @@ -4,7 +4,7 @@ import "dart:async" as asy; import "dart:core" as core; static field () → asy::Future f = () → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -18,17 +18,17 @@ static field () → asy::Future f = () → asy::Future /* :return_value = 0; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }; static method main() → dynamic { self::f; diff --git a/pkg/front_end/testcases/inference/async_closure_return_type_future_or.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/async_closure_return_type_future_or.dart.direct.transformed.expect index 7702de615de..0483a9fe605 100644 --- a/pkg/front_end/testcases/inference/async_closure_return_type_future_or.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/async_closure_return_type_future_or.dart.direct.transformed.expect @@ -6,7 +6,7 @@ import "dart:core" as core; static field asy::FutureOr futureOrInt = null; static field dynamic f = () → dynamic => self::futureOrInt; static field dynamic g = () → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -20,17 +20,17 @@ static field dynamic g = () → asy::Future /* originally async */ { :return_value = self::futureOrInt; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }; static method main() → dynamic { self::f; diff --git a/pkg/front_end/testcases/inference/async_closure_return_type_future_or.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/async_closure_return_type_future_or.dart.strong.transformed.expect index f49a5d2da1e..5910611b43d 100644 --- a/pkg/front_end/testcases/inference/async_closure_return_type_future_or.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/async_closure_return_type_future_or.dart.strong.transformed.expect @@ -6,7 +6,7 @@ import "dart:core" as core; static field asy::FutureOr futureOrInt = null; static field () → asy::FutureOr f = () → asy::FutureOr => self::futureOrInt; static field () → asy::Future g = () → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -20,17 +20,17 @@ static field () → asy::Future g = () → asy::Future /* :return_value = self::futureOrInt; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }; static method main() → dynamic { self::f; diff --git a/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_futures.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_futures.dart.direct.transformed.expect index ae1ed7aa147..cc66edb2133 100644 --- a/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_futures.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_futures.dart.direct.transformed.expect @@ -6,7 +6,7 @@ import "dart:core" as core; static method test() → dynamic { dynamic f = () → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -26,17 +26,17 @@ static method test() → dynamic { break #L1; } } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }; asy::Future g = f.call(); asy::Future h = f.call(); diff --git a/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_futures.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_futures.dart.strong.transformed.expect index 649f4267f30..af005220585 100644 --- a/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_futures.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_futures.dart.strong.transformed.expect @@ -6,7 +6,7 @@ import "dart:math" as math; static method test() → dynamic { () → asy::Future f = () → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -26,17 +26,17 @@ static method test() → dynamic { break #L1; } } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }; asy::Future g = f.call(); asy::Future h = f.call() as{TypeError} asy::Future; diff --git a/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_values.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_values.dart.direct.transformed.expect index 93b15b08192..b16d670726e 100644 --- a/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_values.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_values.dart.direct.transformed.expect @@ -6,7 +6,7 @@ import "dart:core" as core; static method test() → dynamic { dynamic f = () → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -26,17 +26,17 @@ static method test() → dynamic { break #L1; } } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }; asy::Future g = f.call(); asy::Future h = f.call(); diff --git a/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_values.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_values.dart.strong.transformed.expect index 97e2f956522..20873336875 100644 --- a/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_values.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_values.dart.strong.transformed.expect @@ -6,7 +6,7 @@ import "dart:math" as math; static method test() → dynamic { () → asy::Future f = () → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -26,17 +26,17 @@ static method test() → dynamic { break #L1; } } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }; asy::Future g = f.call(); asy::Future h = f.call() as{TypeError} asy::Future; diff --git a/pkg/front_end/testcases/inference/block_bodied_lambdas_async_mix_of_values_and_futures.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/block_bodied_lambdas_async_mix_of_values_and_futures.dart.direct.transformed.expect index 8c968eeb6f7..7c5e12b7bc3 100644 --- a/pkg/front_end/testcases/inference/block_bodied_lambdas_async_mix_of_values_and_futures.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/block_bodied_lambdas_async_mix_of_values_and_futures.dart.direct.transformed.expect @@ -6,7 +6,7 @@ import "dart:core" as core; static method test() → dynamic { dynamic f = () → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -26,17 +26,17 @@ static method test() → dynamic { break #L1; } } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }; asy::Future g = f.call(); asy::Future h = f.call(); diff --git a/pkg/front_end/testcases/inference/block_bodied_lambdas_async_mix_of_values_and_futures.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/block_bodied_lambdas_async_mix_of_values_and_futures.dart.strong.transformed.expect index 45d5637fe32..08a88b292e2 100644 --- a/pkg/front_end/testcases/inference/block_bodied_lambdas_async_mix_of_values_and_futures.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/block_bodied_lambdas_async_mix_of_values_and_futures.dart.strong.transformed.expect @@ -6,7 +6,7 @@ import "dart:math" as math; static method test() → dynamic { () → asy::Future f = () → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -26,17 +26,17 @@ static method test() → dynamic { break #L1; } } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }; asy::Future g = f.call(); asy::Future h = f.call() as{TypeError} asy::Future; diff --git a/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async.dart.direct.transformed.expect index 04b9dad253d..642c44a32e9 100644 --- a/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async.dart.direct.transformed.expect @@ -4,7 +4,7 @@ import "dart:async" as asy; import "dart:core" as core; static method main() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -17,7 +17,7 @@ static method main() → dynamic /* originally async */ { #L1: { dynamic f = () → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -31,32 +31,32 @@ static method main() → dynamic /* originally async */ { :return_value = null; break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }; asy::Future y = f.call(); asy::Future z = f.call(); [yield] let dynamic #t1 = asy::_awaitHelper(f.call(), :async_op_then, :async_op_error, :async_op) in null; core::String s = :result; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } diff --git a/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async.dart.strong.transformed.expect index 1afc8d965a7..da3ad50f93d 100644 --- a/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async.dart.strong.transformed.expect @@ -4,7 +4,7 @@ import "dart:async" as asy; import "dart:core" as core; static method main() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -17,7 +17,7 @@ static method main() → dynamic /* originally async */ { #L1: { () → asy::Future f = () → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -31,32 +31,32 @@ static method main() → dynamic /* originally async */ { :return_value = null; break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }; asy::Future y = f.call(); asy::Future z = f.call(); [yield] let dynamic #t1 = asy::_awaitHelper(f.call(), :async_op_then, :async_op_error, :async_op) in null; core::String s = :result; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } diff --git a/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async_star.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async_star.dart.direct.transformed.expect index e58820a032a..3254b80fda6 100644 --- a/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async_star.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async_star.dart.direct.transformed.expect @@ -4,7 +4,7 @@ import "dart:async" as asy; import "dart:core" as core; static method main() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -54,15 +54,15 @@ static method main() → dynamic /* originally async */ { [yield] let dynamic #t1 = asy::_awaitHelper(f.call().first, :async_op_then, :async_op_error, :async_op) in null; core::String s = :result; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } diff --git a/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async_star.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async_star.dart.strong.transformed.expect index 1d67b452a56..20fe1a2c88f 100644 --- a/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async_star.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async_star.dart.strong.transformed.expect @@ -4,7 +4,7 @@ import "dart:async" as asy; import "dart:core" as core; static method main() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -54,15 +54,15 @@ 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 = :result; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } diff --git a/pkg/front_end/testcases/inference/downwards_inference_async_await.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/downwards_inference_async_await.dart.direct.transformed.expect index 126c90b4e1f..48cd5f2a38b 100644 --- a/pkg/front_end/testcases/inference/downwards_inference_async_await.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/downwards_inference_async_await.dart.direct.transformed.expect @@ -4,7 +4,7 @@ import "dart:async" as asy; import "dart:core" as core; static method main() → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -22,15 +22,15 @@ static method main() → asy::Future /* originally async */ { [yield] let dynamic #t2 = asy::_awaitHelper(asy::Future::value([d]), :async_op_then, :async_op_error, :async_op) in null; core::List l1 = :result; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } diff --git a/pkg/front_end/testcases/inference/downwards_inference_async_await.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/downwards_inference_async_await.dart.strong.transformed.expect index c7716b6bf92..498dfc2665f 100644 --- a/pkg/front_end/testcases/inference/downwards_inference_async_await.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/downwards_inference_async_await.dart.strong.transformed.expect @@ -4,7 +4,7 @@ import "dart:async" as asy; import "dart:core" as core; static method main() → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -22,15 +22,15 @@ static method main() → asy::Future /* originally async */ { [yield] let dynamic #t2 = asy::_awaitHelper(asy::Future::value>([d as{TypeError} core::int]), :async_op_then, :async_op_error, :async_op) in null; core::List l1 = :result; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } diff --git a/pkg/front_end/testcases/inference/downwards_inference_for_each.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/downwards_inference_for_each.dart.direct.transformed.expect index 3ef1a43d422..8a0ba8a8171 100644 --- a/pkg/front_end/testcases/inference/downwards_inference_for_each.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/downwards_inference_for_each.dart.direct.transformed.expect @@ -10,7 +10,7 @@ abstract class MyStream extends asy::Stream() → self::F::T return null; static method f() → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -139,20 +139,20 @@ static method f() → asy::Future /* originally async */ { } } } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method main() → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -212,15 +212,15 @@ static method main() → asy::Future /* originally async */ { } } } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } diff --git a/pkg/front_end/testcases/inference/downwards_inference_for_each.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/downwards_inference_for_each.dart.strong.transformed.expect index 7dee1bb0ca2..49348b80d78 100644 --- a/pkg/front_end/testcases/inference/downwards_inference_for_each.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/downwards_inference_for_each.dart.strong.transformed.expect @@ -10,7 +10,7 @@ abstract class MyStream extends asy::Stream() → self::F::T return null; static method f() → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -139,20 +139,20 @@ static method f() → asy::Future /* originally async */ { } } } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method main() → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -212,15 +212,15 @@ static method main() → asy::Future /* originally async */ { } } } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } diff --git a/pkg/front_end/testcases/inference/for_each_downcast_iterable.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/for_each_downcast_iterable.dart.direct.transformed.expect index 67e28bfbba3..c86a42f8bba 100644 --- a/pkg/front_end/testcases/inference/for_each_downcast_iterable.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/for_each_downcast_iterable.dart.direct.transformed.expect @@ -4,7 +4,7 @@ import "dart:async" as asy; import "dart:core" as core; static method test() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -67,16 +67,16 @@ static method test() → dynamic /* originally async */ { } } } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/for_each_downcast_iterable.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/for_each_downcast_iterable.dart.strong.transformed.expect index 3b987daac6d..ab6f7a783f8 100644 --- a/pkg/front_end/testcases/inference/for_each_downcast_iterable.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/for_each_downcast_iterable.dart.strong.transformed.expect @@ -4,7 +4,7 @@ import "dart:async" as asy; import "dart:core" as core; static method test() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -67,16 +67,16 @@ static method test() → dynamic /* originally async */ { } } } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/future_then.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/future_then.dart.direct.transformed.expect index 440a04c2cba..39bf7669336 100644 --- a/pkg/front_end/testcases/inference/future_then.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/future_then.dart.direct.transformed.expect @@ -24,7 +24,7 @@ class MyFuture extends core::Object implements static method test() → void { self::MyFuture f; asy::Future t1 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -40,20 +40,20 @@ static method test() → void { :return_value = :result; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t2 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -69,20 +69,20 @@ static method test() → void { :return_value = :result; break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t3 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -96,20 +96,20 @@ static method test() → void { :return_value = 3; break #L3; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t4 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -123,24 +123,24 @@ static method test() → void { :return_value = 3; break #L4; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t5 = f.then((dynamic _) → dynamic => asy::Future::value(3)); asy::Future t6 = f.then((dynamic _) → dynamic { return asy::Future::value(3); }); asy::Future t7 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -154,20 +154,20 @@ static method test() → void { :return_value = asy::Future::value(3); break #L5; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t8 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -181,17 +181,17 @@ static method test() → void { :return_value = asy::Future::value(3); break #L6; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/future_then.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_then.dart.strong.transformed.expect index ab76573350c..7eaed281fd0 100644 --- a/pkg/front_end/testcases/inference/future_then.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/future_then.dart.strong.transformed.expect @@ -24,7 +24,7 @@ class MyFuture extends core::Object implements static method test() → void { self::MyFuture f; asy::Future t1 = f.{self::MyFuture::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -40,20 +40,20 @@ static method test() → void { :return_value = :result; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t2 = f.{self::MyFuture::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -69,20 +69,20 @@ static method test() → void { :return_value = :result; break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t3 = f.{self::MyFuture::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -96,20 +96,20 @@ static method test() → void { :return_value = 3; break #L3; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t4 = f.{self::MyFuture::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -123,24 +123,24 @@ static method test() → void { :return_value = 3; break #L4; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t5 = f.{self::MyFuture::then}((dynamic _) → asy::Future => asy::Future::value(3)); asy::Future t6 = f.{self::MyFuture::then}((dynamic _) → asy::Future { return asy::Future::value(3); }); asy::Future t7 = f.{self::MyFuture::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -154,20 +154,20 @@ static method test() → void { :return_value = asy::Future::value(3); break #L5; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t8 = f.{self::MyFuture::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -181,17 +181,17 @@ static method test() → void { :return_value = asy::Future::value(3); break #L6; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/future_then_2.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/future_then_2.dart.direct.transformed.expect index 8dd522cbf23..4b7549d6236 100644 --- a/pkg/front_end/testcases/inference/future_then_2.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/future_then_2.dart.direct.transformed.expect @@ -24,7 +24,7 @@ class MyFuture extends core::Object implements static method test() → void { self::MyFuture f; asy::Future t1 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -40,20 +40,20 @@ static method test() → void { :return_value = :result; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t2 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -69,20 +69,20 @@ static method test() → void { :return_value = :result; break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t3 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -96,20 +96,20 @@ static method test() → void { :return_value = 3; break #L3; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t4 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -123,24 +123,24 @@ static method test() → void { :return_value = 3; break #L4; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t5 = f.then((dynamic _) → dynamic => new self::MyFuture::value(3)); asy::Future t6 = f.then((dynamic _) → dynamic { return new self::MyFuture::value(3); }); asy::Future t7 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -154,20 +154,20 @@ static method test() → void { :return_value = new self::MyFuture::value(3); break #L5; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t8 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -181,17 +181,17 @@ static method test() → void { :return_value = new self::MyFuture::value(3); break #L6; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/future_then_2.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_then_2.dart.strong.transformed.expect index a5f1b3653a7..90bcbbb06d9 100644 --- a/pkg/front_end/testcases/inference/future_then_2.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/future_then_2.dart.strong.transformed.expect @@ -24,7 +24,7 @@ class MyFuture extends core::Object implements static method test() → void { self::MyFuture f; asy::Future t1 = f.{self::MyFuture::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -40,20 +40,20 @@ static method test() → void { :return_value = :result; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t2 = f.{self::MyFuture::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -69,20 +69,20 @@ static method test() → void { :return_value = :result; break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t3 = f.{self::MyFuture::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -96,20 +96,20 @@ static method test() → void { :return_value = 3; break #L3; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t4 = f.{self::MyFuture::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -123,24 +123,24 @@ static method test() → void { :return_value = 3; break #L4; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t5 = f.{self::MyFuture::then}((dynamic _) → self::MyFuture => new self::MyFuture::value(3)); asy::Future t6 = f.{self::MyFuture::then}((dynamic _) → self::MyFuture { return new self::MyFuture::value(3); }); asy::Future t7 = f.{self::MyFuture::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -154,20 +154,20 @@ static method test() → void { :return_value = new self::MyFuture::value(3); break #L5; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t8 = f.{self::MyFuture::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -181,17 +181,17 @@ static method test() → void { :return_value = new self::MyFuture::value(3); break #L6; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/future_then_3.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/future_then_3.dart.direct.transformed.expect index 11ee82ffac8..7c896067105 100644 --- a/pkg/front_end/testcases/inference/future_then_3.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/future_then_3.dart.direct.transformed.expect @@ -24,7 +24,7 @@ class MyFuture extends core::Object implements static method test() → void { self::MyFuture f; self::MyFuture t1 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -40,20 +40,20 @@ static method test() → void { :return_value = :result; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); self::MyFuture t2 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -69,20 +69,20 @@ static method test() → void { :return_value = :result; break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); self::MyFuture t3 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -96,20 +96,20 @@ static method test() → void { :return_value = 3; break #L3; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); self::MyFuture t4 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -123,24 +123,24 @@ static method test() → void { :return_value = 3; break #L4; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); self::MyFuture t5 = f.then((dynamic _) → dynamic => asy::Future::value(3)); self::MyFuture t6 = f.then((dynamic _) → dynamic { return asy::Future::value(3); }); self::MyFuture t7 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -154,20 +154,20 @@ static method test() → void { :return_value = asy::Future::value(3); break #L5; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); self::MyFuture t8 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -181,17 +181,17 @@ static method test() → void { :return_value = asy::Future::value(3); break #L6; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/future_then_3.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_then_3.dart.strong.transformed.expect index 79dea1972fa..ca483a5b7ea 100644 --- a/pkg/front_end/testcases/inference/future_then_3.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/future_then_3.dart.strong.transformed.expect @@ -24,7 +24,7 @@ class MyFuture extends core::Object implements static method test() → void { self::MyFuture f; self::MyFuture t1 = f.{self::MyFuture::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -40,20 +40,20 @@ static method test() → void { :return_value = :result; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); self::MyFuture t2 = f.{self::MyFuture::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -69,20 +69,20 @@ static method test() → void { :return_value = :result; break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); self::MyFuture t3 = f.{self::MyFuture::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -96,20 +96,20 @@ static method test() → void { :return_value = 3; break #L3; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); self::MyFuture t4 = f.{self::MyFuture::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -123,24 +123,24 @@ static method test() → void { :return_value = 3; break #L4; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); self::MyFuture t5 = f.{self::MyFuture::then}((dynamic _) → asy::Future => asy::Future::value(3)); self::MyFuture t6 = f.{self::MyFuture::then}((dynamic _) → asy::Future { return asy::Future::value(3); }); self::MyFuture t7 = f.{self::MyFuture::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -154,20 +154,20 @@ static method test() → void { :return_value = asy::Future::value(3); break #L5; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); self::MyFuture t8 = f.{self::MyFuture::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -181,17 +181,17 @@ static method test() → void { :return_value = asy::Future::value(3); break #L6; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/future_then_4.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/future_then_4.dart.direct.transformed.expect index 2c1403c7501..746d72c3053 100644 --- a/pkg/front_end/testcases/inference/future_then_4.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/future_then_4.dart.direct.transformed.expect @@ -24,7 +24,7 @@ class MyFuture extends core::Object implements static method test() → void { self::MyFuture f; self::MyFuture t1 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -40,20 +40,20 @@ static method test() → void { :return_value = :result; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); self::MyFuture t2 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -69,20 +69,20 @@ static method test() → void { :return_value = :result; break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); self::MyFuture t3 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -96,20 +96,20 @@ static method test() → void { :return_value = 3; break #L3; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); self::MyFuture t4 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -123,24 +123,24 @@ static method test() → void { :return_value = 3; break #L4; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); self::MyFuture t5 = f.then((dynamic _) → dynamic => new self::MyFuture::value(3)); self::MyFuture t6 = f.then((dynamic _) → dynamic { return new self::MyFuture::value(3); }); self::MyFuture t7 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -154,20 +154,20 @@ static method test() → void { :return_value = new self::MyFuture::value(3); break #L5; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); self::MyFuture t8 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -181,17 +181,17 @@ static method test() → void { :return_value = new self::MyFuture::value(3); break #L6; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/future_then_4.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_then_4.dart.strong.transformed.expect index d0224a39c00..21ecf5e0045 100644 --- a/pkg/front_end/testcases/inference/future_then_4.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/future_then_4.dart.strong.transformed.expect @@ -24,7 +24,7 @@ class MyFuture extends core::Object implements static method test() → void { self::MyFuture f; self::MyFuture t1 = f.{self::MyFuture::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -40,20 +40,20 @@ static method test() → void { :return_value = :result; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); self::MyFuture t2 = f.{self::MyFuture::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -69,20 +69,20 @@ static method test() → void { :return_value = :result; break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); self::MyFuture t3 = f.{self::MyFuture::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -96,20 +96,20 @@ static method test() → void { :return_value = 3; break #L3; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); self::MyFuture t4 = f.{self::MyFuture::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -123,24 +123,24 @@ static method test() → void { :return_value = 3; break #L4; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); self::MyFuture t5 = f.{self::MyFuture::then}((dynamic _) → self::MyFuture => new self::MyFuture::value(3)); self::MyFuture t6 = f.{self::MyFuture::then}((dynamic _) → self::MyFuture { return new self::MyFuture::value(3); }); self::MyFuture t7 = f.{self::MyFuture::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -154,20 +154,20 @@ static method test() → void { :return_value = new self::MyFuture::value(3); break #L5; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); self::MyFuture t8 = f.{self::MyFuture::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -181,17 +181,17 @@ static method test() → void { :return_value = new self::MyFuture::value(3); break #L6; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/future_then_5.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/future_then_5.dart.direct.transformed.expect index c3736160714..f996ff92c50 100644 --- a/pkg/front_end/testcases/inference/future_then_5.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/future_then_5.dart.direct.transformed.expect @@ -24,7 +24,7 @@ class MyFuture extends core::Object implements static method test() → void { asy::Future f; asy::Future t1 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -40,20 +40,20 @@ static method test() → void { :return_value = :result; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t2 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -69,20 +69,20 @@ static method test() → void { :return_value = :result; break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t3 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -96,20 +96,20 @@ static method test() → void { :return_value = 3; break #L3; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t4 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -123,24 +123,24 @@ static method test() → void { :return_value = 3; break #L4; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t5 = f.then((dynamic _) → dynamic => new self::MyFuture::value(3)); asy::Future t6 = f.then((dynamic _) → dynamic { return new self::MyFuture::value(3); }); asy::Future t7 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -154,20 +154,20 @@ static method test() → void { :return_value = new self::MyFuture::value(3); break #L5; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t8 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -181,17 +181,17 @@ static method test() → void { :return_value = new self::MyFuture::value(3); break #L6; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/future_then_5.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_then_5.dart.strong.transformed.expect index 4181e8a9a1c..b19d08062d2 100644 --- a/pkg/front_end/testcases/inference/future_then_5.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/future_then_5.dart.strong.transformed.expect @@ -24,7 +24,7 @@ class MyFuture extends core::Object implements static method test() → void { asy::Future f; asy::Future t1 = f.{asy::Future::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -40,20 +40,20 @@ static method test() → void { :return_value = :result; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t2 = f.{asy::Future::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -69,20 +69,20 @@ static method test() → void { :return_value = :result; break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t3 = f.{asy::Future::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -96,20 +96,20 @@ static method test() → void { :return_value = 3; break #L3; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t4 = f.{asy::Future::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -123,24 +123,24 @@ static method test() → void { :return_value = 3; break #L4; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t5 = f.{asy::Future::then}((dynamic _) → self::MyFuture => new self::MyFuture::value(3)); asy::Future t6 = f.{asy::Future::then}((dynamic _) → self::MyFuture { return new self::MyFuture::value(3); }); asy::Future t7 = f.{asy::Future::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -154,20 +154,20 @@ static method test() → void { :return_value = new self::MyFuture::value(3); break #L5; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t8 = f.{asy::Future::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -181,17 +181,17 @@ static method test() → void { :return_value = new self::MyFuture::value(3); break #L6; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/future_then_6.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/future_then_6.dart.direct.transformed.expect index 7ea34b699ba..dda0a4f8450 100644 --- a/pkg/front_end/testcases/inference/future_then_6.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/future_then_6.dart.direct.transformed.expect @@ -24,7 +24,7 @@ class MyFuture extends core::Object implements static method test() → void { asy::Future f; asy::Future t1 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -40,20 +40,20 @@ static method test() → void { :return_value = :result; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t2 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -69,20 +69,20 @@ static method test() → void { :return_value = :result; break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t3 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -96,20 +96,20 @@ static method test() → void { :return_value = 3; break #L3; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t4 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -123,24 +123,24 @@ static method test() → void { :return_value = 3; break #L4; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t5 = f.then((dynamic _) → dynamic => asy::Future::value(3)); asy::Future t6 = f.then((dynamic _) → dynamic { return asy::Future::value(3); }); asy::Future t7 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -154,20 +154,20 @@ static method test() → void { :return_value = asy::Future::value(3); break #L5; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t8 = f.then((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -181,17 +181,17 @@ static method test() → void { :return_value = asy::Future::value(3); break #L6; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/future_then_6.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_then_6.dart.strong.transformed.expect index 5013ebef0f6..8214748613a 100644 --- a/pkg/front_end/testcases/inference/future_then_6.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/future_then_6.dart.strong.transformed.expect @@ -24,7 +24,7 @@ class MyFuture extends core::Object implements static method test() → void { asy::Future f; asy::Future t1 = f.{asy::Future::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -40,20 +40,20 @@ static method test() → void { :return_value = :result; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t2 = f.{asy::Future::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -69,20 +69,20 @@ static method test() → void { :return_value = :result; break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t3 = f.{asy::Future::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -96,20 +96,20 @@ static method test() → void { :return_value = 3; break #L3; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t4 = f.{asy::Future::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -123,24 +123,24 @@ static method test() → void { :return_value = 3; break #L4; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t5 = f.{asy::Future::then}((dynamic _) → asy::Future => asy::Future::value(3)); asy::Future t6 = f.{asy::Future::then}((dynamic _) → asy::Future { return asy::Future::value(3); }); asy::Future t7 = f.{asy::Future::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -154,20 +154,20 @@ static method test() → void { :return_value = asy::Future::value(3); break #L5; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t8 = f.{asy::Future::then}((dynamic _) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -181,17 +181,17 @@ static method test() → void { :return_value = asy::Future::value(3); break #L6; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/future_then_conditional.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/future_then_conditional.dart.direct.transformed.expect index ef09e8043ca..ee8635c6602 100644 --- a/pkg/front_end/testcases/inference/future_then_conditional.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/future_then_conditional.dart.direct.transformed.expect @@ -24,7 +24,7 @@ class MyFuture extends core::Object implements static method test() → void { self::MyFuture f; asy::Future t1 = f.then((dynamic x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -47,20 +47,20 @@ static method test() → void { :return_value = :async_temporary_0; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t2 = f.then((dynamic x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -76,17 +76,17 @@ static method test() → void { :return_value = :result ? 2 : asy::Future::value(3); break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t5 = f.then((dynamic x) → dynamic => x ? 2 : asy::Future::value(3)); asy::Future t6 = f.then((dynamic x) → dynamic { diff --git a/pkg/front_end/testcases/inference/future_then_conditional.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_then_conditional.dart.strong.transformed.expect index d37757e0365..4edac725fd2 100644 --- a/pkg/front_end/testcases/inference/future_then_conditional.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/future_then_conditional.dart.strong.transformed.expect @@ -24,7 +24,7 @@ class MyFuture extends core::Object implements static method test() → void { self::MyFuture f; asy::Future t1 = f.{self::MyFuture::then}((core::bool x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -47,20 +47,20 @@ static method test() → void { :return_value = :async_temporary_0; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t2 = f.{self::MyFuture::then}((core::bool x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -76,17 +76,17 @@ static method test() → void { :return_value = (:result ?{core::Object} 2 : asy::Future::value(3)) as{TypeError} asy::FutureOr; break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t5 = f.{self::MyFuture::then}((core::bool x) → asy::FutureOr => (x ?{core::Object} 2 : asy::Future::value(3)) as{TypeError} asy::FutureOr); asy::Future t6 = f.{self::MyFuture::then}((core::bool x) → asy::FutureOr { diff --git a/pkg/front_end/testcases/inference/future_then_conditional_2.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/future_then_conditional_2.dart.direct.transformed.expect index 633179c0707..0d47534805c 100644 --- a/pkg/front_end/testcases/inference/future_then_conditional_2.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/future_then_conditional_2.dart.direct.transformed.expect @@ -24,7 +24,7 @@ class MyFuture extends core::Object implements static method test() → void { self::MyFuture f; asy::Future t1 = f.then((dynamic x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -47,20 +47,20 @@ static method test() → void { :return_value = :async_temporary_0; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t2 = f.then((dynamic x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -76,17 +76,17 @@ static method test() → void { :return_value = :result ? 2 : new self::MyFuture::value(3); break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t5 = f.then((dynamic x) → dynamic => x ? 2 : new self::MyFuture::value(3)); asy::Future t6 = f.then((dynamic x) → dynamic { diff --git a/pkg/front_end/testcases/inference/future_then_conditional_2.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_then_conditional_2.dart.strong.transformed.expect index ce0b9335632..f44cce1cb22 100644 --- a/pkg/front_end/testcases/inference/future_then_conditional_2.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/future_then_conditional_2.dart.strong.transformed.expect @@ -24,7 +24,7 @@ class MyFuture extends core::Object implements static method test() → void { self::MyFuture f; asy::Future t1 = f.{self::MyFuture::then}((core::bool x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -47,20 +47,20 @@ static method test() → void { :return_value = :async_temporary_0; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t2 = f.{self::MyFuture::then}((core::bool x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -76,17 +76,17 @@ static method test() → void { :return_value = (:result ?{core::Object} 2 : new self::MyFuture::value(3)) as{TypeError} asy::FutureOr; break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t5 = f.{self::MyFuture::then}((core::bool x) → asy::FutureOr => (x ?{core::Object} 2 : new self::MyFuture::value(3)) as{TypeError} asy::FutureOr); asy::Future t6 = f.{self::MyFuture::then}((core::bool x) → asy::FutureOr { diff --git a/pkg/front_end/testcases/inference/future_then_conditional_3.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/future_then_conditional_3.dart.direct.transformed.expect index ef96253733a..1373697cf8d 100644 --- a/pkg/front_end/testcases/inference/future_then_conditional_3.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/future_then_conditional_3.dart.direct.transformed.expect @@ -24,7 +24,7 @@ class MyFuture extends core::Object implements static method test() → void { self::MyFuture f; self::MyFuture t1 = f.then((dynamic x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -47,20 +47,20 @@ static method test() → void { :return_value = :async_temporary_0; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); self::MyFuture t2 = f.then((dynamic x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -76,17 +76,17 @@ static method test() → void { :return_value = :result ? 2 : asy::Future::value(3); break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); self::MyFuture t5 = f.then((dynamic x) → dynamic => x ? 2 : asy::Future::value(3)); self::MyFuture t6 = f.then((dynamic x) → dynamic { diff --git a/pkg/front_end/testcases/inference/future_then_conditional_3.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_then_conditional_3.dart.strong.transformed.expect index cf778122259..15d1ad26fdc 100644 --- a/pkg/front_end/testcases/inference/future_then_conditional_3.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/future_then_conditional_3.dart.strong.transformed.expect @@ -24,7 +24,7 @@ class MyFuture extends core::Object implements static method test() → void { self::MyFuture f; self::MyFuture t1 = f.{self::MyFuture::then}((core::bool x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -47,20 +47,20 @@ static method test() → void { :return_value = :async_temporary_0; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); self::MyFuture t2 = f.{self::MyFuture::then}((core::bool x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -76,17 +76,17 @@ static method test() → void { :return_value = (:result ?{core::Object} 2 : asy::Future::value(3)) as{TypeError} asy::FutureOr; break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); self::MyFuture t5 = f.{self::MyFuture::then}((core::bool x) → asy::FutureOr => (x ?{core::Object} 2 : asy::Future::value(3)) as{TypeError} asy::FutureOr); self::MyFuture t6 = f.{self::MyFuture::then}((core::bool x) → asy::FutureOr { diff --git a/pkg/front_end/testcases/inference/future_then_conditional_4.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/future_then_conditional_4.dart.direct.transformed.expect index 8299fbb289e..f91e051619f 100644 --- a/pkg/front_end/testcases/inference/future_then_conditional_4.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/future_then_conditional_4.dart.direct.transformed.expect @@ -24,7 +24,7 @@ class MyFuture extends core::Object implements static method test() → void { self::MyFuture f; self::MyFuture t1 = f.then((dynamic x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -47,20 +47,20 @@ static method test() → void { :return_value = :async_temporary_0; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); self::MyFuture t2 = f.then((dynamic x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -76,17 +76,17 @@ static method test() → void { :return_value = :result ? 2 : new self::MyFuture::value(3); break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); self::MyFuture t5 = f.then((dynamic x) → dynamic => x ? 2 : new self::MyFuture::value(3)); self::MyFuture t6 = f.then((dynamic x) → dynamic { diff --git a/pkg/front_end/testcases/inference/future_then_conditional_4.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_then_conditional_4.dart.strong.transformed.expect index e57873caa83..ea24809c4fa 100644 --- a/pkg/front_end/testcases/inference/future_then_conditional_4.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/future_then_conditional_4.dart.strong.transformed.expect @@ -24,7 +24,7 @@ class MyFuture extends core::Object implements static method test() → void { self::MyFuture f; self::MyFuture t1 = f.{self::MyFuture::then}((core::bool x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -47,20 +47,20 @@ static method test() → void { :return_value = :async_temporary_0; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); self::MyFuture t2 = f.{self::MyFuture::then}((core::bool x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -76,17 +76,17 @@ static method test() → void { :return_value = (:result ?{core::Object} 2 : new self::MyFuture::value(3)) as{TypeError} asy::FutureOr; break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); self::MyFuture t5 = f.{self::MyFuture::then}((core::bool x) → asy::FutureOr => (x ?{core::Object} 2 : new self::MyFuture::value(3)) as{TypeError} asy::FutureOr); self::MyFuture t6 = f.{self::MyFuture::then}((core::bool x) → asy::FutureOr { diff --git a/pkg/front_end/testcases/inference/future_then_conditional_5.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/future_then_conditional_5.dart.direct.transformed.expect index 4d49b6e2401..21cf31217df 100644 --- a/pkg/front_end/testcases/inference/future_then_conditional_5.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/future_then_conditional_5.dart.direct.transformed.expect @@ -24,7 +24,7 @@ class MyFuture extends core::Object implements static method test() → void { asy::Future f; asy::Future t1 = f.then((dynamic x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -47,20 +47,20 @@ static method test() → void { :return_value = :async_temporary_0; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t2 = f.then((dynamic x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -76,17 +76,17 @@ static method test() → void { :return_value = :result ? 2 : new self::MyFuture::value(3); break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t5 = f.then((dynamic x) → dynamic => x ? 2 : new self::MyFuture::value(3)); asy::Future t6 = f.then((dynamic x) → dynamic { diff --git a/pkg/front_end/testcases/inference/future_then_conditional_5.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_then_conditional_5.dart.strong.transformed.expect index 468ec31cb18..e2587841e95 100644 --- a/pkg/front_end/testcases/inference/future_then_conditional_5.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/future_then_conditional_5.dart.strong.transformed.expect @@ -24,7 +24,7 @@ class MyFuture extends core::Object implements static method test() → void { asy::Future f; asy::Future t1 = f.{asy::Future::then}((core::bool x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -47,20 +47,20 @@ static method test() → void { :return_value = :async_temporary_0; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t2 = f.{asy::Future::then}((core::bool x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -76,17 +76,17 @@ static method test() → void { :return_value = (:result ?{core::Object} 2 : new self::MyFuture::value(3)) as{TypeError} asy::FutureOr; break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t5 = f.{asy::Future::then}((core::bool x) → asy::FutureOr => (x ?{core::Object} 2 : new self::MyFuture::value(3)) as{TypeError} asy::FutureOr); asy::Future t6 = f.{asy::Future::then}((core::bool x) → asy::FutureOr { diff --git a/pkg/front_end/testcases/inference/future_then_conditional_6.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/future_then_conditional_6.dart.direct.transformed.expect index ba9e60053fe..1a49a72e1e1 100644 --- a/pkg/front_end/testcases/inference/future_then_conditional_6.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/future_then_conditional_6.dart.direct.transformed.expect @@ -24,7 +24,7 @@ class MyFuture extends core::Object implements static method test() → void { asy::Future f; asy::Future t1 = f.then((dynamic x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -47,20 +47,20 @@ static method test() → void { :return_value = :async_temporary_0; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t2 = f.then((dynamic x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -76,17 +76,17 @@ static method test() → void { :return_value = :result ? 2 : asy::Future::value(3); break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t5 = f.then((dynamic x) → dynamic => x ? 2 : asy::Future::value(3)); asy::Future t6 = f.then((dynamic x) → dynamic { diff --git a/pkg/front_end/testcases/inference/future_then_conditional_6.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_then_conditional_6.dart.strong.transformed.expect index 792ef915d8c..a172c81c1b0 100644 --- a/pkg/front_end/testcases/inference/future_then_conditional_6.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/future_then_conditional_6.dart.strong.transformed.expect @@ -24,7 +24,7 @@ class MyFuture extends core::Object implements static method test() → void { asy::Future f; asy::Future t1 = f.{asy::Future::then}((core::bool x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -47,20 +47,20 @@ static method test() → void { :return_value = :async_temporary_0; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t2 = f.{asy::Future::then}((core::bool x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -76,17 +76,17 @@ static method test() → void { :return_value = (:result ?{core::Object} 2 : asy::Future::value(3)) as{TypeError} asy::FutureOr; break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t5 = f.{asy::Future::then}((core::bool x) → asy::FutureOr => (x ?{core::Object} 2 : asy::Future::value(3)) as{TypeError} asy::FutureOr); asy::Future t6 = f.{asy::Future::then}((core::bool x) → asy::FutureOr { diff --git a/pkg/front_end/testcases/inference/future_then_ifNull.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/future_then_ifNull.dart.direct.transformed.expect index e57d9377b38..e67586a3365 100644 --- a/pkg/front_end/testcases/inference/future_then_ifNull.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/future_then_ifNull.dart.direct.transformed.expect @@ -24,7 +24,7 @@ class MyFuture extends core::Object implements static method test() → void { self::MyFuture f; asy::Future t1 = f.then((dynamic x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -48,20 +48,20 @@ static method test() → void { :return_value = :async_temporary_0; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t2 = f.then((dynamic x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -77,17 +77,17 @@ static method test() → void { :return_value = let final dynamic #t4 = :result in #t4.==(null) ? asy::Future::value(3) : #t4; break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t5 = f.then((dynamic x) → dynamic => let final dynamic #t5 = x in #t5.==(null) ? asy::Future::value(3) : #t5); asy::Future t6 = f.then((dynamic x) → dynamic { diff --git a/pkg/front_end/testcases/inference/future_then_ifNull.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_then_ifNull.dart.strong.transformed.expect index 311f23d2ec7..871bcf6cf56 100644 --- a/pkg/front_end/testcases/inference/future_then_ifNull.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/future_then_ifNull.dart.strong.transformed.expect @@ -24,7 +24,7 @@ class MyFuture extends core::Object implements static method test() → void { self::MyFuture f; asy::Future t1 = f.{self::MyFuture::then}((core::int x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -48,20 +48,20 @@ static method test() → void { :return_value = :async_temporary_0; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t2 = f.{self::MyFuture::then}((core::int x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -77,17 +77,17 @@ static method test() → void { :return_value = (let final core::int #t4 = :result in #t4.==(null) ?{core::Object} asy::Future::value(3) : #t4) as{TypeError} asy::FutureOr; break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; }); asy::Future t5 = f.{self::MyFuture::then}((core::int x) → asy::FutureOr => (let final core::int #t5 = x in #t5.==(null) ?{core::Object} asy::Future::value(3) : #t5) as{TypeError} asy::FutureOr); asy::Future t6 = f.{self::MyFuture::then}((core::int x) → asy::FutureOr { diff --git a/pkg/front_end/testcases/inference/future_union_async_conditional.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/future_union_async_conditional.dart.direct.transformed.expect index 9397ba5314e..41c48797e3f 100644 --- a/pkg/front_end/testcases/inference/future_union_async_conditional.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/future_union_async_conditional.dart.direct.transformed.expect @@ -22,7 +22,7 @@ class MyFuture extends core::Object implements return this.{self::MyFuture::noSuchMethod}(new core::_InvocationMirror::_withoutType("asStream", const [], const [], core::Map::unmodifiable(const {}), false)) as{TypeError} asy::Stream; } static method g1(core::bool x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -36,20 +36,20 @@ static method g1(core::bool x) → asy::Future /* originally async */ :return_value = x ? 42 : asy::Future::value(42); break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method g2(core::bool x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -63,20 +63,20 @@ static method g2(core::bool x) → asy::Future /* originally async */ :return_value = x ? 42 : asy::Future::value(42); break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method g3(core::bool x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -91,16 +91,16 @@ static method g3(core::bool x) → asy::Future /* originally async */ :return_value = y; break #L3; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/future_union_async_conditional.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_union_async_conditional.dart.strong.transformed.expect index 61d62cb387e..c5b890a2ff5 100644 --- a/pkg/front_end/testcases/inference/future_union_async_conditional.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/future_union_async_conditional.dart.strong.transformed.expect @@ -22,7 +22,7 @@ class MyFuture extends core::Object implements return this.{self::MyFuture::noSuchMethod}(new core::_InvocationMirror::_withoutType("asStream", const [], const [], core::Map::unmodifiable(const {}), false)) as{TypeError} asy::Stream; } static method g1(core::bool x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -36,20 +36,20 @@ static method g1(core::bool x) → asy::Future /* originally async */ :return_value = (x ?{core::Object} 42 : asy::Future::value(42)) as{TypeError} asy::FutureOr; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method g2(core::bool x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -63,20 +63,20 @@ static method g2(core::bool x) → asy::Future /* originally async */ :return_value = (x ?{core::Object} 42 : asy::Future::value(42)) as{TypeError} asy::FutureOr; break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method g3(core::bool x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -91,16 +91,16 @@ static method g3(core::bool x) → asy::Future /* originally async */ :return_value = y as{TypeError} asy::FutureOr; break #L3; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/future_union_async_conditional_2.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/future_union_async_conditional_2.dart.direct.transformed.expect index f31e5ca8f52..4d30bd8e443 100644 --- a/pkg/front_end/testcases/inference/future_union_async_conditional_2.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/future_union_async_conditional_2.dart.direct.transformed.expect @@ -22,7 +22,7 @@ class MyFuture extends core::Object implements return this.{self::MyFuture::noSuchMethod}(new core::_InvocationMirror::_withoutType("asStream", const [], const [], core::Map::unmodifiable(const {}), false)) as{TypeError} asy::Stream; } static method g1(core::bool x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -36,20 +36,20 @@ static method g1(core::bool x) → asy::Future /* originally async */ :return_value = x ? 42 : new self::MyFuture::value(42); break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method g2(core::bool x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -63,20 +63,20 @@ static method g2(core::bool x) → asy::Future /* originally async */ :return_value = x ? 42 : new self::MyFuture::value(42); break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method g3(core::bool x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -91,16 +91,16 @@ static method g3(core::bool x) → asy::Future /* originally async */ :return_value = y; break #L3; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/future_union_async_conditional_2.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_union_async_conditional_2.dart.strong.transformed.expect index ab699477e6a..3e881c5dc78 100644 --- a/pkg/front_end/testcases/inference/future_union_async_conditional_2.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/future_union_async_conditional_2.dart.strong.transformed.expect @@ -22,7 +22,7 @@ class MyFuture extends core::Object implements return this.{self::MyFuture::noSuchMethod}(new core::_InvocationMirror::_withoutType("asStream", const [], const [], core::Map::unmodifiable(const {}), false)) as{TypeError} asy::Stream; } static method g1(core::bool x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -36,20 +36,20 @@ static method g1(core::bool x) → asy::Future /* originally async */ :return_value = (x ?{core::Object} 42 : new self::MyFuture::value(42)) as{TypeError} asy::FutureOr; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method g2(core::bool x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -63,20 +63,20 @@ static method g2(core::bool x) → asy::Future /* originally async */ :return_value = (x ?{core::Object} 42 : new self::MyFuture::value(42)) as{TypeError} asy::FutureOr; break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method g3(core::bool x) → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -91,16 +91,16 @@ static method g3(core::bool x) → asy::Future /* originally async */ :return_value = y as{TypeError} asy::FutureOr; break #L3; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/future_union_downwards.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/future_union_downwards.dart.direct.transformed.expect index fab89fef160..9c55b25c5ba 100644 --- a/pkg/front_end/testcases/inference/future_union_downwards.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/future_union_downwards.dart.direct.transformed.expect @@ -25,7 +25,7 @@ static field self::MyFuture f; static field asy::Future t1 = self::f.then((dynamic _) → dynamic => asy::Future::value("hi")); static field asy::Future> t2 = self::f.then((dynamic _) → dynamic => [3]); static method g2() → asy::Future> /* originally async */ { - final asy::Completer> :completer = asy::Completer::sync>(); + final asy::Completer> :async_completer = asy::Completer::sync>(); asy::FutureOr> :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -39,20 +39,20 @@ static method g2() → asy::Future> /* originally async */ :return_value = [3]; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method g3() → asy::Future> /* originally async */ { - final asy::Completer> :completer = asy::Completer::sync>(); + final asy::Completer> :async_completer = asy::Completer::sync>(); asy::FutureOr> :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -66,16 +66,16 @@ static method g3() → asy::Future> /* originally async */ :return_value = asy::Future::value([3]); break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/future_union_downwards.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_union_downwards.dart.strong.transformed.expect index c8a55a9b6b3..372634f3a0a 100644 --- a/pkg/front_end/testcases/inference/future_union_downwards.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/future_union_downwards.dart.strong.transformed.expect @@ -28,7 +28,7 @@ Try changing the type of the left hand side, or casting the right hand side to ' ^" in let final core::String #t2 = "hi" in null)); static field asy::Future> t2 = self::f.{self::MyFuture::then}>((dynamic _) → core::List => [3]); static method g2() → asy::Future> /* originally async */ { - final asy::Completer> :completer = asy::Completer::sync>(); + final asy::Completer> :async_completer = asy::Completer::sync>(); asy::FutureOr> :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -42,20 +42,20 @@ static method g2() → asy::Future> /* originally async */ :return_value = [3]; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method g3() → asy::Future> /* originally async */ { - final asy::Completer> :completer = asy::Completer::sync>(); + final asy::Completer> :async_completer = asy::Completer::sync>(); asy::FutureOr> :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -69,16 +69,16 @@ static method g3() → asy::Future> /* originally async */ :return_value = asy::Future::value>([3]); break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/future_union_downwards_2.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/future_union_downwards_2.dart.direct.transformed.expect index b669441e3a5..8311768f3a3 100644 --- a/pkg/front_end/testcases/inference/future_union_downwards_2.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/future_union_downwards_2.dart.direct.transformed.expect @@ -25,7 +25,7 @@ static field self::MyFuture f; static field asy::Future t1 = self::f.then((dynamic _) → dynamic => new self::MyFuture::value("hi")); static field asy::Future> t2 = self::f.then((dynamic _) → dynamic => [3]); static method g2() → asy::Future> /* originally async */ { - final asy::Completer> :completer = asy::Completer::sync>(); + final asy::Completer> :async_completer = asy::Completer::sync>(); asy::FutureOr> :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -39,20 +39,20 @@ static method g2() → asy::Future> /* originally async */ :return_value = [3]; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method g3() → asy::Future> /* originally async */ { - final asy::Completer> :completer = asy::Completer::sync>(); + final asy::Completer> :async_completer = asy::Completer::sync>(); asy::FutureOr> :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -66,16 +66,16 @@ static method g3() → asy::Future> /* originally async */ :return_value = new self::MyFuture::value([3]); break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/future_union_downwards_2.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_union_downwards_2.dart.strong.transformed.expect index 9dfa187aa3d..c6eeddae9aa 100644 --- a/pkg/front_end/testcases/inference/future_union_downwards_2.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/future_union_downwards_2.dart.strong.transformed.expect @@ -25,7 +25,7 @@ static field self::MyFuture f; static field asy::Future t1 = self::f.{self::MyFuture::then}((dynamic _) → self::MyFuture => new self::MyFuture::value("hi")); static field asy::Future> t2 = self::f.{self::MyFuture::then}>((dynamic _) → core::List => [3]); static method g2() → asy::Future> /* originally async */ { - final asy::Completer> :completer = asy::Completer::sync>(); + final asy::Completer> :async_completer = asy::Completer::sync>(); asy::FutureOr> :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -39,20 +39,20 @@ static method g2() → asy::Future> /* originally async */ :return_value = [3]; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method g3() → asy::Future> /* originally async */ { - final asy::Completer> :completer = asy::Completer::sync>(); + final asy::Completer> :async_completer = asy::Completer::sync>(); asy::FutureOr> :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -66,16 +66,16 @@ static method g3() → asy::Future> /* originally async */ :return_value = new self::MyFuture::value>([3]); break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/future_union_downwards_3.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/future_union_downwards_3.dart.direct.transformed.expect index 7e22485a663..d310fa8e5ae 100644 --- a/pkg/front_end/testcases/inference/future_union_downwards_3.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/future_union_downwards_3.dart.direct.transformed.expect @@ -25,7 +25,7 @@ static field asy::Future f; static field asy::Future t1 = self::f.then((dynamic _) → dynamic => asy::Future::value("hi")); static field asy::Future> t2 = self::f.then((dynamic _) → dynamic => [3]); static method g2() → asy::Future> /* originally async */ { - final asy::Completer> :completer = asy::Completer::sync>(); + final asy::Completer> :async_completer = asy::Completer::sync>(); asy::FutureOr> :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -39,20 +39,20 @@ static method g2() → asy::Future> /* originally async */ :return_value = [3]; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method g3() → asy::Future> /* originally async */ { - final asy::Completer> :completer = asy::Completer::sync>(); + final asy::Completer> :async_completer = asy::Completer::sync>(); asy::FutureOr> :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -66,16 +66,16 @@ static method g3() → asy::Future> /* originally async */ :return_value = asy::Future::value([3]); break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/future_union_downwards_3.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_union_downwards_3.dart.strong.transformed.expect index 55eb919fbca..85c2fcda855 100644 --- a/pkg/front_end/testcases/inference/future_union_downwards_3.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/future_union_downwards_3.dart.strong.transformed.expect @@ -28,7 +28,7 @@ Try changing the type of the left hand side, or casting the right hand side to ' ^" in let final core::String #t2 = "hi" in null)); static field asy::Future> t2 = self::f.{asy::Future::then}>((dynamic _) → core::List => [3]); static method g2() → asy::Future> /* originally async */ { - final asy::Completer> :completer = asy::Completer::sync>(); + final asy::Completer> :async_completer = asy::Completer::sync>(); asy::FutureOr> :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -42,20 +42,20 @@ static method g2() → asy::Future> /* originally async */ :return_value = [3]; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method g3() → asy::Future> /* originally async */ { - final asy::Completer> :completer = asy::Completer::sync>(); + final asy::Completer> :async_completer = asy::Completer::sync>(); asy::FutureOr> :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -69,16 +69,16 @@ static method g3() → asy::Future> /* originally async */ :return_value = asy::Future::value>([3]); break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/future_union_downwards_4.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/future_union_downwards_4.dart.direct.transformed.expect index 7d02922f630..5b25967e872 100644 --- a/pkg/front_end/testcases/inference/future_union_downwards_4.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/future_union_downwards_4.dart.direct.transformed.expect @@ -25,7 +25,7 @@ static field asy::Future f; static field asy::Future t1 = self::f.then((dynamic _) → dynamic => new self::MyFuture::value("hi")); static field asy::Future> t2 = self::f.then((dynamic _) → dynamic => [3]); static method g2() → asy::Future> /* originally async */ { - final asy::Completer> :completer = asy::Completer::sync>(); + final asy::Completer> :async_completer = asy::Completer::sync>(); asy::FutureOr> :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -39,20 +39,20 @@ static method g2() → asy::Future> /* originally async */ :return_value = [3]; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method g3() → asy::Future> /* originally async */ { - final asy::Completer> :completer = asy::Completer::sync>(); + final asy::Completer> :async_completer = asy::Completer::sync>(); asy::FutureOr> :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -66,16 +66,16 @@ static method g3() → asy::Future> /* originally async */ :return_value = new self::MyFuture::value([3]); break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/future_union_downwards_4.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_union_downwards_4.dart.strong.transformed.expect index f9e32bb4410..39403ea407b 100644 --- a/pkg/front_end/testcases/inference/future_union_downwards_4.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/future_union_downwards_4.dart.strong.transformed.expect @@ -25,7 +25,7 @@ static field asy::Future f; static field asy::Future t1 = self::f.{asy::Future::then}((dynamic _) → self::MyFuture => new self::MyFuture::value("hi")); static field asy::Future> t2 = self::f.{asy::Future::then}>((dynamic _) → core::List => [3]); static method g2() → asy::Future> /* originally async */ { - final asy::Completer> :completer = asy::Completer::sync>(); + final asy::Completer> :async_completer = asy::Completer::sync>(); asy::FutureOr> :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -39,20 +39,20 @@ static method g2() → asy::Future> /* originally async */ :return_value = [3]; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method g3() → asy::Future> /* originally async */ { - final asy::Completer> :completer = asy::Completer::sync>(); + final asy::Completer> :async_completer = asy::Completer::sync>(); asy::FutureOr> :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -66,16 +66,16 @@ static method g3() → asy::Future> /* originally async */ :return_value = new self::MyFuture::value>([3]); break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_future_return.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_future_return.dart.direct.transformed.expect index 4851f6237e8..a702c6909cb 100644 --- a/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_future_return.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_future_return.dart.direct.transformed.expect @@ -9,7 +9,7 @@ class A extends core::Object { ; } static method foo() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -26,16 +26,16 @@ static method foo() → dynamic /* originally async */ { [yield] let dynamic #t1 = asy::_awaitHelper(asy::Future::wait([f1, f2]), :async_op_then, :async_op_error, :async_op) in null; core::List> merged = :result; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_future_return.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_future_return.dart.strong.transformed.expect index 17ee2b47c45..5491836910c 100644 --- a/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_future_return.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_future_return.dart.strong.transformed.expect @@ -9,7 +9,7 @@ class A extends core::Object { ; } static method foo() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -26,16 +26,16 @@ static method foo() → dynamic /* originally async */ { [yield] let dynamic #t1 = asy::_awaitHelper(asy::Future::wait>(>>[f1, f2]), :async_op_then, :async_op_error, :async_op) in null; core::List> merged = :result; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_generic_return.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_generic_return.dart.direct.transformed.expect index 91cb8b0ba84..767567e2c6e 100644 --- a/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_generic_return.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_generic_return.dart.direct.transformed.expect @@ -6,7 +6,7 @@ import "dart:async" as asy; static method id(self::id::T x) → self::id::T return x; static method test() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -22,16 +22,16 @@ static method test() → dynamic /* originally async */ { [yield] let dynamic #t1 = asy::_awaitHelper(self::id(f), :async_op_then, :async_op_error, :async_op) in null; core::String s = :result; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_generic_return.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_generic_return.dart.strong.transformed.expect index 92c8c6be5b6..96f60cf43ba 100644 --- a/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_generic_return.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_generic_return.dart.strong.transformed.expect @@ -6,7 +6,7 @@ import "dart:async" as asy; static method id(self::id::T x) → self::id::T return x; static method test() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -22,16 +22,16 @@ static method test() → dynamic /* originally async */ { [yield] let dynamic #t1 = asy::_awaitHelper(self::id>(f), :async_op_then, :async_op_error, :async_op) in null; core::String s = :result; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/future_union_upwards_generic_methods.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/future_union_upwards_generic_methods.dart.direct.transformed.expect index 0747a443687..9be5e89db13 100644 --- a/pkg/front_end/testcases/inference/future_union_upwards_generic_methods.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/future_union_upwards_generic_methods.dart.direct.transformed.expect @@ -19,7 +19,7 @@ class C extends self::A { ; } static method main() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -41,15 +41,15 @@ static method main() → dynamic /* originally async */ { core::List list = result; list = result2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } diff --git a/pkg/front_end/testcases/inference/future_union_upwards_generic_methods.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_union_upwards_generic_methods.dart.strong.transformed.expect index 6fc7a69638b..bb722724b35 100644 --- a/pkg/front_end/testcases/inference/future_union_upwards_generic_methods.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/future_union_upwards_generic_methods.dart.strong.transformed.expect @@ -19,7 +19,7 @@ class C extends self::A { ; } static method main() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -41,15 +41,15 @@ static method main() → dynamic /* originally async */ { core::List list = result; list = result2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } diff --git a/pkg/front_end/testcases/inference/infer_local_function_return_type.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/infer_local_function_return_type.dart.direct.transformed.expect index 95cdc128e98..7a13cb27ef6 100644 --- a/pkg/front_end/testcases/inference/infer_local_function_return_type.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/infer_local_function_return_type.dart.direct.transformed.expect @@ -7,7 +7,7 @@ static method test() → dynamic { function f0() → dynamic return 42; function f1() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -21,23 +21,23 @@ static method test() → dynamic { :return_value = 42; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } function f2() → dynamic { return 42; } function f3() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -51,17 +51,17 @@ static method test() → dynamic { :return_value = 42; break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } function f4() → dynamic /* originally sync* */ { dynamic :await_jump_var = 0; diff --git a/pkg/front_end/testcases/inference/infer_local_function_return_type.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/infer_local_function_return_type.dart.strong.transformed.expect index 5e738e7c5d2..a0901317a73 100644 --- a/pkg/front_end/testcases/inference/infer_local_function_return_type.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/infer_local_function_return_type.dart.strong.transformed.expect @@ -7,7 +7,7 @@ static method test() → dynamic { function f0() → core::int return 42; function f1() → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -21,23 +21,23 @@ static method test() → dynamic { :return_value = 42; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } function f2() → core::int { return 42; } function f3() → asy::Future /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -51,17 +51,17 @@ static method test() → dynamic { :return_value = 42; break #L2; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } function f4() → core::Iterable /* originally sync* */ { dynamic :await_jump_var = 0; diff --git a/pkg/front_end/testcases/inference/infer_types_on_loop_indices_for_each_loop_async.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/infer_types_on_loop_indices_for_each_loop_async.dart.direct.transformed.expect index f8f99d39363..9b911b8d141 100644 --- a/pkg/front_end/testcases/inference/infer_types_on_loop_indices_for_each_loop_async.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/infer_types_on_loop_indices_for_each_loop_async.dart.direct.transformed.expect @@ -14,7 +14,7 @@ class Bar = dynamic> extends core::Object { : super core::Object::•() ; method foo(self::Bar::T t) → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -51,17 +51,17 @@ class Bar = dynamic> extends core::Object { } } } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } } class Baz = dynamic, S extends self::Baz::E = dynamic> extends core::Object { @@ -69,7 +69,7 @@ class Baz : super core::Object::•() ; method foo(self::Baz::S t) → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -107,17 +107,17 @@ class Baz } } } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } } abstract class MyStream extends asy::Stream { @@ -125,7 +125,7 @@ abstract class MyStream extends asy::Stream :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -294,16 +294,16 @@ static method test() → dynamic /* originally async */ { } } } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/infer_types_on_loop_indices_for_each_loop_async.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/infer_types_on_loop_indices_for_each_loop_async.dart.strong.transformed.expect index 9b52d116732..e515591b7ab 100644 --- a/pkg/front_end/testcases/inference/infer_types_on_loop_indices_for_each_loop_async.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/infer_types_on_loop_indices_for_each_loop_async.dart.strong.transformed.expect @@ -14,7 +14,7 @@ class Bar = asy::Stream> exten : super core::Object::•() ; method foo(generic-covariant-impl self::Bar::T t) → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -54,17 +54,17 @@ Try changing the type of the left hand side, or casting the right hand side to ' } } } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } } class Baz = asy::Stream, S extends self::Baz::E = asy::Stream> extends core::Object { @@ -72,7 +72,7 @@ class Baz : super core::Object::•() ; method foo(generic-covariant-impl self::Baz::S t) → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -113,17 +113,17 @@ Try changing the type of the left hand side, or casting the right hand side to ' } } } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } } abstract class MyStream extends asy::Stream { @@ -131,7 +131,7 @@ abstract class MyStream extends asy::Stream :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -312,16 +312,16 @@ Try changing the type of the left hand side, or casting the right hand side to ' } } } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference/local_return_and_yield.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/local_return_and_yield.dart.direct.transformed.expect index 3af0dce9057..f15128524ae 100644 --- a/pkg/front_end/testcases/inference/local_return_and_yield.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/local_return_and_yield.dart.direct.transformed.expect @@ -9,7 +9,7 @@ static method main() → dynamic { return (dynamic x) → dynamic => x; } function b() → asy::Future<(core::int) → core::int> /* originally async */ { - final asy::Completer<(core::int) → core::int> :completer = asy::Completer::sync<(core::int) → core::int>(); + final asy::Completer<(core::int) → core::int> :async_completer = asy::Completer::sync<(core::int) → core::int>(); asy::FutureOr<(core::int) → core::int> :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -23,17 +23,17 @@ static method main() → dynamic { :return_value = (dynamic x) → dynamic => x; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } function c() → core::Iterable<(core::int) → core::int> /* originally sync* */ { dynamic :await_jump_var = 0; diff --git a/pkg/front_end/testcases/inference/local_return_and_yield.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/local_return_and_yield.dart.strong.transformed.expect index 3710faf59cf..2a29a2c1a80 100644 --- a/pkg/front_end/testcases/inference/local_return_and_yield.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/local_return_and_yield.dart.strong.transformed.expect @@ -9,7 +9,7 @@ static method main() → dynamic { return (core::int x) → core::int => x; } function b() → asy::Future<(core::int) → core::int> /* originally async */ { - final asy::Completer<(core::int) → core::int> :completer = asy::Completer::sync<(core::int) → core::int>(); + final asy::Completer<(core::int) → core::int> :async_completer = asy::Completer::sync<(core::int) → core::int>(); asy::FutureOr<(core::int) → core::int> :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -26,17 +26,17 @@ Try changing the type of the left hand side, or casting the right hand side to ' ^" in let final (dynamic) → dynamic #t2 = (dynamic x) → dynamic => x in null; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } function c() → core::Iterable<(core::int) → core::int> /* originally sync* */ { dynamic :await_jump_var = 0; diff --git a/pkg/front_end/testcases/inference/top_level_return_and_yield.dart.direct.transformed.expect b/pkg/front_end/testcases/inference/top_level_return_and_yield.dart.direct.transformed.expect index 5ffcce01da4..129d552dc6b 100644 --- a/pkg/front_end/testcases/inference/top_level_return_and_yield.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference/top_level_return_and_yield.dart.direct.transformed.expect @@ -8,7 +8,7 @@ static method a() → (core::int) → core::int { return (dynamic x) → dynamic => x; } static method b() → asy::Future<(core::int) → core::int> /* originally async */ { - final asy::Completer<(core::int) → core::int> :completer = asy::Completer::sync<(core::int) → core::int>(); + final asy::Completer<(core::int) → core::int> :async_completer = asy::Completer::sync<(core::int) → core::int>(); asy::FutureOr<(core::int) → core::int> :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -22,17 +22,17 @@ static method b() → asy::Future<(core::int) → core::int> /* originally async :return_value = (dynamic x) → dynamic => x; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method c() → core::Iterable<(core::int) → core::int> /* originally sync* */ { dynamic :await_jump_var = 0; diff --git a/pkg/front_end/testcases/inference/top_level_return_and_yield.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/top_level_return_and_yield.dart.strong.transformed.expect index 02edb721a35..cb53a5209aa 100644 --- a/pkg/front_end/testcases/inference/top_level_return_and_yield.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference/top_level_return_and_yield.dart.strong.transformed.expect @@ -8,7 +8,7 @@ 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::Completer<(core::int) → core::int> :completer = asy::Completer::sync<(core::int) → core::int>(); + final asy::Completer<(core::int) → core::int> :async_completer = asy::Completer::sync<(core::int) → core::int>(); asy::FutureOr<(core::int) → core::int> :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -25,17 +25,17 @@ Try changing the type of the left hand side, or casting the right hand side to ' ^" in let final (dynamic) → dynamic #t2 = (dynamic x) → dynamic => x in null; break #L1; } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method c() → core::Iterable<(core::int) → core::int> /* originally sync* */ { dynamic :await_jump_var = 0; diff --git a/pkg/front_end/testcases/inference_new/for_each_invalid_iterable.dart.direct.transformed.expect b/pkg/front_end/testcases/inference_new/for_each_invalid_iterable.dart.direct.transformed.expect index 4381b61ae14..2b3bdf6a5fe 100644 --- a/pkg/front_end/testcases/inference_new/for_each_invalid_iterable.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference_new/for_each_invalid_iterable.dart.direct.transformed.expect @@ -4,7 +4,7 @@ import "dart:async" as asy; import "dart:core" as core; static method test() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -67,16 +67,16 @@ static method test() → dynamic /* originally async */ { } } } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference_new/for_each_invalid_iterable.dart.strong.transformed.expect b/pkg/front_end/testcases/inference_new/for_each_invalid_iterable.dart.strong.transformed.expect index a61a3ed076c..bb9b75a1fb1 100644 --- a/pkg/front_end/testcases/inference_new/for_each_invalid_iterable.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference_new/for_each_invalid_iterable.dart.strong.transformed.expect @@ -4,7 +4,7 @@ import "dart:async" as asy; import "dart:core" as core; static method test() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -82,16 +82,16 @@ Try changing the type of the left hand side, or casting the right hand side to ' } } } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference_new/for_each_outer_var_type.dart.direct.transformed.expect b/pkg/front_end/testcases/inference_new/for_each_outer_var_type.dart.direct.transformed.expect index c6044b0852f..b82a06fa3de 100644 --- a/pkg/front_end/testcases/inference_new/for_each_outer_var_type.dart.direct.transformed.expect +++ b/pkg/front_end/testcases/inference_new/for_each_outer_var_type.dart.direct.transformed.expect @@ -16,7 +16,7 @@ class B extends self::A { static method f() → self::f::T return null; static method test() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -133,16 +133,16 @@ static method test() → dynamic /* originally async */ { } } } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method main() → dynamic {} diff --git a/pkg/front_end/testcases/inference_new/for_each_outer_var_type.dart.strong.transformed.expect b/pkg/front_end/testcases/inference_new/for_each_outer_var_type.dart.strong.transformed.expect index e8c97af00bd..c6335243084 100644 --- a/pkg/front_end/testcases/inference_new/for_each_outer_var_type.dart.strong.transformed.expect +++ b/pkg/front_end/testcases/inference_new/for_each_outer_var_type.dart.strong.transformed.expect @@ -16,7 +16,7 @@ class B extends self::A { static method f() → self::f::T return null; static method test() → dynamic /* originally async */ { - final asy::Completer :completer = asy::Completer::sync(); + final asy::Completer :async_completer = asy::Completer::sync(); asy::FutureOr :return_value; dynamic :async_stack_trace; dynamic :async_op_then; @@ -139,16 +139,16 @@ Try changing the type of the left hand side, or casting the right hand side to ' } } } - :completer.{asy::Completer::complete}(:return_value); + :async_completer.{asy::Completer::complete}(:return_value); return; } on dynamic catch(dynamic :exception, dynamic :stack_trace) { - :completer.{asy::Completer::completeError}(:exception, :stack_trace); + :async_completer.{asy::Completer::completeError}(:exception, :stack_trace); } :async_stack_trace = asy::_asyncStackTraceHelper(:async_op); :async_op_then = asy::_asyncThenWrapperHelper(:async_op); :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); asy::Future::microtask(:async_op); - return :completer.{asy::Completer::future}; + return :async_completer.{asy::Completer::future}; } static method main() → dynamic {} diff --git a/pkg/kernel/lib/transformations/continuation.dart b/pkg/kernel/lib/transformations/continuation.dart index 7cfea5e211f..d31f70a208a 100644 --- a/pkg/kernel/lib/transformations/continuation.dart +++ b/pkg/kernel/lib/transformations/continuation.dart @@ -969,8 +969,8 @@ class AsyncFunctionRewriter extends AsyncRewriterBase { if (syncAsync) { final completerType = new InterfaceType( helper.asyncAwaitCompleterClass, completerTypeArguments); - // final Completer :completer = new _AsyncAwaitCompleter(); - completerVariable = new VariableDeclaration(":completer", + // final Completer :async_completer = new _AsyncAwaitCompleter(); + completerVariable = new VariableDeclaration(":async_completer", initializer: new ConstructorInvocation( helper.asyncAwaitCompleterConstructor, new Arguments([], types: completerTypeArguments)) @@ -980,8 +980,8 @@ class AsyncFunctionRewriter extends AsyncRewriterBase { } else { final completerType = new InterfaceType(helper.completerClass, completerTypeArguments); - // final Completer :completer = new Completer.sync(); - completerVariable = new VariableDeclaration(":completer", + // final Completer :async_completer = new Completer.sync(); + completerVariable = new VariableDeclaration(":async_completer", initializer: new StaticInvocation(helper.completerConstructor, new Arguments([], types: completerTypeArguments)) ..fileOffset = enclosingFunction.body?.fileOffset ?? -1, @@ -996,7 +996,7 @@ class AsyncFunctionRewriter extends AsyncRewriterBase { setupAsyncContinuations(statements); if (syncAsync) { - // :completer.start(:async_op); + // :async_completer.start(:async_op); var startStatement = new ExpressionStatement(new MethodInvocation( new VariableGet(completerVariable), new Name('start'), @@ -1012,7 +1012,7 @@ class AsyncFunctionRewriter extends AsyncRewriterBase { ..fileOffset = enclosingFunction.fileOffset); statements.add(newMicrotaskStatement); } - // return :completer.future; + // return :async_completer.future; var completerGet = new VariableGet(completerVariable); var returnStatement = new ReturnStatement(new PropertyGet(completerGet, new Name('future', helper.asyncLibrary), helper.completerFuture)); diff --git a/runtime/observatory/tests/service/service_kernel.status b/runtime/observatory/tests/service/service_kernel.status index 8003fb4c3dc..d93a63c4e99 100644 --- a/runtime/observatory/tests/service/service_kernel.status +++ b/runtime/observatory/tests/service/service_kernel.status @@ -15,7 +15,6 @@ evaluate_activation_in_method_class_test: RuntimeError evaluate_activation_test/instance: RuntimeError evaluate_activation_test/scope: RuntimeError evaluate_in_sync_star_activation_test: RuntimeError -pause_on_unhandled_async_exceptions_test: RuntimeError # --pause-isolates-on-unhandled-exceptions doesn't currently work. Issue #29056 step_through_arithmetic_test: RuntimeError # probably constant evaluator pre-evaluating e.g. 1+2 unused_changes_in_last_reload_test: RuntimeError @@ -31,7 +30,6 @@ complex_reload_test: RuntimeError [ $arch == simdbc64 && $compiler == dartk ] get_cpu_profile_timeline_rpc_test: Pass, RuntimeError # http://dartbug.com/31794 -pause_on_unhandled_async_exceptions_test: RuntimeError, Timeout # Issue 31765 [ $arch == simdbc64 && $compiler == dartk && $mode == debug ] eval_test: Pass, Slow @@ -108,7 +106,7 @@ async_single_step_exception_test: RuntimeError [ $compiler == dartk && ($arch == simarm || $arch == simarm64 || $arch == simdbc64) ] add_breakpoint_rpc_kernel_test: RuntimeError # Issue #33087 -async_generator_breakpoint_test: Pass, RuntimeError +async_generator_breakpoint_test: Pass, RuntimeError, Crash # dartbug.com/33175 for the crash bad_reload_test: Skip # Times out on sim architectures, also RuntimeError. break_on_activation_test: RuntimeError # Issue #33087 complex_reload_test: Skip # Times out on sim architectures, also RuntimeError. diff --git a/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc b/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc index 45e08a3fd9c..457641fe36e 100644 --- a/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc +++ b/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc @@ -1598,8 +1598,8 @@ void StreamingScopeBuilder::VisitFunctionNode() { first_body_token_position_ = builder_->reader_.min_position(); } - // Ensure that :await_jump_var, :await_ctx_var, :async_op and - // :async_stack_trace are captured. + // Ensure that :await_jump_var, :await_ctx_var, :async_op, + // :async_completer and :async_stack_trace are captured. if (function_node_helper.async_marker_ == FunctionNodeHelper::kSyncYielding) { { LocalVariable* temp = NULL; @@ -1620,6 +1620,13 @@ void StreamingScopeBuilder::VisitFunctionNode() { scope_->CaptureVariable(temp); } } + { + LocalVariable* temp = + scope_->LookupVariable(Symbols::AsyncCompleter(), true); + if (temp != NULL) { + scope_->CaptureVariable(temp); + } + } if (FLAG_causal_async_stacks) { LocalVariable* temp = scope_->LookupVariable(Symbols::AsyncStackTraceVar(), true); @@ -5980,7 +5987,7 @@ FlowGraph* StreamingFlowGraphBuilder::BuildGraphOfFunction(bool constructor) { dispatch += Drop(); } if (i == (yield_continuations().length() - 1)) { - // We reached the last possility, no need to build more ifs. + // We reached the last possibility, no need to build more ifs. // Continue to the last continuation. // Note: continuations start with nop DropTemps instruction // which acts like an anchor, so we need to skip it. diff --git a/runtime/vm/debugger.cc b/runtime/vm/debugger.cc index 559b954d001..00cc7719fa5 100644 --- a/runtime/vm/debugger.cc +++ b/runtime/vm/debugger.cc @@ -752,15 +752,26 @@ RawObject* ActivationFrame::GetAsyncCompleter() { } RawObject* ActivationFrame::GetAsyncCompleterAwaiter(const Object& completer) { - const Class& sync_completer_cls = Class::Handle(completer.clazz()); - ASSERT(!sync_completer_cls.IsNull()); - const Class& completer_cls = Class::Handle(sync_completer_cls.SuperClass()); - const Field& future_field = - Field::Handle(completer_cls.LookupInstanceFieldAllowPrivate( - Symbols::CompleterFuture())); - ASSERT(!future_field.IsNull()); Instance& future = Instance::Handle(); - future ^= Instance::Cast(completer).GetField(future_field); + if (FLAG_sync_async) { + const Class& completer_cls = Class::Handle(completer.clazz()); + ASSERT(!completer_cls.IsNull()); + const Function& future_getter = Function::Handle( + completer_cls.LookupGetterFunction(Symbols::CompleterFuture())); + ASSERT(!future_getter.IsNull()); + const Array& args = Array::Handle(Array::New(1)); + args.SetAt(0, Instance::Cast(completer)); + future ^= DartEntry::InvokeFunction(future_getter, args); + } else { + const Class& sync_completer_cls = Class::Handle(completer.clazz()); + ASSERT(!sync_completer_cls.IsNull()); + const Class& completer_cls = Class::Handle(sync_completer_cls.SuperClass()); + const Field& future_field = + Field::Handle(completer_cls.LookupInstanceFieldAllowPrivate( + Symbols::CompleterFuture())); + ASSERT(!future_field.IsNull()); + future ^= Instance::Cast(completer).GetField(future_field); + } if (future.IsNull()) { // The completer object may not be fully initialized yet. return Object::null(); @@ -855,11 +866,18 @@ bool ActivationFrame::HandlesException(const Instance& exc_obj) { void ActivationFrame::ExtractTokenPositionFromAsyncClosure() { // Attempt to determine the token position from the async closure. + Thread* thread = Thread::Current(); + Zone* zone = thread->zone(); + const Script& script = Script::Handle(zone, function().script()); + ASSERT(function_.IsAsyncGenClosure() || function_.IsAsyncClosure()); // This should only be called on frames that aren't active on the stack. ASSERT(fp() == 0); + const Array& await_to_token_map = - Array::Handle(code_.await_token_positions()); + Array::Handle(zone, script.kind() == RawScript::kKernelTag + ? script.yield_positions() + : code_.await_token_positions()); if (await_to_token_map.IsNull()) { // No mapping. return; @@ -883,9 +901,15 @@ void ActivationFrame::ExtractTokenPositionFromAsyncClosure() { if (await_jump_var < 0) { return; } - ASSERT(await_jump_var < await_to_token_map.Length()); + intptr_t await_to_token_map_index = + script.kind() == RawScript::kKernelTag + ? await_jump_var - 1 + : + // source script tokens array has first element duplicated + await_jump_var; + ASSERT(await_to_token_map_index < await_to_token_map.Length()); const Object& token_pos = - Object::Handle(await_to_token_map.At(await_jump_var)); + Object::Handle(await_to_token_map.At(await_to_token_map_index)); if (token_pos.IsNull()) { return; } @@ -2017,13 +2041,37 @@ DebuggerStackTrace* Debugger::CollectAwaiterReturnStackTrace() { Array& deopt_frame = Array::Handle(zone); class StackTrace& async_stack_trace = StackTrace::Handle(zone); bool stack_has_async_function = false; + + // Number of frames we are trying to skip that form "sync async" entry. + int skipSyncAsyncFramesCount = -1; + String& function_name = String::Handle(zone); for (StackFrame* frame = iterator.NextFrame(); frame != NULL; frame = iterator.NextFrame()) { ASSERT(frame->IsValid()); if (FLAG_trace_debugger_stacktrace) { - OS::PrintErr("CollectStackTrace: visiting frame:\n\t%s\n", + OS::PrintErr("CollectAwaiterReturnStackTrace: visiting frame:\n\t%s\n", frame->ToCString()); } + if (skipSyncAsyncFramesCount >= 0) { + if (!frame->IsDartFrame()) { + break; + } + // Assume that the code we are looking for is not inlined. + code = frame->LookupDartCode(); + function = code.function(); + function_name ^= function.QualifiedScrubbedName(); + if (skipSyncAsyncFramesCount == 2) { + if (!function_name.Equals(Symbols::_ClosureCall())) { + break; + } + } else if (skipSyncAsyncFramesCount == 1) { + if (!function_name.Equals(Symbols::_AsyncAwaitCompleterStart())) { + break; + } + } + + skipSyncAsyncFramesCount--; + } if (frame->IsDartFrame()) { code = frame->LookupDartCode(); if (code.is_optimized()) { @@ -2035,8 +2083,10 @@ DebuggerStackTrace* Debugger::CollectAwaiterReturnStackTrace() { function = it.function(); if (FLAG_trace_debugger_stacktrace) { ASSERT(!function.IsNull()); - OS::PrintErr("CollectStackTrace: visiting inlined function: %s\n", - function.ToFullyQualifiedCString()); + OS::PrintErr( + "CollectAwaiterReturnStackTrace: visiting inlined function: " + "%s\n", + function.ToFullyQualifiedCString()); } intptr_t deopt_frame_offset = it.GetDeoptFpOffset(); if (function.IsAsyncClosure() || function.IsAsyncGenClosure()) { @@ -2072,7 +2122,16 @@ DebuggerStackTrace* Debugger::CollectAwaiterReturnStackTrace() { // Grab the awaiter. async_activation ^= activation->GetAsyncAwaiter(); async_stack_trace ^= activation->GetCausalStack(); - break; + if (FLAG_sync_async) { + // async function might have been called synchronously, in which + // case we need to keep going down the stack. + // To determine how we are called we peek few more frames further + // expecting to see Closure_call followed by + // AsyncAwaitCompleter_start. + skipSyncAsyncFramesCount = 2; + } else { + break; + } } else { stack_trace->AddActivation(CollectDartFrame( isolate, frame->pc(), frame, code, Object::null_array(), 0)); diff --git a/runtime/vm/kernel_loader.cc b/runtime/vm/kernel_loader.cc index 9a95b46a6b0..607c1e9f352 100644 --- a/runtime/vm/kernel_loader.cc +++ b/runtime/vm/kernel_loader.cc @@ -1398,8 +1398,16 @@ void KernelLoader::LoadProcedure(const Library& library, ASSERT(function_node_tag == kSomething); FunctionNodeHelper function_node_helper(&builder_); function_node_helper.ReadUntilIncluding(FunctionNodeHelper::kDartAsyncMarker); + // _AsyncAwaitCompleter.future should be made non-debuggable, otherwise + // stepping out of async methods will keep hitting breakpoint resulting in + // infinite loop. + bool isAsyncAwaitCompleterFuture = + Symbols::_AsyncAwaitCompleter().Equals( + String::Handle(owner.ScrubbedName())) && + Symbols::CompleterGetFuture().Equals(String::Handle(function.name())); function.set_is_debuggable(function_node_helper.dart_async_marker_ == - FunctionNodeHelper::kSync); + FunctionNodeHelper::kSync && + !isAsyncAwaitCompleterFuture); switch (function_node_helper.dart_async_marker_) { case FunctionNodeHelper::kSyncStar: function.set_modifier(RawFunction::kSyncGen); diff --git a/runtime/vm/symbols.h b/runtime/vm/symbols.h index 576e903cd51..fdd9ee4ebce 100644 --- a/runtime/vm/symbols.h +++ b/runtime/vm/symbols.h @@ -150,8 +150,10 @@ class ObjectPointerVisitor; V(CompleterSyncConstructor, "Completer.sync") \ V(_AsyncAwaitCompleter, "_AsyncAwaitCompleter") \ V(_AsyncAwaitCompleterConstructor, "_AsyncAwaitCompleter.") \ + V(_AsyncAwaitCompleterStart, "_AsyncAwaitCompleter.start") \ V(_AsyncAwaitStart, "start") \ V(CompleterFuture, "future") \ + V(CompleterGetFuture, "get:future") \ V(StreamIterator, "StreamIterator") \ V(StreamIteratorConstructor, "StreamIterator.") \ V(Native, "native") \ @@ -171,6 +173,7 @@ class ObjectPointerVisitor; V(PatchClass, "PatchClass") \ V(Function, "Function") \ V(_Closure, "_Closure") \ + V(_ClosureCall, "_Closure.call") \ V(FunctionResult, "function result") \ V(FactoryResult, "factory result") \ V(ClosureData, "ClosureData") \