[Kernel] Remove the syncAsync flag

This flag was always true so we can remove it and specialize the
remaining code that used it.  The only code that used it was in the
Dart VM's async transformation.

Specializing that code led to some unused fields in the async helper
class which were removed.  This triggered me to look at core types
which seems to have a lot of unused stuff.

Change-Id: I7da800ca17ac05478149f4c90337a38d2c2b1459
Reviewed-on: https://dart-review.googlesource.com/c/87960
Reviewed-by: Peter von der Ahé <ahe@google.com>
Commit-Queue: Kevin Millikin <kmillikin@google.com>

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(

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

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

pkg/kernel/lib/transformations/async.dart

@@ -499,8 +499,8 @@ class ExpressionLifter extends Transformer {
   }
 
   visitFunctionNode(FunctionNode node) {
-    var nestedRewriter = new RecursiveContinuationRewriter(
+    var nestedRewriter =
-        continuationRewriter.helper, continuationRewriter.syncAsync);
+        new RecursiveContinuationRewriter(continuationRewriter.helper);
     return node.accept(nestedRewriter);
   }
 }

pkg/kernel/lib/transformations/continuation.dart

@@ -23,42 +23,36 @@ class ContinuationVariables {
   static String stackTraceVar(int depth) => ':stack_trace$depth';
 }
 
-void transformLibraries(
+void transformLibraries(CoreTypes coreTypes, List<Library> libraries) {
-    CoreTypes coreTypes, List<Library> libraries, bool syncAsync) {
   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(
+Component transformComponent(CoreTypes coreTypes, Component component) {
-    CoreTypes coreTypes, Component component, bool syncAsync) {
   var helper = new HelperNodes.fromCoreTypes(coreTypes);
-  var rewriter = new RecursiveContinuationRewriter(helper, syncAsync);
+  var rewriter = new RecursiveContinuationRewriter(helper);
   return rewriter.rewriteComponent(component);
 }
 
-Procedure transformProcedure(
+Procedure transformProcedure(CoreTypes coreTypes, Procedure procedure) {
-    CoreTypes coreTypes, Procedure procedure, bool syncAsync) {
   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(
+        node.transformChildren(new RecursiveContinuationRewriter(helper));
-            new RecursiveContinuationRewriter(helper, syncAsync));
         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(
+  ContinuationRewriterBase(HelperNodes helper, this.enclosingFunction)
-      HelperNodes helper, this.enclosingFunction, bool syncAsync)
+      : super(helper);
-      : super(helper, syncAsync);
 
   /// 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(
+  SyncStarFunctionRewriter(HelperNodes helper, FunctionNode enclosingFunction)
-      HelperNodes helper, FunctionNode enclosingFunction, syncAsync)
       : 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(
+  AsyncRewriterBase(HelperNodes helper, FunctionNode enclosingFunction)
-      HelperNodes helper, FunctionNode enclosingFunction, bool syncAsync)
+      : super(helper, enclosingFunction) {}
-      : super(helper, enclosingFunction, syncAsync) {}
 
   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(
+  AsyncStarFunctionRewriter(HelperNodes helper, FunctionNode enclosingFunction)
-      HelperNodes helper, FunctionNode enclosingFunction, bool syncAsync)
+      : super(helper, enclosingFunction);
-      : super(helper, enclosingFunction, syncAsync);
 
   FunctionNode rewrite() {
     var statements = <Statement>[];
@@ -1022,9 +1011,8 @@ class AsyncFunctionRewriter extends AsyncRewriterBase {
   VariableDeclaration completerVariable;
   VariableDeclaration returnVariable;
 
-  AsyncFunctionRewriter(
+  AsyncFunctionRewriter(HelperNodes helper, FunctionNode enclosingFunction)
-      HelperNodes helper, FunctionNode enclosingFunction, bool syncAsync)
+      : super(helper, enclosingFunction);
-      : super(helper, enclosingFunction, syncAsync);
 
   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(
-      final completerType = new InterfaceType(
+        helper.asyncAwaitCompleterClass, completerTypeArguments);
-          helper.asyncAwaitCompleterClass, completerTypeArguments);
+    // final Completer<T> :async_completer = new _AsyncAwaitCompleter<T>();
-      // final Completer<T> :async_completer = new _AsyncAwaitCompleter<T>();
+    completerVariable = new VariableDeclaration(":async_completer",
-      completerVariable = new VariableDeclaration(":async_completer",
+        initializer: new ConstructorInvocation(
-          initializer: new ConstructorInvocation(
+            helper.asyncAwaitCompleterConstructor,
-              helper.asyncAwaitCompleterConstructor,
+            new Arguments([], types: completerTypeArguments))
-              new Arguments([], types: completerTypeArguments))
+          ..fileOffset = enclosingFunction.body?.fileOffset ?? -1,
-            ..fileOffset = enclosingFunction.body?.fileOffset ?? -1,
+        isFinal: true,
-          isFinal: true,
+        type: completerType);
-          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);
-    }
     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);
-      // :async_completer.start(:async_op);
+    var startStatement = new ExpressionStatement(new MethodInvocation(
-      var startStatement = new ExpressionStatement(new MethodInvocation(
+        new VariableGet(completerVariable),
-          new VariableGet(completerVariable),
+        new Name('start'),
-          new Name('start'),
+        new Arguments([new VariableGet(nestedClosureVariable)]))
-          new Arguments([new VariableGet(nestedClosureVariable)]))
+      ..fileOffset = enclosingFunction.fileOffset);
-        ..fileOffset = enclosingFunction.fileOffset);
+    statements.add(startStatement);
-      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);
-    }
     // 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,

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

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 {