[vm, kernel] Fix async stack code traversal in dart2.

With this change debugger requests yield(await) positions from kernel builder so it can confirm which frame handles what exceptions.
This also renames ':completer' to ':async_completer' in constructed kernel, so it is compliant with what VM expects to see(and updates test expectations accordingly).
Further it fixes async stack navigation for sync-async that became default in dart vm since first version went for the review((uses `future` getter, rather than property).
It also makes `future` getter non-debuggable to allow stepping-out of async methods.

Make Handle zone-scoped. Clean up frame counter var name.

Bug: https://github.com/dart-lang/sdk/issues/29056

Change-Id: Ia71f3c851a6b313655b57dad28c296f5dd081eda
Reviewed-on: https://dart-review.googlesource.com/54640
Commit-Queue: Alexander Aprelev <aam@google.com>
Reviewed-by: Siva Annamalai <asiva@google.com>

pkg/front_end/testcases/async_function.dart.direct.transformed.expect

@@ -5,7 +5,7 @@ import "dart:core" as core;
 
 static field core::List<core::String> stringList = <dynamic>["bar"];
 static method asyncString() → asy::Future<core::String> /* originally async */ {
-  final asy::Completer<core::String> :completer = asy::Completer::sync<core::String>();
+  final asy::Completer<core::String> :async_completer = asy::Completer::sync<core::String>();
   asy::FutureOr<core::String> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -19,20 +19,20 @@ static method asyncString() → asy::Future<core::String> /* 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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method asyncString2() → asy::Future<core::String> /* originally async */ {
-  final asy::Completer<core::String> :completer = asy::Completer::sync<core::String>();
+  final asy::Completer<core::String> :async_completer = asy::Completer::sync<core::String>();
   asy::FutureOr<core::String> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -46,17 +46,17 @@ static method asyncString2() → asy::Future<core::String> /* 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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method syncStarString() → core::Iterable<core::String> /* originally sync* */ {
   dynamic :await_jump_var = 0;
@@ -170,7 +170,7 @@ static method asyncStarString2() → asy::Stream<core::String> /* originally asy
   return :controller.{asy::_AsyncStarStreamController::stream};
 }
 static method main() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }

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<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }

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<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }

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<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }

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<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(: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<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   }
 }
 static method main() → dynamic {}

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<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(: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<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<core::int>;
           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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   }
 }
 static method main() → dynamic {}

pkg/front_end/testcases/inference/async_await.dart.direct.transformed.expect

@@ -9,7 +9,7 @@ abstract class MyFuture extends core::Object implements asy::Future<core::int> {
     ;
 }
 static method test() → void /* originally async */ {
-  final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -32,7 +32,7 @@ static method test() → void /* originally async */ {
         asy::FutureOr<self::MyFuture> x8;
         self::MyFuture x9;
         function test0() → dynamic /* originally async */ {
-          final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+          final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
           asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-          return :completer.{asy::Completer::future};
+          return :async_completer.{asy::Completer::future};
         }
         function test1() → dynamic /* originally async */ {
-          final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+          final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
           asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-          return :completer.{asy::Completer::future};
+          return :async_completer.{asy::Completer::future};
         }
         function test2() → dynamic /* originally async */ {
-          final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+          final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
           asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-          return :completer.{asy::Completer::future};
+          return :async_completer.{asy::Completer::future};
         }
         function test3() → dynamic /* originally async */ {
-          final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+          final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
           asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-          return :completer.{asy::Completer::future};
+          return :async_completer.{asy::Completer::future};
         }
         function test4() → dynamic /* originally async */ {
-          final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+          final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
           asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-          return :completer.{asy::Completer::future};
+          return :async_completer.{asy::Completer::future};
         }
         function test5() → dynamic /* originally async */ {
-          final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+          final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
           asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-          return :completer.{asy::Completer::future};
+          return :async_completer.{asy::Completer::future};
         }
         function test6() → dynamic /* originally async */ {
-          final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+          final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
           asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-          return :completer.{asy::Completer::future};
+          return :async_completer.{asy::Completer::future};
         }
         function test7() → dynamic /* originally async */ {
-          final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+          final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
           asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-          return :completer.{asy::Completer::future};
+          return :async_completer.{asy::Completer::future};
         }
         function test8() → dynamic /* originally async */ {
-          final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+          final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
           asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-          return :completer.{asy::Completer::future};
+          return :async_completer.{asy::Completer::future};
         }
         function test9() → dynamic /* originally async */ {
-          final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+          final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
           asy::FutureOr<dynamic> :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<dynamic>(: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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}

pkg/front_end/testcases/inference/async_await.dart.strong.transformed.expect

@@ -9,7 +9,7 @@ abstract class MyFuture extends core::Object implements asy::Future<core::int> {
     ;
 }
 static method test() → void /* originally async */ {
-  final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -32,7 +32,7 @@ static method test() → void /* originally async */ {
         asy::FutureOr<self::MyFuture> x8;
         self::MyFuture x9;
         function test0() → asy::Future<core::int> /* originally async */ {
-          final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+          final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
           asy::FutureOr<core::int> :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<dynamic>(:async_op);
-          return :completer.{asy::Completer::future};
+          return :async_completer.{asy::Completer::future};
         }
         function test1() → asy::Future<core::int> /* originally async */ {
-          final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+          final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
           asy::FutureOr<core::int> :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<dynamic>(:async_op);
-          return :completer.{asy::Completer::future};
+          return :async_completer.{asy::Completer::future};
         }
         function test2() → asy::Future<asy::Future<core::int>> /* originally async */ {
-          final asy::Completer<asy::Future<core::int>> :completer = asy::Completer::sync<asy::Future<core::int>>();
+          final asy::Completer<asy::Future<core::int>> :async_completer = asy::Completer::sync<asy::Future<core::int>>();
           asy::FutureOr<asy::Future<core::int>> :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<dynamic>(:async_op);
-          return :completer.{asy::Completer::future};
+          return :async_completer.{asy::Completer::future};
         }
         function test3() → asy::Future<asy::FutureOr<core::int>> /* originally async */ {
-          final asy::Completer<asy::FutureOr<core::int>> :completer = asy::Completer::sync<asy::FutureOr<core::int>>();
+          final asy::Completer<asy::FutureOr<core::int>> :async_completer = asy::Completer::sync<asy::FutureOr<core::int>>();
           asy::FutureOr<asy::FutureOr<core::int>> :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<dynamic>(:async_op);
-          return :completer.{asy::Completer::future};
+          return :async_completer.{asy::Completer::future};
         }
         function test4() → asy::Future<self::MyFuture> /* originally async */ {
-          final asy::Completer<self::MyFuture> :completer = asy::Completer::sync<self::MyFuture>();
+          final asy::Completer<self::MyFuture> :async_completer = asy::Completer::sync<self::MyFuture>();
           asy::FutureOr<self::MyFuture> :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<dynamic>(:async_op);
-          return :completer.{asy::Completer::future};
+          return :async_completer.{asy::Completer::future};
         }
         function test5() → asy::Future<core::int> /* originally async */ {
-          final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+          final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
           asy::FutureOr<core::int> :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<dynamic>(:async_op);
-          return :completer.{asy::Completer::future};
+          return :async_completer.{asy::Completer::future};
         }
         function test6() → asy::Future<asy::Future<core::int>> /* originally async */ {
-          final asy::Completer<asy::Future<core::int>> :completer = asy::Completer::sync<asy::Future<core::int>>();
+          final asy::Completer<asy::Future<core::int>> :async_completer = asy::Completer::sync<asy::Future<core::int>>();
           asy::FutureOr<asy::Future<core::int>> :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<dynamic>(:async_op);
-          return :completer.{asy::Completer::future};
+          return :async_completer.{asy::Completer::future};
         }
         function test7() → asy::Future<asy::FutureOr<core::int>> /* originally async */ {
-          final asy::Completer<asy::FutureOr<core::int>> :completer = asy::Completer::sync<asy::FutureOr<core::int>>();
+          final asy::Completer<asy::FutureOr<core::int>> :async_completer = asy::Completer::sync<asy::FutureOr<core::int>>();
           asy::FutureOr<asy::FutureOr<core::int>> :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<dynamic>(:async_op);
-          return :completer.{asy::Completer::future};
+          return :async_completer.{asy::Completer::future};
         }
         function test8() → asy::Future<self::MyFuture> /* originally async */ {
-          final asy::Completer<self::MyFuture> :completer = asy::Completer::sync<self::MyFuture>();
+          final asy::Completer<self::MyFuture> :async_completer = asy::Completer::sync<self::MyFuture>();
           asy::FutureOr<self::MyFuture> :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<dynamic>(:async_op);
-          return :completer.{asy::Completer::future};
+          return :async_completer.{asy::Completer::future};
         }
         function test9() → asy::Future<core::int> /* originally async */ {
-          final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+          final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
           asy::FutureOr<core::int> :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<dynamic>(: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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}

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<core::int> futureInt = null;
 static field dynamic f = () → dynamic => self::futureInt;
 static field dynamic g = () → asy::Future<dynamic> /* originally async */ {
-  final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -20,17 +20,17 @@ static field dynamic g = () → asy::Future<dynamic> /* 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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 };
 static method main() → dynamic {
   self::f;

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<core::int> futureInt = null;
 static field () → asy::Future<core::int> f = () → asy::Future<core::int> => self::futureInt;
 static field () → asy::Future<core::int> g = () → asy::Future<core::int> /* originally async */ {
-  final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+  final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
   asy::FutureOr<core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -20,17 +20,17 @@ static field () → asy::Future<core::int> g = () → asy::Future<core::int> /*
         :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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 };
 static method main() → dynamic {
   self::f;

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<dynamic> /* originally async */ {
-  final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -17,17 +17,17 @@ static field dynamic f = () → asy::Future<dynamic> /* 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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 };
 static method main() → dynamic {
   self::f;

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<core::int> f = () → asy::Future<core::int> /* originally async */ {
-  final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+  final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
   asy::FutureOr<core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -18,17 +18,17 @@ static field () → asy::Future<core::int> f = () → asy::Future<core::int> /*
         :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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 };
 static method main() → dynamic {
   self::f;

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<core::int> futureOrInt = null;
 static field dynamic f = () → dynamic => self::futureOrInt;
 static field dynamic g = () → asy::Future<dynamic> /* originally async */ {
-  final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -20,17 +20,17 @@ static field dynamic g = () → asy::Future<dynamic> /* 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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 };
 static method main() → dynamic {
   self::f;

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<core::int> futureOrInt = null;
 static field () → asy::FutureOr<core::int> f = () → asy::FutureOr<core::int> => self::futureOrInt;
 static field () → asy::Future<core::int> g = () → asy::Future<core::int> /* originally async */ {
-  final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+  final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
   asy::FutureOr<core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -20,17 +20,17 @@ static field () → asy::Future<core::int> g = () → asy::Future<core::int> /*
         :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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 };
 static method main() → dynamic {
   self::f;

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<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   };
   asy::Future<core::num> g = f.call();
   asy::Future<core::int> h = f.call();

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<core::num> f = () → asy::Future<core::num> /* originally async */ {
-    final asy::Completer<core::num> :completer = asy::Completer::sync<core::num>();
+    final asy::Completer<core::num> :async_completer = asy::Completer::sync<core::num>();
     asy::FutureOr<core::num> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   };
   asy::Future<core::num> g = f.call();
   asy::Future<core::int> h = f.call() as{TypeError} asy::Future<core::int>;

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<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   };
   asy::Future<core::num> g = f.call();
   asy::Future<core::int> h = f.call();

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<core::num> f = () → asy::Future<core::num> /* originally async */ {
-    final asy::Completer<core::num> :completer = asy::Completer::sync<core::num>();
+    final asy::Completer<core::num> :async_completer = asy::Completer::sync<core::num>();
     asy::FutureOr<core::num> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   };
   asy::Future<core::num> g = f.call();
   asy::Future<core::int> h = f.call() as{TypeError} asy::Future<core::int>;

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<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   };
   asy::Future<core::num> g = f.call();
   asy::Future<core::int> h = f.call();

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<core::num> f = () → asy::Future<core::num> /* originally async */ {
-    final asy::Completer<core::num> :completer = asy::Completer::sync<core::num>();
+    final asy::Completer<core::num> :async_completer = asy::Completer::sync<core::num>();
     asy::FutureOr<core::num> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   };
   asy::Future<core::num> g = f.call();
   asy::Future<core::int> h = f.call() as{TypeError} asy::Future<core::int>;

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<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :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<dynamic> /* originally async */ {
-          final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+          final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
           asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-          return :completer.{asy::Completer::future};
+          return :async_completer.{asy::Completer::future};
         };
         asy::Future<dynamic> y = f.call();
         asy::Future<core::String> z = f.call();
         [yield] let dynamic #t1 = asy::_awaitHelper(f.call(), :async_op_then, :async_op_error, :async_op) in null;
         core::String s = :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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }

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<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -17,7 +17,7 @@ static method main() → dynamic /* originally async */ {
       #L1:
       {
         () → asy::Future<core::Null> f = () → asy::Future<core::Null> /* originally async */ {
-          final asy::Completer<core::Null> :completer = asy::Completer::sync<core::Null>();
+          final asy::Completer<core::Null> :async_completer = asy::Completer::sync<core::Null>();
           asy::FutureOr<core::Null> :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<dynamic>(:async_op);
-          return :completer.{asy::Completer::future};
+          return :async_completer.{asy::Completer::future};
         };
         asy::Future<dynamic> y = f.call();
         asy::Future<core::String> z = f.call();
         [yield] let dynamic #t1 = asy::_awaitHelper(f.call(), :async_op_then, :async_op_error, :async_op) in null;
         core::String s = :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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }

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<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }

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<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }

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<dynamic> /* originally async */ {
-  final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -22,15 +22,15 @@ static method main() → asy::Future<dynamic> /* originally async */ {
         [yield] let dynamic #t2 = asy::_awaitHelper(asy::Future::value<dynamic>(<dynamic>[d]), :async_op_then, :async_op_error, :async_op) in null;
         core::List<core::int> 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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }

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<dynamic> /* originally async */ {
-  final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -22,15 +22,15 @@ static method main() → asy::Future<dynamic> /* originally async */ {
         [yield] let dynamic #t2 = asy::_awaitHelper(asy::Future::value<core::List<core::int>>(<core::int>[d as{TypeError} core::int]), :async_op_then, :async_op_error, :async_op) in null;
         core::List<core::int> 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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }

pkg/front_end/testcases/inference/downwards_inference_for_each.dart.direct.transformed.expect

@@ -10,7 +10,7 @@ abstract class MyStream<T extends core::Object = dynamic> extends asy::Stream<se
 static method F<T extends core::Object = dynamic>() → self::F::T
   return null;
 static method f() → asy::Future<dynamic> /* originally async */ {
-  final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -139,20 +139,20 @@ static method f() → asy::Future<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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method main() → asy::Future<dynamic> /* originally async */ {
-  final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -212,15 +212,15 @@ static method main() → asy::Future<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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }

pkg/front_end/testcases/inference/downwards_inference_for_each.dart.strong.transformed.expect

@@ -10,7 +10,7 @@ abstract class MyStream<T extends core::Object = dynamic> extends asy::Stream<se
 static method F<T extends core::Object = dynamic>() → self::F::T
   return null;
 static method f() → asy::Future<dynamic> /* originally async */ {
-  final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -139,20 +139,20 @@ static method f() → asy::Future<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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method main() → asy::Future<dynamic> /* originally async */ {
-  final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -212,15 +212,15 @@ static method main() → asy::Future<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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }

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<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}

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<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}

pkg/front_end/testcases/inference/future_then.dart.direct.transformed.expect

@@ -24,7 +24,7 @@ class MyFuture<T extends core::Object = dynamic> extends core::Object implements
 static method test() → void {
   self::MyFuture<dynamic> f;
   asy::Future<core::int> t1 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t2 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t3 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t4 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t5 = f.then((dynamic _) → dynamic => asy::Future::value<core::int>(3));
   asy::Future<core::int> t6 = f.then((dynamic _) → dynamic {
     return asy::Future::value<core::int>(3);
   });
   asy::Future<core::int> t7 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -154,20 +154,20 @@ static method test() → void {
           :return_value = asy::Future::value<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t8 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -181,17 +181,17 @@ static method test() → void {
           :return_value = asy::Future::value<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
 }
 static method main() → dynamic {}

pkg/front_end/testcases/inference/future_then.dart.strong.transformed.expect

@@ -24,7 +24,7 @@ class MyFuture<T extends core::Object = dynamic> extends core::Object implements
 static method test() → void {
   self::MyFuture<dynamic> f;
   asy::Future<core::int> t1 = f.{self::MyFuture::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t2 = f.{self::MyFuture::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t3 = f.{self::MyFuture::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t4 = f.{self::MyFuture::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t5 = f.{self::MyFuture::then}<core::int>((dynamic _) → asy::Future<core::int> => asy::Future::value<core::int>(3));
   asy::Future<core::int> t6 = f.{self::MyFuture::then}<core::int>((dynamic _) → asy::Future<core::int> {
     return asy::Future::value<core::int>(3);
   });
   asy::Future<core::int> t7 = f.{self::MyFuture::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -154,20 +154,20 @@ static method test() → void {
           :return_value = asy::Future::value<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t8 = f.{self::MyFuture::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -181,17 +181,17 @@ static method test() → void {
           :return_value = asy::Future::value<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
 }
 static method main() → dynamic {}

pkg/front_end/testcases/inference/future_then_2.dart.direct.transformed.expect

@@ -24,7 +24,7 @@ class MyFuture<T extends core::Object = dynamic> extends core::Object implements
 static method test() → void {
   self::MyFuture<dynamic> f;
   asy::Future<core::int> t1 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t2 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t3 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t4 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t5 = f.then((dynamic _) → dynamic => new self::MyFuture::value<core::int>(3));
   asy::Future<core::int> t6 = f.then((dynamic _) → dynamic {
     return new self::MyFuture::value<core::int>(3);
   });
   asy::Future<core::int> t7 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -154,20 +154,20 @@ static method test() → void {
           :return_value = new self::MyFuture::value<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t8 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -181,17 +181,17 @@ static method test() → void {
           :return_value = new self::MyFuture::value<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
 }
 static method main() → dynamic {}

pkg/front_end/testcases/inference/future_then_2.dart.strong.transformed.expect

@@ -24,7 +24,7 @@ class MyFuture<T extends core::Object = dynamic> extends core::Object implements
 static method test() → void {
   self::MyFuture<dynamic> f;
   asy::Future<core::int> t1 = f.{self::MyFuture::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t2 = f.{self::MyFuture::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t3 = f.{self::MyFuture::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t4 = f.{self::MyFuture::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t5 = f.{self::MyFuture::then}<core::int>((dynamic _) → self::MyFuture<core::int> => new self::MyFuture::value<core::int>(3));
   asy::Future<core::int> t6 = f.{self::MyFuture::then}<core::int>((dynamic _) → self::MyFuture<core::int> {
     return new self::MyFuture::value<core::int>(3);
   });
   asy::Future<core::int> t7 = f.{self::MyFuture::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -154,20 +154,20 @@ static method test() → void {
           :return_value = new self::MyFuture::value<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t8 = f.{self::MyFuture::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -181,17 +181,17 @@ static method test() → void {
           :return_value = new self::MyFuture::value<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
 }
 static method main() → dynamic {}

pkg/front_end/testcases/inference/future_then_3.dart.direct.transformed.expect

@@ -24,7 +24,7 @@ class MyFuture<T extends core::Object = dynamic> extends core::Object implements
 static method test() → void {
   self::MyFuture<dynamic> f;
   self::MyFuture<core::int> t1 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t2 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t3 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t4 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t5 = f.then((dynamic _) → dynamic => asy::Future::value<core::int>(3));
   self::MyFuture<core::int> t6 = f.then((dynamic _) → dynamic {
     return asy::Future::value<core::int>(3);
   });
   self::MyFuture<core::int> t7 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -154,20 +154,20 @@ static method test() → void {
           :return_value = asy::Future::value<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t8 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -181,17 +181,17 @@ static method test() → void {
           :return_value = asy::Future::value<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
 }
 static method main() → dynamic {}

pkg/front_end/testcases/inference/future_then_3.dart.strong.transformed.expect

@@ -24,7 +24,7 @@ class MyFuture<T extends core::Object = dynamic> extends core::Object implements
 static method test() → void {
   self::MyFuture<dynamic> f;
   self::MyFuture<core::int> t1 = f.{self::MyFuture::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t2 = f.{self::MyFuture::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t3 = f.{self::MyFuture::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t4 = f.{self::MyFuture::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t5 = f.{self::MyFuture::then}<core::int>((dynamic _) → asy::Future<core::int> => asy::Future::value<core::int>(3));
   self::MyFuture<core::int> t6 = f.{self::MyFuture::then}<core::int>((dynamic _) → asy::Future<core::int> {
     return asy::Future::value<core::int>(3);
   });
   self::MyFuture<core::int> t7 = f.{self::MyFuture::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -154,20 +154,20 @@ static method test() → void {
           :return_value = asy::Future::value<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t8 = f.{self::MyFuture::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -181,17 +181,17 @@ static method test() → void {
           :return_value = asy::Future::value<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
 }
 static method main() → dynamic {}

pkg/front_end/testcases/inference/future_then_4.dart.direct.transformed.expect

@@ -24,7 +24,7 @@ class MyFuture<T extends core::Object = dynamic> extends core::Object implements
 static method test() → void {
   self::MyFuture<dynamic> f;
   self::MyFuture<core::int> t1 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t2 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t3 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t4 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t5 = f.then((dynamic _) → dynamic => new self::MyFuture::value<core::int>(3));
   self::MyFuture<core::int> t6 = f.then((dynamic _) → dynamic {
     return new self::MyFuture::value<core::int>(3);
   });
   self::MyFuture<core::int> t7 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -154,20 +154,20 @@ static method test() → void {
           :return_value = new self::MyFuture::value<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t8 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -181,17 +181,17 @@ static method test() → void {
           :return_value = new self::MyFuture::value<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
 }
 static method main() → dynamic {}

pkg/front_end/testcases/inference/future_then_4.dart.strong.transformed.expect

@@ -24,7 +24,7 @@ class MyFuture<T extends core::Object = dynamic> extends core::Object implements
 static method test() → void {
   self::MyFuture<dynamic> f;
   self::MyFuture<core::int> t1 = f.{self::MyFuture::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t2 = f.{self::MyFuture::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t3 = f.{self::MyFuture::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t4 = f.{self::MyFuture::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t5 = f.{self::MyFuture::then}<core::int>((dynamic _) → self::MyFuture<core::int> => new self::MyFuture::value<core::int>(3));
   self::MyFuture<core::int> t6 = f.{self::MyFuture::then}<core::int>((dynamic _) → self::MyFuture<core::int> {
     return new self::MyFuture::value<core::int>(3);
   });
   self::MyFuture<core::int> t7 = f.{self::MyFuture::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -154,20 +154,20 @@ static method test() → void {
           :return_value = new self::MyFuture::value<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t8 = f.{self::MyFuture::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -181,17 +181,17 @@ static method test() → void {
           :return_value = new self::MyFuture::value<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
 }
 static method main() → dynamic {}

pkg/front_end/testcases/inference/future_then_5.dart.direct.transformed.expect

@@ -24,7 +24,7 @@ class MyFuture<T extends core::Object = dynamic> extends core::Object implements
 static method test() → void {
   asy::Future<dynamic> f;
   asy::Future<core::int> t1 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t2 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t3 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t4 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t5 = f.then((dynamic _) → dynamic => new self::MyFuture::value<core::int>(3));
   asy::Future<core::int> t6 = f.then((dynamic _) → dynamic {
     return new self::MyFuture::value<core::int>(3);
   });
   asy::Future<core::int> t7 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -154,20 +154,20 @@ static method test() → void {
           :return_value = new self::MyFuture::value<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t8 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -181,17 +181,17 @@ static method test() → void {
           :return_value = new self::MyFuture::value<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
 }
 static method main() → dynamic {}

pkg/front_end/testcases/inference/future_then_5.dart.strong.transformed.expect

@@ -24,7 +24,7 @@ class MyFuture<T extends core::Object = dynamic> extends core::Object implements
 static method test() → void {
   asy::Future<dynamic> f;
   asy::Future<core::int> t1 = f.{asy::Future::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t2 = f.{asy::Future::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t3 = f.{asy::Future::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t4 = f.{asy::Future::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t5 = f.{asy::Future::then}<core::int>((dynamic _) → self::MyFuture<core::int> => new self::MyFuture::value<core::int>(3));
   asy::Future<core::int> t6 = f.{asy::Future::then}<core::int>((dynamic _) → self::MyFuture<core::int> {
     return new self::MyFuture::value<core::int>(3);
   });
   asy::Future<core::int> t7 = f.{asy::Future::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -154,20 +154,20 @@ static method test() → void {
           :return_value = new self::MyFuture::value<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t8 = f.{asy::Future::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -181,17 +181,17 @@ static method test() → void {
           :return_value = new self::MyFuture::value<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
 }
 static method main() → dynamic {}

pkg/front_end/testcases/inference/future_then_6.dart.direct.transformed.expect

@@ -24,7 +24,7 @@ class MyFuture<T extends core::Object = dynamic> extends core::Object implements
 static method test() → void {
   asy::Future<dynamic> f;
   asy::Future<core::int> t1 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t2 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t3 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t4 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t5 = f.then((dynamic _) → dynamic => asy::Future::value<core::int>(3));
   asy::Future<core::int> t6 = f.then((dynamic _) → dynamic {
     return asy::Future::value<core::int>(3);
   });
   asy::Future<core::int> t7 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -154,20 +154,20 @@ static method test() → void {
           :return_value = asy::Future::value<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t8 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -181,17 +181,17 @@ static method test() → void {
           :return_value = asy::Future::value<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
 }
 static method main() → dynamic {}

pkg/front_end/testcases/inference/future_then_6.dart.strong.transformed.expect

@@ -24,7 +24,7 @@ class MyFuture<T extends core::Object = dynamic> extends core::Object implements
 static method test() → void {
   asy::Future<dynamic> f;
   asy::Future<core::int> t1 = f.{asy::Future::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t2 = f.{asy::Future::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t3 = f.{asy::Future::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t4 = f.{asy::Future::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t5 = f.{asy::Future::then}<core::int>((dynamic _) → asy::Future<core::int> => asy::Future::value<core::int>(3));
   asy::Future<core::int> t6 = f.{asy::Future::then}<core::int>((dynamic _) → asy::Future<core::int> {
     return asy::Future::value<core::int>(3);
   });
   asy::Future<core::int> t7 = f.{asy::Future::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -154,20 +154,20 @@ static method test() → void {
           :return_value = asy::Future::value<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t8 = f.{asy::Future::then}<core::int>((dynamic _) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -181,17 +181,17 @@ static method test() → void {
           :return_value = asy::Future::value<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
 }
 static method main() → dynamic {}

pkg/front_end/testcases/inference/future_then_conditional.dart.direct.transformed.expect

@@ -24,7 +24,7 @@ class MyFuture<T extends core::Object = dynamic> extends core::Object implements
 static method test() → void {
   self::MyFuture<core::bool> f;
   asy::Future<core::int> t1 = f.then((dynamic x) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t2 = f.then((dynamic x) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t5 = f.then((dynamic x) → dynamic => x ? 2 : asy::Future::value<core::int>(3));
   asy::Future<core::int> t6 = f.then((dynamic x) → dynamic {

pkg/front_end/testcases/inference/future_then_conditional.dart.strong.transformed.expect

@@ -24,7 +24,7 @@ class MyFuture<T extends core::Object = dynamic> extends core::Object implements
 static method test() → void {
   self::MyFuture<core::bool> f;
   asy::Future<core::int> t1 = f.{self::MyFuture::then}<core::int>((core::bool x) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t2 = f.{self::MyFuture::then}<core::int>((core::bool x) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<core::int>(3)) as{TypeError} asy::FutureOr<core::int>;
           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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t5 = f.{self::MyFuture::then}<core::int>((core::bool x) → asy::FutureOr<core::int> => (x ?{core::Object} 2 : asy::Future::value<core::int>(3)) as{TypeError} asy::FutureOr<core::int>);
   asy::Future<core::int> t6 = f.{self::MyFuture::then}<core::int>((core::bool x) → asy::FutureOr<core::int> {

pkg/front_end/testcases/inference/future_then_conditional_2.dart.direct.transformed.expect

@@ -24,7 +24,7 @@ class MyFuture<T extends core::Object = dynamic> extends core::Object implements
 static method test() → void {
   self::MyFuture<core::bool> f;
   asy::Future<core::int> t1 = f.then((dynamic x) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t2 = f.then((dynamic x) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t5 = f.then((dynamic x) → dynamic => x ? 2 : new self::MyFuture::value<core::int>(3));
   asy::Future<core::int> t6 = f.then((dynamic x) → dynamic {

pkg/front_end/testcases/inference/future_then_conditional_2.dart.strong.transformed.expect

@@ -24,7 +24,7 @@ class MyFuture<T extends core::Object = dynamic> extends core::Object implements
 static method test() → void {
   self::MyFuture<core::bool> f;
   asy::Future<core::int> t1 = f.{self::MyFuture::then}<core::int>((core::bool x) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t2 = f.{self::MyFuture::then}<core::int>((core::bool x) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<core::int>(3)) as{TypeError} asy::FutureOr<core::int>;
           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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t5 = f.{self::MyFuture::then}<core::int>((core::bool x) → asy::FutureOr<core::int> => (x ?{core::Object} 2 : new self::MyFuture::value<core::int>(3)) as{TypeError} asy::FutureOr<core::int>);
   asy::Future<core::int> t6 = f.{self::MyFuture::then}<core::int>((core::bool x) → asy::FutureOr<core::int> {

pkg/front_end/testcases/inference/future_then_conditional_3.dart.direct.transformed.expect

@@ -24,7 +24,7 @@ class MyFuture<T extends core::Object = dynamic> extends core::Object implements
 static method test() → void {
   self::MyFuture<core::bool> f;
   self::MyFuture<core::int> t1 = f.then((dynamic x) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t2 = f.then((dynamic x) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t5 = f.then((dynamic x) → dynamic => x ? 2 : asy::Future::value<core::int>(3));
   self::MyFuture<core::int> t6 = f.then((dynamic x) → dynamic {

pkg/front_end/testcases/inference/future_then_conditional_3.dart.strong.transformed.expect

@@ -24,7 +24,7 @@ class MyFuture<T extends core::Object = dynamic> extends core::Object implements
 static method test() → void {
   self::MyFuture<core::bool> f;
   self::MyFuture<core::int> t1 = f.{self::MyFuture::then}<core::int>((core::bool x) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t2 = f.{self::MyFuture::then}<core::int>((core::bool x) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<core::int>(3)) as{TypeError} asy::FutureOr<core::int>;
           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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t5 = f.{self::MyFuture::then}<core::int>((core::bool x) → asy::FutureOr<core::int> => (x ?{core::Object} 2 : asy::Future::value<core::int>(3)) as{TypeError} asy::FutureOr<core::int>);
   self::MyFuture<core::int> t6 = f.{self::MyFuture::then}<core::int>((core::bool x) → asy::FutureOr<core::int> {

pkg/front_end/testcases/inference/future_then_conditional_4.dart.direct.transformed.expect

@@ -24,7 +24,7 @@ class MyFuture<T extends core::Object = dynamic> extends core::Object implements
 static method test() → void {
   self::MyFuture<core::bool> f;
   self::MyFuture<core::int> t1 = f.then((dynamic x) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t2 = f.then((dynamic x) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t5 = f.then((dynamic x) → dynamic => x ? 2 : new self::MyFuture::value<core::int>(3));
   self::MyFuture<core::int> t6 = f.then((dynamic x) → dynamic {

pkg/front_end/testcases/inference/future_then_conditional_4.dart.strong.transformed.expect

@@ -24,7 +24,7 @@ class MyFuture<T extends core::Object = dynamic> extends core::Object implements
 static method test() → void {
   self::MyFuture<core::bool> f;
   self::MyFuture<core::int> t1 = f.{self::MyFuture::then}<core::int>((core::bool x) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t2 = f.{self::MyFuture::then}<core::int>((core::bool x) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<core::int>(3)) as{TypeError} asy::FutureOr<core::int>;
           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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t5 = f.{self::MyFuture::then}<core::int>((core::bool x) → asy::FutureOr<core::int> => (x ?{core::Object} 2 : new self::MyFuture::value<core::int>(3)) as{TypeError} asy::FutureOr<core::int>);
   self::MyFuture<core::int> t6 = f.{self::MyFuture::then}<core::int>((core::bool x) → asy::FutureOr<core::int> {

pkg/front_end/testcases/inference/future_then_conditional_5.dart.direct.transformed.expect

@@ -24,7 +24,7 @@ class MyFuture<T extends core::Object = dynamic> extends core::Object implements
 static method test() → void {
   asy::Future<core::bool> f;
   asy::Future<core::int> t1 = f.then((dynamic x) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t2 = f.then((dynamic x) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t5 = f.then((dynamic x) → dynamic => x ? 2 : new self::MyFuture::value<core::int>(3));
   asy::Future<core::int> t6 = f.then((dynamic x) → dynamic {

pkg/front_end/testcases/inference/future_then_conditional_5.dart.strong.transformed.expect

@@ -24,7 +24,7 @@ class MyFuture<T extends core::Object = dynamic> extends core::Object implements
 static method test() → void {
   asy::Future<core::bool> f;
   asy::Future<core::int> t1 = f.{asy::Future::then}<core::int>((core::bool x) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t2 = f.{asy::Future::then}<core::int>((core::bool x) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<core::int>(3)) as{TypeError} asy::FutureOr<core::int>;
           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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t5 = f.{asy::Future::then}<core::int>((core::bool x) → asy::FutureOr<core::int> => (x ?{core::Object} 2 : new self::MyFuture::value<core::int>(3)) as{TypeError} asy::FutureOr<core::int>);
   asy::Future<core::int> t6 = f.{asy::Future::then}<core::int>((core::bool x) → asy::FutureOr<core::int> {

pkg/front_end/testcases/inference/future_then_conditional_6.dart.direct.transformed.expect

@@ -24,7 +24,7 @@ class MyFuture<T extends core::Object = dynamic> extends core::Object implements
 static method test() → void {
   asy::Future<core::bool> f;
   asy::Future<core::int> t1 = f.then((dynamic x) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t2 = f.then((dynamic x) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t5 = f.then((dynamic x) → dynamic => x ? 2 : asy::Future::value<core::int>(3));
   asy::Future<core::int> t6 = f.then((dynamic x) → dynamic {

pkg/front_end/testcases/inference/future_then_conditional_6.dart.strong.transformed.expect

@@ -24,7 +24,7 @@ class MyFuture<T extends core::Object = dynamic> extends core::Object implements
 static method test() → void {
   asy::Future<core::bool> f;
   asy::Future<core::int> t1 = f.{asy::Future::then}<core::int>((core::bool x) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t2 = f.{asy::Future::then}<core::int>((core::bool x) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<core::int>(3)) as{TypeError} asy::FutureOr<core::int>;
           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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t5 = f.{asy::Future::then}<core::int>((core::bool x) → asy::FutureOr<core::int> => (x ?{core::Object} 2 : asy::Future::value<core::int>(3)) as{TypeError} asy::FutureOr<core::int>);
   asy::Future<core::int> t6 = f.{asy::Future::then}<core::int>((core::bool x) → asy::FutureOr<core::int> {

pkg/front_end/testcases/inference/future_then_ifNull.dart.direct.transformed.expect

@@ -24,7 +24,7 @@ class MyFuture<T extends core::Object = dynamic> extends core::Object implements
 static method test() → void {
   self::MyFuture<core::int> f;
   asy::Future<core::int> t1 = f.then((dynamic x) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t2 = f.then((dynamic x) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<core::int>(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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t5 = f.then((dynamic x) → dynamic => let final dynamic #t5 = x in #t5.==(null) ? asy::Future::value<core::int>(3) : #t5);
   asy::Future<core::int> t6 = f.then((dynamic x) → dynamic {

pkg/front_end/testcases/inference/future_then_ifNull.dart.strong.transformed.expect

@@ -24,7 +24,7 @@ class MyFuture<T extends core::Object = dynamic> extends core::Object implements
 static method test() → void {
   self::MyFuture<core::int> f;
   asy::Future<core::int> t1 = f.{self::MyFuture::then}<core::int>((core::int x) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t2 = f.{self::MyFuture::then}<core::int>((core::int x) → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<core::int>(3) : #t4) as{TypeError} asy::FutureOr<core::int>;
           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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t5 = f.{self::MyFuture::then}<core::int>((core::int x) → asy::FutureOr<core::int> => (let final core::int #t5 = x in #t5.==(null) ?{core::Object} asy::Future::value<core::int>(3) : #t5) as{TypeError} asy::FutureOr<core::int>);
   asy::Future<core::int> t6 = f.{self::MyFuture::then}<core::int>((core::int x) → asy::FutureOr<core::int> {

pkg/front_end/testcases/inference/future_union_async_conditional.dart.direct.transformed.expect

@@ -22,7 +22,7 @@ class MyFuture<T extends core::Object = dynamic> extends core::Object implements
     return this.{self::MyFuture::noSuchMethod}(new core::_InvocationMirror::_withoutType("asStream", const <core::Type>[], const <dynamic>[], core::Map::unmodifiable<core::Symbol, dynamic>(const <core::Symbol, dynamic>{}), false)) as{TypeError} asy::Stream<self::MyFuture::T>;
 }
 static method g1(core::bool x) → asy::Future<core::int> /* originally async */ {
-  final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+  final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
   asy::FutureOr<core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -36,20 +36,20 @@ static method g1(core::bool x) → asy::Future<core::int> /* originally async */
         :return_value = x ? 42 : asy::Future::value<dynamic>(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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method g2(core::bool x) → asy::Future<core::int> /* originally async */ {
-  final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+  final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
   asy::FutureOr<core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -63,20 +63,20 @@ static method g2(core::bool x) → asy::Future<core::int> /* originally async */
         :return_value = x ? 42 : asy::Future::value<dynamic>(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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method g3(core::bool x) → asy::Future<core::int> /* originally async */ {
-  final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+  final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
   asy::FutureOr<core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -91,16 +91,16 @@ static method g3(core::bool x) → asy::Future<core::int> /* 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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}

pkg/front_end/testcases/inference/future_union_async_conditional.dart.strong.transformed.expect

@@ -22,7 +22,7 @@ class MyFuture<T extends core::Object = dynamic> extends core::Object implements
     return this.{self::MyFuture::noSuchMethod}(new core::_InvocationMirror::_withoutType("asStream", const <core::Type>[], const <dynamic>[], core::Map::unmodifiable<core::Symbol, dynamic>(const <core::Symbol, dynamic>{}), false)) as{TypeError} asy::Stream<self::MyFuture::T>;
 }
 static method g1(core::bool x) → asy::Future<core::int> /* originally async */ {
-  final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+  final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
   asy::FutureOr<core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -36,20 +36,20 @@ static method g1(core::bool x) → asy::Future<core::int> /* originally async */
         :return_value = (x ?{core::Object} 42 : asy::Future::value<core::int>(42)) as{TypeError} asy::FutureOr<core::int>;
         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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method g2(core::bool x) → asy::Future<core::int> /* originally async */ {
-  final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+  final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
   asy::FutureOr<core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -63,20 +63,20 @@ static method g2(core::bool x) → asy::Future<core::int> /* originally async */
         :return_value = (x ?{core::Object} 42 : asy::Future::value<core::int>(42)) as{TypeError} asy::FutureOr<core::int>;
         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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method g3(core::bool x) → asy::Future<core::int> /* originally async */ {
-  final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+  final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
   asy::FutureOr<core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -91,16 +91,16 @@ static method g3(core::bool x) → asy::Future<core::int> /* originally async */
         :return_value = y as{TypeError} asy::FutureOr<core::int>;
         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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}

pkg/front_end/testcases/inference/future_union_async_conditional_2.dart.direct.transformed.expect

@@ -22,7 +22,7 @@ class MyFuture<T extends core::Object = dynamic> extends core::Object implements
     return this.{self::MyFuture::noSuchMethod}(new core::_InvocationMirror::_withoutType("asStream", const <core::Type>[], const <dynamic>[], core::Map::unmodifiable<core::Symbol, dynamic>(const <core::Symbol, dynamic>{}), false)) as{TypeError} asy::Stream<self::MyFuture::T>;
 }
 static method g1(core::bool x) → asy::Future<core::int> /* originally async */ {
-  final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+  final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
   asy::FutureOr<core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -36,20 +36,20 @@ static method g1(core::bool x) → asy::Future<core::int> /* originally async */
         :return_value = x ? 42 : new self::MyFuture::value<dynamic>(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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method g2(core::bool x) → asy::Future<core::int> /* originally async */ {
-  final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+  final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
   asy::FutureOr<core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -63,20 +63,20 @@ static method g2(core::bool x) → asy::Future<core::int> /* originally async */
         :return_value = x ? 42 : new self::MyFuture::value<dynamic>(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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method g3(core::bool x) → asy::Future<core::int> /* originally async */ {
-  final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+  final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
   asy::FutureOr<core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -91,16 +91,16 @@ static method g3(core::bool x) → asy::Future<core::int> /* 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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}

pkg/front_end/testcases/inference/future_union_async_conditional_2.dart.strong.transformed.expect

@@ -22,7 +22,7 @@ class MyFuture<T extends core::Object = dynamic> extends core::Object implements
     return this.{self::MyFuture::noSuchMethod}(new core::_InvocationMirror::_withoutType("asStream", const <core::Type>[], const <dynamic>[], core::Map::unmodifiable<core::Symbol, dynamic>(const <core::Symbol, dynamic>{}), false)) as{TypeError} asy::Stream<self::MyFuture::T>;
 }
 static method g1(core::bool x) → asy::Future<core::int> /* originally async */ {
-  final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+  final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
   asy::FutureOr<core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -36,20 +36,20 @@ static method g1(core::bool x) → asy::Future<core::int> /* originally async */
         :return_value = (x ?{core::Object} 42 : new self::MyFuture::value<core::int>(42)) as{TypeError} asy::FutureOr<core::int>;
         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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method g2(core::bool x) → asy::Future<core::int> /* originally async */ {
-  final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+  final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
   asy::FutureOr<core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -63,20 +63,20 @@ static method g2(core::bool x) → asy::Future<core::int> /* originally async */
         :return_value = (x ?{core::Object} 42 : new self::MyFuture::value<core::int>(42)) as{TypeError} asy::FutureOr<core::int>;
         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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method g3(core::bool x) → asy::Future<core::int> /* originally async */ {
-  final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+  final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
   asy::FutureOr<core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -91,16 +91,16 @@ static method g3(core::bool x) → asy::Future<core::int> /* originally async */
         :return_value = y as{TypeError} asy::FutureOr<core::int>;
         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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}

pkg/front_end/testcases/inference/future_union_downwards.dart.direct.transformed.expect

@@ -25,7 +25,7 @@ static field self::MyFuture<dynamic> f;
 static field asy::Future<core::int> t1 = self::f.then((dynamic _) → dynamic => asy::Future::value<dynamic>("hi"));
 static field asy::Future<core::List<core::int>> t2 = self::f.then((dynamic _) → dynamic => <dynamic>[3]);
 static method g2() → asy::Future<core::List<core::int>> /* originally async */ {
-  final asy::Completer<core::List<core::int>> :completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::Completer<core::List<core::int>> :async_completer = asy::Completer::sync<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -39,20 +39,20 @@ static method g2() → asy::Future<core::List<core::int>> /* originally async */
         :return_value = <dynamic>[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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method g3() → asy::Future<core::List<core::int>> /* originally async */ {
-  final asy::Completer<core::List<core::int>> :completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::Completer<core::List<core::int>> :async_completer = asy::Completer::sync<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -66,16 +66,16 @@ static method g3() → asy::Future<core::List<core::int>> /* originally async */
         :return_value = asy::Future::value<dynamic>(<dynamic>[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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}

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<core::List<core::int>> t2 = self::f.{self::MyFuture::then}<core::List<core::int>>((dynamic _) → core::List<core::int> => <core::int>[3]);
 static method g2() → asy::Future<core::List<core::int>> /* originally async */ {
-  final asy::Completer<core::List<core::int>> :completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::Completer<core::List<core::int>> :async_completer = asy::Completer::sync<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -42,20 +42,20 @@ static method g2() → asy::Future<core::List<core::int>> /* originally async */
         :return_value = <core::int>[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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method g3() → asy::Future<core::List<core::int>> /* originally async */ {
-  final asy::Completer<core::List<core::int>> :completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::Completer<core::List<core::int>> :async_completer = asy::Completer::sync<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -69,16 +69,16 @@ static method g3() → asy::Future<core::List<core::int>> /* originally async */
         :return_value = asy::Future::value<core::List<core::int>>(<core::int>[3]);
         break #L2;
       }
-      :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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}

pkg/front_end/testcases/inference/future_union_downwards_2.dart.direct.transformed.expect

@@ -25,7 +25,7 @@ static field self::MyFuture<dynamic> f;
 static field asy::Future<core::int> t1 = self::f.then((dynamic _) → dynamic => new self::MyFuture::value<dynamic>("hi"));
 static field asy::Future<core::List<core::int>> t2 = self::f.then((dynamic _) → dynamic => <dynamic>[3]);
 static method g2() → asy::Future<core::List<core::int>> /* originally async */ {
-  final asy::Completer<core::List<core::int>> :completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::Completer<core::List<core::int>> :async_completer = asy::Completer::sync<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -39,20 +39,20 @@ static method g2() → asy::Future<core::List<core::int>> /* originally async */
         :return_value = <dynamic>[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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method g3() → asy::Future<core::List<core::int>> /* originally async */ {
-  final asy::Completer<core::List<core::int>> :completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::Completer<core::List<core::int>> :async_completer = asy::Completer::sync<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -66,16 +66,16 @@ static method g3() → asy::Future<core::List<core::int>> /* originally async */
         :return_value = new self::MyFuture::value<dynamic>(<dynamic>[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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}

pkg/front_end/testcases/inference/future_union_downwards_2.dart.strong.transformed.expect

@@ -25,7 +25,7 @@ static field self::MyFuture<dynamic> f;
 static field asy::Future<core::int> t1 = self::f.{self::MyFuture::then}<core::int>((dynamic _) → self::MyFuture<core::int> => new self::MyFuture::value<core::int>("hi"));
 static field asy::Future<core::List<core::int>> t2 = self::f.{self::MyFuture::then}<core::List<core::int>>((dynamic _) → core::List<core::int> => <core::int>[3]);
 static method g2() → asy::Future<core::List<core::int>> /* originally async */ {
-  final asy::Completer<core::List<core::int>> :completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::Completer<core::List<core::int>> :async_completer = asy::Completer::sync<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -39,20 +39,20 @@ static method g2() → asy::Future<core::List<core::int>> /* originally async */
         :return_value = <core::int>[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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method g3() → asy::Future<core::List<core::int>> /* originally async */ {
-  final asy::Completer<core::List<core::int>> :completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::Completer<core::List<core::int>> :async_completer = asy::Completer::sync<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -66,16 +66,16 @@ static method g3() → asy::Future<core::List<core::int>> /* originally async */
         :return_value = new self::MyFuture::value<core::List<core::int>>(<core::int>[3]);
         break #L2;
       }
-      :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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}

pkg/front_end/testcases/inference/future_union_downwards_3.dart.direct.transformed.expect

@@ -25,7 +25,7 @@ static field asy::Future<dynamic> f;
 static field asy::Future<core::int> t1 = self::f.then((dynamic _) → dynamic => asy::Future::value<dynamic>("hi"));
 static field asy::Future<core::List<core::int>> t2 = self::f.then((dynamic _) → dynamic => <dynamic>[3]);
 static method g2() → asy::Future<core::List<core::int>> /* originally async */ {
-  final asy::Completer<core::List<core::int>> :completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::Completer<core::List<core::int>> :async_completer = asy::Completer::sync<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -39,20 +39,20 @@ static method g2() → asy::Future<core::List<core::int>> /* originally async */
         :return_value = <dynamic>[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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method g3() → asy::Future<core::List<core::int>> /* originally async */ {
-  final asy::Completer<core::List<core::int>> :completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::Completer<core::List<core::int>> :async_completer = asy::Completer::sync<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -66,16 +66,16 @@ static method g3() → asy::Future<core::List<core::int>> /* originally async */
         :return_value = asy::Future::value<dynamic>(<dynamic>[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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}

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<core::List<core::int>> t2 = self::f.{asy::Future::then}<core::List<core::int>>((dynamic _) → core::List<core::int> => <core::int>[3]);
 static method g2() → asy::Future<core::List<core::int>> /* originally async */ {
-  final asy::Completer<core::List<core::int>> :completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::Completer<core::List<core::int>> :async_completer = asy::Completer::sync<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -42,20 +42,20 @@ static method g2() → asy::Future<core::List<core::int>> /* originally async */
         :return_value = <core::int>[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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method g3() → asy::Future<core::List<core::int>> /* originally async */ {
-  final asy::Completer<core::List<core::int>> :completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::Completer<core::List<core::int>> :async_completer = asy::Completer::sync<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -69,16 +69,16 @@ static method g3() → asy::Future<core::List<core::int>> /* originally async */
         :return_value = asy::Future::value<core::List<core::int>>(<core::int>[3]);
         break #L2;
       }
-      :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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}

pkg/front_end/testcases/inference/future_union_downwards_4.dart.direct.transformed.expect

@@ -25,7 +25,7 @@ static field asy::Future<dynamic> f;
 static field asy::Future<core::int> t1 = self::f.then((dynamic _) → dynamic => new self::MyFuture::value<dynamic>("hi"));
 static field asy::Future<core::List<core::int>> t2 = self::f.then((dynamic _) → dynamic => <dynamic>[3]);
 static method g2() → asy::Future<core::List<core::int>> /* originally async */ {
-  final asy::Completer<core::List<core::int>> :completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::Completer<core::List<core::int>> :async_completer = asy::Completer::sync<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -39,20 +39,20 @@ static method g2() → asy::Future<core::List<core::int>> /* originally async */
         :return_value = <dynamic>[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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method g3() → asy::Future<core::List<core::int>> /* originally async */ {
-  final asy::Completer<core::List<core::int>> :completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::Completer<core::List<core::int>> :async_completer = asy::Completer::sync<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -66,16 +66,16 @@ static method g3() → asy::Future<core::List<core::int>> /* originally async */
         :return_value = new self::MyFuture::value<dynamic>(<dynamic>[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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}

pkg/front_end/testcases/inference/future_union_downwards_4.dart.strong.transformed.expect

@@ -25,7 +25,7 @@ static field asy::Future<dynamic> f;
 static field asy::Future<core::int> t1 = self::f.{asy::Future::then}<core::int>((dynamic _) → self::MyFuture<core::int> => new self::MyFuture::value<core::int>("hi"));
 static field asy::Future<core::List<core::int>> t2 = self::f.{asy::Future::then}<core::List<core::int>>((dynamic _) → core::List<core::int> => <core::int>[3]);
 static method g2() → asy::Future<core::List<core::int>> /* originally async */ {
-  final asy::Completer<core::List<core::int>> :completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::Completer<core::List<core::int>> :async_completer = asy::Completer::sync<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -39,20 +39,20 @@ static method g2() → asy::Future<core::List<core::int>> /* originally async */
         :return_value = <core::int>[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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method g3() → asy::Future<core::List<core::int>> /* originally async */ {
-  final asy::Completer<core::List<core::int>> :completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::Completer<core::List<core::int>> :async_completer = asy::Completer::sync<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -66,16 +66,16 @@ static method g3() → asy::Future<core::List<core::int>> /* originally async */
         :return_value = new self::MyFuture::value<core::List<core::int>>(<core::int>[3]);
         break #L2;
       }
-      :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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}

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<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :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<dynamic>(<dynamic>[f1, f2]), :async_op_then, :async_op_error, :async_op) in null;
         core::List<core::List<self::A>> 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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}

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<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :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<core::List<self::A>>(<asy::Future<core::List<self::A>>>[f1, f2]), :async_op_then, :async_op_error, :async_op) in null;
         core::List<core::List<self::A>> merged = :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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}

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<T extends core::Object = dynamic>(self::id::T x) → self::id::T
   return x;
 static method test() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :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<dynamic>(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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}

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<T extends core::Object = dynamic>(self::id::T x) → self::id::T
   return x;
 static method test() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :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<asy::FutureOr<core::String>>(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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}

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<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -41,15 +41,15 @@ static method main() → dynamic /* originally async */ {
         core::List<self::A> 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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }

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<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -41,15 +41,15 @@ static method main() → dynamic /* originally async */ {
         core::List<self::A> 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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }

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<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(: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<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   }
   function f4() → dynamic /* originally sync* */ {
     dynamic :await_jump_var = 0;

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<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   }
   function f2() → core::int {
     return 42;
   }
   function f3() → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :completer = asy::Completer::sync<core::int>();
+    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
     asy::FutureOr<core::int> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   }
   function f4() → core::Iterable<core::int> /* originally sync* */ {
     dynamic :await_jump_var = 0;

pkg/front_end/testcases/inference/infer_types_on_loop_indices_for_each_loop_async.dart.direct.transformed.expect

@@ -14,7 +14,7 @@ class Bar<T extends asy::Stream<core::String> = dynamic> extends core::Object {
     : super core::Object::•()
     ;
   method foo(self::Bar::T t) → dynamic /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -51,17 +51,17 @@ class Bar<T extends asy::Stream<core::String> = 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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   }
 }
 class Baz<T extends core::Object = dynamic, E extends asy::Stream<self::Baz::T> = dynamic, S extends self::Baz::E = dynamic> extends core::Object {
@@ -69,7 +69,7 @@ class Baz<T extends core::Object = dynamic, E extends asy::Stream<self::Baz::T>
     : super core::Object::•()
     ;
   method foo(self::Baz::S t) → dynamic /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -107,17 +107,17 @@ class Baz<T extends core::Object = dynamic, E extends asy::Stream<self::Baz::T>
               }
           }
         }
-        :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   }
 }
 abstract class MyStream<T extends core::Object = dynamic> extends asy::Stream<self::MyStream::T> {
@@ -125,7 +125,7 @@ abstract class MyStream<T extends core::Object = dynamic> extends asy::Stream<se
     return null;
 }
 static method test() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}

pkg/front_end/testcases/inference/infer_types_on_loop_indices_for_each_loop_async.dart.strong.transformed.expect

@@ -14,7 +14,7 @@ class Bar<T extends asy::Stream<core::String> = asy::Stream<core::String>> exten
     : super core::Object::•()
     ;
   method foo(generic-covariant-impl self::Bar::T t) → dynamic /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   }
 }
 class Baz<T extends core::Object = dynamic, E extends asy::Stream<self::Baz::T> = asy::Stream<dynamic>, S extends self::Baz::E = asy::Stream<dynamic>> extends core::Object {
@@ -72,7 +72,7 @@ class Baz<T extends core::Object = dynamic, E extends asy::Stream<self::Baz::T>
     : super core::Object::•()
     ;
   method foo(generic-covariant-impl self::Baz::S t) → dynamic /* originally async */ {
-    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
     asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-    return :completer.{asy::Completer::future};
+    return :async_completer.{asy::Completer::future};
   }
 }
 abstract class MyStream<T extends core::Object = dynamic> extends asy::Stream<self::MyStream::T> {
@@ -131,7 +131,7 @@ abstract class MyStream<T extends core::Object = dynamic> extends asy::Stream<se
     return null;
 }
 static method test() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}

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<dynamic>(: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;

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<dynamic>(: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;

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<dynamic>(: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;

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<dynamic>(: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;

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<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}

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<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}

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<T extends core::Object = dynamic>() → self::f::T
   return null;
 static method test() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}

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<T extends core::Object = dynamic>() → self::f::T
   return null;
 static method test() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
+  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
   asy::FutureOr<dynamic> :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<dynamic>(:async_op);
-  return :completer.{asy::Completer::future};
+  return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}

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<T> :completer = new _AsyncAwaitCompleter<T>();
-      completerVariable = new VariableDeclaration(":completer",
+      // final Completer<T> :async_completer = new _AsyncAwaitCompleter<T>();
+      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<T> :completer = new Completer<T>.sync();
-      completerVariable = new VariableDeclaration(":completer",
+      // final Completer<T> :async_completer = new Completer<T>.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));

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.

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.

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));

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);

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")                                                \