Add primitive to create closures and use it for closure conversion

pkg/kernel/lib/transformations/closure/converter.dart

 // Copyright (c) 2016, 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.
 
 library kernel.transformations.closure.converter;
 
 import '../../ast.dart'
     show
         Arguments,
         Block,
         Catch,
         Class,
+        ClosureCreation,
         Constructor,
         ConstructorInvocation,
         DartType,
+        DynamicType,
         EmptyStatement,
         Expression,
         ExpressionStatement,
         Field,
         FieldInitializer,
         ForInStatement,
         ForStatement,
         FunctionDeclaration,
         FunctionExpression,
         FunctionNode,
+        FunctionType,
         Initializer,
+        InterfaceType,
         InvalidExpression,
         InvocationExpression,
         Let,
         Library,
         LocalInitializer,
         Member,
         MethodInvocation,
         Name,
         NamedExpression,
+        NamedType,
         NullLiteral,
         Procedure,
         ProcedureKind,
         PropertyGet,
         ReturnStatement,
         Statement,
         StaticGet,
         StaticInvocation,
         StringLiteral,
         Supertype,
@@ skipping 57 matching lines @@
   Member currentMember;
 
   FunctionNode currentMemberFunction;
 
   FunctionNode currentFunction;
 
   Context context;
 
   AstRewriter rewriter;
 
+  /// TODO(29181): update this comment when the type variables are restored.
   /// Maps original type variable (aka type parameter) to a hoisted type
   /// variable type.
   ///
   /// For example, consider:
   ///
   ///     class C<T> {
   ///       f() => (x) => x is T;
   ///     }
   ///
   /// This is currently converted to:
@@ skipping 122 matching lines @@
 
   AstRewriter makeRewriterForBody(FunctionNode function) {
     Statement body = function.body;
     if (body is! Block) {
       body = new Block(<Statement>[body]);
       function.body = function.body.parent = body;
     }
     return new BlockRewriter(body);
   }
 
+  bool isObject(DartType type) {
+    return type is InterfaceType && type.classNode.supertype == null;
+  }
+
   Expression handleLocalFunction(FunctionNode function) {
     FunctionNode enclosingFunction = currentFunction;
     Map<TypeParameter, DartType> enclosingTypeSubstitution = typeSubstitution;
     currentFunction = function;
     Statement body = function.body;
     assert(body != null);
 
     rewriter = makeRewriterForBody(function);
 
-    VariableDeclaration contextVariable = new VariableDeclaration(
-        "#contextParameter",
-        type: const VectorType(),
-        isFinal: true);
+    VariableDeclaration contextVariable =
+        new VariableDeclaration("#contextParameter", type: const VectorType());
     Context parent = context;
     context = context.toNestedContext(
         new VariableAccessor(contextVariable, null, TreeNode.noOffset));
 
     Set<TypeParameter> captured = capturedTypeVariables[currentFunction];
     if (captured != null) {
       typeSubstitution = copyTypeVariables(captured);
     } else {
       typeSubstitution = const <TypeParameter, DartType>{};
     }
 
+    // TODO(29181): remove replacementTypeSubstitution variable and its usages.
+    // All the type variables used in this function body are replaced with
+    // either dynamic or their bounds. This is to temporarily remove the type
+    // variables from closure conversion. They should be returned after the VM
+    // changes are done to support vectors and closure creation. See #29181.
+    Map<TypeParameter, DartType> replacementTypeSubstitution =
+        <TypeParameter, DartType>{};
+    for (TypeParameter parameter in typeSubstitution.keys) {
+      replacementTypeSubstitution[parameter] = const DynamicType();
+    }
+    for (TypeParameter parameter in typeSubstitution.keys) {
+      if (!isObject(parameter.bound)) {
+        replacementTypeSubstitution[parameter] =
+            substitute(parameter.bound, replacementTypeSubstitution);
+      }
+    }
+    typeSubstitution = replacementTypeSubstitution;
     function.transformChildren(this);
 
+    // TODO(29181): don't replace typeSubstitution with an empty map.
+    // Information about captured type variables is deleted from the closure
+    // class, because the type variables in this function body are already
+    // replaced with either dynamic or their bounds. This change should be
+    // undone after the VM support for vectors and closure creation is
+    // implemented. See #29181.
+    typeSubstitution = <TypeParameter, DartType>{};
     Expression result = addClosure(function, contextVariable, parent.expression,
         typeSubstitution, enclosingTypeSubstitution);
     currentFunction = enclosingFunction;
     typeSubstitution = enclosingTypeSubstitution;
     return result;
   }
 
   TreeNode visitFunctionDeclaration(FunctionDeclaration node) {
     /// Is this closure itself captured by a closure?
     bool isCaptured = capturedVariables.contains(node.variable);
@@ skipping 14 matching lines @@
       }
     });
   }
 
   TreeNode visitFunctionExpression(FunctionExpression node) {
     return saveContext(() {
       return handleLocalFunction(node.function);
     });
   }
 
-  /// Add a new class to the current library that looks like this:
+  /// Add a new procedure to the current library that looks like this:
   ///
-  ///     class Closure#0 extends core::Object implements core::Function {
-  ///       field Vector context;
-  ///       constructor •(final Vector #t1) → dynamic
-  ///         : self::Closure#0::context = #t1
-  ///         ;
-  ///       method call(/* The parameters of [function] */) → dynamic {
-  ///         /// #t2 is [contextVariable].
-  ///         final Vector #t2 = this.{self::Closure#0::context};
-  ///         /* The body of [function]. */
-  ///       }
+  ///     static method closure#0(Vector #c, /* Parameters of [function]. */)
+  ///         → dynamic {
+  ///
+  ///       /* Context is represented by #c. */
+  ///
+  ///       /* Body of [function]. */
+  ///
   ///     }
   ///
-  /// Returns a constructor call to invoke the above constructor.
-  ///
-  /// TODO(ahe): We shouldn't create a class for each closure. Instead we turn
-  /// [function] into a top-level function and use the Dart VM's mechnism for
-  /// closures.
+  /// Returns an invocation of the closure creation primitive that binds the
+  /// above top-level function to a context represented as Vector.
   Expression addClosure(
       FunctionNode function,
       VariableDeclaration contextVariable,
       Expression accessContext,
       Map<TypeParameter, DartType> substitution,
       Map<TypeParameter, DartType> enclosingTypeSubstitution) {
-    Field contextField = new Field(
-        // TODO(ahe): Rename to #context.
-        new Name("context"),
-        type: const VectorType(),
+    function.positionalParameters.insert(0, contextVariable);
+    ++function.requiredParameterCount;
+    Procedure closedTopLevelFunction = new Procedure(
+        new Name(createNameForClosedTopLevelFunction(function)),
+        ProcedureKind.Method,
+        function,
+        isStatic: true,
         fileUri: currentFileUri);
-    Class closureClass = createClosureClass(function,
-        fields: [contextField], substitution: substitution);
-    closureClass.addMember(new Procedure(
-        new Name("call"), ProcedureKind.Method, function,
-        fileUri: currentFileUri));
-    newLibraryMembers.add(closureClass);
-    Statement note = new ExpressionStatement(
-        new StringLiteral("This is a temporary solution. "
-            "In the VM, this will become an additional parameter."));
-    List<Statement> statements = <Statement>[note, contextVariable];
-    Statement body = function.body;
-    if (body is Block) {
-      statements.addAll(body.statements);
-    } else {
-      statements.add(body);
-    }
-    function.body = new Block(statements);
-    function.body.parent = function;
-    contextVariable.initializer =
-        new PropertyGet(new ThisExpression(), contextField.name, contextField);
-    contextVariable.initializer.parent = contextVariable;
-    return new ConstructorInvocation(
-        closureClass.constructors.single,
-        new Arguments(<Expression>[accessContext], types:
-            new List<DartType>.from(substitution.keys.map((TypeParameter t) {
-          return substitute(
-              new TypeParameterType(t), enclosingTypeSubstitution);
-        }))));
+    newLibraryMembers.add(closedTopLevelFunction);
+
+    FunctionType closureType = new FunctionType(
+        function.positionalParameters
+            .map((VariableDeclaration decl) => decl.type)
+            .toList()..removeAt(0),

[asgerf, 2017/03/31 11:03:52]

How about positionalParameters.skip(1).map(...)?  Or just build the type before
mutating the function parameter list.

[Dmitry Stefantsov, 2017/03/31 11:54:13]

I like the 'skip' approach better. Done. Thanks!

+        function.returnType,
+        namedParameters: function.namedParameters
+            .map((VariableDeclaration decl) =>
+                new NamedType(decl.name, decl.type))
+            .toList(),
+        typeParameters: function.typeParameters,
+        requiredParameterCount: function.requiredParameterCount - 1);
+
+    return new ClosureCreation(
+        closedTopLevelFunction.name.name, accessContext, closureType);
   }
 
   TreeNode visitField(Field node) {
     currentMember = node;
     context = new NoContext(this);
     if (node.isInstanceMember) {
       Name tearOffName = tearOffGetterNames[node.name];
       if (tearOffName != null) {
         // TODO(ahe): If we rewrite setters, we can rename the field to avoid
         // an indirection in most cases.
@@ skipping 13 matching lines @@
 
     if (node.isInstanceMember) {
       Name tearOffName = tearOffGetterNames[node.name];
       if (tearOffName != null) {
         if (node.isGetter) {
           // We rename the getter to avoid an indirection in most cases.
           Name oldName = node.name;
           node.name = tearOffName;
           addGetterForwarder(oldName, node);
         } else if (node.kind == ProcedureKind.Method) {
-          addTearOffGetter(tearOffName, node);
+          addTearOffMethod(tearOffName, node);
         }
       }
     }
 
     FunctionNode function = node.function;
     if (function.body != null) {
       setupContextForFunctionBody(function);
       VariableDeclaration self = thisAccess[currentMemberFunction];
       if (self != null) {
         context.extend(self, new ThisExpression());
@@ skipping 54 matching lines @@
       BlockRewriter blockRewriter = rewriter = rewriter.forNestedBlock(node);
       blockRewriter.transformStatements(node, this);
       return node;
     });
   }
 
   TreeNode visitVariableDeclaration(VariableDeclaration node) {
     node.transformChildren(this);
 
     if (!capturedVariables.contains(node)) return node;
-    context.extend(node, node.initializer ?? new NullLiteral());
+    if (node.initializer == null && node.parent is FunctionNode) {
+      // If the variable is a function parameter and doesn't have an
+      // initializer, just use this variable name to put it into the context.
+      context.extend(node, new VariableGet(node));
+    } else {
+      context.extend(node, node.initializer ?? new NullLiteral());
+    }
 
     if (node.parent == currentFunction) {
       return node;
     } else {
       assert(node.parent is Block);
       // When returning null, the parent block will remove this node from its
       // list of statements.
       return null;
     }
   }
@@ skipping 110 matching lines @@
 
   TreeNode visitThisExpression(ThisExpression node) {
     return isOuterMostContext
         ? node
         : context.lookup(thisAccess[currentMemberFunction]);
   }
 
   TreeNode visitStaticGet(StaticGet node) {
     Member target = node.target;
     if (target is Procedure && target.kind == ProcedureKind.Method) {
-      Expression expression = getTearOffExpression(node.target);
+      VariableDeclaration contextVariable = new VariableDeclaration(
+          "#contextParameter",
+          type: const VectorType());
+      Expression expression = getTearOffExpression(
+          null, node.target, contextVariable, new NullLiteral());
       expression.transformChildren(this);
       return expression;
     }
     return super.visitStaticGet(node);
   }
 
   TreeNode visitPropertyGet(PropertyGet node) {
     Name tearOffName = tearOffGetterNames[node.name];
     if (tearOffName != null) {
-      node.name = tearOffName;
+      MethodInvocation replacement = new MethodInvocation(
+          node.receiver, tearOffName, new Arguments(<Expression>[]));
+      return super.visitMethodInvocation(replacement);
     }
     return super.visitPropertyGet(node);
   }
 
   TreeNode visitCatch(Catch node) {
     VariableDeclaration exception = node.exception;
     VariableDeclaration stackTrace = node.stackTrace;
     if (stackTrace != null && capturedVariables.contains(stackTrace)) {
       Block block = node.body = ensureBlock(node.body);
       block.parent = node;
@@ skipping 12 matching lines @@
       block.statements.insert(0, exception);
       exception.parent = block;
     }
     return super.visitCatch(node);
   }
 
   Block ensureBlock(Statement statement) {
     return statement is Block ? statement : new Block(<Statement>[statement]);
   }
 
-  /// Creates a closure that will invoke [procedure] and return an expression
-  /// that instantiates that closure.
-  Expression getTearOffExpression(Procedure procedure) {
+  /// Creates a closure that will invoke method [procedure] of [receiver] and
+  /// return an expression that instantiates that closure.
+  Expression getTearOffExpression(
+      VariableDeclaration receiver,
+      Procedure procedure,
+      VariableDeclaration contextVariable,
+      Expression accessContext) {
     Map<TypeParameter, DartType> substitution = procedure.isInstanceMember
         // Note: we do not attempt to avoid copying type variables that aren't
         // used in the signature of [procedure]. It might be more economical to
         // only copy type variables that are used. However, we assume that
         // passing type arguments that match the enclosing class' type
         // variables will be handled most efficiently.
         ? copyTypeVariables(procedure.enclosingClass.typeParameters)
         : const <TypeParameter, DartType>{};
-    Expression receiver = null;
-    List<Field> fields = null;
-    if (procedure.isInstanceMember) {
-      // TODO(ahe): Rename to #self.
-      Field self = new Field(new Name("self"), fileUri: currentFileUri);
-      self.type = substitute(procedure.enclosingClass.thisType, substitution);
-      fields = <Field>[self];
-      receiver = new PropertyGet(new ThisExpression(), self.name, self);
+
+    // TODO(29181): remove variable `dynamicSubstitution` and replace its usages
+    // with `substitution`.
+
+    Map<TypeParameter, DartType> dynamicSubstitution =
+        <TypeParameter, DartType>{};
+    for (TypeParameter parameter in substitution.keys) {
+      dynamicSubstitution[parameter] = const DynamicType();
+    }
+    for (TypeParameter parameter in substitution.keys) {
+      if (!isObject(parameter.bound)) {
+        dynamicSubstitution[parameter] =
+            substitute(parameter.bound, dynamicSubstitution);
+      }
     }
 
     // Find the closure class for the function. If there isn't one, create it.
-    String closureClassName = createNameForClosureClass(procedure.function);
-    Class closureClass = null;
+    String closedTopLevelFunctionName =
+        createNameForClosedTopLevelFunction(procedure.function);
+    Procedure closedTopLevelFunction = null;
     for (TreeNode node in newLibraryMembers) {
-      if (node is Class && node.name == closureClassName) {
-        closureClass = node;
+      if (node is Procedure && node.name.name == closedTopLevelFunctionName) {
+        closedTopLevelFunction = node;
       }
     }
-    if (closureClass == null) {
-      closureClass = createClosureClass(procedure.function,
-          fields: fields, substitution: substitution);
-      closureClass.addMember(new Procedure(
-          new Name("call"),
+    if (closedTopLevelFunction == null) {
+      closedTopLevelFunction = new Procedure(
+          new Name(closedTopLevelFunctionName),
           ProcedureKind.Method,
-          forwardFunction(procedure, receiver, substitution),
-          fileUri: currentFileUri));
-      newLibraryMembers.add(closureClass);
+          forwardFunction(
+              procedure, receiver, contextVariable, dynamicSubstitution),
+          isStatic: true,
+          fileUri: currentFileUri);
+      newLibraryMembers.add(closedTopLevelFunction);
     }
 
-    Arguments constructorArguments = procedure.isInstanceMember
-        ? new Arguments(<Expression>[new ThisExpression()])
-        : new Arguments.empty();
-    if (substitution.isNotEmpty) {
-      constructorArguments.types
-          .addAll(procedure.enclosingClass.thisType.typeArguments);
-    }
-    return new ConstructorInvocation(
-        closureClass.constructors.single, constructorArguments);
+    return new ClosureCreation(closedTopLevelFunctionName, accessContext,
+        procedure.function.functionType);
   }
 
   /// Creates a function that has the same signature as `procedure.function`
   /// and which forwards all arguments to `procedure`.
-  FunctionNode forwardFunction(Procedure procedure, Expression receiver,
+  FunctionNode forwardFunction(
+      Procedure procedure,
+      VariableDeclaration receiver,
+      VariableDeclaration contextVariable,
       Map<TypeParameter, DartType> substitution) {
     CloneVisitor cloner = substitution.isEmpty
         ? this.cloner
         : new CloneWithoutBody(typeSubstitution: substitution);
     FunctionNode function = procedure.function;
     List<TypeParameter> typeParameters =
         function.typeParameters.map(cloner.clone).toList();
     List<VariableDeclaration> positionalParameters =
         function.positionalParameters.map(cloner.clone).toList();
+    if (contextVariable != null) {
+      positionalParameters.insert(0, contextVariable);
+    }
     List<VariableDeclaration> namedParameters =
         function.namedParameters.map(cloner.clone).toList();
 
     List<DartType> types = typeParameters
         .map((TypeParameter parameter) => new TypeParameterType(parameter))
         .toList();
     List<Expression> positional = positionalParameters
         .map((VariableDeclaration parameter) => new VariableGet(parameter))
         .toList();
+    if (contextVariable != null) {
+      positional.removeAt(0);
+    }
     List<NamedExpression> named =
         namedParameters.map((VariableDeclaration parameter) {
       return new NamedExpression(parameter.name, new VariableGet(parameter));
     }).toList();
 
     Arguments arguments = new Arguments(positional, types: types, named: named);
     InvocationExpression invocation = procedure.isInstanceMember
-        ? new MethodInvocation(receiver, procedure.name, arguments, procedure)
+        ? new MethodInvocation(
+            context.lookup(receiver), procedure.name, arguments, procedure)
         : new StaticInvocation(procedure, arguments);
+    int requiredParameterCount = function.requiredParameterCount;
+    if (contextVariable != null) {
+      ++requiredParameterCount;
+    }
     return new FunctionNode(new ReturnStatement(invocation),
         typeParameters: typeParameters,
         positionalParameters: positionalParameters,
         namedParameters: namedParameters,
-        requiredParameterCount: function.requiredParameterCount,
+        requiredParameterCount: requiredParameterCount,
         returnType: substitute(function.returnType, cloner.typeSubstitution));
   }
 
   /// Creates copies of the type variables in [original] and returns a
   /// substitution that can be passed to [substitute] to substitute all uses of
   /// [original] with their copies.
   Map<TypeParameter, DartType> copyTypeVariables(
       Iterable<TypeParameter> original) {
     if (original.isEmpty) return const <TypeParameter, DartType>{};
     Map<TypeParameter, DartType> substitution = <TypeParameter, DartType>{};
     for (TypeParameter t in original) {
       substitution[t] = new TypeParameterType(new TypeParameter(t.name));
     }
     substitution.forEach((TypeParameter t, DartType copy) {
       if (copy is TypeParameterType) {
         copy.parameter.bound = substitute(t.bound, substitution);
       }
     });
     return substitution;
   }
 
-  String createNameForClosureClass(FunctionNode function) {
-    return 'Closure#${localNames[function]}';
-  }
-
-  Class createClosureClass(FunctionNode function,
-      {List<Field> fields, Map<TypeParameter, DartType> substitution}) {
-    List<TypeParameter> typeParameters = new List<TypeParameter>.from(
-        substitution.values
-            .map((DartType t) => (t as TypeParameterType).parameter));
-    Class closureClass = new Class(
-        name: createNameForClosureClass(function),
-        supertype: new Supertype(coreTypes.objectClass, const <DartType>[]),
-        typeParameters: typeParameters,
-        implementedTypes: <Supertype>[
-          new Supertype(coreTypes.functionClass, const <DartType>[])
-        ],
-        fileUri: currentFileUri);
-    addClosureClassNote(closureClass);
-
-    List<VariableDeclaration> parameters = <VariableDeclaration>[];
-    List<Initializer> initializers = <Initializer>[];
-    for (Field field in fields ?? const <Field>[]) {
-      closureClass.addMember(field);
-      VariableDeclaration parameter = new VariableDeclaration(field.name.name,
-          type: field.type, isFinal: true);
-      parameters.add(parameter);
-      initializers.add(new FieldInitializer(field, new VariableGet(parameter)));
-    }
-
-    closureClass.addMember(new Constructor(
-        new FunctionNode(new EmptyStatement(),
-            positionalParameters: parameters),
-        name: new Name(""),
-        initializers: initializers));
-
-    return closureClass;
+  String createNameForClosedTopLevelFunction(FunctionNode function) {
+    return 'closure#${localNames[function]}';
   }
 
   Statement forwardToThisProperty(Member node) {
     assert(node is Field || (node is Procedure && node.isGetter));
     return new ReturnStatement(
         new PropertyGet(new ThisExpression(), node.name, node));
   }
 
   void addFieldForwarder(Name name, Field field) {
     newClassMembers.add(new Procedure(name, ProcedureKind.Getter,
         new FunctionNode(forwardToThisProperty(field)),
         fileUri: currentFileUri));
   }
 
   Procedure copyWithBody(Procedure procedure, Statement body) {
     Procedure copy = cloner.clone(procedure);
     copy.function.body = body;
     copy.function.body.parent = copy.function;
     return copy;
   }
 
   void addGetterForwarder(Name name, Procedure getter) {
     assert(getter.isGetter);
     newClassMembers
         .add(copyWithBody(getter, forwardToThisProperty(getter))..name = name);
   }
 
-  void addTearOffGetter(Name name, Procedure procedure) {
-    newClassMembers.add(new Procedure(name, ProcedureKind.Getter,
-        new FunctionNode(new ReturnStatement(getTearOffExpression(procedure))),
-        fileUri: currentFileUri));
-  }
+  void addTearOffMethod(Name name, Procedure procedure) {
+    // [addTearOffMethod] generates a method along with a context that captures
+    // `this`. The work with contexts is typically done using the data gathered
+    // by a [ClosureInfo] instance. In absence of this information, we need to
+    // create some variables, like `#self` and `#context`, and manipulate
+    // contexts directly in some cases.
+    //
+    // Also, the tear-off method is generated during a visit to the AST node
+    // of the procedure being torn off, so we need to save and restore some
+    // auxiliary variables like `currentMember` and `currentMemberFunction`
+    // and use [saveContext], so that those variables have proper values when
+    // the procedure itself is being transformed.
+    Member oldCurrentMember = currentMember;
+    FunctionNode oldCurrentMemberFunction = currentMemberFunction;
+    try {
+      saveContext(() {
+        Block body = new Block(<Statement>[]);
+        FunctionNode tearOffMethodFunction = new FunctionNode(body);
+        setupContextForFunctionBody(tearOffMethodFunction);
 
-  // TODO(ahe): Remove this method when we don't generate closure classes
-  // anymore.
-  void addClosureClassNote(Class closureClass) {
-    closureClass.addMember(new Field(new Name("note"),
-        type: coreTypes.stringClass.rawType,
-        initializer: new StringLiteral(
-            "This is temporary. The VM doesn't need closure classes."),
-        fileUri: currentFileUri));
+        // We need a variable that refers to `this` to put it into the context.
+        VariableDeclaration self = new VariableDeclaration("#self",
+            type: procedure.enclosingClass.rawType);
+        context.extend(self, new ThisExpression());
+
+        // The `#context` variable is used to access the context in the closed
+        // top-level function that represents the closure and is generated in
+        // [getTearOffExpression].
+        VariableDeclaration contextVariable = new VariableDeclaration(
+            "#contextParameter",
+            type: const VectorType());
+        Context parent = context;
+        context = context.toNestedContext(
+            new VariableAccessor(contextVariable, null, TreeNode.noOffset));
+
+        body.addStatement(new ReturnStatement(getTearOffExpression(
+            self, procedure, contextVariable, parent.expression)));
+
+        Procedure tearOffMethod = new Procedure(
+            name, ProcedureKind.Method, tearOffMethodFunction,
+            fileUri: currentFileUri);
+        newClassMembers.add(tearOffMethod);
+
+        resetContext();
+      });
+    } finally {
+      currentMember = oldCurrentMember;
+      currentMemberFunction = oldCurrentMemberFunction;
+    }
   }
 }