[vm] Cleanup old async/async*/sync* implementation from kernel

This change removes kernel transformation which was used to
desugar async/async*/sync* functions in the old implementation of
async/async*/sync*.

The useful part of the transformation is retained in
pkg/vm/lib/transformations/for_in_lowering.dart.

TEST=ci

Issue: #48378
Change-Id: Ic70c1fb35162a31bcc22eac3a8f6488b61e945b4
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/249944
Reviewed-by: Slava Egorov <vegorov@google.com>
Reviewed-by: Johnni Winther <johnniwinther@google.com>
Reviewed-by: Martin Kustermann <kustermann@google.com>
Commit-Queue: Alexander Markov <alexmarkov@google.com>

pkg/front_end/lib/src/fasta/source/source_loader.dart

@@ -2730,45 +2730,14 @@ class int extends num {}
 
 class num {}
 
-class _SyncIterable {}
-
-class _SyncIterator {
-  var _current;
-  var _yieldEachIterable;
-}
-
 class Function {}
 """;
 
 /// A minimal implementation of dart:async that is sufficient to create an
 /// instance of [CoreTypes] and compile program.
 const String defaultDartAsyncSource = """
-_asyncErrorWrapperHelper(continuation) {}
-
 void _asyncStarMoveNextHelper(var stream) {}
 
-_asyncThenWrapperHelper(continuation) {}
-
-_awaitHelper(object, thenCallback, errorCallback) {}
-
-_completeOnAsyncReturn(_future, value, async_jump_var) {}
-
-_completeWithNoFutureOnAsyncReturn(_future, value, async_jump_var) {}
-
-_completeOnAsyncError(_future, e, st, async_jump_var) {}
-
-class _AsyncStarStreamController {
-  add(event) {}
-
-  addError(error, stackTrace) {}
-
-  addStream(stream) {}
-
-  close() {}
-
-  get stream => null;
-}
-
 abstract class Completer {
   factory Completer.sync() => null;
 

pkg/frontend_server/lib/frontend_server.dart

@@ -58,8 +58,7 @@ ArgParser argParser = ArgParser(allowTrailingOptions: true)
       help: 'Whether dart:mirrors is supported. By default dart:mirrors is '
           'supported when --aot and --minimal-kernel are not used.',
       defaultsTo: null)
-  ..addFlag('compact-async',
-      help: 'Enable new compact async/await implementation.', defaultsTo: true)
+  ..addFlag('compact-async', help: 'Obsolete, ignored.', hide: true)
   ..addFlag('tfa',
       help:
           'Enable global type flow analysis and related transformations in AOT mode.',
@@ -543,7 +542,6 @@ class FrontendCompiler implements CompilerInterface {
       nullSafety: compilerOptions.nnbdMode == NnbdMode.Strong,
       supportMirrors: options['support-mirrors'] ??
           !(options['aot'] || options['minimal-kernel']),
-      compactAsync: options['compact-async'],
     );
     if (compilerOptions.target == null) {
       print('Failed to create front-end target ${options['target']}.');

pkg/kernel/lib/core_types.dart

@@ -119,57 +119,15 @@ class CoreTypes {
   CoreTypes(Component component)
       : index = new LibraryIndex.coreLibraries(component);
 
-  late final Procedure asyncErrorWrapperHelperProcedure =
-      index.getTopLevelProcedure('dart:async', '_asyncErrorWrapperHelper');
-
   late final Library asyncLibrary = index.getLibrary('dart:async');
 
-  late final Procedure asyncStarStreamControllerAdd =
-      index.getProcedure('dart:async', '_AsyncStarStreamController', 'add');
-
-  late final Procedure asyncStarStreamControllerAddError = index.getProcedure(
-      'dart:async', '_AsyncStarStreamController', 'addError');
-
-  late final Procedure asyncStarStreamControllerAddStream = index.getProcedure(
-      'dart:async', '_AsyncStarStreamController', 'addStream');
-
-  late final Class asyncStarStreamControllerClass =
-      index.getClass('dart:async', '_AsyncStarStreamController');
-
-  late final Procedure asyncStarStreamControllerClose =
-      index.getProcedure('dart:async', '_AsyncStarStreamController', 'close');
-
-  late final Constructor asyncStarStreamControllerDefaultConstructor =
-      index.getConstructor('dart:async', '_AsyncStarStreamController', '');
-
-  late final Member asyncStarStreamControllerStream =
-      index.getMember('dart:async', '_AsyncStarStreamController', 'get:stream');
-
   late final Procedure asyncStarMoveNextHelper =
       index.getTopLevelProcedure('dart:async', '_asyncStarMoveNextHelper');
 
-  late final Procedure asyncThenWrapperHelperProcedure =
-      index.getTopLevelProcedure('dart:async', '_asyncThenWrapperHelper');
-
-  late final Procedure awaitHelperProcedure =
-      index.getTopLevelProcedure('dart:async', '_awaitHelper');
-
   late final Class boolClass = index.getClass('dart:core', 'bool');
 
   late final Class futureImplClass = index.getClass('dart:async', '_Future');
 
-  late final Constructor futureImplConstructor =
-      index.getConstructor('dart:async', '_Future', '');
-
-  late final Procedure completeOnAsyncReturn =
-      index.getTopLevelProcedure('dart:async', '_completeOnAsyncReturn');
-
-  late final Procedure completeWithNoFutureOnAsyncReturn = index
-      .getTopLevelProcedure('dart:async', '_completeWithNoFutureOnAsyncReturn');
-
-  late final Procedure completeOnAsyncError =
-      index.getTopLevelProcedure('dart:async', '_completeOnAsyncError');
-
   late final Library coreLibrary = index.getLibrary('dart:core');
 
   late final Class doubleClass = index.getClass('dart:core', 'double');
@@ -287,18 +245,6 @@ class CoreTypes {
 
   late final Class symbolClass = index.getClass('dart:core', 'Symbol');
 
-  late final Constructor syncIterableDefaultConstructor =
-      index.getConstructor('dart:core', '_SyncIterable', '');
-
-  late final Class syncIteratorClass =
-      index.getClass('dart:core', '_SyncIterator');
-
-  late final Member syncIteratorCurrent =
-      index.getMember('dart:core', '_SyncIterator', '_current');
-
-  late final Member syncIteratorYieldEachIterable =
-      index.getMember('dart:core', '_SyncIterator', '_yieldEachIterable');
-
   late final Class typeClass = index.getClass('dart:core', 'Type');
 
   late final Constructor fallThroughErrorUrlAndLineConstructor =

pkg/kernel/lib/target/targets.dart

@@ -16,22 +16,19 @@ class TargetFlags {
   final bool trackWidgetCreation;
   final bool enableNullSafety;
   final bool supportMirrors;
-  final bool compactAsync;
 
   const TargetFlags(
       {this.trackWidgetCreation = false,
       this.enableNullSafety = false,
-      this.supportMirrors = true,
-      this.compactAsync = true});
+      this.supportMirrors = true});
 
   @override
   bool operator ==(other) {
     if (identical(this, other)) return true;
     return other is TargetFlags &&
         trackWidgetCreation == other.trackWidgetCreation &&
         enableNullSafety == other.enableNullSafety &&
-        supportMirrors == other.supportMirrors &&
-        compactAsync == other.compactAsync;
+        supportMirrors == other.supportMirrors;
   }
 
   @override
@@ -40,7 +37,6 @@ class TargetFlags {
     hash = 0x3fffffff & (hash * 31 + (hash ^ trackWidgetCreation.hashCode));
     hash = 0x3fffffff & (hash * 31 + (hash ^ enableNullSafety.hashCode));
     hash = 0x3fffffff & (hash * 31 + (hash ^ supportMirrors.hashCode));
-    hash = 0x3fffffff & (hash * 31 + (hash ^ compactAsync.hashCode));
     return hash;
   }
 }

pkg/vm/lib/kernel_front_end.dart

@@ -81,8 +81,7 @@ void declareCompilerOptions(ArgParser args) {
       help: 'Whether dart:mirrors is supported. By default dart:mirrors is '
           'supported when --aot and --minimal-kernel are not used.',
       defaultsTo: null);
-  args.addFlag('compact-async',
-      help: 'Enable new compact async/await implementation.', defaultsTo: true);
+  args.addFlag('compact-async', help: 'Obsolete, ignored.', hide: true);
   args.addOption('depfile', help: 'Path to output Ninja depfile');
   args.addOption('from-dill',
       help: 'Read existing dill file instead of compiling from sources',
@@ -203,7 +202,6 @@ Future<int> runCompiler(ArgResults options, String usage) async {
   final String? manifestFilename = options['manifest'];
   final String? dataDir = options['component-name'] ?? options['data-dir'];
   final bool? supportMirrors = options['support-mirrors'];
-  final bool compactAsync = options['compact-async'];
 
   final bool minimalKernel = options['minimal-kernel'];
   final bool treeShakeWriteOnlyFields = options['tree-shake-write-only-fields'];
@@ -287,8 +285,7 @@ Future<int> runCompiler(ArgResults options, String usage) async {
   compilerOptions.target = createFrontEndTarget(targetName,
       trackWidgetCreation: options['track-widget-creation'],
       nullSafety: compilerOptions.nnbdMode == NnbdMode.Strong,
-      supportMirrors: supportMirrors ?? !(aot || minimalKernel),
-      compactAsync: compactAsync);
+      supportMirrors: supportMirrors ?? !(aot || minimalKernel));
   if (compilerOptions.target == null) {
     print('Failed to create front-end target $targetName.');
     return badUsageExitCode;
@@ -617,16 +614,14 @@ Future<void> autoDetectNullSafetyMode(
 Target? createFrontEndTarget(String targetName,
     {bool trackWidgetCreation = false,
     bool nullSafety = false,
-    bool supportMirrors = true,
-    bool compactAsync = true}) {
+    bool supportMirrors = true}) {
   // Make sure VM-specific targets are available.
   installAdditionalTargets();
 
   final TargetFlags targetFlags = new TargetFlags(
       trackWidgetCreation: trackWidgetCreation,
       enableNullSafety: nullSafety,
-      supportMirrors: supportMirrors,
-      compactAsync: compactAsync);
+      supportMirrors: supportMirrors);
   return getTarget(targetName, targetFlags);
 }
 

pkg/vm/lib/target/vm.dart

@@ -9,11 +9,8 @@ import 'package:kernel/core_types.dart';
 import 'package:kernel/reference_from_index.dart';
 import 'package:kernel/target/changed_structure_notifier.dart';
 import 'package:kernel/target/targets.dart';
-import 'package:kernel/type_environment.dart';
 
 import '../transformations/call_site_annotator.dart' as callSiteAnnotator;
-import '../transformations/continuation.dart' as transformAsync
-    show transformLibraries, transformProcedure;
 import '../transformations/lowering.dart' as lowering
     show transformLibraries, transformProcedure;
 import '../transformations/mixin_full_resolution.dart' as transformMixins
@@ -183,15 +180,9 @@ class VmTarget extends Target {
       logger?.call("Transformed ffi annotations");
     }
 
-    // TODO(kmillikin): Make this run on a per-method basis.
     bool productMode = environmentDefines!["dart.vm.product"] == "true";
-    transformAsync.transformLibraries(
-        new TypeEnvironment(coreTypes, hierarchy), libraries,
-        productMode: productMode, desugarAsync: !flags.compactAsync);
-    logger?.call("Transformed async methods");
-
-    lowering.transformLibraries(
-        libraries, coreTypes, hierarchy, flags.enableNullSafety);
+    lowering.transformLibraries(libraries, coreTypes, hierarchy,
+        nullSafety: flags.enableNullSafety, productMode: productMode);
     logger?.call("Lowering transformations performed");
 
     callSiteAnnotator.transformLibraries(
@@ -207,13 +198,8 @@ class VmTarget extends Target {
       Map<String, String>? environmentDefines,
       {void Function(String msg)? logger}) {
     bool productMode = environmentDefines!["dart.vm.product"] == "true";
-    transformAsync.transformProcedure(
-        new TypeEnvironment(coreTypes, hierarchy), procedure,
-        productMode: productMode, desugarAsync: !flags.compactAsync);
-    logger?.call("Transformed async functions");
-
-    lowering.transformProcedure(
-        procedure, coreTypes, hierarchy, flags.enableNullSafety);
+    lowering.transformProcedure(procedure, coreTypes, hierarchy,
+        nullSafety: flags.enableNullSafety, productMode: productMode);
     logger?.call("Lowering transformations performed");
   }