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;

[karlklose, 2017/06/19 11:58:14]

Please check if this is still required.

[Dmitry Stefantsov, 2017/06/19 12:12:44]

Thanks for pointing to this!  Apparently, DillLibraryBuilder code doesn't have
this requirement any more.  So I removed this line and the body-restoration code
in lines 437-452 below.

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