diff --git a/pkg/kernel/bin/transform.dart b/pkg/kernel/bin/transform.dart
index 33279dc37b0..a2d90aeb040 100755
--- a/pkg/kernel/bin/transform.dart
+++ b/pkg/kernel/bin/transform.dart
@@ -82,7 +82,7 @@ Future<CompilerOutcome> runTransformation(List<String> arguments) async {
   final hierarchy = new ClassHierarchy(component);
   switch (options['transformation']) {
     case 'continuation':
-      component = cont.transformComponent(coreTypes, component, true);
+      component = cont.transformComponent(coreTypes, component);
       break;
     case 'resolve-mixins':
       mix.transformLibraries(
diff --git a/pkg/kernel/lib/core_types.dart b/pkg/kernel/lib/core_types.dart
index 7b61a65bd50..9df95cad4b0 100644
--- a/pkg/kernel/lib/core_types.dart
+++ b/pkg/kernel/lib/core_types.dart
@@ -55,19 +55,13 @@ class CoreTypes {
   Class _typeClass;
   Class _functionClass;
   Class _invocationClass;
-  Constructor _externalNameDefaultConstructor;
   Class _invocationMirrorClass;
   Constructor _invocationMirrorWithTypeConstructor;
-  Constructor _invocationMirrorWithoutTypeConstructor;
-  Class _noSuchMethodErrorClass;
   Constructor _noSuchMethodErrorDefaultConstructor;
   Procedure _listFromConstructor;
   Procedure _listUnmodifiableConstructor;
-  Procedure _printProcedure;
   Procedure _identicalProcedure;
-  Constructor _duplicatedFieldInitializerErrorDefaultConstructor;
   Constructor _fallThroughErrorUrlAndLineConstructor;
-  Constructor _compileTimeErrorDefaultConstructor;
   Procedure _objectEquals;
   Procedure _mapUnmodifiable;
 
@@ -77,15 +71,11 @@ class CoreTypes {
   Class _futureClass;
   Class _stackTraceClass;
   Class _streamClass;
-  Class _completerClass;
   Class _asyncAwaitCompleterClass;
   Class _futureOrClass;
   Constructor _asyncAwaitCompleterConstructor;
   Procedure _completeOnAsyncReturnProcedure;
-  Procedure _completerSyncConstructor;
-  Procedure _completerComplete;
   Procedure _completerCompleteError;
-  Procedure _futureMicrotaskConstructor;
   Constructor _syncIterableDefaultConstructor;
   Constructor _streamIteratorDefaultConstructor;
   Constructor _asyncStarStreamControllerDefaultConstructor;
@@ -177,20 +167,11 @@ class CoreTypes {
     return _boolClass ??= index.getClass('dart:core', 'bool');
   }
 
-  Class get completerClass {
-    return _completerClass ??= index.getClass('dart:async', 'Completer');
-  }
-
   Class get asyncAwaitCompleterClass {
     return _asyncAwaitCompleterClass ??=
         index.getClass('dart:async', '_AsyncAwaitCompleter');
   }
 
-  Procedure get completerSyncConstructor {
-    return _completerSyncConstructor ??=
-        index.getMember('dart:async', 'Completer', 'sync');
-  }
-
   Constructor get asyncAwaitCompleterConstructor {
     return _asyncAwaitCompleterConstructor ??=
         index.getMember('dart:async', '_AsyncAwaitCompleter', '');
@@ -201,11 +182,6 @@ class CoreTypes {
         index.getTopLevelMember('dart:async', '_completeOnAsyncReturn');
   }
 
-  Procedure get completerComplete {
-    return _completerComplete ??=
-        index.getMember('dart:async', 'Completer', 'complete');
-  }
-
   Procedure get completerCompleteError {
     return _completerCompleteError ??=
         index.getMember('dart:async', 'Completer', 'completeError');
@@ -223,11 +199,6 @@ class CoreTypes {
     return _doubleClass ??= index.getClass('dart:core', 'double');
   }
 
-  Constructor get externalNameDefaultConstructor {
-    return _externalNameDefaultConstructor ??=
-        index.getMember('dart:_internal', 'ExternalName', '');
-  }
-
   Class get functionClass {
     return _functionClass ??= index.getClass('dart:core', 'Function');
   }
@@ -236,11 +207,6 @@ class CoreTypes {
     return _futureClass ??= index.getClass('dart:async', 'Future');
   }
 
-  Procedure get futureMicrotaskConstructor {
-    return _futureMicrotaskConstructor ??=
-        index.getMember('dart:async', 'Future', 'microtask');
-  }
-
   Class get futureOrClass {
     return _futureOrClass ??= index.getClass('dart:async', 'FutureOr');
   }
@@ -272,11 +238,6 @@ class CoreTypes {
         index.getMember('dart:core', '_InvocationMirror', '_withType');
   }
 
-  Constructor get invocationMirrorWithoutTypeConstructor {
-    return _invocationMirrorWithoutTypeConstructor ??=
-        index.getMember('dart:core', '_InvocationMirror', '_withoutType');
-  }
-
   Class get iterableClass {
     return _iterableClass ??= index.getClass('dart:core', 'Iterable');
   }
@@ -316,11 +277,6 @@ class CoreTypes {
     return _mirrorsLibrary ??= index.tryGetLibrary('dart:mirrors');
   }
 
-  Class get noSuchMethodErrorClass {
-    return _noSuchMethodErrorClass ??=
-        index.getClass('dart:core', 'NoSuchMethodError');
-  }
-
   Constructor get noSuchMethodErrorDefaultConstructor {
     return _noSuchMethodErrorDefaultConstructor ??=
         // TODO(regis): Replace 'withInvocation' with '' after dart2js is fixed.
@@ -355,10 +311,6 @@ class CoreTypes {
     return _pragmaOptions ??= index.getMember('dart:core', 'pragma', 'options');
   }
 
-  Procedure get printProcedure {
-    return _printProcedure ??= index.getTopLevelMember('dart:core', 'print');
-  }
-
   Class get stackTraceClass {
     return _stackTraceClass ??= index.getClass('dart:core', 'StackTrace');
   }
@@ -421,21 +373,11 @@ class CoreTypes {
     return _typeClass ??= index.getClass('dart:core', 'Type');
   }
 
-  Constructor get duplicatedFieldInitializerErrorDefaultConstructor {
-    return _duplicatedFieldInitializerErrorDefaultConstructor ??=
-        index.getMember('dart:core', '_DuplicatedFieldInitializerError', '');
-  }
-
   Constructor get fallThroughErrorUrlAndLineConstructor {
     return _fallThroughErrorUrlAndLineConstructor ??=
         index.getMember('dart:core', 'FallThroughError', '_create');
   }
 
-  Constructor get compileTimeErrorDefaultConstructor {
-    return _compileTimeErrorDefaultConstructor ??=
-        index.getMember('dart:core', '_CompileTimeError', '');
-  }
-
   Procedure get boolFromEnvironment {
     return _boolFromEnvironment ??=
         index.getMember('dart:core', 'bool', 'fromEnvironment');
diff --git a/pkg/kernel/lib/target/targets.dart b/pkg/kernel/lib/target/targets.dart
index 456bcfdc9c2..e10b05dfbfc 100644
--- a/pkg/kernel/lib/target/targets.dart
+++ b/pkg/kernel/lib/target/targets.dart
@@ -14,15 +14,12 @@ class TargetFlags {
   final bool legacyMode;
   final bool treeShake;
 
-  /// Whether `async` functions start synchronously.
-  final bool syncAsync;
   final List<ProgramRoot> programRoots;
   final Uri kernelRuntime;
 
   TargetFlags(
       {this.legacyMode: false,
       this.treeShake: false,
-      this.syncAsync: true,
       this.programRoots: const <ProgramRoot>[],
       this.kernelRuntime});
 }
diff --git a/pkg/kernel/lib/transformations/async.dart b/pkg/kernel/lib/transformations/async.dart
index 797704524ac..31fe3f37c45 100644
--- a/pkg/kernel/lib/transformations/async.dart
+++ b/pkg/kernel/lib/transformations/async.dart
@@ -499,8 +499,8 @@ class ExpressionLifter extends Transformer {
   }
 
   visitFunctionNode(FunctionNode node) {
-    var nestedRewriter = new RecursiveContinuationRewriter(
-        continuationRewriter.helper, continuationRewriter.syncAsync);
+    var nestedRewriter =
+        new RecursiveContinuationRewriter(continuationRewriter.helper);
     return node.accept(nestedRewriter);
   }
 }
diff --git a/pkg/kernel/lib/transformations/continuation.dart b/pkg/kernel/lib/transformations/continuation.dart
index 723c78da452..a78a3ab2a97 100644
--- a/pkg/kernel/lib/transformations/continuation.dart
+++ b/pkg/kernel/lib/transformations/continuation.dart
@@ -23,42 +23,36 @@ class ContinuationVariables {
   static String stackTraceVar(int depth) => ':stack_trace$depth';
 }
 
-void transformLibraries(
-    CoreTypes coreTypes, List<Library> libraries, bool syncAsync) {
+void transformLibraries(CoreTypes coreTypes, List<Library> libraries) {
   var helper = new HelperNodes.fromCoreTypes(coreTypes);
-  var rewriter = new RecursiveContinuationRewriter(helper, syncAsync);
+  var rewriter = new RecursiveContinuationRewriter(helper);
   for (var library in libraries) {
     rewriter.rewriteLibrary(library);
   }
 }
 
-Component transformComponent(
-    CoreTypes coreTypes, Component component, bool syncAsync) {
+Component transformComponent(CoreTypes coreTypes, Component component) {
   var helper = new HelperNodes.fromCoreTypes(coreTypes);
-  var rewriter = new RecursiveContinuationRewriter(helper, syncAsync);
+  var rewriter = new RecursiveContinuationRewriter(helper);
   return rewriter.rewriteComponent(component);
 }
 
-Procedure transformProcedure(
-    CoreTypes coreTypes, Procedure procedure, bool syncAsync) {
+Procedure transformProcedure(CoreTypes coreTypes, Procedure procedure) {
   var helper = new HelperNodes.fromCoreTypes(coreTypes);
-  var rewriter = new RecursiveContinuationRewriter(helper, syncAsync);
+  var rewriter = new RecursiveContinuationRewriter(helper);
   return rewriter.visitProcedure(procedure);
 }
 
 class RecursiveContinuationRewriter extends Transformer {
   final HelperNodes helper;
 
-  /// Whether `async` functions should start synchronously.
-  final bool syncAsync;
-
   final VariableDeclaration asyncJumpVariable = new VariableDeclaration(
       ContinuationVariables.awaitJumpVar,
       initializer: new IntLiteral(0));
   final VariableDeclaration asyncContextVariable =
       new VariableDeclaration(ContinuationVariables.awaitContextVar);
 
-  RecursiveContinuationRewriter(this.helper, this.syncAsync);
+  RecursiveContinuationRewriter(this.helper);
 
   Component rewriteComponent(Component node) {
     return node.accept(this);
@@ -76,15 +70,14 @@ class RecursiveContinuationRewriter extends Transformer {
     switch (node.asyncMarker) {
       case AsyncMarker.Sync:
       case AsyncMarker.SyncYielding:
-        node.transformChildren(
-            new RecursiveContinuationRewriter(helper, syncAsync));
+        node.transformChildren(new RecursiveContinuationRewriter(helper));
         return node;
       case AsyncMarker.SyncStar:
-        return new SyncStarFunctionRewriter(helper, node, syncAsync).rewrite();
+        return new SyncStarFunctionRewriter(helper, node).rewrite();
       case AsyncMarker.Async:
-        return new AsyncFunctionRewriter(helper, node, syncAsync).rewrite();
+        return new AsyncFunctionRewriter(helper, node).rewrite();
       case AsyncMarker.AsyncStar:
-        return new AsyncStarFunctionRewriter(helper, node, syncAsync).rewrite();
+        return new AsyncStarFunctionRewriter(helper, node).rewrite();
       default:
         return null;
     }
@@ -99,9 +92,8 @@ abstract class ContinuationRewriterBase extends RecursiveContinuationRewriter {
   int capturedTryDepth = 0; // Deepest yield point within a try-block.
   int capturedCatchDepth = 0; // Deepest yield point within a catch-block.
 
-  ContinuationRewriterBase(
-      HelperNodes helper, this.enclosingFunction, bool syncAsync)
-      : super(helper, syncAsync);
+  ContinuationRewriterBase(HelperNodes helper, this.enclosingFunction)
+      : super(helper);
 
   /// Given a container [type], which is an instantiation of the given
   /// [containerClass] extract its element type.
@@ -187,14 +179,13 @@ abstract class ContinuationRewriterBase extends RecursiveContinuationRewriter {
 class SyncStarFunctionRewriter extends ContinuationRewriterBase {
   final VariableDeclaration iteratorVariable;
 
-  SyncStarFunctionRewriter(
-      HelperNodes helper, FunctionNode enclosingFunction, syncAsync)
+  SyncStarFunctionRewriter(HelperNodes helper, FunctionNode enclosingFunction)
       : iteratorVariable = new VariableDeclaration(':iterator')
           ..type = new InterfaceType(helper.syncIteratorClass, [
             ContinuationRewriterBase.elementTypeFrom(
                 helper.iterableClass, enclosingFunction.returnType)
           ]),
-        super(helper, enclosingFunction, syncAsync);
+        super(helper, enclosingFunction);
 
   FunctionNode rewrite() {
     // :sync_op(:iterator) {
@@ -289,9 +280,8 @@ abstract class AsyncRewriterBase extends ContinuationRewriterBase {
 
   ExpressionLifter expressionRewriter;
 
-  AsyncRewriterBase(
-      HelperNodes helper, FunctionNode enclosingFunction, bool syncAsync)
-      : super(helper, enclosingFunction, syncAsync) {}
+  AsyncRewriterBase(HelperNodes helper, FunctionNode enclosingFunction)
+      : super(helper, enclosingFunction) {}
 
   void setupAsyncContinuations(List<Statement> statements) {
     expressionRewriter = new ExpressionLifter(this);
@@ -904,9 +894,8 @@ abstract class AsyncRewriterBase extends ContinuationRewriterBase {
 class AsyncStarFunctionRewriter extends AsyncRewriterBase {
   VariableDeclaration controllerVariable;
 
-  AsyncStarFunctionRewriter(
-      HelperNodes helper, FunctionNode enclosingFunction, bool syncAsync)
-      : super(helper, enclosingFunction, syncAsync);
+  AsyncStarFunctionRewriter(HelperNodes helper, FunctionNode enclosingFunction)
+      : super(helper, enclosingFunction);
 
   FunctionNode rewrite() {
     var statements = <Statement>[];
@@ -1022,9 +1011,8 @@ class AsyncFunctionRewriter extends AsyncRewriterBase {
   VariableDeclaration completerVariable;
   VariableDeclaration returnVariable;
 
-  AsyncFunctionRewriter(
-      HelperNodes helper, FunctionNode enclosingFunction, bool syncAsync)
-      : super(helper, enclosingFunction, syncAsync);
+  AsyncFunctionRewriter(HelperNodes helper, FunctionNode enclosingFunction)
+      : super(helper, enclosingFunction);
 
   FunctionNode rewrite() {
     var statements = <Statement>[];
@@ -1042,28 +1030,16 @@ class AsyncFunctionRewriter extends AsyncRewriterBase {
         new InterfaceType(helper.futureOrClass, <DartType>[valueType]);
     var completerTypeArguments = <DartType>[valueType];
 
-    if (syncAsync) {
-      final completerType = new InterfaceType(
-          helper.asyncAwaitCompleterClass, completerTypeArguments);
-      // final Completer<T> :async_completer = new _AsyncAwaitCompleter<T>();
-      completerVariable = new VariableDeclaration(":async_completer",
-          initializer: new ConstructorInvocation(
-              helper.asyncAwaitCompleterConstructor,
-              new Arguments([], types: completerTypeArguments))
-            ..fileOffset = enclosingFunction.body?.fileOffset ?? -1,
-          isFinal: true,
-          type: completerType);
-    } else {
-      final completerType =
-          new InterfaceType(helper.completerClass, completerTypeArguments);
-      // final Completer<T> :async_completer = new Completer<T>.sync();
-      completerVariable = new VariableDeclaration(":async_completer",
-          initializer: new StaticInvocation(helper.completerConstructor,
-              new Arguments([], types: completerTypeArguments))
-            ..fileOffset = enclosingFunction.body?.fileOffset ?? -1,
-          isFinal: true,
-          type: completerType);
-    }
+    final completerType = new InterfaceType(
+        helper.asyncAwaitCompleterClass, completerTypeArguments);
+    // final Completer<T> :async_completer = new _AsyncAwaitCompleter<T>();
+    completerVariable = new VariableDeclaration(":async_completer",
+        initializer: new ConstructorInvocation(
+            helper.asyncAwaitCompleterConstructor,
+            new Arguments([], types: completerTypeArguments))
+          ..fileOffset = enclosingFunction.body?.fileOffset ?? -1,
+        isFinal: true,
+        type: completerType);
     statements.add(completerVariable);
 
     returnVariable = new VariableDeclaration(":return_value", type: returnType);
@@ -1071,23 +1047,13 @@ class AsyncFunctionRewriter extends AsyncRewriterBase {
 
     setupAsyncContinuations(statements);
 
-    if (syncAsync) {
-      // :async_completer.start(:async_op);
-      var startStatement = new ExpressionStatement(new MethodInvocation(
-          new VariableGet(completerVariable),
-          new Name('start'),
-          new Arguments([new VariableGet(nestedClosureVariable)]))
-        ..fileOffset = enclosingFunction.fileOffset);
-      statements.add(startStatement);
-    } else {
-      // new Future.microtask(:async_op);
-      var newMicrotaskStatement = new ExpressionStatement(new StaticInvocation(
-          helper.futureMicrotaskConstructor,
-          new Arguments([new VariableGet(nestedClosureVariable)],
-              types: [const DynamicType()]))
-        ..fileOffset = enclosingFunction.fileOffset);
-      statements.add(newMicrotaskStatement);
-    }
+    // :async_completer.start(:async_op);
+    var startStatement = new ExpressionStatement(new MethodInvocation(
+        new VariableGet(completerVariable),
+        new Name('start'),
+        new Arguments([new VariableGet(nestedClosureVariable)]))
+      ..fileOffset = enclosingFunction.fileOffset);
+    statements.add(startStatement);
     // return :async_completer.future;
     var completerGet = new VariableGet(completerVariable);
     var returnStatement = new ReturnStatement(new PropertyGet(completerGet,
@@ -1152,22 +1118,16 @@ class HelperNodes {
   final Member asyncStarMoveNextHelper;
   final Procedure asyncThenWrapper;
   final Procedure awaitHelper;
-  final Class completerClass;
   final Class asyncAwaitCompleterClass;
-  final Member completerComplete;
   final Member completerCompleteError;
-  final Member completerConstructor;
   final Member asyncAwaitCompleterConstructor;
   final Member completeOnAsyncReturn;
   final Member completerFuture;
   final Library coreLibrary;
   final CoreTypes coreTypes;
   final Class futureClass;
-  final Procedure futureMicrotaskConstructor;
   final Class futureOrClass;
   final Class iterableClass;
-  final Class iteratorClass;
-  final Procedure printProcedure;
   final Class streamClass;
   final Member streamIteratorCancel;
   final Class streamIteratorClass;
@@ -1196,22 +1156,16 @@ class HelperNodes {
       this.asyncStarMoveNextHelper,
       this.asyncThenWrapper,
       this.awaitHelper,
-      this.completerClass,
       this.asyncAwaitCompleterClass,
-      this.completerComplete,
       this.completerCompleteError,
-      this.completerConstructor,
       this.asyncAwaitCompleterConstructor,
       this.completeOnAsyncReturn,
       this.completerFuture,
       this.coreLibrary,
       this.coreTypes,
       this.futureClass,
-      this.futureMicrotaskConstructor,
       this.futureOrClass,
       this.iterableClass,
-      this.iteratorClass,
-      this.printProcedure,
       this.streamClass,
       this.streamIteratorCancel,
       this.streamIteratorClass,
@@ -1241,22 +1195,16 @@ class HelperNodes {
         coreTypes.asyncStarMoveNextHelper,
         coreTypes.asyncThenWrapperHelperProcedure,
         coreTypes.awaitHelperProcedure,
-        coreTypes.completerClass,
         coreTypes.asyncAwaitCompleterClass,
-        coreTypes.completerComplete,
         coreTypes.completerCompleteError,
-        coreTypes.completerSyncConstructor,
         coreTypes.asyncAwaitCompleterConstructor,
         coreTypes.completeOnAsyncReturn,
         coreTypes.completerFuture,
         coreTypes.coreLibrary,
         coreTypes,
         coreTypes.futureClass,
-        coreTypes.futureMicrotaskConstructor,
         coreTypes.futureOrClass,
         coreTypes.iterableClass,
-        coreTypes.iteratorClass,
-        coreTypes.printProcedure,
         coreTypes.streamClass,
         coreTypes.streamIteratorCancel,
         coreTypes.streamIteratorClass,
diff --git a/pkg/vm/lib/target/vm.dart b/pkg/vm/lib/target/vm.dart
index 817672ec630..a43e07c206c 100644
--- a/pkg/vm/lib/target/vm.dart
+++ b/pkg/vm/lib/target/vm.dart
@@ -76,7 +76,7 @@ class VmTarget extends Target {
     logger?.call("Transformed mixin applications");
 
     // TODO(kmillikin): Make this run on a per-method basis.
-    transformAsync.transformLibraries(coreTypes, libraries, flags.syncAsync);
+    transformAsync.transformLibraries(coreTypes, libraries);
     logger?.call("Transformed async methods");
 
     listFactorySpecializer.transformLibraries(libraries, coreTypes);
@@ -90,7 +90,7 @@ class VmTarget extends Target {
   void performTransformationsOnProcedure(
       CoreTypes coreTypes, ClassHierarchy hierarchy, Procedure procedure,
       {void logger(String msg)}) {
-    transformAsync.transformProcedure(coreTypes, procedure, flags.syncAsync);
+    transformAsync.transformProcedure(coreTypes, procedure);
     logger?.call("Transformed async functions");
   }
 
diff --git a/utils/bazel/kernel_worker.dart b/utils/bazel/kernel_worker.dart
index 45faa400811..a9a01458251 100644
--- a/utils/bazel/kernel_worker.dart
+++ b/utils/bazel/kernel_worker.dart
@@ -132,7 +132,7 @@ Future<bool> computeKernel(List<String> args,
   Target target;
   var summaryOnly = parsedArgs['summary-only'] as bool;
   var excludeNonSources = parsedArgs['exclude-non-sources'] as bool;
-  var targetFlags = new TargetFlags(syncAsync: true);
+  var targetFlags = new TargetFlags();
   if (summaryOnly) {
     target = new SummaryTarget(sources, excludeNonSources, targetFlags);
   } else {