[vm,kernel] New async/await implementation in the VM, part 1 - kernel

This change includes kernel-related changes:

* --compact-async option is added to kernel compilers (front-end
  server and gen_kernel). This option disables desugaring of async
  and await on kernel AST. Note that 'await for' is still desugared.

* File offset of the 'await' is now written for AwaitExpression nodes
  in the kernel binaries (will be used for async stack traces).

* Async/async*/sync* functions and AwaitExpression nodes are supported
  in TFA.

Design doc: go/compact-async-await.

TEST=ci

Issue: #48378
Change-Id: I4233086b7434bc48347f4220645b0be5f9133456
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/241842
Reviewed-by: Slava Egorov <[email protected]>
Reviewed-by: Martin Kustermann <[email protected]>
Reviewed-by: Johnni Winther <[email protected]>
Commit-Queue: Alexander Markov <[email protected]>

Author: alexmarkov

pkg/frontend_server/lib/frontend_server.dart

@@ -57,6 +57,8 @@ 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: null)
   ..addFlag('tfa',
       help:
           'Enable global type flow analysis and related transformations in AOT mode.',
@@ -538,6 +540,7 @@ class FrontendCompiler implements CompilerInterface {
       nullSafety: compilerOptions.nnbdMode == NnbdMode.Strong,
       supportMirrors: options['support-mirrors'] ??
           !(options['aot'] || options['minimal-kernel']),
+      compactAsync: options['compact-async'] ?? false /*options['aot']*/,
     );
     if (compilerOptions.target == null) {
       print('Failed to create front-end target ${options['target']}.');

pkg/kernel/binary.md

@@ -147,7 +147,7 @@ type CanonicalName {
 
 type ComponentFile {
   UInt32 magic = 0x90ABCDEF;
-  UInt32 formatVersion = 78;
+  UInt32 formatVersion = 79;
   Byte[10] shortSdkHash;
   List<String> problemsAsJson; // Described in problems.md.
   Library[] libraries;
@@ -1070,6 +1070,7 @@ type MapEntry {
 
 type AwaitExpression extends Expression {
   Byte tag = 51;
+  FileOffset fileOffset;
   Expression operand;
 }
 

pkg/kernel/lib/binary/ast_from_binary.dart

@@ -2602,7 +2602,8 @@ class BinaryBuilder {
   }
 
   Expression _readAwaitExpression() {
-    return new AwaitExpression(readExpression());
+    int offset = readOffset();
+    return new AwaitExpression(readExpression())..fileOffset = offset;
   }
 
   Expression _readFunctionExpression() {

pkg/kernel/lib/binary/ast_to_binary.dart

@@ -1986,6 +1986,7 @@ class BinaryPrinter implements Visitor<void>, BinarySink {
   @override
   void visitAwaitExpression(AwaitExpression node) {
     writeByte(Tag.AwaitExpression);
+    writeOffset(node.fileOffset);
     writeNode(node.operand);
   }
 

pkg/kernel/lib/binary/tag.dart

@@ -176,7 +176,7 @@ class Tag {
   /// Internal version of kernel binary format.
   /// Bump it when making incompatible changes in kernel binaries.
   /// Keep in sync with runtime/vm/kernel_binary.h, pkg/kernel/binary.md.
-  static const int BinaryFormatVersion = 78;
+  static const int BinaryFormatVersion = 79;
 }
 
 abstract class ConstantTag {

pkg/kernel/lib/target/targets.dart

@@ -16,19 +16,22 @@ 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.supportMirrors = true,
+      this.compactAsync = false});
 
   @override
   bool operator ==(other) {
     if (identical(this, other)) return true;
     return other is TargetFlags &&
         trackWidgetCreation == other.trackWidgetCreation &&
         enableNullSafety == other.enableNullSafety &&
-        supportMirrors == other.supportMirrors;
+        supportMirrors == other.supportMirrors &&
+        compactAsync == other.compactAsync;
   }
 
   @override
@@ -37,6 +40,7 @@ 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;
   }
 }
@@ -547,6 +551,8 @@ abstract class Target {
   Class? concreteDoubleLiteralClass(CoreTypes coreTypes, double value) => null;
   Class? concreteStringLiteralClass(CoreTypes coreTypes, String value) => null;
 
+  Class? concreteAsyncResultClass(CoreTypes coreTypes) => null;
+
   ConstantsBackend get constantsBackend;
 
   /// Returns an [DartLibrarySupport] the defines which, if any, of the

pkg/vm/lib/kernel_front_end.dart

@@ -80,6 +80,8 @@ 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: null);
   args.addOption('depfile', help: 'Path to output Ninja depfile');
   args.addOption('from-dill',
       help: 'Read existing dill file instead of compiling from sources',
@@ -200,6 +202,7 @@ 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'] ?? false /*aot*/;
 
   final bool minimalKernel = options['minimal-kernel'];
   final bool treeShakeWriteOnlyFields = options['tree-shake-write-only-fields'];
@@ -283,7 +286,8 @@ 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));
+      supportMirrors: supportMirrors ?? !(aot || minimalKernel),
+      compactAsync: compactAsync);
   if (compilerOptions.target == null) {
     print('Failed to create front-end target $targetName.');
     return badUsageExitCode;
@@ -612,14 +616,16 @@ Future<void> autoDetectNullSafetyMode(
 Target? createFrontEndTarget(String targetName,
     {bool trackWidgetCreation = false,
     bool nullSafety = false,
-    bool supportMirrors = true}) {
+    bool supportMirrors = true,
+    bool compactAsync = false}) {
   // Make sure VM-specific targets are available.
   installAdditionalTargets();
 
   final TargetFlags targetFlags = new TargetFlags(
       trackWidgetCreation: trackWidgetCreation,
       enableNullSafety: nullSafety,
-      supportMirrors: supportMirrors);
+      supportMirrors: supportMirrors,
+      compactAsync: compactAsync);
   return getTarget(targetName, targetFlags);
 }
 

pkg/vm/lib/target/vm.dart

@@ -186,7 +186,7 @@ class VmTarget extends Target {
     bool productMode = environmentDefines!["dart.vm.product"] == "true";
     transformAsync.transformLibraries(
         new TypeEnvironment(coreTypes, hierarchy), libraries,
-        productMode: productMode);
+        productMode: productMode, desugarAsync: !flags.compactAsync);
     logger?.call("Transformed async methods");
 
     lowering.transformLibraries(
@@ -208,7 +208,7 @@ class VmTarget extends Target {
     bool productMode = environmentDefines!["dart.vm.product"] == "true";
     transformAsync.transformProcedure(
         new TypeEnvironment(coreTypes, hierarchy), procedure,
-        productMode: productMode);
+        productMode: productMode, desugarAsync: flags.supportMirrors);
     logger?.call("Transformed async functions");
 
     lowering.transformProcedure(
@@ -496,6 +496,10 @@ class VmTarget extends Target {
         coreTypes.index.getClass('dart:core', '_OneByteString');
   }
 
+  @override
+  Class? concreteAsyncResultClass(CoreTypes coreTypes) =>
+      coreTypes.futureImplClass;
+
   @override
   ConstantsBackend get constantsBackend => const ConstantsBackend();
 

pkg/vm/lib/transformations/async.dart

@@ -618,7 +618,9 @@ class ExpressionLifter extends Transformer {
   @override
   TreeNode visitFunctionNode(FunctionNode node) {
     var nestedRewriter = new RecursiveContinuationRewriter(
-        continuationRewriter.helper, _staticTypeContext);
+        continuationRewriter.helper,
+        _staticTypeContext,
+        continuationRewriter.desugarAsync);
     return nestedRewriter.transform(node);
   }