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 174 matching lines @@
           node.canonicalName?.unbind();
           addGetterForwarder(oldName, node);
         } else if (node.kind == ProcedureKind.Method) {
           addTearOffMethod(tearOffName, node);
         }
       }
     }
 
     FunctionNode function = node.function;
     if (function.body != null) {
+      bool hadSingleStatementBody = function.body is! Block;
+
       setupContextForFunctionBody(function);
       VariableDeclaration self = thisAccess[currentMemberFunction];
       if (self != null) {
         context.extend(self, new ThisExpression());
       }
       node.transformChildren(this);
       resetContext();
+
+      // Here a special case is handled: the body of the procedure was a single
+      // statement and after the transformation it is a block with a single
+      // statement inside.  In this case we make this statement the body of the
+      // procedure again.  It is required to follow the conventions imposed by
+      // [addClass] in [DillLibraryBuilder].
+      // See [dill_library_builder.dart]
+      // (../../../../front_end/lib/src/fasta/dill/dill_library_builder.dart)
+      // for details.
+      if (hadSingleStatementBody && function.body is Block) {
+        Block body = function.body;
+        if (body.statements.length == 1) {
+          function.body = body.statements[0];
+          function.body.parent = function;
+        }
+      }
     }
 
     return node;
   }
 
   void setupContextForFunctionBody(FunctionNode function) {
     Statement body = function.body;
     assert(body != null);
     currentMemberFunction = function;
     // Ensure that the body is a block which becomes the current block.
@@ skipping 32 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 139 matching lines @@
           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;
     }
   }
 }