sdk/pkg/dart2wasm/lib/transformers.dart

// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import 'package:kernel/ast.dart';
import 'package:kernel/class_hierarchy.dart';
import 'package:kernel/clone.dart';
import 'package:kernel/core_types.dart';
import 'package:kernel/type_algebra.dart';
import 'package:kernel/type_environment.dart';

import 'factory_specializer.dart';
import 'util.dart';

void transformLibraries(
  List<Library> libraries,
  CoreTypes coreTypes,
  ClassHierarchy hierarchy,
) {
  final transformer = _WasmTransformer(coreTypes, hierarchy);
  libraries.forEach(transformer.visitLibrary);
}

void transformProcedure(
  Procedure procedure,
  CoreTypes coreTypes,
  ClassHierarchy hierarchy,
) {
  final transformer = _WasmTransformer(coreTypes, hierarchy);
  procedure.accept(transformer);
}

class _WasmTransformer extends Transformer {
  final TypeEnvironment env;

  Member? _currentMember;
  StaticTypeContext? _cachedTypeContext;
  final Set<Variable> _implicitFinalVariables = {};

  final Library _coreLibrary;
  final InterfaceType _nonNullableTypeType;

  final Class _completerClass;
  final Class _streamControllerClass;
  final Class _wasmArrayClass;
  final Class _wasmBaseClass;

  final Procedure _completerComplete;
  final Procedure _completerCompleteError;
  final Procedure _completerConstructor;
  final Procedure _completerSyncConstructor;
  final Procedure _completerGetFuture;
  final Procedure _streamControllerAdd;
  final Procedure _streamControllerAddError;
  final Procedure _streamControllerAddStream;
  final Procedure _streamControllerClose;
  final Procedure _streamControllerConstructor;
  final Procedure _streamControllerGetHasListener;
  final Procedure _streamControllerGetIsPaused;
  final Procedure _streamControllerGetStream;
  final Procedure _streamControllerSetOnListen;

  final Procedure _trySetStackTraceForwarder;
  final Procedure _trySetStackTrace;

  final List<_AsyncStarFrame> _asyncStarFrames = [];
  bool _enclosingIsAsyncStar = false;

  final FactorySpecializer _factorySpecializer;

  final PushPopWasmArrayTransformer _pushPopWasmArrayTransformer;

  StaticTypeContext get typeContext =>
      _cachedTypeContext ??= StaticTypeContext(_currentMember!, env);

  CoreTypes get coreTypes => env.coreTypes;

  /// Maps error handling function, constructor, factory references to functions
  /// that, when minifying, throw errors without details, saving binary space.
  ///
  /// Calls to these error handling function etc. references are transformed
  /// when they are introduced by the front-end, as indicated by
  /// [Throw.forErrorHandling].
  late final Map<Reference, Procedure> _errorHandlingFunctions = {
    coreTypes.index
        .getConstructor('dart:_internal', 'LateError', 'fieldADI')
        .reference: coreTypes.index.getTopLevelProcedure(
      'dart:_error_utils',
      '_throwLateErrorFieldADI',
    ),
    coreTypes.index
        .getConstructor('dart:_internal', 'LateError', 'localADI')
        .reference: coreTypes.index.getTopLevelProcedure(
      'dart:_error_utils',
      '_throwLateErrorLocalADI',
    ),
    coreTypes.index
        .getConstructor('dart:_internal', 'LateError', 'fieldNI')
        .reference: coreTypes.index.getTopLevelProcedure(
      'dart:_error_utils',
      '_throwLateErrorFieldNI',
    ),
    coreTypes.index
        .getConstructor('dart:_internal', 'LateError', 'localNI')
        .reference: coreTypes.index.getTopLevelProcedure(
      'dart:_error_utils',
      '_throwLateErrorLocalNI',
    ),
    coreTypes.index
        .getConstructor('dart:_internal', 'LateError', 'fieldAI')
        .reference: coreTypes.index.getTopLevelProcedure(
      'dart:_error_utils',
      '_throwLateErrorFieldAI',
    ),
    coreTypes.index
        .getConstructor('dart:_internal', 'LateError', 'localAI')
        .reference: coreTypes.index.getTopLevelProcedure(
      'dart:_error_utils',
      '_throwLateErrorLocalAI',
    ),
    coreTypes.index
        .getProcedure('dart:core', 'NoSuchMethodError', 'withInvocation')
        .reference: coreTypes.index.getTopLevelProcedure(
      'dart:_error_utils',
      '_throwNoSuchMethodErrorWithInvocation',
    ),
    coreTypes.index
        .getConstructor('dart:_internal', 'ReachabilityError', '')
        .reference: coreTypes.index.getTopLevelProcedure(
      'dart:_error_utils',
      '_throwReachabilityError',
    ),
  };

  _WasmTransformer(CoreTypes coreTypes, ClassHierarchy hierarchy)
    : env = TypeEnvironment(coreTypes, hierarchy),
      _nonNullableTypeType = coreTypes.index
          .getClass('dart:core', '_Type')
          .getThisType(coreTypes, Nullability.nonNullable),
      _coreLibrary = coreTypes.index.getLibrary('dart:core'),
      _completerClass = coreTypes.index.getClass('dart:async', 'Completer'),
      _streamControllerClass = coreTypes.index.getClass(
        'dart:async',
        'StreamController',
      ),
      _wasmArrayClass = coreTypes.index.getClass('dart:_wasm', 'WasmArray'),
      _wasmBaseClass = coreTypes.index.getClass('dart:_wasm', '_WasmBase'),
      _completerComplete = coreTypes.index.getProcedure(
        'dart:async',
        'Completer',
        'complete',
      ),
      _completerCompleteError = coreTypes.index.getProcedure(
        'dart:async',
        'Completer',
        'completeError',
      ),
      _completerConstructor = coreTypes.index.getProcedure(
        'dart:async',
        'Completer',
        '',
      ),
      _completerSyncConstructor = coreTypes.index.getProcedure(
        'dart:async',
        'Completer',
        'sync',
      ),
      _completerGetFuture = coreTypes.index.getProcedure(
        'dart:async',
        'Completer',
        'get:future',
      ),
      _streamControllerAdd = coreTypes.index.getProcedure(
        'dart:async',
        'StreamController',
        'add',
      ),
      _streamControllerAddError = coreTypes.index.getProcedure(
        'dart:async',
        'StreamController',
        'addError',
      ),
      _streamControllerAddStream = coreTypes.index.getProcedure(
        'dart:async',
        'StreamController',
        'addStream',
      ),
      _streamControllerClose = coreTypes.index.getProcedure(
        'dart:async',
        'StreamController',
        'close',
      ),
      _streamControllerConstructor = coreTypes.index.getProcedure(
        'dart:async',
        'StreamController',
        '',
      ),
      _streamControllerGetHasListener = coreTypes.index.getProcedure(
        'dart:async',
        'StreamController',
        'get:hasListener',
      ),
      _streamControllerGetIsPaused = coreTypes.index.getProcedure(
        'dart:async',
        'StreamController',
        'get:isPaused',
      ),
      _streamControllerGetStream = coreTypes.index.getProcedure(
        'dart:async',
        'StreamController',
        'get:stream',
      ),
      _streamControllerSetOnListen = coreTypes.index.getProcedure(
        'dart:async',
        'StreamController',
        'set:onListen',
      ),
      _trySetStackTraceForwarder = coreTypes.index.getTopLevelProcedure(
        'dart:async',
        '_trySetStackTrace',
      ),
      _trySetStackTrace = coreTypes.index.getProcedure(
        'dart:core',
        'Error',
        '_trySetStackTrace',
      ),
      _factorySpecializer = FactorySpecializer(coreTypes),
      _pushPopWasmArrayTransformer = PushPopWasmArrayTransformer(coreTypes);

  @override
  defaultMember(Member node) {
    _currentMember = node;
    _cachedTypeContext = null;
    _implicitFinalVariables.clear();

    final result = super.defaultMember(node);

    for (final node in _implicitFinalVariables) {
      node.isFinal = true;
    }
    _currentMember = null;
    _cachedTypeContext = null;
    return result;
  }

  /// Checks to see if it is safe to reuse `super._typeArguments`.
  bool canReuseSuperMethod(Class cls) {
    // We search for the first non-abstract super in [cls]'s inheritance chain
    // to see if we can reuse its `_typeArguments` method.
    Class classIter = cls;
    late Supertype supertype;
    while (classIter.supertype != null) {
      Supertype supertypeIter = classIter.supertype!;
      Class superclass = supertypeIter.classNode;
      if (!superclass.isAbstract) {
        supertype = supertypeIter;
        break;
      }
      classIter = classIter.supertype!.classNode;
    }

    // We can reuse a superclass' `_typeArguments` method if the subclass and
    // the superclass have the exact same type parameters in the exact same
    // order.
    if (cls.typeParameters.length != supertype.typeArguments.length) {
      return false;
    }
    for (int i = 0; i < cls.typeParameters.length; i++) {
      TypeParameter parameter = cls.typeParameters[i];
      DartType superTypeArg = supertype.typeArguments[i];
      if (superTypeArg is! TypeParameterType ||
          superTypeArg.parameter != parameter ||
          superTypeArg.nullability == Nullability.nullable) {
        return false;
      }
    }
    return true;
  }

  @override
  defaultVariable(Variable node) {
    if (!node.isFinal) {
      _implicitFinalVariables.add(node);
    }
    return super.defaultVariable(node);
  }

  @override
  visitVariableSet(VariableSet node) {
    _implicitFinalVariables.remove(node.variable);
    return super.visitVariableSet(node);
  }

  @override
  TreeNode visitClass(Class cls) {
    // For every concrete class whose type parameters do not match the type
    // parameters of it's super class we embed a special virtual function
    // `_getTypeArguments`.  When generating code for `_getTypeArguments`, we
    // read the `TypeParameter`s off the instantiated object and generate a
    // `List<Type>` to pass to `_getRuntimeType` which then returns a reified
    // `Type` object.
    if (!cls.isAbstract &&
        cls != coreTypes.objectClass &&
        !env.hierarchy.isSubclassOf(cls, _wasmBaseClass) &&
        !canReuseSuperMethod(cls)) {
      Procedure getTypeArguments = Procedure(
        Name("_typeArguments", _coreLibrary),
        ProcedureKind.Getter,
        FunctionNode(
          null,
          returnType: InterfaceType(_wasmArrayClass, Nullability.nonNullable, [
            _nonNullableTypeType,
          ]),
        ),
        isExternal: true,
        isSynthetic: true,
        fileUri: cls.fileUri,
      );
      addPragma(getTypeArguments, 'wasm:intrinsic', coreTypes);
      cls.addProcedure(getTypeArguments);
    }
    return super.visitClass(cls);
  }

  TreeNode _lowerForIn(ForInStatement stmt) {
    // Transform
    //
    //   for ({var/final} T <variable> in <iterable>) { ... }
    //
    // Into
    //
    //  {
    //    final Iterator<T> #forIterator = <iterable>.iterator;
    //    for (; #forIterator.moveNext() ;) {
    //        {var/final} T variable = #forIterator.current;
    //        ...
    //      }
    //    }
    //  }
    //
    // and:
    //
    //   await for ({var/final} T <variable> in <stream>) { ... }
    //
    // Into
    //
    //  {
    //    final StreamIterator<T> #forIterator = StreamIterator(<stream>);
    //    bool #jumpSentinel = false;
    //    try {
    //      for (; jumpSentinel = await #forIterator.moveNext() ;) {
    //        {var/final} T variable = #forIterator.current;
    //        ...
    //      }
    //    } finally {
    //      if (#jumpSentinel) {
    //        await #forIterator.cancel();
    //      }
    //    }
    //  }

    // The CFE might invoke this transformation despite the program having
    // compile-time errors. So we will not transform this [stmt] if the
    // `stmt.iterable` is an invalid expression or has an invalid type and
    // instead eliminate the entire for-in and replace it with a invalid
    // expression statement.
    final iterable = stmt.iterable;
    final iterableType = iterable.getStaticType(typeContext);
    if (iterableType is InvalidType) {
      return ExpressionStatement(
        InvalidExpression('Invalid iterable type in for-in'),
      );
    }

    final isAsync = stmt.isAsync;
    late final Class iteratorClass;
    late final Procedure iteratorMoveNext;
    late final Member iteratorCurrent;
    if (isAsync) {
      iteratorClass = coreTypes.streamIteratorClass;
      iteratorMoveNext = coreTypes.streamIteratorMoveNext;
      iteratorCurrent = coreTypes.streamIteratorCurrent;
    } else {
      iteratorClass = coreTypes.iteratorClass;
      iteratorMoveNext = coreTypes.iteratorMoveNext;
      iteratorCurrent = coreTypes.iteratorGetCurrent;
    }

    final DartType elementType = stmt.getElementType(typeContext);
    final iteratorType = InterfaceType(iteratorClass, Nullability.nonNullable, [
      elementType,
    ]);

    late final Expression iteratorInitializer;
    if (isAsync) {
      iteratorInitializer = ConstructorInvocation(
        coreTypes.streamIteratorDefaultConstructor,
        Arguments([iterable], types: [elementType]),
      );
    } else {
      iteratorInitializer = InstanceGet(
        InstanceAccessKind.Instance,
        iterable,
        Name('iterator'),
        interfaceTarget: coreTypes.iterableGetIterator,
        resultType: iteratorType,
      );
    }

    final iterator = Variable(
      "#forIterator",
      initializer: iteratorInitializer..fileOffset = iterable.fileOffset,
      type: iteratorType,
      isSynthesized: true,
    )..fileOffset = iterable.fileOffset;

    // Only used when `isAsync` is true.
    final jumpSentinel = Variable(
      "#jumpSentinel",
      initializer: ConstantExpression(BoolConstant(false)),
      type: InterfaceType(coreTypes.boolClass, Nullability.nonNullable),
      isSynthesized: true,
    );

    final condition = InstanceInvocation(
      InstanceAccessKind.Instance,
      VariableGet(iterator),
      Name('moveNext'),
      Arguments(const []),
      interfaceTarget: iteratorMoveNext,
      functionType: iteratorMoveNext.getterType as FunctionType,
    )..fileOffset = iterable.fileOffset;

    final variable = stmt.variable
      ..initializer = (InstanceGet(
        InstanceAccessKind.Instance,
        VariableGet(iterator),
        Name('current'),
        interfaceTarget: iteratorCurrent,
        resultType: elementType,
      )..fileOffset = stmt.bodyOffset);

    Block body = Block([
      VariableStatement(VariableDeclaration(variable)),
      stmt.body,
    ])..fileOffset = stmt.fileOffset;

    Statement forStatement = ForStatement(
      const [],
      isAsync
          ? VariableSet(jumpSentinel, AwaitExpression(condition))
          : condition,
      const [],
      body,
    );

    // Wrap the body with a try / finally to cancel the stream on breaking out
    // of the loop.
    if (isAsync) {
      forStatement = TryFinally(
        Block([forStatement]),
        Block([
          IfStatement(
            VariableGet(jumpSentinel),
            ExpressionStatement(
              AwaitExpression(
                InstanceInvocation(
                  InstanceAccessKind.Instance,
                  VariableGet(iterator),
                  Name('cancel'),
                  Arguments(const []),
                  interfaceTarget: coreTypes.streamIteratorCancel,
                  functionType:
                      coreTypes.streamIteratorCancel.getterType as FunctionType,
                ),
              ),
            ),
            null,
          ),
        ]),
      );
    }

    return Block([
      VariableStatement(VariableDeclaration(iterator)),
      if (isAsync) VariableStatement(VariableDeclaration(jumpSentinel)),
      forStatement,
    ]).accept<TreeNode>(this);
  }

  @override
  TreeNode visitForInStatement(ForInStatement stmt) {
    return _lowerForIn(stmt);
  }

  InstanceInvocation _addToController(
    Variable controller,
    Expression expression,
    int fileOffset,
  ) {
    final controllerNullableObjectType = InterfaceType(
      _streamControllerClass,
      Nullability.nonNullable,
      [coreTypes.objectNullableRawType],
    );
    FunctionType controllerAddType =
        Substitution.fromInterfaceType(
              controllerNullableObjectType,
            ).substituteType(
              _streamControllerAdd.function.computeThisFunctionType(
                Nullability.nonNullable,
              ),
            )
            as FunctionType;
    return InstanceInvocation(
      InstanceAccessKind.Instance,
      VariableGet(controller),
      Name('add'),
      Arguments([expression]),
      interfaceTarget: _streamControllerAdd,
      functionType: controllerAddType,
    )..fileOffset = fileOffset;
  }

  TreeNode _lowerAsyncStar(FunctionNode functionNode) {
    // Convert the function into:
    //
    //    Stream<T> name(args) {
    //      var #paused;
    //      var #cancelCompleter;
    //      var #isDone = false;
    //      var #onCancelCallback = () {
    //        if (#isDone) return null;
    //        if (#paused != null) {
    //          #paused?.complete(null);
    //          #paused = null;
    //        }
    //        #cancelCompleter ??= Completer.sync<void>();
    //        return #cancelCompleter.future;
    //      };
    //      var #onResumeCallback = () {
    //        if (#paused != null) {
    //          #paused?.complete(null);
    //          #paused = null;
    //        }
    //      }
    //      var #controller = StreamController<T>(sync: true, onCancel: #onCancelCallback, onResume: #onResumeCallback);
    //
    //      void #body() async {
    //        try {
    //          <transformed body>
    //        } catch (e, s) {
    //          if (#cancelCompleter != null) {
    //            #cancelCompleter?.completeError(e, s);
    //            #cancelCompleter = null;
    //          } else {
    //            #controller.addError(e, s);
    //          }
    //        } finally {
    //          #isDone = true;
    //          #controller.close();
    //          if (#cancelCompleter != null) {
    //            #cancelCompleter?.complete(null);
    //            #cancelCompleter = null;
    //          }
    //        }
    //      }
    //
    //      #controller.onListen = () {
    //        scheduleMicrotask(#body);
    //      };
    //
    //      return controller.stream;
    //    }
    //
    // Where `<transformed body>` is the body of `functionNode` with these
    // transformations:
    //
    // - yield* e
    //
    //   ==>
    //
    //   await #controller.addStream(e);
    //   if (!#controller.hasListener) {
    //     return;
    //   }
    //
    // - yield e
    //
    //   ==>
    //
    //   #controller.add(e);
    //   if (#controller.isPaused) {
    //     await (#paused = Completer()).future;
    //   }
    //   if (!#controller.hasListener) {
    //     return;
    //   }
    //
    // The `yield` and `yield*` transformations are done by [visitYieldStatement].

    final fileOffset = functionNode.fileOffset;
    final emittedValueType = functionNode.emittedValueType!;

    // var #controller = StreamController<T>(sync: true);
    final controllerObjectType = InterfaceType(
      _streamControllerClass,
      Nullability.nonNullable,
      [emittedValueType],
    );

    // `void #body() async { ... }` statements.
    final List<Statement> bodyStatements = [];

    // Completer<void>? #paused;
    final pausedVarType = InterfaceType(_completerClass, Nullability.nullable, [
      const VoidType(),
    ]);

    final pausedVar = Variable(
      '#paused',
      initializer: null,
      type: pausedVarType,
      isSynthesized: true,
    );

    final cancelCompleterVar = Variable(
      '#cancelCompleter',
      initializer: null,
      type: InterfaceType(_completerClass, Nullability.nullable, [
        const VoidType(),
      ]),
      isSynthesized: true,
    );

    final isDoneVar = Variable(
      '#isDone',
      type: InterfaceType(coreTypes.boolClass, Nullability.nonNullable),
      initializer: ConstantExpression(BoolConstant(false)),
      isSynthesized: true,
    );

    IfStatement makePauseCheck() => IfStatement(
      EqualsNull(VariableGet(pausedVar)),
      Block([]),
      Block([
        ExpressionStatement(
          InstanceInvocation(
            InstanceAccessKind.Instance,
            VariableGet(pausedVar),
            Name('complete'),
            Arguments([ConstantExpression(NullConstant())]),
            interfaceTarget: _completerComplete,
            functionType:
                substitute(_completerComplete.getterType, {
                      _completerClass.typeParameters.first: const VoidType(),
                    })
                    as FunctionType,
          ),
        ),
        ExpressionStatement(
          VariableSet(pausedVar, ConstantExpression(NullConstant())),
        ),
      ]),
    );

    final List<Statement> onCancelCallbackBodyStatements = [
      IfStatement(
        VariableGet(isDoneVar),
        ReturnStatement(ConstantExpression(NullConstant())),
        null,
      ),
      makePauseCheck(),
      IfStatement(
        EqualsNull(VariableGet(cancelCompleterVar)),
        ExpressionStatement(
          VariableSet(
            cancelCompleterVar,
            StaticInvocation(
              _completerSyncConstructor,
              Arguments([], types: [const VoidType()]),
            ),
          ),
        ),
        null,
      ),
      ReturnStatement(
        InstanceGet(
          InstanceAccessKind.Instance,
          VariableGet(cancelCompleterVar),
          Name('future'),
          interfaceTarget: _completerGetFuture,
          resultType: InterfaceType(
            coreTypes.futureClass,
            Nullability.nonNullable,
            [const VoidType()],
          ),
        ),
      ),
    ];

    final onCancelCallback = FunctionExpression(
      FunctionNode(
        Block(onCancelCallbackBodyStatements),
        returnType: FutureOrType(const VoidType(), Nullability.nonNullable),
      ),
    );

    final onCancelCallbackVar = Variable(
      "#onCancelCallback",
      initializer: onCancelCallback,
    );

    final onResumeCallback = FunctionExpression(
      FunctionNode(makePauseCheck(), returnType: const VoidType()),
    );

    final onResumeCallbackVar = Variable(
      "#onResumeCallback",
      initializer: onResumeCallback,
    );

    // StreamController<T>(sync: true)
    final controllerInitializer = StaticInvocation(
      _streamControllerConstructor,
      Arguments(
        [],
        types: [emittedValueType],
        named: [
          NamedExpression('sync', ConstantExpression(BoolConstant(true))),
          NamedExpression('onCancel', VariableGet(onCancelCallbackVar)),
          NamedExpression('onResume', VariableGet(onResumeCallbackVar)),
        ],
      ),
    );

    // var #controller = ...
    final controllerVar = Variable(
      '#controller',
      initializer: controllerInitializer..fileOffset = fileOffset,
      type: controllerObjectType,
      isSynthesized: true,
    )..fileOffset = fileOffset;

    _asyncStarFrames.add(
      _AsyncStarFrame(controllerVar, pausedVar, emittedValueType),
    );
    final Statement transformedBody =
        functionNode.body!.accept<TreeNode>(this) as Statement;
    _asyncStarFrames.removeLast();

    // The body will be wrapped with a `try-catch` to pass the error to the
    // controller, and `try-finally` to close the controller.
    final exceptionVar = Variable(null, isSynthesized: true);

    final stackTraceVar = Variable(
      null,
      isSynthesized: true,
      type: coreTypes.stackTraceRawType(Nullability.nonNullable),
    );

    final catch_ = Catch(
      exceptionVar,
      stackTrace: stackTraceVar,
      IfStatement(
        EqualsNull(VariableGet(cancelCompleterVar)),
        ExpressionStatement(
          InstanceInvocation(
            InstanceAccessKind.Instance,
            VariableGet(controllerVar),
            Name("addError"),
            Arguments([VariableGet(exceptionVar), VariableGet(stackTraceVar)]),
            interfaceTarget: _streamControllerAddError,
            functionType: _streamControllerAddError.getterType as FunctionType,
          ),
        ),
        Block([
          ExpressionStatement(
            InstanceInvocation(
              InstanceAccessKind.Instance,
              VariableGet(cancelCompleterVar),
              Name("completeError"),
              Arguments([
                VariableGet(exceptionVar),
                VariableGet(stackTraceVar),
              ]),
              interfaceTarget: _completerCompleteError,
              functionType: _completerCompleteError.getterType as FunctionType,
            ),
          ),
          ExpressionStatement(
            VariableSet(cancelCompleterVar, ConstantExpression(NullConstant())),
          ),
        ]),
      ),
    );

    final finalizer = Block([
      ExpressionStatement(
        VariableSet(isDoneVar, ConstantExpression(BoolConstant(true))),
      ),
      ExpressionStatement(
        InstanceInvocation(
          InstanceAccessKind.Instance,
          VariableGet(controllerVar),
          Name("close"),
          Arguments([]),
          interfaceTarget: _streamControllerClose,
          functionType: _streamControllerClose.getterType as FunctionType,
        ),
      ),
      // Only complete the cancel completer if there was no error.
      IfStatement(
        Not(EqualsNull(VariableGet(cancelCompleterVar))),
        ExpressionStatement(
          InstanceInvocation(
            InstanceAccessKind.Instance,
            VariableGet(cancelCompleterVar),
            Name('complete'),
            Arguments([ConstantExpression(NullConstant())]),
            interfaceTarget: _completerComplete,
            functionType:
                substitute(_completerComplete.getterType, {
                      _completerClass.typeParameters.first: const VoidType(),
                    })
                    as FunctionType,
          ),
        ),
        null,
      ),
    ]);

    bodyStatements.add(
      TryFinally(TryCatch(transformedBody, [catch_]), finalizer),
    );

    final bodyFunction = FunctionNode(
      Block(bodyStatements),
      emittedValueType: const VoidType(),
      returnType: InterfaceType(
        coreTypes.futureClass,
        Nullability.nonNullable,
        [const VoidType()],
      ),
      asyncMarker: AsyncMarker.Async,
      dartAsyncMarker: AsyncMarker.Async,
    );

    final bodyInitializer = FunctionExpression(bodyFunction);

    final bodyFunctionType = bodyFunction.computeThisFunctionType(
      Nullability.nonNullable,
    );

    final bodyVar = Variable(
      '#body',
      initializer: bodyInitializer..fileOffset = fileOffset,
      type: bodyFunctionType,
      isSynthesized: true,
    )..fileOffset = fileOffset;

    // controller.onListen = () {
    //   scheduleMicrotask(_body);
    // };
    final scheduleMicrotaskProcedure = coreTypes.index.getTopLevelProcedure(
      'dart:async',
      'scheduleMicrotask',
    );

    final setControllerOnListen = InstanceSet(
      InstanceAccessKind.Instance,
      VariableGet(controllerVar),
      Name('onListen'),
      FunctionExpression(
        FunctionNode(
          ExpressionStatement(
            StaticInvocation(
              scheduleMicrotaskProcedure,
              Arguments([VariableGet(bodyVar)]),
            ),
          ),
        ),
      ),
      interfaceTarget: _streamControllerSetOnListen,
    );

    return FunctionNode(
      Block([
        VariableStatement(VariableDeclaration(pausedVar)),
        VariableStatement(VariableDeclaration(cancelCompleterVar)),
        VariableStatement(VariableDeclaration(isDoneVar)),
        VariableStatement(VariableDeclaration(onCancelCallbackVar)),
        VariableStatement(VariableDeclaration(onResumeCallbackVar)),

        // var controller = StreamController<T>(sync: true, onCancel: onCancelCallback, onResume: onResumeCallback);
        VariableStatement(VariableDeclaration(controllerVar)),

        // var #body = ...;
        VariableStatement(VariableDeclaration(bodyVar)),

        // controller.onListen = ...;
        ExpressionStatement(setControllerOnListen),

        // return controller.stream;
        ReturnStatement(
          InstanceGet(
            InstanceAccessKind.Instance,
            VariableGet(controllerVar),
            Name("stream"),
            interfaceTarget: _streamControllerGetStream,
            resultType: substitute(_streamControllerGetStream.getterType, {
              _streamControllerClass.typeParameters.first: emittedValueType,
            }),
          ),
        ),
      ]),
      typeParameters: functionNode.typeParameters,
      positionalParameters: functionNode.positionalParameters,
      namedParameters: functionNode.namedParameters,
      requiredParameterCount: functionNode.requiredParameterCount,
      returnType: functionNode.returnType,
      asyncMarker: AsyncMarker.Sync,
      dartAsyncMarker: AsyncMarker.Sync,
    );
  }

  void _lowerAsync(FunctionNode functionNode) {
    /*
    Convert `async` functions with "simple" bodies to `sync` functions, using
    `Future.value`.

    "Simple" means: constant or basic literal. In general, this transformation
    can be done on any function body that doesn't `await` and doesn't throw.

    Example:

    foo() async { return const ...; }
    ==>
    foo() { return Future.value(const ...); }
    */
    final functionBody = functionNode.body!;
    final simpleReturn = _getSimpleReturn(functionBody);
    if (simpleReturn is BasicLiteral || simpleReturn is ConstantExpression) {
      final futureValueType = functionNode.emittedValueType!;
      final newBody = ReturnStatement(
        StaticInvocation(
          coreTypes.futureValueFactory,
          Arguments([simpleReturn!], types: [futureValueType]),
        ),
      );
      newBody.parent = functionNode;
      functionNode.body = newBody;
      functionNode.asyncMarker = AsyncMarker.Sync;
    }
  }

  @override
  TreeNode visitYieldStatement(YieldStatement yield) {
    // We currently ignore yields in 'sync*'.
    if (!_enclosingIsAsyncStar) {
      return super.visitYieldStatement(yield);
    }

    final fileOffset = yield.fileOffset;
    final frame = _asyncStarFrames.last;
    final controllerVar = frame.controllerVar;
    final pausedVar = frame.pausedVar;
    final isYieldStar = yield.isYieldStar;

    final transformedExpression = yield.expression.accept(this) as Expression;

    final List<Statement> statements = [];

    if (isYieldStar) {
      // yield* e
      //
      // ==>
      //
      // await #controller.addStream(e);
      // if (!#controller.hasListener) return;

      final controllerAddStreamProcedureType =
          _streamControllerAddStream.getterType as FunctionType;

      statements.add(
        ExpressionStatement(
          AwaitExpression(
            InstanceInvocation(
              InstanceAccessKind.Instance,
              VariableGet(controllerVar),
              Name('addStream'),
              Arguments([transformedExpression]),
              interfaceTarget: _streamControllerAddStream,
              functionType:
                  substitute(controllerAddStreamProcedureType, {
                        _streamControllerClass.typeParameters.first:
                            frame.emittedValueType,
                      })
                      as FunctionType,
            ),
          ),
        ),
      );

      statements.add(
        IfStatement(
          InstanceGet(
            InstanceAccessKind.Instance,
            VariableGet(controllerVar),
            Name('hasListener'),
            interfaceTarget: _streamControllerGetHasListener,
            resultType: coreTypes.boolNonNullableRawType,
          ),
          Block([]),
          ReturnStatement(),
        ),
      );
    } else {
      // yield e
      //
      // ==>
      //
      // #controller.add(e);
      // if (#controller.isPaused) {
      //   await (#paused = Completer()).future;
      // }
      // if (!#controller.hasListener) {
      //   return;
      // }

      statements.add(
        ExpressionStatement(
          _addToController(controllerVar, yield.expression, fileOffset),
        ),
      );

      // if (controller.isPaused) ...
      statements.add(
        IfStatement(
          InstanceGet(
            InstanceAccessKind.Instance,
            VariableGet(controllerVar),
            Name('isPaused'),
            interfaceTarget: _streamControllerGetIsPaused,
            resultType: coreTypes.boolNonNullableRawType,
          ),
          ExpressionStatement(
            AwaitExpression(
              InstanceGet(
                InstanceAccessKind.Instance,
                VariableSet(
                  pausedVar,
                  StaticInvocation(
                    _completerConstructor,
                    Arguments([], types: [const VoidType()]),
                  ),
                ),
                Name('future'),
                interfaceTarget: _completerGetFuture,
                resultType: substitute(_completerGetFuture.getterType, {
                  _completerClass.typeParameters.first: const VoidType(),
                }),
              ),
            ),
          ),
          null,
        ),
      );

      // if (!controller.hasListener) return;
      statements.add(
        IfStatement(
          InstanceGet(
            InstanceAccessKind.Instance,
            VariableGet(controllerVar),
            Name('hasListener'),
            interfaceTarget: _streamControllerGetHasListener,
            resultType: coreTypes.boolNonNullableRawType,
          ),
          Block([]),
          ReturnStatement(),
        ),
      );
    }

    return Block(statements);
  }

  @override
  TreeNode visitFunctionNode(FunctionNode functionNode) {
    final previousEnclosing = _enclosingIsAsyncStar;
    final FunctionNode transformed;

    if (functionNode.asyncMarker == AsyncMarker.AsyncStar) {
      _enclosingIsAsyncStar = true;
      functionNode = _lowerAsyncStar(functionNode) as FunctionNode;
      _enclosingIsAsyncStar = previousEnclosing;
      transformed = super.visitFunctionNode(functionNode) as FunctionNode;
    } else {
      _enclosingIsAsyncStar = false;
      transformed = super.visitFunctionNode(functionNode) as FunctionNode;
      _enclosingIsAsyncStar = previousEnclosing;
    }

    if (transformed.asyncMarker == AsyncMarker.Async) {
      _lowerAsync(transformed);
    }

    return transformed;
  }

  @override
  TreeNode visitStaticInvocation(StaticInvocation node) {
    node.transformChildren(this);

    // Forward calls in `dart:async` to private `dart:core` method.
    if (node.target == _trySetStackTraceForwarder) {
      node.target = _trySetStackTrace;
    }

    TreeNode transformed = _pushPopWasmArrayTransformer
        .transformStaticInvocation(node);

    if (transformed is StaticInvocation) {
      transformed = _factorySpecializer.transformStaticInvocation(transformed);
    }

    return transformed;
  }

  @override
  TreeNode visitFunctionTearOff(FunctionTearOff node) {
    node.transformChildren(this);
    return node.receiver;
  }

  @override
  TreeNode visitThrow(Throw node) {
    node.transformChildren(this);
    if (node.forErrorHandling) {
      final expression = node.expression;
      if (expression is ConstructorInvocation) {
        final throwFunction =
            _errorHandlingFunctions[expression.targetReference];
        if (throwFunction != null) {
          return StaticInvocation(throwFunction, expression.arguments);
        }
      } else if (expression is StaticInvocation) {
        final throwFunction =
            _errorHandlingFunctions[expression.targetReference];
        if (throwFunction != null) {
          return StaticInvocation(throwFunction, expression.arguments);
        }
      }
    }
    return node;
  }
}

class _AsyncStarFrame {
  final Variable controllerVar;
  final Variable pausedVar;
  final DartType emittedValueType;

  _AsyncStarFrame(this.controllerVar, this.pausedVar, this.emittedValueType);
}

/// Converts `pushWasmArray<T>(array, length, elem, nextCapacity)` to:
///
///     if (array.length == length) {
///       final newArray = WasmArray<T>(nextCapacity);
///       newArray.copy(0, array, 0, length);
///       array = newArray;
///     }
///     array[length] = elem;
///     length += 1;
///
/// and `popWasmArray<T>(array, length)` to block expression:
///
///     {
///       length -= 1;
///       final T _value = array[length];
///       array[length] = null;
///     } => _value
///
/// This allows unboxing growable list in class fields.
///
/// `array` and `length` arguments need to be either `VariableGet` or
/// `InstanceGet`.
class PushPopWasmArrayTransformer {
  final CoreTypes _coreTypes;
  final Procedure _intAdd;
  final Procedure _intSubtract;
  final InterfaceType _intType;
  final Procedure _popWasmArray;
  final Procedure _pushWasmArray;
  final Class _wasmArrayClass;
  final Procedure _wasmArrayCopy;
  final Procedure _wasmArrayElementGet;
  final Procedure _wasmArrayElementSet;
  final Procedure _wasmArrayFactory;
  final Member _wasmArrayLength;

  PushPopWasmArrayTransformer(this._coreTypes)
    : _intAdd = _coreTypes.index.getProcedure('dart:core', 'num', '+'),
      _intSubtract = _coreTypes.index.getProcedure('dart:core', 'num', '-'),
      _intType = _coreTypes.intNonNullableRawType,
      _popWasmArray = _coreTypes.index.getTopLevelProcedure(
        'dart:_internal',
        'popWasmArray',
      ),
      _pushWasmArray = _coreTypes.index.getTopLevelProcedure(
        'dart:_internal',
        'pushWasmArray',
      ),
      _wasmArrayClass = _coreTypes.index.getClass('dart:_wasm', 'WasmArray'),
      _wasmArrayCopy = _coreTypes.index.getProcedure(
        'dart:_wasm',
        'WasmArrayExt',
        'copy',
      ),
      _wasmArrayElementGet = _coreTypes.index.getProcedure(
        'dart:_wasm',
        'WasmArrayExt',
        '[]',
      ),
      _wasmArrayElementSet = _coreTypes.index.getProcedure(
        'dart:_wasm',
        'WasmArrayExt',
        '[]=',
      ),
      _wasmArrayFactory = _coreTypes.index.getProcedure(
        'dart:_wasm',
        'WasmArray',
        '',
      ),
      _wasmArrayLength = _coreTypes.index.getProcedure(
        'dart:_wasm',
        'WasmArrayRef',
        'get:length',
      );

  Expression transformStaticInvocation(StaticInvocation invocation) {
    if (invocation.target == _pushWasmArray) {
      return _transformPushWasmArray(invocation);
    } else if (invocation.target == _popWasmArray) {
      return _transformPopWasmArray(invocation);
    } else {
      return invocation;
    }
  }

  Expression _transformPushWasmArray(StaticInvocation invocation) {
    final elementType = invocation.arguments.types[0];

    final positionalArguments = invocation.arguments.positional;
    assert(positionalArguments.length == 4);

    final array = positionalArguments[0];
    final length = positionalArguments[1];
    final elem = positionalArguments[2];
    final nextCapacity = positionalArguments[3];

    assert(array is InstanceGet || array is VariableGet);
    assert(length is InstanceGet || length is VariableGet);

    // Collect variables referenced in `VariableGet`s. These will be passed to
    // the cloner as "already cloned" to avoid cloning them.
    final variableCollector = _VariableCollector();
    array.accept(variableCollector);
    length.accept(variableCollector);
    elem.accept(variableCollector);
    nextCapacity.accept(variableCollector);

    final variables = variableCollector.variables;

    // Clone an expression.
    Expression clone(Expression node) {
      final cloner = CloneVisitorNotMembers();
      for (final variable in variables) {
        cloner.setVariableClone(variable, variable);
      }
      return cloner.clone(node);
    }

    // array.length == length
    final objectEqualsType = _coreTypes.objectEquals
        .computeSignatureOrFunctionType();
    final lengthCheck = EqualsCall(
      InstanceGet(
        InstanceAccessKind.Instance,
        array,
        Name('length'),
        interfaceTarget: _wasmArrayLength,
        resultType: _intType,
      ),
      length,
      functionType: objectEqualsType,
      interfaceTarget: _coreTypes.objectEquals,
    );

    // WasmArray<T>(nextCapacity)
    final arrayAllocation = StaticInvocation(
      _wasmArrayFactory,
      Arguments([nextCapacity], types: [elementType]),
    );

    // var newArray = WasmArray<T>(nextCapacity)
    final newArrayVariable = Variable(
      'newArray',
      initializer: arrayAllocation,
      type: InterfaceType(_wasmArrayClass, Nullability.nonNullable, [
        elementType,
      ]),
    );

    // newArray.copy(...)
    final newArrayCopy = StaticInvocation(
      _wasmArrayCopy,
      Arguments(
        [
          VariableGet(newArrayVariable),
          IntLiteral(0),
          clone(array),
          IntLiteral(0),
          clone(length),
        ],
        types: [elementType],
      ),
    );

    // array = newArray
    final Statement arrayFieldUpdate;
    if (array is InstanceGet) {
      arrayFieldUpdate = ExpressionStatement(
        InstanceSet(
          array.kind,
          clone(array.receiver),
          array.name,
          VariableGet(newArrayVariable),
          interfaceTarget: array.interfaceTarget,
        ),
      );
    } else {
      final arrayVariableGet = array as VariableGet;
      arrayFieldUpdate = ExpressionStatement(
        VariableSet(arrayVariableGet.variable, VariableGet(newArrayVariable)),
      );
    }

    final List<Statement> arrayGrowStatements = [
      VariableStatement(VariableDeclaration(newArrayVariable)),
      ExpressionStatement(newArrayCopy),
      arrayFieldUpdate,
    ];

    // array[length] = elem
    final arrayPush = ExpressionStatement(
      StaticInvocation(
        _wasmArrayElementSet,
        Arguments([clone(array), clone(length), elem], types: [elementType]),
      ),
    );

    // length + 1
    final intAddType = _intAdd.computeSignatureOrFunctionType();
    final lengthPlusOne = InstanceInvocation(
      InstanceAccessKind.Instance,
      clone(length),
      Name('+'),
      Arguments([IntLiteral(1)]),
      interfaceTarget: _intAdd,
      functionType: intAddType,
    );

    // length = length + 1
    final Statement arrayLengthUpdate;
    if (length is InstanceGet) {
      arrayLengthUpdate = ExpressionStatement(
        InstanceSet(
          length.kind,
          clone(length.receiver),
          length.name,
          lengthPlusOne,
          interfaceTarget: length.interfaceTarget,
        ),
      );
    } else {
      final lengthVariableGet = length as VariableGet;
      arrayLengthUpdate = ExpressionStatement(
        VariableSet(lengthVariableGet.variable, lengthPlusOne),
      );
    }

    return BlockExpression(
      Block([
        IfStatement(lengthCheck, Block(arrayGrowStatements), null),
        arrayPush,
        arrayLengthUpdate,
      ]),
      NullLiteral(),
    );
  }

  Expression _transformPopWasmArray(StaticInvocation invocation) {
    final elementType = invocation.arguments.types[0] as InterfaceType;
    final elementIsNullable =
        elementType.nullability != Nullability.nonNullable;

    final positionalArguments = invocation.arguments.positional;
    assert(positionalArguments.length == 2);

    final array = positionalArguments[0];
    final length = positionalArguments[1];

    assert(array is InstanceGet || array is VariableGet);
    assert(length is InstanceGet || length is VariableGet);

    // Collect variables referenced in `VariableGet`s. These will be passed to
    // the cloner as "already cloned" to avoid cloning them.
    final variableCollector = _VariableCollector();
    array.accept(variableCollector);
    length.accept(variableCollector);

    final variables = variableCollector.variables;

    // Clone an expression.
    Expression clone(Expression node) {
      final cloner = CloneVisitorNotMembers();
      for (final variable in variables) {
        cloner.setVariableClone(variable, variable);
      }
      return cloner.clone(node);
    }

    final List<Statement> blockStatements = [];

    // length - 1
    final intSubtractType = _intSubtract.computeSignatureOrFunctionType();
    final lengthMinusOne = InstanceInvocation(
      InstanceAccessKind.Instance,
      clone(length),
      Name('-'),
      Arguments([IntLiteral(1)]),
      interfaceTarget: _intSubtract,
      functionType: intSubtractType,
    );

    // length -= 1
    final Statement arrayLengthUpdate;
    if (length is InstanceGet) {
      arrayLengthUpdate = ExpressionStatement(
        InstanceSet(
          length.kind,
          clone(length.receiver),
          length.name,
          lengthMinusOne,
          interfaceTarget: length.interfaceTarget,
        ),
      );
    } else {
      final lengthVariableGet = length as VariableGet;
      arrayLengthUpdate = ExpressionStatement(
        VariableSet(lengthVariableGet.variable, lengthMinusOne),
      );
    }
    blockStatements.add(arrayLengthUpdate);

    // array[length]
    final arrayGet = StaticInvocation(
      _wasmArrayElementGet,
      Arguments([clone(array), clone(length)], types: [elementType]),
    );

    // final temp = array[length]
    final arrayGetVariable = Variable.forValue(
      arrayGet,
      isFinal: true,
      type: elementType,
    );
    blockStatements.add(
      VariableStatement(VariableDeclaration(arrayGetVariable)),
    );

    // array[length] = null
    if (elementIsNullable) {
      final arrayClearElement = ExpressionStatement(
        StaticInvocation(
          _wasmArrayElementSet,
          Arguments(
            [clone(array), clone(length), NullLiteral()],
            types: [elementType],
          ),
        ),
      );
      blockStatements.add(arrayClearElement);
    }

    return BlockExpression(
      Block(blockStatements),
      VariableGet(arrayGetVariable),
    );
  }
}

class _VariableCollector extends RecursiveVisitor {
  Set<Variable> variables = {};

  @override
  void visitVariableGet(VariableGet node) {
    variables.add(node.variable);
  }
}

Expression? _getSimpleReturn(Statement functionBody) {
  if (functionBody is ReturnStatement) {
    if (functionBody.expression == null) {
      return NullLiteral();
    }
    return functionBody.expression;
  }

  if (functionBody is Block) {
    if (functionBody.statements.isEmpty) {
      return NullLiteral();
    }
    if (functionBody.statements.length == 1) {
      final statement = functionBody.statements.single;
      if (statement is ReturnStatement) {
        return statement.expression;
      }
    }
  }

  return null;
}