Add support for converted closures with explicit contexts to VM

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,
@@ skipping 212 matching lines @@
           parent.body = initializerExpression;
         } else if (parent is FieldInitializer) {
           parent.value = initializerExpression;
         } else {
           throw "Found unexpected node '${node.runtimeType}, expected a 'Let' "
               "or a 'FieldInitializer'.";
         }
       }
     }
     rewriter = null;
+    context = null;
     // Transform constructor body.
     FunctionNode function = node.function;
     if (function.body != null && function.body is! EmptyStatement) {
       setupContextForFunctionBody(function);
       VariableDeclaration self = thisAccess[currentMemberFunction];
       if (self != null) {
         context.extend(self, new ThisExpression());
       }
       node.function.accept(this);
       resetContext();
@@ skipping 233 matching lines @@
         .forEach(extendContextWith);
     assert(node.body != null);
     node.body = node.body.accept(this);
     node.body.parent = node;
     return node;
   }
 
   TreeNode visitBlock(Block node) {
     return saveContext(() {
       BlockRewriter blockRewriter = rewriter = rewriter.forNestedBlock(node);
-      blockRewriter.transformStatements(node, this);
+      blockRewriter.transformStatements(this);
       return node;
     });
   }
 
   TreeNode visitVariableDeclaration(VariableDeclaration node) {
     node.transformChildren(this);
 
     if (!capturedVariables.contains(node)) return node;
     if (node.initializer == null && node.parent is FunctionNode) {
       // If the variable is a function parameter and doesn't have an
@@ skipping 123 matching lines @@
     return super.visitForInStatement(node);
   }
 
   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) {
-      VariableDeclaration contextVariable = new VariableDeclaration(
-          "#contextParameter",
-          type: const VectorType());
-      Expression expression = getTearOffExpression(
-          null, node.target, contextVariable, new NullLiteral());
-      expression.transformChildren(this);
-      return expression;
-    }
+    // TODO(dmitryas): Add support for tear-offs. When added, uncomment this.

[kustermann, 2017/06/20 12:13:13]

Consider filing an issue about kernel-based closure support and reference it
from all commits related to it.

[Dmitry Stefantsov, 2017/06/22 14:12:51]

Good idea!  I was thinking about doing it, but then realized that tear-offs are
probably won't be implemented in Kernel, but rather at back-ends.  The reason
for this is that it's easier to implement it having the global knowledge and
doing it lazily at link time or even more lazily at invocation and use time
(which is exactly how it happens now in VM).

So, given that tear-offs probably won't be implemented in a Kernel
transformation, this and similar comments should be removed along with the
accompanying code in a follow-up CL.

+    //
+    // Member target = node.target;
+    // if (target is Procedure && target.kind == ProcedureKind.Method) {
+    //   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) {
-      MethodInvocation replacement = new MethodInvocation(
-          node.receiver, tearOffName, new Arguments(<Expression>[]));
-      return super.visitMethodInvocation(replacement);
+      PropertyGet replacement = new PropertyGet(node.receiver, tearOffName);
+      return super.visitPropertyGet(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 205 matching lines @@
             "#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,
+            name, ProcedureKind.Getter, tearOffMethodFunction,
             fileUri: currentFileUri);
         newClassMembers.add(tearOffMethod);
 
         resetContext();
       });
     } finally {
       currentMember = oldCurrentMember;
       currentMemberFunction = oldCurrentMemberFunction;
     }
   }
 }