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.
+    //
+    // 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;
     }
   }
 }