diff --git a/pkg/front_end/lib/src/base/processed_options.dart b/pkg/front_end/lib/src/base/processed_options.dart
index 196a03f..126a0c0 100644
--- a/pkg/front_end/lib/src/base/processed_options.dart
+++ b/pkg/front_end/lib/src/base/processed_options.dart
@@ -290,8 +290,8 @@
   bool get bytecode => _raw.bytecode;
 
   Target _target;
-  Target get target => _target ??= _raw.target ??
-      new NoneTarget(new TargetFlags(legacyMode: legacyMode, syncAsync: false));
+  Target get target => _target ??=
+      _raw.target ?? new NoneTarget(new TargetFlags(legacyMode: legacyMode));
 
   /// Get an outline component that summarizes the SDK, if any.
   // TODO(sigmund): move, this doesn't feel like an "option".
diff --git a/pkg/front_end/test/fasta/expression_test.dart b/pkg/front_end/test/fasta/expression_test.dart
index c2eacd3..0a895c8 100644
--- a/pkg/front_end/test/fasta/expression_test.dart
+++ b/pkg/front_end/test/fasta/expression_test.dart
@@ -388,7 +388,7 @@
   final List<DiagnosticMessage> errors = <DiagnosticMessage>[];
 
   final CompilerOptions optionBuilder = new CompilerOptions()
-    ..target = new VmTarget(new TargetFlags(syncAsync: false))
+    ..target = new VmTarget(new TargetFlags())
     ..verbose = true
     ..fileSystem = fs
     ..sdkSummary = sdkSummary
diff --git a/pkg/front_end/test/fasta/generator_to_string_test.dart b/pkg/front_end/test/fasta/generator_to_string_test.dart
index bb79be5..7580c2a 100644
--- a/pkg/front_end/test/fasta/generator_to_string_test.dart
+++ b/pkg/front_end/test/fasta/generator_to_string_test.dart
@@ -100,11 +100,8 @@
         new KernelTarget(
                 null,
                 false,
-                new DillTarget(
-                    null,
-                    null,
-                    new NoneTarget(
-                        new TargetFlags(legacyMode: true, syncAsync: false))),
+                new DillTarget(null, null,
+                    new NoneTarget(new TargetFlags(legacyMode: true))),
                 null)
             .loader,
         null,
diff --git a/pkg/front_end/test/fasta/incremental_hello_test.dart b/pkg/front_end/test/fasta/incremental_hello_test.dart
index b9fcf5f..1ac768d 100644
--- a/pkg/front_end/test/fasta/incremental_hello_test.dart
+++ b/pkg/front_end/test/fasta/incremental_hello_test.dart
@@ -35,7 +35,7 @@
 test({bool sdkFromSource}) async {
   final CompilerOptions optionBuilder = new CompilerOptions()
     ..packagesFileUri = Uri.base.resolve(".packages")
-    ..target = new VmTarget(new TargetFlags(legacyMode: true, syncAsync: false))
+    ..target = new VmTarget(new TargetFlags(legacyMode: true))
     ..legacyMode = true
     ..onDiagnostic = diagnosticMessageHandler;
 
diff --git a/pkg/front_end/test/fasta/messages_test.dart b/pkg/front_end/test/fasta/messages_test.dart
index 650bcc4..de25e18 100644
--- a/pkg/front_end/test/fasta/messages_test.dart
+++ b/pkg/front_end/test/fasta/messages_test.dart
@@ -461,7 +461,7 @@
         new CompilerOptions()
           ..sdkSummary = computePlatformBinariesLocation(forceBuildDir: true)
               .resolve("vm_platform_strong.dill")
-          ..target = new VmTarget(new TargetFlags(syncAsync: false))
+          ..target = new VmTarget(new TargetFlags())
           ..fileSystem = new HybridFileSystem(suite.fileSystem)
           ..onDiagnostic = messages.add,
         main,
diff --git a/pkg/front_end/test/fasta/super_mixins_test.dart b/pkg/front_end/test/fasta/super_mixins_test.dart
index d15d9d9..03f30af 100644
--- a/pkg/front_end/test/fasta/super_mixins_test.dart
+++ b/pkg/front_end/test/fasta/super_mixins_test.dart
@@ -105,7 +105,7 @@
   var missingSuperMethodNames = new Set<String>();
   var options = new CompilerOptions()
     ..onDiagnostic = _makeDiagnosticMessageHandler(missingSuperMethodNames)
-    ..target = new NoneTargetWithSuperMixins(new TargetFlags(syncAsync: false));
+    ..target = new NoneTargetWithSuperMixins(new TargetFlags());
   await compileScript(testSource, options: options);
   Expect.setEquals(
       const <String>['baz', 'foo', 'quux'], missingSuperMethodNames);
diff --git a/pkg/front_end/test/fasta/testing/suite.dart b/pkg/front_end/test/fasta/testing/suite.dart
index 3e53a80..69fd53d 100644
--- a/pkg/front_end/test/fasta/testing/suite.dart
+++ b/pkg/front_end/test/fasta/testing/suite.dart
@@ -291,11 +291,8 @@
       CompilerContext.current.disableColors();
       Component platform = await context.loadPlatform();
       Ticker ticker = new Ticker();
-      DillTarget dillTarget = new DillTarget(
-          ticker,
-          context.uriTranslator,
-          new TestVmTarget(
-              new TargetFlags(legacyMode: legacyMode, syncAsync: false)));
+      DillTarget dillTarget = new DillTarget(ticker, context.uriTranslator,
+          new TestVmTarget(new TargetFlags(legacyMode: legacyMode)));
       dillTarget.loader.appendLibraries(platform);
       // We create a new URI translator to avoid reading platform libraries from
       // file system.
diff --git a/pkg/front_end/test/fasta/unlinked_scope_test.dart b/pkg/front_end/test/fasta/unlinked_scope_test.dart
index 02cd4b1..e58294c 100644
--- a/pkg/front_end/test/fasta/unlinked_scope_test.dart
+++ b/pkg/front_end/test/fasta/unlinked_scope_test.dart
@@ -49,11 +49,8 @@
             new KernelTarget(
                     null,
                     false,
-                    new DillTarget(
-                        null,
-                        null,
-                        new NoneTarget(new TargetFlags(
-                            legacyMode: true, syncAsync: false))),
+                    new DillTarget(null, null,
+                        new NoneTarget(new TargetFlags(legacyMode: true))),
                     null)
                 .loader,
             null,
diff --git a/pkg/front_end/test/incremental_load_from_dill_test.dart b/pkg/front_end/test/incremental_load_from_dill_test.dart
index a27a78c..8a1495d4 100644
--- a/pkg/front_end/test/incremental_load_from_dill_test.dart
+++ b/pkg/front_end/test/incremental_load_from_dill_test.dart
@@ -356,8 +356,7 @@
   final Uri sdkRoot = computePlatformBinariesLocation(forceBuildDir: true);
   CompilerOptions options = new CompilerOptions()
     ..sdkRoot = sdkRoot
-    ..target =
-        new VmTarget(new TargetFlags(legacyMode: !strong, syncAsync: false))
+    ..target = new VmTarget(new TargetFlags(legacyMode: !strong))
     ..librariesSpecificationUri = Uri.base.resolve("sdk/lib/libraries.json")
     ..onDiagnostic = (DiagnosticMessage message) {
       if (message.severity == Severity.error ||
diff --git a/pkg/front_end/testcases/async_function.dart.legacy.transformed.expect b/pkg/front_end/testcases/async_function.dart.legacy.transformed.expect
index d09ecec..c4a5b51 100644
--- a/pkg/front_end/testcases/async_function.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/async_function.dart.legacy.transformed.expect
@@ -5,7 +5,7 @@
 
 static field core::List<core::String> stringList = <dynamic>["bar"];
 static method asyncString() → asy::Future<core::String> /* originally async */ {
-  final asy::Completer<core::String> :async_completer = asy::Completer::sync<core::String>();
+  final asy::_AsyncAwaitCompleter<core::String> :async_completer = new asy::_AsyncAwaitCompleter::•<core::String>();
   asy::FutureOr<core::String> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -28,11 +28,11 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method asyncString2() → asy::Future<core::String> /* originally async */ {
-  final asy::Completer<core::String> :async_completer = asy::Completer::sync<core::String>();
+  final asy::_AsyncAwaitCompleter<core::String> :async_completer = new asy::_AsyncAwaitCompleter::•<core::String>();
   asy::FutureOr<core::String> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -55,7 +55,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method syncStarString() → core::Iterable<core::String> /* originally sync* */ {
@@ -174,7 +174,7 @@
   return :controller_stream;
 }
 static method main() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -198,6 +198,6 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
diff --git a/pkg/front_end/testcases/async_function.dart.strong.transformed.expect b/pkg/front_end/testcases/async_function.dart.strong.transformed.expect
index e0c9dae..a57a753 100644
--- a/pkg/front_end/testcases/async_function.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/async_function.dart.strong.transformed.expect
@@ -5,7 +5,7 @@
 
 static field core::List<core::String> stringList = <core::String>["bar"];
 static method asyncString() → asy::Future<core::String> /* originally async */ {
-  final asy::Completer<core::String> :async_completer = asy::Completer::sync<core::String>();
+  final asy::_AsyncAwaitCompleter<core::String> :async_completer = new asy::_AsyncAwaitCompleter::•<core::String>();
   asy::FutureOr<core::String> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -28,11 +28,11 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method asyncString2() → asy::Future<core::String> /* originally async */ {
-  final asy::Completer<core::String> :async_completer = asy::Completer::sync<core::String>();
+  final asy::_AsyncAwaitCompleter<core::String> :async_completer = new asy::_AsyncAwaitCompleter::•<core::String>();
   asy::FutureOr<core::String> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -55,7 +55,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method syncStarString() → core::Iterable<core::String> /* originally sync* */ {
@@ -174,7 +174,7 @@
   return :controller_stream;
 }
 static method main() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -198,6 +198,6 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
diff --git a/pkg/front_end/testcases/async_nested.dart.legacy.transformed.expect b/pkg/front_end/testcases/async_nested.dart.legacy.transformed.expect
index 0dc1f7d..ad071a1 100644
--- a/pkg/front_end/testcases/async_nested.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/async_nested.dart.legacy.transformed.expect
@@ -16,7 +16,7 @@
   }
 }
 static method main() → void /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -59,6 +59,6 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
diff --git a/pkg/front_end/testcases/async_nested.dart.strong.transformed.expect b/pkg/front_end/testcases/async_nested.dart.strong.transformed.expect
index f173dfc7..b5b0c4b 100644
--- a/pkg/front_end/testcases/async_nested.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/async_nested.dart.strong.transformed.expect
@@ -16,7 +16,7 @@
   }
 }
 static method main() → void /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -59,6 +59,6 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
diff --git a/pkg/front_end/testcases/await.dart.legacy.transformed.expect b/pkg/front_end/testcases/await.dart.legacy.transformed.expect
index 7693f8c..6a66550 100644
--- a/pkg/front_end/testcases/await.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/await.dart.legacy.transformed.expect
@@ -4,7 +4,7 @@
 import "dart:core" as core;
 
 static method main() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -28,6 +28,6 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
diff --git a/pkg/front_end/testcases/await.dart.strong.transformed.expect b/pkg/front_end/testcases/await.dart.strong.transformed.expect
index 7693f8c..6a66550 100644
--- a/pkg/front_end/testcases/await.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/await.dart.strong.transformed.expect
@@ -4,7 +4,7 @@
 import "dart:core" as core;
 
 static method main() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -28,6 +28,6 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
diff --git a/pkg/front_end/testcases/bug33196.dart.legacy.transformed.expect b/pkg/front_end/testcases/bug33196.dart.legacy.transformed.expect
index cc0de23..8f79612 100644
--- a/pkg/front_end/testcases/bug33196.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/bug33196.dart.legacy.transformed.expect
@@ -8,7 +8,7 @@
   core::print(result.runtimeType);
 }
 static method returnsString() → asy::FutureOr<core::String> /* originally async */ {
-  final asy::Completer<core::String> :async_completer = asy::Completer::sync<core::String>();
+  final asy::_AsyncAwaitCompleter<core::String> :async_completer = new asy::_AsyncAwaitCompleter::•<core::String>();
   asy::FutureOr<core::String> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -31,6 +31,6 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
diff --git a/pkg/front_end/testcases/bug33196.dart.strong.transformed.expect b/pkg/front_end/testcases/bug33196.dart.strong.transformed.expect
index 94661f3..1b395b7 100644
--- a/pkg/front_end/testcases/bug33196.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/bug33196.dart.strong.transformed.expect
@@ -8,7 +8,7 @@
   core::print(result.{core::Object::runtimeType});
 }
 static method returnsString() → asy::FutureOr<core::String> /* originally async */ {
-  final asy::Completer<core::String> :async_completer = asy::Completer::sync<core::String>();
+  final asy::_AsyncAwaitCompleter<core::String> :async_completer = new asy::_AsyncAwaitCompleter::•<core::String>();
   asy::FutureOr<core::String> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -31,6 +31,6 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
diff --git a/pkg/front_end/testcases/bug33206.dart.legacy.transformed.expect b/pkg/front_end/testcases/bug33206.dart.legacy.transformed.expect
index 94af5a5..e19e82a 100644
--- a/pkg/front_end/testcases/bug33206.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/bug33206.dart.legacy.transformed.expect
@@ -19,7 +19,7 @@
   method f(dynamic _) → dynamic {}
 }
 static method f1() → asy::Future<core::List<core::Object>> /* originally async */ {
-  final asy::Completer<core::List<core::Object>> :async_completer = asy::Completer::sync<core::List<core::Object>>();
+  final asy::_AsyncAwaitCompleter<core::List<core::Object>> :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<core::Object>>();
   asy::FutureOr<core::List<core::Object>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -42,13 +42,13 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method f2() → core::List<core::Object>
   return <dynamic>[2];
 static method f3() → asy::Future<core::Object> /* originally async */ {
-  final asy::Completer<core::Object> :async_completer = asy::Completer::sync<core::Object>();
+  final asy::_AsyncAwaitCompleter<core::Object> :async_completer = new asy::_AsyncAwaitCompleter::•<core::Object>();
   asy::FutureOr<core::Object> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -71,11 +71,11 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method foo() → asy::Future<self::X> /* originally async */ {
-  final asy::Completer<self::X> :async_completer = asy::Completer::sync<self::X>();
+  final asy::_AsyncAwaitCompleter<self::X> :async_completer = new asy::_AsyncAwaitCompleter::•<self::X>();
   asy::FutureOr<self::X> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -104,11 +104,11 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → asy::Future<void> /* originally async */ {
-  final asy::Completer<void> :async_completer = asy::Completer::sync<void>();
+  final asy::_AsyncAwaitCompleter<void> :async_completer = new asy::_AsyncAwaitCompleter::•<void>();
   asy::FutureOr<void> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -132,6 +132,6 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
diff --git a/pkg/front_end/testcases/bug33206.dart.strong.transformed.expect b/pkg/front_end/testcases/bug33206.dart.strong.transformed.expect
index 62903f9..217f7b0 100644
--- a/pkg/front_end/testcases/bug33206.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/bug33206.dart.strong.transformed.expect
@@ -19,7 +19,7 @@
   method f(dynamic _) → dynamic {}
 }
 static method f1() → asy::Future<core::List<core::Object>> /* originally async */ {
-  final asy::Completer<core::List<core::Object>> :async_completer = asy::Completer::sync<core::List<core::Object>>();
+  final asy::_AsyncAwaitCompleter<core::List<core::Object>> :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<core::Object>>();
   asy::FutureOr<core::List<core::Object>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -42,13 +42,13 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method f2() → core::List<core::Object>
   return <core::Object>[2];
 static method f3() → asy::Future<core::Object> /* originally async */ {
-  final asy::Completer<core::Object> :async_completer = asy::Completer::sync<core::Object>();
+  final asy::_AsyncAwaitCompleter<core::Object> :async_completer = new asy::_AsyncAwaitCompleter::•<core::Object>();
   asy::FutureOr<core::Object> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -71,11 +71,11 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method foo() → asy::Future<self::X> /* originally async */ {
-  final asy::Completer<self::X> :async_completer = asy::Completer::sync<self::X>();
+  final asy::_AsyncAwaitCompleter<self::X> :async_completer = new asy::_AsyncAwaitCompleter::•<self::X>();
   asy::FutureOr<self::X> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -104,11 +104,11 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → asy::Future<void> /* originally async */ {
-  final asy::Completer<void> :async_completer = asy::Completer::sync<void>();
+  final asy::_AsyncAwaitCompleter<void> :async_completer = new asy::_AsyncAwaitCompleter::•<void>();
   asy::FutureOr<void> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -132,6 +132,6 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
diff --git a/pkg/front_end/testcases/check_deferred_before_args2.dart.legacy.transformed.expect b/pkg/front_end/testcases/check_deferred_before_args2.dart.legacy.transformed.expect
index c4b209d..f04ef3d 100644
--- a/pkg/front_end/testcases/check_deferred_before_args2.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/check_deferred_before_args2.dart.legacy.transformed.expect
@@ -5,7 +5,7 @@
 
 static method main() → dynamic {}
 static method test() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -30,6 +30,6 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
diff --git a/pkg/front_end/testcases/check_deferred_before_args2.dart.strong.transformed.expect b/pkg/front_end/testcases/check_deferred_before_args2.dart.strong.transformed.expect
index 8155d6a..6821c33 100644
--- a/pkg/front_end/testcases/check_deferred_before_args2.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/check_deferred_before_args2.dart.strong.transformed.expect
@@ -6,7 +6,7 @@
 
 static method main() → dynamic {}
 static method test() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -31,6 +31,6 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
diff --git a/pkg/front_end/testcases/future_or_test.dart.legacy.transformed.expect b/pkg/front_end/testcases/future_or_test.dart.legacy.transformed.expect
index 1461a82..e7939ce 100644
--- a/pkg/front_end/testcases/future_or_test.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/future_or_test.dart.legacy.transformed.expect
@@ -16,7 +16,7 @@
     : super core::Object::•()
     ;
   method bar() → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -39,7 +39,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   }
 }
@@ -49,7 +49,7 @@
     : super core::Object::•()
     ;
   method baz() → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -72,7 +72,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   }
 }
diff --git a/pkg/front_end/testcases/future_or_test.dart.strong.transformed.expect b/pkg/front_end/testcases/future_or_test.dart.strong.transformed.expect
index 5ee7d6b..91c8f82 100644
--- a/pkg/front_end/testcases/future_or_test.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/future_or_test.dart.strong.transformed.expect
@@ -16,7 +16,7 @@
     : super core::Object::•()
     ;
   method bar() → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -39,7 +39,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   }
 }
@@ -49,7 +49,7 @@
     : super core::Object::•()
     ;
   method baz() → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -72,7 +72,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   }
 }
diff --git a/pkg/front_end/testcases/inference/async_await.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/async_await.dart.legacy.transformed.expect
index 7e5db5d..939d401 100644
--- a/pkg/front_end/testcases/inference/async_await.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/async_await.dart.legacy.transformed.expect
@@ -9,7 +9,7 @@
     ;
 }
 static method test() → void /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -32,7 +32,7 @@
         asy::FutureOr<self::MyFuture> x8;
         self::MyFuture x9;
         function test0() → dynamic /* originally async */ {
-          final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+          final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
           asy::FutureOr<dynamic> :return_value;
           dynamic :async_stack_trace;
           dynamic :async_op_then;
@@ -55,11 +55,11 @@
           :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);
+          :async_completer.start(:async_op);
           return :async_completer.{asy::Completer::future};
         }
         function test1() → dynamic /* originally async */ {
-          final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+          final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
           asy::FutureOr<dynamic> :return_value;
           dynamic :async_stack_trace;
           dynamic :async_op_then;
@@ -82,11 +82,11 @@
           :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);
+          :async_completer.start(:async_op);
           return :async_completer.{asy::Completer::future};
         }
         function test2() → dynamic /* originally async */ {
-          final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+          final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
           asy::FutureOr<dynamic> :return_value;
           dynamic :async_stack_trace;
           dynamic :async_op_then;
@@ -109,11 +109,11 @@
           :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);
+          :async_completer.start(:async_op);
           return :async_completer.{asy::Completer::future};
         }
         function test3() → dynamic /* originally async */ {
-          final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+          final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
           asy::FutureOr<dynamic> :return_value;
           dynamic :async_stack_trace;
           dynamic :async_op_then;
@@ -136,11 +136,11 @@
           :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);
+          :async_completer.start(:async_op);
           return :async_completer.{asy::Completer::future};
         }
         function test4() → dynamic /* originally async */ {
-          final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+          final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
           asy::FutureOr<dynamic> :return_value;
           dynamic :async_stack_trace;
           dynamic :async_op_then;
@@ -163,11 +163,11 @@
           :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);
+          :async_completer.start(:async_op);
           return :async_completer.{asy::Completer::future};
         }
         function test5() → dynamic /* originally async */ {
-          final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+          final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
           asy::FutureOr<dynamic> :return_value;
           dynamic :async_stack_trace;
           dynamic :async_op_then;
@@ -190,11 +190,11 @@
           :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);
+          :async_completer.start(:async_op);
           return :async_completer.{asy::Completer::future};
         }
         function test6() → dynamic /* originally async */ {
-          final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+          final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
           asy::FutureOr<dynamic> :return_value;
           dynamic :async_stack_trace;
           dynamic :async_op_then;
@@ -217,11 +217,11 @@
           :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);
+          :async_completer.start(:async_op);
           return :async_completer.{asy::Completer::future};
         }
         function test7() → dynamic /* originally async */ {
-          final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+          final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
           asy::FutureOr<dynamic> :return_value;
           dynamic :async_stack_trace;
           dynamic :async_op_then;
@@ -244,11 +244,11 @@
           :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);
+          :async_completer.start(:async_op);
           return :async_completer.{asy::Completer::future};
         }
         function test8() → dynamic /* originally async */ {
-          final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+          final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
           asy::FutureOr<dynamic> :return_value;
           dynamic :async_stack_trace;
           dynamic :async_op_then;
@@ -271,11 +271,11 @@
           :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);
+          :async_completer.start(:async_op);
           return :async_completer.{asy::Completer::future};
         }
         function test9() → dynamic /* originally async */ {
-          final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+          final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
           asy::FutureOr<dynamic> :return_value;
           dynamic :async_stack_trace;
           dynamic :async_op_then;
@@ -298,7 +298,7 @@
           :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);
+          :async_completer.start(:async_op);
           return :async_completer.{asy::Completer::future};
         }
         [yield] let dynamic #t1 = asy::_awaitHelper(x0, :async_op_then, :async_op_error, :async_op) in null;
@@ -331,7 +331,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/async_await.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/async_await.dart.strong.transformed.expect
index beac918..a6dc499 100644
--- a/pkg/front_end/testcases/inference/async_await.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/async_await.dart.strong.transformed.expect
@@ -9,7 +9,7 @@
     ;
 }
 static method test() → void /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -32,7 +32,7 @@
         asy::FutureOr<self::MyFuture> x8;
         self::MyFuture x9;
         function test0() → asy::Future<core::int> /* originally async */ {
-          final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
+          final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
           asy::FutureOr<core::int> :return_value;
           dynamic :async_stack_trace;
           dynamic :async_op_then;
@@ -55,11 +55,11 @@
           :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);
+          :async_completer.start(:async_op);
           return :async_completer.{asy::Completer::future};
         }
         function test1() → asy::Future<core::int> /* originally async */ {
-          final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
+          final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
           asy::FutureOr<core::int> :return_value;
           dynamic :async_stack_trace;
           dynamic :async_op_then;
@@ -82,11 +82,11 @@
           :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);
+          :async_completer.start(:async_op);
           return :async_completer.{asy::Completer::future};
         }
         function test2() → asy::Future<asy::Future<core::int>> /* originally async */ {
-          final asy::Completer<asy::Future<core::int>> :async_completer = asy::Completer::sync<asy::Future<core::int>>();
+          final asy::_AsyncAwaitCompleter<asy::Future<core::int>> :async_completer = new asy::_AsyncAwaitCompleter::•<asy::Future<core::int>>();
           asy::FutureOr<asy::Future<core::int>> :return_value;
           dynamic :async_stack_trace;
           dynamic :async_op_then;
@@ -109,11 +109,11 @@
           :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);
+          :async_completer.start(:async_op);
           return :async_completer.{asy::Completer::future};
         }
         function test3() → asy::Future<asy::FutureOr<core::int>> /* originally async */ {
-          final asy::Completer<asy::FutureOr<core::int>> :async_completer = asy::Completer::sync<asy::FutureOr<core::int>>();
+          final asy::_AsyncAwaitCompleter<asy::FutureOr<core::int>> :async_completer = new asy::_AsyncAwaitCompleter::•<asy::FutureOr<core::int>>();
           asy::FutureOr<asy::FutureOr<core::int>> :return_value;
           dynamic :async_stack_trace;
           dynamic :async_op_then;
@@ -136,11 +136,11 @@
           :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);
+          :async_completer.start(:async_op);
           return :async_completer.{asy::Completer::future};
         }
         function test4() → asy::Future<self::MyFuture> /* originally async */ {
-          final asy::Completer<self::MyFuture> :async_completer = asy::Completer::sync<self::MyFuture>();
+          final asy::_AsyncAwaitCompleter<self::MyFuture> :async_completer = new asy::_AsyncAwaitCompleter::•<self::MyFuture>();
           asy::FutureOr<self::MyFuture> :return_value;
           dynamic :async_stack_trace;
           dynamic :async_op_then;
@@ -163,11 +163,11 @@
           :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);
+          :async_completer.start(:async_op);
           return :async_completer.{asy::Completer::future};
         }
         function test5() → asy::Future<core::int> /* originally async */ {
-          final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
+          final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
           asy::FutureOr<core::int> :return_value;
           dynamic :async_stack_trace;
           dynamic :async_op_then;
@@ -190,11 +190,11 @@
           :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);
+          :async_completer.start(:async_op);
           return :async_completer.{asy::Completer::future};
         }
         function test6() → asy::Future<asy::Future<core::int>> /* originally async */ {
-          final asy::Completer<asy::Future<core::int>> :async_completer = asy::Completer::sync<asy::Future<core::int>>();
+          final asy::_AsyncAwaitCompleter<asy::Future<core::int>> :async_completer = new asy::_AsyncAwaitCompleter::•<asy::Future<core::int>>();
           asy::FutureOr<asy::Future<core::int>> :return_value;
           dynamic :async_stack_trace;
           dynamic :async_op_then;
@@ -217,11 +217,11 @@
           :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);
+          :async_completer.start(:async_op);
           return :async_completer.{asy::Completer::future};
         }
         function test7() → asy::Future<asy::FutureOr<core::int>> /* originally async */ {
-          final asy::Completer<asy::FutureOr<core::int>> :async_completer = asy::Completer::sync<asy::FutureOr<core::int>>();
+          final asy::_AsyncAwaitCompleter<asy::FutureOr<core::int>> :async_completer = new asy::_AsyncAwaitCompleter::•<asy::FutureOr<core::int>>();
           asy::FutureOr<asy::FutureOr<core::int>> :return_value;
           dynamic :async_stack_trace;
           dynamic :async_op_then;
@@ -244,11 +244,11 @@
           :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);
+          :async_completer.start(:async_op);
           return :async_completer.{asy::Completer::future};
         }
         function test8() → asy::Future<self::MyFuture> /* originally async */ {
-          final asy::Completer<self::MyFuture> :async_completer = asy::Completer::sync<self::MyFuture>();
+          final asy::_AsyncAwaitCompleter<self::MyFuture> :async_completer = new asy::_AsyncAwaitCompleter::•<self::MyFuture>();
           asy::FutureOr<self::MyFuture> :return_value;
           dynamic :async_stack_trace;
           dynamic :async_op_then;
@@ -271,11 +271,11 @@
           :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);
+          :async_completer.start(:async_op);
           return :async_completer.{asy::Completer::future};
         }
         function test9() → asy::Future<core::int> /* originally async */ {
-          final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
+          final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
           asy::FutureOr<core::int> :return_value;
           dynamic :async_stack_trace;
           dynamic :async_op_then;
@@ -298,7 +298,7 @@
           :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);
+          :async_completer.start(:async_op);
           return :async_completer.{asy::Completer::future};
         }
         [yield] let dynamic #t1 = asy::_awaitHelper(x0, :async_op_then, :async_op_error, :async_op) in null;
@@ -331,7 +331,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/async_closure_return_type_flatten.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/async_closure_return_type_flatten.dart.legacy.transformed.expect
index 0f3c9ac..32f482b 100644
--- a/pkg/front_end/testcases/inference/async_closure_return_type_flatten.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/async_closure_return_type_flatten.dart.legacy.transformed.expect
@@ -6,7 +6,7 @@
 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> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -29,7 +29,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 };
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/inference/async_closure_return_type_flatten.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/async_closure_return_type_flatten.dart.strong.transformed.expect
index 1959108..f94e9db 100644
--- a/pkg/front_end/testcases/inference/async_closure_return_type_flatten.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/async_closure_return_type_flatten.dart.strong.transformed.expect
@@ -6,7 +6,7 @@
 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> :async_completer = asy::Completer::sync<core::int>();
+  final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
   asy::FutureOr<core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -29,7 +29,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 };
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/inference/async_closure_return_type_future.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/async_closure_return_type_future.dart.legacy.transformed.expect
index a45113d..3f444b6 100644
--- a/pkg/front_end/testcases/inference/async_closure_return_type_future.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/async_closure_return_type_future.dart.legacy.transformed.expect
@@ -3,7 +3,7 @@
 import "dart:async" as asy;
 
 static field dynamic f = () → asy::Future<dynamic> /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -26,7 +26,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 };
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/inference/async_closure_return_type_future.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/async_closure_return_type_future.dart.strong.transformed.expect
index 2c350bc..fb23adf 100644
--- a/pkg/front_end/testcases/inference/async_closure_return_type_future.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/async_closure_return_type_future.dart.strong.transformed.expect
@@ -4,7 +4,7 @@
 import "dart:core" as core;
 
 static field () → asy::Future<core::int> f = () → asy::Future<core::int> /* originally async */ {
-  final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
+  final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
   asy::FutureOr<core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -27,7 +27,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 };
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/inference/async_closure_return_type_future_or.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/async_closure_return_type_future_or.dart.legacy.transformed.expect
index 1c04583..694b2f2 100644
--- a/pkg/front_end/testcases/inference/async_closure_return_type_future_or.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/async_closure_return_type_future_or.dart.legacy.transformed.expect
@@ -6,7 +6,7 @@
 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> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -29,7 +29,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 };
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/inference/async_closure_return_type_future_or.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/async_closure_return_type_future_or.dart.strong.transformed.expect
index 5cc8ee5..b6536b0 100644
--- a/pkg/front_end/testcases/inference/async_closure_return_type_future_or.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/async_closure_return_type_future_or.dart.strong.transformed.expect
@@ -6,7 +6,7 @@
 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> :async_completer = asy::Completer::sync<core::int>();
+  final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
   asy::FutureOr<core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -29,7 +29,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 };
 static method main() → dynamic {
diff --git a/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_futures.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_futures.dart.legacy.transformed.expect
index eeada89..298fc06 100644
--- a/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_futures.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_futures.dart.legacy.transformed.expect
@@ -6,7 +6,7 @@
 
 static method test() → dynamic {
   dynamic f = () → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -35,7 +35,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   };
   asy::Future<core::num> g = f.call();
diff --git a/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_futures.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_futures.dart.strong.transformed.expect
index 1325622..28def78 100644
--- a/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_futures.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_futures.dart.strong.transformed.expect
@@ -6,7 +6,7 @@
 
 static method test() → dynamic {
   () → asy::Future<core::num> f = () → asy::Future<core::num> /* originally async */ {
-    final asy::Completer<core::num> :async_completer = asy::Completer::sync<core::num>();
+    final asy::_AsyncAwaitCompleter<core::num> :async_completer = new asy::_AsyncAwaitCompleter::•<core::num>();
     asy::FutureOr<core::num> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -35,7 +35,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   };
   asy::Future<core::num> g = f.call();
diff --git a/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_values.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_values.dart.legacy.transformed.expect
index e651a4a..860e645 100644
--- a/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_values.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_values.dart.legacy.transformed.expect
@@ -6,7 +6,7 @@
 
 static method test() → dynamic {
   dynamic f = () → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -35,7 +35,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   };
   asy::Future<core::num> g = f.call();
diff --git a/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_values.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_values.dart.strong.transformed.expect
index 4d101fa..3a4d495 100644
--- a/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_values.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/block_bodied_lambdas_async_all_returns_are_values.dart.strong.transformed.expect
@@ -6,7 +6,7 @@
 
 static method test() → dynamic {
   () → asy::Future<core::num> f = () → asy::Future<core::num> /* originally async */ {
-    final asy::Completer<core::num> :async_completer = asy::Completer::sync<core::num>();
+    final asy::_AsyncAwaitCompleter<core::num> :async_completer = new asy::_AsyncAwaitCompleter::•<core::num>();
     asy::FutureOr<core::num> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -35,7 +35,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   };
   asy::Future<core::num> g = f.call();
diff --git a/pkg/front_end/testcases/inference/block_bodied_lambdas_async_mix_of_values_and_futures.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/block_bodied_lambdas_async_mix_of_values_and_futures.dart.legacy.transformed.expect
index d306ab4..128abb0 100644
--- a/pkg/front_end/testcases/inference/block_bodied_lambdas_async_mix_of_values_and_futures.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/block_bodied_lambdas_async_mix_of_values_and_futures.dart.legacy.transformed.expect
@@ -6,7 +6,7 @@
 
 static method test() → dynamic {
   dynamic f = () → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -35,7 +35,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   };
   asy::Future<core::num> g = f.call();
diff --git a/pkg/front_end/testcases/inference/block_bodied_lambdas_async_mix_of_values_and_futures.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/block_bodied_lambdas_async_mix_of_values_and_futures.dart.strong.transformed.expect
index be516f9..85a11ea 100644
--- a/pkg/front_end/testcases/inference/block_bodied_lambdas_async_mix_of_values_and_futures.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/block_bodied_lambdas_async_mix_of_values_and_futures.dart.strong.transformed.expect
@@ -6,7 +6,7 @@
 
 static method test() → dynamic {
   () → asy::Future<core::num> f = () → asy::Future<core::num> /* originally async */ {
-    final asy::Completer<core::num> :async_completer = asy::Completer::sync<core::num>();
+    final asy::_AsyncAwaitCompleter<core::num> :async_completer = new asy::_AsyncAwaitCompleter::•<core::num>();
     asy::FutureOr<core::num> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -35,7 +35,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   };
   asy::Future<core::num> g = f.call();
diff --git a/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async.dart.legacy.transformed.expect
index 7eafe2e..3ebd45f 100644
--- a/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async.dart.legacy.transformed.expect
@@ -4,7 +4,7 @@
 import "dart:core" as core;
 
 static method main() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -17,7 +17,7 @@
       #L1:
       {
         dynamic f = () → asy::Future<dynamic> /* originally async */ {
-          final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+          final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
           asy::FutureOr<dynamic> :return_value;
           dynamic :async_stack_trace;
           dynamic :async_op_then;
@@ -40,7 +40,7 @@
           :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);
+          :async_completer.start(:async_op);
           return :async_completer.{asy::Completer::future};
         };
         asy::Future<dynamic> y = f.call();
@@ -57,6 +57,6 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
diff --git a/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async.dart.strong.transformed.expect
index 510f5e8..aab7652 100644
--- a/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async.dart.strong.transformed.expect
@@ -4,7 +4,7 @@
 import "dart:core" as core;
 
 static method main() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -17,7 +17,7 @@
       #L1:
       {
         () → asy::Future<core::Null> f = () → asy::Future<core::Null> /* originally async */ {
-          final asy::Completer<core::Null> :async_completer = asy::Completer::sync<core::Null>();
+          final asy::_AsyncAwaitCompleter<core::Null> :async_completer = new asy::_AsyncAwaitCompleter::•<core::Null>();
           asy::FutureOr<core::Null> :return_value;
           dynamic :async_stack_trace;
           dynamic :async_op_then;
@@ -40,7 +40,7 @@
           :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);
+          :async_completer.start(:async_op);
           return :async_completer.{asy::Completer::future};
         };
         asy::Future<dynamic> y = f.call();
@@ -57,6 +57,6 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
diff --git a/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async_star.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async_star.dart.legacy.transformed.expect
index 74093d5..35c6546 100644
--- a/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async_star.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async_star.dart.legacy.transformed.expect
@@ -4,7 +4,7 @@
 import "dart:core" as core;
 
 static method main() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -65,6 +65,6 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
diff --git a/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async_star.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async_star.dart.strong.transformed.expect
index 3b73b9c..bb70985 100644
--- a/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async_star.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/block_bodied_lambdas_infer_bottom_async_star.dart.strong.transformed.expect
@@ -4,7 +4,7 @@
 import "dart:core" as core;
 
 static method main() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -65,6 +65,6 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
diff --git a/pkg/front_end/testcases/inference/downwards_inference_async_await.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/downwards_inference_async_await.dart.legacy.transformed.expect
index af02e87..b10f37a 100644
--- a/pkg/front_end/testcases/inference/downwards_inference_async_await.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/downwards_inference_async_await.dart.legacy.transformed.expect
@@ -4,7 +4,7 @@
 import "dart:core" as core;
 
 static method main() → asy::Future<dynamic> /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -31,6 +31,6 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
diff --git a/pkg/front_end/testcases/inference/downwards_inference_async_await.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/downwards_inference_async_await.dart.strong.transformed.expect
index fdda593..64565b5 100644
--- a/pkg/front_end/testcases/inference/downwards_inference_async_await.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/downwards_inference_async_await.dart.strong.transformed.expect
@@ -4,7 +4,7 @@
 import "dart:core" as core;
 
 static method main() → asy::Future<dynamic> /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -31,6 +31,6 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
diff --git a/pkg/front_end/testcases/inference/downwards_inference_for_each.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/downwards_inference_for_each.dart.legacy.transformed.expect
index c6a2b38..4c365f3 100644
--- a/pkg/front_end/testcases/inference/downwards_inference_for_each.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/downwards_inference_for_each.dart.legacy.transformed.expect
@@ -10,7 +10,7 @@
 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> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -168,11 +168,11 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → asy::Future<dynamic> /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -249,6 +249,6 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
diff --git a/pkg/front_end/testcases/inference/downwards_inference_for_each.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/downwards_inference_for_each.dart.strong.transformed.expect
index 60d8dbb..852887c 100644
--- a/pkg/front_end/testcases/inference/downwards_inference_for_each.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/downwards_inference_for_each.dart.strong.transformed.expect
@@ -10,7 +10,7 @@
 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> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -168,11 +168,11 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → asy::Future<dynamic> /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -249,6 +249,6 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
diff --git a/pkg/front_end/testcases/inference/for_each_downcast_iterable.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/for_each_downcast_iterable.dart.legacy.transformed.expect
index 46d4a06..70c1eb6 100644
--- a/pkg/front_end/testcases/inference/for_each_downcast_iterable.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/for_each_downcast_iterable.dart.legacy.transformed.expect
@@ -4,7 +4,7 @@
 import "dart:core" as core;
 
 static method test() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -84,7 +84,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/for_each_downcast_iterable.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/for_each_downcast_iterable.dart.strong.transformed.expect
index abfce65..9572d11 100644
--- a/pkg/front_end/testcases/inference/for_each_downcast_iterable.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/for_each_downcast_iterable.dart.strong.transformed.expect
@@ -4,7 +4,7 @@
 import "dart:core" as core;
 
 static method test() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -84,7 +84,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/future_then.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_then.dart.legacy.transformed.expect
index 0011b02..2523367 100644
--- a/pkg/front_end/testcases/inference/future_then.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then.dart.legacy.transformed.expect
@@ -24,7 +24,7 @@
 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> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -49,11 +49,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t2 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -78,11 +78,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t3 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -105,11 +105,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t4 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -132,7 +132,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t5 = f.then((dynamic _) → dynamic => asy::Future::value<core::int>(3));
@@ -140,7 +140,7 @@
     return asy::Future::value<core::int>(3);
   });
   asy::Future<core::int> t7 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -163,11 +163,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t8 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -190,7 +190,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
 }
diff --git a/pkg/front_end/testcases/inference/future_then.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_then.dart.strong.transformed.expect
index 804cb3b..cfca0bf 100644
--- a/pkg/front_end/testcases/inference/future_then.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then.dart.strong.transformed.expect
@@ -24,7 +24,7 @@
 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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -49,11 +49,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -78,11 +78,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -105,11 +105,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -132,7 +132,7 @@
     :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);
+    :async_completer.start(:async_op);
     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));
@@ -140,7 +140,7 @@
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -163,11 +163,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -190,7 +190,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
 }
diff --git a/pkg/front_end/testcases/inference/future_then_2.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_then_2.dart.legacy.transformed.expect
index b7670ca..5305928 100644
--- a/pkg/front_end/testcases/inference/future_then_2.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_2.dart.legacy.transformed.expect
@@ -24,7 +24,7 @@
 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> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -49,11 +49,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t2 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -78,11 +78,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t3 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -105,11 +105,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t4 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -132,7 +132,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t5 = f.then((dynamic _) → dynamic => new self::MyFuture::value<core::int>(3));
@@ -140,7 +140,7 @@
     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> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -163,11 +163,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t8 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -190,7 +190,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
 }
diff --git a/pkg/front_end/testcases/inference/future_then_2.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_then_2.dart.strong.transformed.expect
index 0af6f19..16a1cda 100644
--- a/pkg/front_end/testcases/inference/future_then_2.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_2.dart.strong.transformed.expect
@@ -24,7 +24,7 @@
 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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -49,11 +49,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -78,11 +78,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -105,11 +105,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -132,7 +132,7 @@
     :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);
+    :async_completer.start(:async_op);
     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));
@@ -140,7 +140,7 @@
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -163,11 +163,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -190,7 +190,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
 }
diff --git a/pkg/front_end/testcases/inference/future_then_3.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_then_3.dart.legacy.transformed.expect
index 27b7116..a8a5bcf 100644
--- a/pkg/front_end/testcases/inference/future_then_3.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_3.dart.legacy.transformed.expect
@@ -24,7 +24,7 @@
 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> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -49,11 +49,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t2 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -78,11 +78,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t3 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -105,11 +105,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t4 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -132,7 +132,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t5 = f.then((dynamic _) → dynamic => asy::Future::value<core::int>(3));
@@ -140,7 +140,7 @@
     return asy::Future::value<core::int>(3);
   });
   self::MyFuture<core::int> t7 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -163,11 +163,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t8 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -190,7 +190,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
 }
diff --git a/pkg/front_end/testcases/inference/future_then_3.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_then_3.dart.strong.transformed.expect
index 4893183..ebec13e 100644
--- a/pkg/front_end/testcases/inference/future_then_3.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_3.dart.strong.transformed.expect
@@ -24,7 +24,7 @@
 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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -49,11 +49,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -78,11 +78,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -105,11 +105,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -132,7 +132,7 @@
     :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);
+    :async_completer.start(:async_op);
     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));
@@ -140,7 +140,7 @@
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -163,11 +163,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -190,7 +190,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
 }
diff --git a/pkg/front_end/testcases/inference/future_then_4.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_then_4.dart.legacy.transformed.expect
index 6429f8a..ec60686 100644
--- a/pkg/front_end/testcases/inference/future_then_4.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_4.dart.legacy.transformed.expect
@@ -24,7 +24,7 @@
 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> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -49,11 +49,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t2 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -78,11 +78,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t3 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -105,11 +105,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t4 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -132,7 +132,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t5 = f.then((dynamic _) → dynamic => new self::MyFuture::value<core::int>(3));
@@ -140,7 +140,7 @@
     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> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -163,11 +163,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t8 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -190,7 +190,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
 }
diff --git a/pkg/front_end/testcases/inference/future_then_4.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_then_4.dart.strong.transformed.expect
index b063fca..b9f26c5 100644
--- a/pkg/front_end/testcases/inference/future_then_4.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_4.dart.strong.transformed.expect
@@ -24,7 +24,7 @@
 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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -49,11 +49,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -78,11 +78,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -105,11 +105,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -132,7 +132,7 @@
     :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);
+    :async_completer.start(:async_op);
     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));
@@ -140,7 +140,7 @@
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -163,11 +163,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -190,7 +190,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
 }
diff --git a/pkg/front_end/testcases/inference/future_then_5.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_then_5.dart.legacy.transformed.expect
index 3d8e9145..3652669 100644
--- a/pkg/front_end/testcases/inference/future_then_5.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_5.dart.legacy.transformed.expect
@@ -24,7 +24,7 @@
 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> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -49,11 +49,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t2 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -78,11 +78,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t3 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -105,11 +105,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t4 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -132,7 +132,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t5 = f.then((dynamic _) → dynamic => new self::MyFuture::value<core::int>(3));
@@ -140,7 +140,7 @@
     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> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -163,11 +163,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t8 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -190,7 +190,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
 }
diff --git a/pkg/front_end/testcases/inference/future_then_5.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_then_5.dart.strong.transformed.expect
index 84c5216..aa2b0b1 100644
--- a/pkg/front_end/testcases/inference/future_then_5.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_5.dart.strong.transformed.expect
@@ -24,7 +24,7 @@
 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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -49,11 +49,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -78,11 +78,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -105,11 +105,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -132,7 +132,7 @@
     :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);
+    :async_completer.start(:async_op);
     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));
@@ -140,7 +140,7 @@
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -163,11 +163,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -190,7 +190,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
 }
diff --git a/pkg/front_end/testcases/inference/future_then_6.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_then_6.dart.legacy.transformed.expect
index 62b8c37..df4e351 100644
--- a/pkg/front_end/testcases/inference/future_then_6.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_6.dart.legacy.transformed.expect
@@ -24,7 +24,7 @@
 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> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -49,11 +49,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t2 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -78,11 +78,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t3 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -105,11 +105,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t4 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -132,7 +132,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t5 = f.then((dynamic _) → dynamic => asy::Future::value<core::int>(3));
@@ -140,7 +140,7 @@
     return asy::Future::value<core::int>(3);
   });
   asy::Future<core::int> t7 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -163,11 +163,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t8 = f.then((dynamic _) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -190,7 +190,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
 }
diff --git a/pkg/front_end/testcases/inference/future_then_6.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_then_6.dart.strong.transformed.expect
index 22c3d9c..3895fa1 100644
--- a/pkg/front_end/testcases/inference/future_then_6.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_6.dart.strong.transformed.expect
@@ -24,7 +24,7 @@
 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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -49,11 +49,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -78,11 +78,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -105,11 +105,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -132,7 +132,7 @@
     :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);
+    :async_completer.start(:async_op);
     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));
@@ -140,7 +140,7 @@
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -163,11 +163,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -190,7 +190,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
 }
diff --git a/pkg/front_end/testcases/inference/future_then_conditional.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_then_conditional.dart.legacy.transformed.expect
index 1886dfc..d665857 100644
--- a/pkg/front_end/testcases/inference/future_then_conditional.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_conditional.dart.legacy.transformed.expect
@@ -24,7 +24,7 @@
 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> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -56,11 +56,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t2 = f.then((dynamic x) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -85,7 +85,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t5 = f.then((dynamic x) → dynamic => x ? 2 : asy::Future::value<core::int>(3));
diff --git a/pkg/front_end/testcases/inference/future_then_conditional.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_then_conditional.dart.strong.transformed.expect
index ba028aa..acbce4c 100644
--- a/pkg/front_end/testcases/inference/future_then_conditional.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_conditional.dart.strong.transformed.expect
@@ -24,7 +24,7 @@
 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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -56,11 +56,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -85,7 +85,7 @@
     :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);
+    :async_completer.start(:async_op);
     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>);
diff --git a/pkg/front_end/testcases/inference/future_then_conditional_2.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_then_conditional_2.dart.legacy.transformed.expect
index 85a1122..cae1f2d 100644
--- a/pkg/front_end/testcases/inference/future_then_conditional_2.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_conditional_2.dart.legacy.transformed.expect
@@ -24,7 +24,7 @@
 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> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -56,11 +56,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t2 = f.then((dynamic x) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -85,7 +85,7 @@
     :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);
+    :async_completer.start(:async_op);
     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));
diff --git a/pkg/front_end/testcases/inference/future_then_conditional_2.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_then_conditional_2.dart.strong.transformed.expect
index a7e329f..3f3e26c 100644
--- a/pkg/front_end/testcases/inference/future_then_conditional_2.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_conditional_2.dart.strong.transformed.expect
@@ -24,7 +24,7 @@
 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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -56,11 +56,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -85,7 +85,7 @@
     :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);
+    :async_completer.start(:async_op);
     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>);
diff --git a/pkg/front_end/testcases/inference/future_then_conditional_3.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_then_conditional_3.dart.legacy.transformed.expect
index 75321b8..2288861 100644
--- a/pkg/front_end/testcases/inference/future_then_conditional_3.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_conditional_3.dart.legacy.transformed.expect
@@ -24,7 +24,7 @@
 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> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -56,11 +56,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t2 = f.then((dynamic x) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -85,7 +85,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t5 = f.then((dynamic x) → dynamic => x ? 2 : asy::Future::value<core::int>(3));
diff --git a/pkg/front_end/testcases/inference/future_then_conditional_3.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_then_conditional_3.dart.strong.transformed.expect
index 7471d69..6e76891 100644
--- a/pkg/front_end/testcases/inference/future_then_conditional_3.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_conditional_3.dart.strong.transformed.expect
@@ -24,7 +24,7 @@
 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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -56,11 +56,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -85,7 +85,7 @@
     :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);
+    :async_completer.start(:async_op);
     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>);
diff --git a/pkg/front_end/testcases/inference/future_then_conditional_4.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_then_conditional_4.dart.legacy.transformed.expect
index 9b1a087..97a50ab 100644
--- a/pkg/front_end/testcases/inference/future_then_conditional_4.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_conditional_4.dart.legacy.transformed.expect
@@ -24,7 +24,7 @@
 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> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -56,11 +56,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   self::MyFuture<core::int> t2 = f.then((dynamic x) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -85,7 +85,7 @@
     :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);
+    :async_completer.start(:async_op);
     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));
diff --git a/pkg/front_end/testcases/inference/future_then_conditional_4.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_then_conditional_4.dart.strong.transformed.expect
index 6c13a80..c07cdcb 100644
--- a/pkg/front_end/testcases/inference/future_then_conditional_4.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_conditional_4.dart.strong.transformed.expect
@@ -24,7 +24,7 @@
 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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -56,11 +56,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -85,7 +85,7 @@
     :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);
+    :async_completer.start(:async_op);
     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>);
diff --git a/pkg/front_end/testcases/inference/future_then_conditional_5.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_then_conditional_5.dart.legacy.transformed.expect
index 2c23aa4..c58e4b1 100644
--- a/pkg/front_end/testcases/inference/future_then_conditional_5.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_conditional_5.dart.legacy.transformed.expect
@@ -24,7 +24,7 @@
 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> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -56,11 +56,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t2 = f.then((dynamic x) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -85,7 +85,7 @@
     :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);
+    :async_completer.start(:async_op);
     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));
diff --git a/pkg/front_end/testcases/inference/future_then_conditional_5.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_then_conditional_5.dart.strong.transformed.expect
index a937bf0..a74751a 100644
--- a/pkg/front_end/testcases/inference/future_then_conditional_5.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_conditional_5.dart.strong.transformed.expect
@@ -24,7 +24,7 @@
 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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -56,11 +56,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -85,7 +85,7 @@
     :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);
+    :async_completer.start(:async_op);
     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>);
diff --git a/pkg/front_end/testcases/inference/future_then_conditional_6.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_then_conditional_6.dart.legacy.transformed.expect
index 7e89366..69471c1 100644
--- a/pkg/front_end/testcases/inference/future_then_conditional_6.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_conditional_6.dart.legacy.transformed.expect
@@ -24,7 +24,7 @@
 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> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -56,11 +56,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t2 = f.then((dynamic x) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -85,7 +85,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t5 = f.then((dynamic x) → dynamic => x ? 2 : asy::Future::value<core::int>(3));
diff --git a/pkg/front_end/testcases/inference/future_then_conditional_6.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_then_conditional_6.dart.strong.transformed.expect
index 1f05b11..16db4a6 100644
--- a/pkg/front_end/testcases/inference/future_then_conditional_6.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_conditional_6.dart.strong.transformed.expect
@@ -24,7 +24,7 @@
 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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -56,11 +56,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -85,7 +85,7 @@
     :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);
+    :async_completer.start(:async_op);
     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>);
diff --git a/pkg/front_end/testcases/inference/future_then_ifNull.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_then_ifNull.dart.legacy.transformed.expect
index 204e5f2..816cc71 100644
--- a/pkg/front_end/testcases/inference/future_then_ifNull.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_ifNull.dart.legacy.transformed.expect
@@ -24,7 +24,7 @@
 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> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -57,11 +57,11 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   });
   asy::Future<core::int> t2 = f.then((dynamic x) → asy::Future<dynamic> /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -86,7 +86,7 @@
     :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);
+    :async_completer.start(:async_op);
     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);
diff --git a/pkg/front_end/testcases/inference/future_then_ifNull.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_then_ifNull.dart.strong.transformed.expect
index d5c32ce..aa278ac 100644
--- a/pkg/front_end/testcases/inference/future_then_ifNull.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_then_ifNull.dart.strong.transformed.expect
@@ -24,7 +24,7 @@
 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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -57,11 +57,11 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -86,7 +86,7 @@
     :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);
+    :async_completer.start(:async_op);
     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>);
diff --git a/pkg/front_end/testcases/inference/future_union_async_conditional.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_union_async_conditional.dart.legacy.transformed.expect
index 52f6962..23aa903 100644
--- a/pkg/front_end/testcases/inference/future_union_async_conditional.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_union_async_conditional.dart.legacy.transformed.expect
@@ -22,7 +22,7 @@
     return this.{self::MyFuture::noSuchMethod}(new core::_InvocationMirror::_withType(#asStream, 0, const <core::Type>[], const <dynamic>[], core::Map::unmodifiable<core::Symbol, dynamic>(const <core::Symbol, dynamic>{}))) as{TypeError} asy::Stream<self::MyFuture::T>;
 }
 static method g1(core::bool x) → asy::Future<core::int> /* originally async */ {
-  final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
+  final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
   asy::FutureOr<core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -45,11 +45,11 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method g2(core::bool x) → asy::Future<core::int> /* originally async */ {
-  final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
+  final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
   asy::FutureOr<core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -72,11 +72,11 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method g3(core::bool x) → asy::Future<core::int> /* originally async */ {
-  final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
+  final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
   asy::FutureOr<core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -100,7 +100,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/future_union_async_conditional.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_union_async_conditional.dart.strong.transformed.expect
index d27c725..a0d28bb1 100644
--- a/pkg/front_end/testcases/inference/future_union_async_conditional.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_union_async_conditional.dart.strong.transformed.expect
@@ -22,7 +22,7 @@
     return this.{self::MyFuture::noSuchMethod}(new core::_InvocationMirror::_withType(#asStream, 0, const <core::Type>[], const <dynamic>[], core::Map::unmodifiable<core::Symbol, dynamic>(const <core::Symbol, dynamic>{}))) as{TypeError} asy::Stream<self::MyFuture::T>;
 }
 static method g1(core::bool x) → asy::Future<core::int> /* originally async */ {
-  final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
+  final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
   asy::FutureOr<core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -45,11 +45,11 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method g2(core::bool x) → asy::Future<core::int> /* originally async */ {
-  final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
+  final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
   asy::FutureOr<core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -72,11 +72,11 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method g3(core::bool x) → asy::Future<core::int> /* originally async */ {
-  final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
+  final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
   asy::FutureOr<core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -100,7 +100,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/future_union_async_conditional_2.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_union_async_conditional_2.dart.legacy.transformed.expect
index f82b48c..f292acd 100644
--- a/pkg/front_end/testcases/inference/future_union_async_conditional_2.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_union_async_conditional_2.dart.legacy.transformed.expect
@@ -22,7 +22,7 @@
     return this.{self::MyFuture::noSuchMethod}(new core::_InvocationMirror::_withType(#asStream, 0, const <core::Type>[], const <dynamic>[], core::Map::unmodifiable<core::Symbol, dynamic>(const <core::Symbol, dynamic>{}))) as{TypeError} asy::Stream<self::MyFuture::T>;
 }
 static method g1(core::bool x) → asy::Future<core::int> /* originally async */ {
-  final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
+  final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
   asy::FutureOr<core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -45,11 +45,11 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method g2(core::bool x) → asy::Future<core::int> /* originally async */ {
-  final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
+  final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
   asy::FutureOr<core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -72,11 +72,11 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method g3(core::bool x) → asy::Future<core::int> /* originally async */ {
-  final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
+  final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
   asy::FutureOr<core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -100,7 +100,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/future_union_async_conditional_2.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_union_async_conditional_2.dart.strong.transformed.expect
index 0d01746..84da7bd 100644
--- a/pkg/front_end/testcases/inference/future_union_async_conditional_2.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_union_async_conditional_2.dart.strong.transformed.expect
@@ -22,7 +22,7 @@
     return this.{self::MyFuture::noSuchMethod}(new core::_InvocationMirror::_withType(#asStream, 0, const <core::Type>[], const <dynamic>[], core::Map::unmodifiable<core::Symbol, dynamic>(const <core::Symbol, dynamic>{}))) as{TypeError} asy::Stream<self::MyFuture::T>;
 }
 static method g1(core::bool x) → asy::Future<core::int> /* originally async */ {
-  final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
+  final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
   asy::FutureOr<core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -45,11 +45,11 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method g2(core::bool x) → asy::Future<core::int> /* originally async */ {
-  final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
+  final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
   asy::FutureOr<core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -72,11 +72,11 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method g3(core::bool x) → asy::Future<core::int> /* originally async */ {
-  final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
+  final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
   asy::FutureOr<core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -100,7 +100,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/future_union_downwards.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_union_downwards.dart.legacy.transformed.expect
index c60fde1..62fcaa6 100644
--- a/pkg/front_end/testcases/inference/future_union_downwards.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_union_downwards.dart.legacy.transformed.expect
@@ -25,7 +25,7 @@
 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>> :async_completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::_AsyncAwaitCompleter<core::List<core::int>> :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -48,11 +48,11 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method g3() → asy::Future<core::List<core::int>> /* originally async */ {
-  final asy::Completer<core::List<core::int>> :async_completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::_AsyncAwaitCompleter<core::List<core::int>> :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -75,7 +75,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/future_union_downwards.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_union_downwards.dart.strong.transformed.expect
index 0ad3306..53247c8 100644
--- a/pkg/front_end/testcases/inference/future_union_downwards.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_union_downwards.dart.strong.transformed.expect
@@ -29,7 +29,7 @@
                                            ^" in "hi" as{TypeError} asy::FutureOr<core::int>));
 static field asy::Future<core::List<core::int>> t2 = self::f.{self::MyFuture::then}<core::List<core::int>>((dynamic _) → core::List<core::int> => <core::int>[3]);
 static method g2() → asy::Future<core::List<core::int>> /* originally async */ {
-  final asy::Completer<core::List<core::int>> :async_completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::_AsyncAwaitCompleter<core::List<core::int>> :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -52,11 +52,11 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method g3() → asy::Future<core::List<core::int>> /* originally async */ {
-  final asy::Completer<core::List<core::int>> :async_completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::_AsyncAwaitCompleter<core::List<core::int>> :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -79,7 +79,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/future_union_downwards_2.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_union_downwards_2.dart.legacy.transformed.expect
index b4d3d28..a332fc2 100644
--- a/pkg/front_end/testcases/inference/future_union_downwards_2.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_union_downwards_2.dart.legacy.transformed.expect
@@ -25,7 +25,7 @@
 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>> :async_completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::_AsyncAwaitCompleter<core::List<core::int>> :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -48,11 +48,11 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method g3() → asy::Future<core::List<core::int>> /* originally async */ {
-  final asy::Completer<core::List<core::int>> :async_completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::_AsyncAwaitCompleter<core::List<core::int>> :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -75,7 +75,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/future_union_downwards_2.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_union_downwards_2.dart.strong.transformed.expect
index e2b3327..1e11465 100644
--- a/pkg/front_end/testcases/inference/future_union_downwards_2.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_union_downwards_2.dart.strong.transformed.expect
@@ -25,7 +25,7 @@
 static field 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>> :async_completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::_AsyncAwaitCompleter<core::List<core::int>> :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -48,11 +48,11 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method g3() → asy::Future<core::List<core::int>> /* originally async */ {
-  final asy::Completer<core::List<core::int>> :async_completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::_AsyncAwaitCompleter<core::List<core::int>> :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -75,7 +75,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/future_union_downwards_3.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_union_downwards_3.dart.legacy.transformed.expect
index 125fd56..704909d 100644
--- a/pkg/front_end/testcases/inference/future_union_downwards_3.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_union_downwards_3.dart.legacy.transformed.expect
@@ -25,7 +25,7 @@
 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>> :async_completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::_AsyncAwaitCompleter<core::List<core::int>> :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -48,11 +48,11 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method g3() → asy::Future<core::List<core::int>> /* originally async */ {
-  final asy::Completer<core::List<core::int>> :async_completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::_AsyncAwaitCompleter<core::List<core::int>> :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -75,7 +75,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/future_union_downwards_3.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_union_downwards_3.dart.strong.transformed.expect
index acd3be5..3e0356f 100644
--- a/pkg/front_end/testcases/inference/future_union_downwards_3.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_union_downwards_3.dart.strong.transformed.expect
@@ -29,7 +29,7 @@
                                            ^" in "hi" as{TypeError} asy::FutureOr<core::int>));
 static field asy::Future<core::List<core::int>> t2 = self::f.{asy::Future::then}<core::List<core::int>>((dynamic _) → core::List<core::int> => <core::int>[3]);
 static method g2() → asy::Future<core::List<core::int>> /* originally async */ {
-  final asy::Completer<core::List<core::int>> :async_completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::_AsyncAwaitCompleter<core::List<core::int>> :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -52,11 +52,11 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method g3() → asy::Future<core::List<core::int>> /* originally async */ {
-  final asy::Completer<core::List<core::int>> :async_completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::_AsyncAwaitCompleter<core::List<core::int>> :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -79,7 +79,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/future_union_downwards_4.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_union_downwards_4.dart.legacy.transformed.expect
index 50b3bb1..598ecd1 100644
--- a/pkg/front_end/testcases/inference/future_union_downwards_4.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_union_downwards_4.dart.legacy.transformed.expect
@@ -25,7 +25,7 @@
 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>> :async_completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::_AsyncAwaitCompleter<core::List<core::int>> :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -48,11 +48,11 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method g3() → asy::Future<core::List<core::int>> /* originally async */ {
-  final asy::Completer<core::List<core::int>> :async_completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::_AsyncAwaitCompleter<core::List<core::int>> :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -75,7 +75,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/future_union_downwards_4.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_union_downwards_4.dart.strong.transformed.expect
index 918aaab..4232dc3 100644
--- a/pkg/front_end/testcases/inference/future_union_downwards_4.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_union_downwards_4.dart.strong.transformed.expect
@@ -25,7 +25,7 @@
 static field asy::Future<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>> :async_completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::_AsyncAwaitCompleter<core::List<core::int>> :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -48,11 +48,11 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method g3() → asy::Future<core::List<core::int>> /* originally async */ {
-  final asy::Completer<core::List<core::int>> :async_completer = asy::Completer::sync<core::List<core::int>>();
+  final asy::_AsyncAwaitCompleter<core::List<core::int>> :async_completer = new asy::_AsyncAwaitCompleter::•<core::List<core::int>>();
   asy::FutureOr<core::List<core::int>> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -75,7 +75,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_future_return.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_future_return.dart.legacy.transformed.expect
index 58c7e21..c0244b3 100644
--- a/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_future_return.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_future_return.dart.legacy.transformed.expect
@@ -9,7 +9,7 @@
     ;
 }
 static method foo() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -35,7 +35,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_future_return.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_future_return.dart.strong.transformed.expect
index dd2c304..45afa71 100644
--- a/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_future_return.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_future_return.dart.strong.transformed.expect
@@ -9,7 +9,7 @@
     ;
 }
 static method foo() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -35,7 +35,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_generic_return.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_generic_return.dart.legacy.transformed.expect
index 6b4820f..fc9ead3 100644
--- a/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_generic_return.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_generic_return.dart.legacy.transformed.expect
@@ -6,7 +6,7 @@
 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> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -31,7 +31,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_generic_return.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_generic_return.dart.strong.transformed.expect
index 8a4ec7e..8e23bd8 100644
--- a/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_generic_return.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_union_downwards_generic_method_with_generic_return.dart.strong.transformed.expect
@@ -6,7 +6,7 @@
 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> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -31,7 +31,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/future_union_upwards_generic_methods.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/future_union_upwards_generic_methods.dart.legacy.transformed.expect
index a8cd981..f6baa93 100644
--- a/pkg/front_end/testcases/inference/future_union_upwards_generic_methods.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_union_upwards_generic_methods.dart.legacy.transformed.expect
@@ -19,7 +19,7 @@
     ;
 }
 static method main() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -50,6 +50,6 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
diff --git a/pkg/front_end/testcases/inference/future_union_upwards_generic_methods.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/future_union_upwards_generic_methods.dart.strong.transformed.expect
index 160256c..e55e2bc 100644
--- a/pkg/front_end/testcases/inference/future_union_upwards_generic_methods.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/future_union_upwards_generic_methods.dart.strong.transformed.expect
@@ -19,7 +19,7 @@
     ;
 }
 static method main() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -50,6 +50,6 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
diff --git a/pkg/front_end/testcases/inference/infer_local_function_return_type.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/infer_local_function_return_type.dart.legacy.transformed.expect
index 7e23d3a..256e504 100644
--- a/pkg/front_end/testcases/inference/infer_local_function_return_type.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_local_function_return_type.dart.legacy.transformed.expect
@@ -7,7 +7,7 @@
   function f0() → dynamic
     return 42;
   function f1() → dynamic /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -30,14 +30,14 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   }
   function f2() → dynamic {
     return 42;
   }
   function f3() → dynamic /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -60,7 +60,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   }
   function f4() → dynamic /* originally sync* */ {
diff --git a/pkg/front_end/testcases/inference/infer_local_function_return_type.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/infer_local_function_return_type.dart.strong.transformed.expect
index 7946c1c..a6f275f 100644
--- a/pkg/front_end/testcases/inference/infer_local_function_return_type.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_local_function_return_type.dart.strong.transformed.expect
@@ -7,7 +7,7 @@
   function f0() → core::int
     return 42;
   function f1() → asy::Future<core::int> /* originally async */ {
-    final asy::Completer<core::int> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -30,14 +30,14 @@
     :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);
+    :async_completer.start(:async_op);
     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> :async_completer = asy::Completer::sync<core::int>();
+    final asy::_AsyncAwaitCompleter<core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<core::int>();
     asy::FutureOr<core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -60,7 +60,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   }
   function f4() → core::Iterable<core::int> /* originally sync* */ {
diff --git a/pkg/front_end/testcases/inference/infer_types_on_loop_indices_for_each_loop_async.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/infer_types_on_loop_indices_for_each_loop_async.dart.legacy.transformed.expect
index 0893769..22b3803 100644
--- a/pkg/front_end/testcases/inference/infer_types_on_loop_indices_for_each_loop_async.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_types_on_loop_indices_for_each_loop_async.dart.legacy.transformed.expect
@@ -14,7 +14,7 @@
     : super core::Object::•()
     ;
   method foo(self::Bar::T t) → dynamic /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -64,7 +64,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   }
 }
@@ -73,7 +73,7 @@
     : super core::Object::•()
     ;
   method foo(self::Baz::S t) → dynamic /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -124,7 +124,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   }
 }
@@ -133,7 +133,7 @@
     return null;
 }
 static method test() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -339,7 +339,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/infer_types_on_loop_indices_for_each_loop_async.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/infer_types_on_loop_indices_for_each_loop_async.dart.strong.transformed.expect
index 10ec7fe..d01610c 100644
--- a/pkg/front_end/testcases/inference/infer_types_on_loop_indices_for_each_loop_async.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/infer_types_on_loop_indices_for_each_loop_async.dart.strong.transformed.expect
@@ -14,7 +14,7 @@
     : super core::Object::•()
     ;
   method foo(generic-covariant-impl self::Bar::T t) → dynamic /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -67,7 +67,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   }
 }
@@ -76,7 +76,7 @@
     : super core::Object::•()
     ;
   method foo(generic-covariant-impl self::Baz::S t) → dynamic /* originally async */ {
-    final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+    final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
     asy::FutureOr<dynamic> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -130,7 +130,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   }
 }
@@ -139,7 +139,7 @@
     return null;
 }
 static method test() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -361,7 +361,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/local_return_and_yield.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/local_return_and_yield.dart.legacy.transformed.expect
index 0460a17..a138755 100644
--- a/pkg/front_end/testcases/inference/local_return_and_yield.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/local_return_and_yield.dart.legacy.transformed.expect
@@ -9,7 +9,7 @@
     return (dynamic x) → dynamic => x;
   }
   function b() → asy::Future<(core::int) → core::int> /* originally async */ {
-    final asy::Completer<(core::int) → core::int> :async_completer = asy::Completer::sync<(core::int) → core::int>();
+    final asy::_AsyncAwaitCompleter<(core::int) → core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<(core::int) → core::int>();
     asy::FutureOr<(core::int) → core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -32,7 +32,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   }
   function c() → core::Iterable<(core::int) → core::int> /* originally sync* */ {
diff --git a/pkg/front_end/testcases/inference/local_return_and_yield.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/local_return_and_yield.dart.strong.transformed.expect
index 198327c..bba0bec 100644
--- a/pkg/front_end/testcases/inference/local_return_and_yield.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/local_return_and_yield.dart.strong.transformed.expect
@@ -9,7 +9,7 @@
     return (core::int x) → core::int => x;
   }
   function b() → asy::Future<(core::int) → core::int> /* originally async */ {
-    final asy::Completer<(core::int) → core::int> :async_completer = asy::Completer::sync<(core::int) → core::int>();
+    final asy::_AsyncAwaitCompleter<(core::int) → core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<(core::int) → core::int>();
     asy::FutureOr<(core::int) → core::int> :return_value;
     dynamic :async_stack_trace;
     dynamic :async_op_then;
@@ -36,7 +36,7 @@
     :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);
+    :async_completer.start(:async_op);
     return :async_completer.{asy::Completer::future};
   }
   function c() → core::Iterable<(core::int) → core::int> /* originally sync* */ {
diff --git a/pkg/front_end/testcases/inference/top_level_return_and_yield.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference/top_level_return_and_yield.dart.legacy.transformed.expect
index c955da7..5058c0e 100644
--- a/pkg/front_end/testcases/inference/top_level_return_and_yield.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference/top_level_return_and_yield.dart.legacy.transformed.expect
@@ -8,7 +8,7 @@
   return (dynamic x) → dynamic => x;
 }
 static method b() → asy::Future<(core::int) → core::int> /* originally async */ {
-  final asy::Completer<(core::int) → core::int> :async_completer = asy::Completer::sync<(core::int) → core::int>();
+  final asy::_AsyncAwaitCompleter<(core::int) → core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<(core::int) → core::int>();
   asy::FutureOr<(core::int) → core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -31,7 +31,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method c() → core::Iterable<(core::int) → core::int> /* originally sync* */ {
diff --git a/pkg/front_end/testcases/inference/top_level_return_and_yield.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/top_level_return_and_yield.dart.strong.transformed.expect
index e548d63..ae67a0b 100644
--- a/pkg/front_end/testcases/inference/top_level_return_and_yield.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/top_level_return_and_yield.dart.strong.transformed.expect
@@ -8,7 +8,7 @@
   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> :async_completer = asy::Completer::sync<(core::int) → core::int>();
+  final asy::_AsyncAwaitCompleter<(core::int) → core::int> :async_completer = new asy::_AsyncAwaitCompleter::•<(core::int) → core::int>();
   asy::FutureOr<(core::int) → core::int> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -35,7 +35,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method c() → core::Iterable<(core::int) → core::int> /* originally sync* */ {
diff --git a/pkg/front_end/testcases/inference_new/for_each_invalid_iterable.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference_new/for_each_invalid_iterable.dart.legacy.transformed.expect
index 3eefc91..0e5e658 100644
--- a/pkg/front_end/testcases/inference_new/for_each_invalid_iterable.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference_new/for_each_invalid_iterable.dart.legacy.transformed.expect
@@ -4,7 +4,7 @@
 import "dart:core" as core;
 
 static method test() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -84,7 +84,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference_new/for_each_invalid_iterable.dart.strong.transformed.expect b/pkg/front_end/testcases/inference_new/for_each_invalid_iterable.dart.strong.transformed.expect
index ef34ec9..062ec9e 100644
--- a/pkg/front_end/testcases/inference_new/for_each_invalid_iterable.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference_new/for_each_invalid_iterable.dart.strong.transformed.expect
@@ -4,7 +4,7 @@
 import "dart:core" as core;
 
 static method test() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -99,7 +99,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference_new/for_each_outer_var_type.dart.legacy.transformed.expect b/pkg/front_end/testcases/inference_new/for_each_outer_var_type.dart.legacy.transformed.expect
index c54ed4e..4ef5873 100644
--- a/pkg/front_end/testcases/inference_new/for_each_outer_var_type.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/inference_new/for_each_outer_var_type.dart.legacy.transformed.expect
@@ -16,7 +16,7 @@
 static method f<T extends core::Object = dynamic>() → self::f::T
   return null;
 static method test() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -158,7 +158,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference_new/for_each_outer_var_type.dart.strong.transformed.expect b/pkg/front_end/testcases/inference_new/for_each_outer_var_type.dart.strong.transformed.expect
index 692a025..b77def2 100644
--- a/pkg/front_end/testcases/inference_new/for_each_outer_var_type.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference_new/for_each_outer_var_type.dart.strong.transformed.expect
@@ -16,7 +16,7 @@
 static method f<T extends core::Object = dynamic>() → self::f::T
   return null;
 static method test() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -166,7 +166,7 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/regress/issue_34850.dart.legacy.transformed.expect b/pkg/front_end/testcases/regress/issue_34850.dart.legacy.transformed.expect
index 2ae0673..38947f8 100644
--- a/pkg/front_end/testcases/regress/issue_34850.dart.legacy.transformed.expect
+++ b/pkg/front_end/testcases/regress/issue_34850.dart.legacy.transformed.expect
@@ -35,7 +35,7 @@
 }
 static method Future<List extends core::Object = dynamic>() → invalid-type {}
 static method f2() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -58,11 +58,11 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method f3() → invalid-type /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -85,11 +85,11 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -116,6 +116,6 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
diff --git a/pkg/front_end/testcases/regress/issue_34850.dart.strong.transformed.expect b/pkg/front_end/testcases/regress/issue_34850.dart.strong.transformed.expect
index 64ced99..72bac6c 100644
--- a/pkg/front_end/testcases/regress/issue_34850.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/regress/issue_34850.dart.strong.transformed.expect
@@ -51,7 +51,7 @@
 }
 static method Future<List extends core::Object = dynamic>() → invalid-type {}
 static method f2() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -74,11 +74,11 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method f3() → invalid-type /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -101,11 +101,11 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
 static method main() → dynamic /* originally async */ {
-  final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
+  final asy::_AsyncAwaitCompleter<dynamic> :async_completer = new asy::_AsyncAwaitCompleter::•<dynamic>();
   asy::FutureOr<dynamic> :return_value;
   dynamic :async_stack_trace;
   dynamic :async_op_then;
@@ -132,6 +132,6 @@
   :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);
+  :async_completer.start(:async_op);
   return :async_completer.{asy::Completer::future};
 }
diff --git a/pkg/front_end/tool/_fasta/entry_points.dart b/pkg/front_end/tool/_fasta/entry_points.dart
index 3f8f6b1..c5dea7c 100644
--- a/pkg/front_end/tool/_fasta/entry_points.dart
+++ b/pkg/front_end/tool/_fasta/entry_points.dart
@@ -346,7 +346,7 @@
   // mode), this is only an approximation, albeit accurate.  Once Fasta is
   // self-hosting, this isn't an approximation. Regardless, strong mode
   // shouldn't affect which files are read.
-  Target hostTarget = getTarget("vm", new TargetFlags(syncAsync: false));
+  Target hostTarget = getTarget("vm", new TargetFlags());
   return getDependencies(Platform.script,
       platform: hostPlatform, target: hostTarget);
 }
diff --git a/pkg/front_end/tool/perf_common.dart b/pkg/front_end/tool/perf_common.dart
index 5c1d4c5..a6054cc 100644
--- a/pkg/front_end/tool/perf_common.dart
+++ b/pkg/front_end/tool/perf_common.dart
@@ -71,7 +71,7 @@
 // legacyMode flag get merged, and we have a single way of specifying the
 // legacy-mode flag to the FE.
 Target createTarget({bool isFlutter: false, bool legacyMode: false}) {
-  var flags = new TargetFlags(legacyMode: legacyMode, syncAsync: false);
+  var flags = new TargetFlags(legacyMode: legacyMode);
   if (isFlutter) {
     return legacyMode
         ? new LegacyFlutterTarget(flags)