anchor.diff:    ///
     /// The stub function unwraps the arguments from the struct and calls the
     /// inner function, containing the implementation of the async function.
  -  void generateAsyncWrapper(FunctionNode functionNode, w.BaseFunction inner) {
  +  void generateAsyncWrapper(
  +      FunctionNode functionNode, w.BaseFunction inner, int parameterOffset) {
       w.DefinedFunction stub =
           m.addFunction(translator.functions.asyncStubFunctionType);
       w.BaseFunction asyncHelper =
  
positive.code:       } else {
          preciseThisLocal = paramLocals[0];
        }
      }
  
      closures.collectContexts(member);
      if (member is Constructor) {
        for (Field field in member.enclosingClass.fields) {
          if (field.isInstanceMember && field.initializer != null) {
            closures.collectContexts(field.initializer!,
                container: member.function);
          }
        }
      }
      closures.buildContexts();
  
      allocateContext(member.function!);
      captureParameters();
  
      if (member is Constructor) {
        Class cls = member.enclosingClass;
        ClassInfo info = translator.classInfo[cls]!;
        for (TypeParameter typeParam in cls.typeParameters) {
          b.local_get(thisLocal!);
          b.local_get(typeLocals[typeParam]!);
          b.struct_set(info.struct, translator.typeParameterIndex[typeParam]!);
        }
        for (Field field in cls.fields) {
          if (field.isInstanceMember &&
              field.initializer != null &&
              field.type is! VoidType) {
            int fieldIndex = translator.fieldIndex[field]!;
            b.local_get(thisLocal!);
            wrap(
                field.initializer!, info.struct.fields[fieldIndex].type.unpacked);
            b.struct_set(info.struct, fieldIndex);
          }
        }
        for (Initializer initializer in member.initializers) {
          visitInitializer(initializer);
        }
      }
  
      Statement? body = member.function!.body;
      if (body != null) {
        visitStatement(body);
      }
      _implicitReturn();
      b.end();
    }
  
    /// Generate code for the body of a lambda.
    w.DefinedFunction generateLambda(Lambda lambda, Closures closures) {
      FunctionNode functionNode = lambda.functionNode;
      if (functionNode.asyncMarker == AsyncMarker.Async &&
          lambda.function == function) {
        w.DefinedFunction inner =
            translator.functions.addAsyncInnerFunctionFor(function);
        generateAsyncWrapper(functionNode, inner);
        return CodeGenerator(translator, inner, reference)
            .generateLambda(lambda, closures);
      }
  
      this.closures = closures;
  
      int paramIndex = 1;
      for (TypeParameter typeParam in functionNode.typeParameters) {
        typeLocals[typeParam] = paramLocals[paramIndex++];
      }
      for (VariableDeclaration param in functionNode.positionalParameters) {
        locals[param] = paramLocals[paramIndex++];
      }
      for (VariableDeclaration param in functionNode.namedParameters) {
        locals[param] = paramLocals[paramIndex++];
      }
  
      Context? context = closures.contexts[functionNode]?.parent;
      if (context != null) {
        b.local_get(paramLocals[0]);
  
negative.code:         b.local_set(thisLocal!);
        }
      }
    }
  
    void _implicitReturn() {
  