Handle constructor bodies

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 129 matching lines @@
         this.tearOffGetterNames = info.tearOffGetterNames;
 
   bool get isOuterMostContext {
     return currentFunction == null || currentMemberFunction == currentFunction;
   }
 
   String get currentFileUri {
     if (currentMember is Constructor) return currentClass.fileUri;
     if (currentMember is Field) return (currentMember as Field).fileUri;
     if (currentMember is Procedure) return (currentMember as Procedure).fileUri;
-    throw "No file uri";
+    throw "No file uri for ${currentMember.runtimeType}";
   }
 
   void insert(Statement statement) {
     _currentBlock.statements.insert(_insertionIndex++, statement);
     statement.parent = _currentBlock;
   }
 
   TreeNode saveContext(TreeNode f()) {
     Block savedBlock = _currentBlock;
     int savedIndex = _insertionIndex;
     Context savedContext = context;
     try {
       return f();
     } finally {
       _currentBlock = savedBlock;
       _insertionIndex = savedIndex;
       context = savedContext;
     }
   }
 
   TreeNode visitLibrary(Library node) {
     assert(newLibraryMembers.isEmpty);
     if (node == contextClass.enclosingLibrary) return node;
+
     currentLibrary = node;
     node = super.visitLibrary(node);
     for (TreeNode member in newLibraryMembers) {
       if (member is Class) {
         node.addClass(member);
       } else {
         node.addMember(member);
       }
     }
     newLibraryMembers.clear();
     currentLibrary = null;
     return node;
   }
 
   TreeNode visitClass(Class node) {
     assert(newClassMembers.isEmpty);
     currentClass = node;
     node = super.visitClass(node);
     newClassMembers.forEach(node.addMember);
     newClassMembers.clear();
     currentClass = null;
     return node;
   }
 
   TreeNode visitConstructor(Constructor node) {
-    // TODO(ahe): Convert closures in constructors as well.
+    assert(isEmptyContext);
+
+    currentMember = node;
+
+    FunctionNode function = node.function;
+    if (function.body != null && function.body is! EmptyStatement) {
+      setupContextForFunctionBody(function);
+      VariableDeclaration self = thisAccess[currentMemberFunction];
+      // TODO(karlklose): transform initializers
+      if (self != null) {
+        context.extend(self, new ThisExpression());
+      }
+      node.function.accept(this);
+      resetContext();
+    }
+
     return node;
   }
 
   Expression handleLocalFunction(FunctionNode function) {
     FunctionNode enclosingFunction = currentFunction;
     Map<TypeParameter, DartType> enclosingTypeSubstitution = typeSubstitution;
     currentFunction = function;
     Statement body = function.body;
     assert(body != null);
 
@@ skipping 124 matching lines @@
         addFieldForwarder(tearOffName, node);
       }
     }
     node = super.visitField(node);
     context = null;
     currentMember = null;
     return node;
   }
 
   TreeNode visitProcedure(Procedure node) {
+    assert(isEmptyContext);
+
     currentMember = node;
-    assert(_currentBlock == null);
-    assert(_insertionIndex == 0);
-    assert(context == null);
-
-    Statement body = node.function.body;
 
     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);
         }
       }
     }
 
-    if (body == null) return node;
+    FunctionNode function = node.function;
+    if (function.body != null) {
+      setupContextForFunctionBody(function);
+      VariableDeclaration self = thisAccess[currentMemberFunction];
+      if (self != null) {
+        context.extend(self, new ThisExpression());
+      }
+      node.transformChildren(this);
+      resetContext();
+    }
 
-    currentMemberFunction = node.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.
     if (body is Block) {
       _currentBlock = body;
     } else {
       _currentBlock = new Block(<Statement>[body]);
-      node.function.body = body.parent = _currentBlock;
+      function.body = body.parent = _currentBlock;
     }
     _insertionIndex = 0;
-
     // Start with no context.  This happens after setting up _currentBlock
     // so statements can be emitted into _currentBlock if necessary.
     context = new NoContext(this);
+  }
 
-    VariableDeclaration self = thisAccess[currentMemberFunction];
-    if (self != null) {
-      context.extend(self, new ThisExpression());
-    }
-
-    node.transformChildren(this);
-
+  void resetContext() {
     _currentBlock = null;
     _insertionIndex = 0;
     context = null;
     currentMemberFunction = null;
     currentMember = null;
-    return node;
+  }
+
+  bool get isEmptyContext {
+    return _currentBlock == null && _insertionIndex == 0 && context == null;
   }
 
   TreeNode visitLocalInitializer(LocalInitializer node) {
     assert(!capturedVariables.contains(node.variable));
     node.transformChildren(this);
     return node;
   }
 
   TreeNode visitFunctionNode(FunctionNode node) {
     transformList(node.typeParameters, this, node);
 
     void extend(VariableDeclaration parameter) {
       context.extend(parameter, new VariableGet(parameter));
     }
 
     // TODO: Can parameters contain initializers (e.g., for optional ones) that
     // need to be closure converted?
     node.positionalParameters.where(capturedVariables.contains).forEach(extend);
     node.namedParameters.where(capturedVariables.contains).forEach(extend);
 
     assert(node.body != null);
     node.body = node.body.accept(this);
     node.body.parent = node;
     return node;
   }
 
-  TreeNode visitBlock(Block node) => saveContext(() {
-        if (_currentBlock != node) {
-          _currentBlock = node;
-          _insertionIndex = 0;
+  TreeNode visitBlock(Block node) {
+    return saveContext(() {
+      if (_currentBlock != node) {
+        _currentBlock = node;
+        _insertionIndex = 0;
+      }
+
+      while (_insertionIndex < _currentBlock.statements.length) {
+        assert(_currentBlock == node);
+
+        var original = _currentBlock.statements[_insertionIndex];
+        var transformed = original.accept(this);
+        assert(_currentBlock.statements[_insertionIndex] == original);
+        if (transformed == null) {
+          _currentBlock.statements.removeAt(_insertionIndex);
+        } else {
+          _currentBlock.statements[_insertionIndex++] = transformed;
+          transformed.parent = _currentBlock;
         }
+      }
 
-        while (_insertionIndex < _currentBlock.statements.length) {
-          assert(_currentBlock == node);
-
-          var original = _currentBlock.statements[_insertionIndex];
-          var transformed = original.accept(this);
-          assert(_currentBlock.statements[_insertionIndex] == original);
-          if (transformed == null) {
-            _currentBlock.statements.removeAt(_insertionIndex);
-          } else {
-            _currentBlock.statements[_insertionIndex++] = transformed;
-            transformed.parent = _currentBlock;
-          }
-        }
-
-        return node;
-      });
+      return node;
+    });
+  }
 
   TreeNode visitVariableDeclaration(VariableDeclaration node) {
     node.transformChildren(this);
 
     if (!capturedVariables.contains(node)) return node;
     context.extend(node, node.initializer ?? new NullLiteral());
 
-    if (node.parent == currentFunction) return node;
-    if (node.parent is Block) {
+    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.
-      // TODO(ahe): I'd like to avoid testing on the parent pointer.
       return null;
     }
-    throw "Unexpected parent for $node: ${node.parent.parent}";
   }
 
   TreeNode visitVariableGet(VariableGet node) {
     return capturedVariables.contains(node.variable)
         ? context.lookup(node.variable)
         : node;
   }
 
   TreeNode visitVariableSet(VariableSet node) {
     node.transformChildren(this);
@@ skipping 315 matching lines @@
   // 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));
   }
 }