Inline generative constructor calls.

sdk/lib/_internal/compiler/implementation/ssa/builder.dart

 // Copyright (c) 2012, 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.
 
 part of ssa;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to override [Element.computeType] because our
  * optimizers may look at its declared type.
@@ skipping 85 matching lines @@
           name = "${element.name.slowToString()}";
         }
         compiler.tracer.traceCompilation(name, work.compilationContext);
         compiler.tracer.traceGraph('builder', graph);
       }
       return graph;
     });
   }
 
   HGraph compileConstructor(SsaBuilder builder, CodegenWorkItem work) {
-    // The body of the constructor will be generated in a separate function.
-    final ClassElement classElement = work.element.getEnclosingClass();
-    return builder.buildFactory(classElement.implementation,
-                                work.element.implementation);
+    return builder.buildFactory(work.element);
   }
 }
 
 
 /**
  * Keeps track of locals (including parameters and phis) when building. The
  * 'this' reference is treated as parameter and hence handled by this class,
  * too.
  */
 class LocalsHandler {
@@ skipping 152 matching lines @@
     closureData.freeVariableMapping.forEach((Element from, Element to) {
       redirectElement(from, to);
     });
     if (closureData.isClosure()) {
       // Inside closure redirect references to itself to [:this:].
       HThis thisInstruction = new HThis(closureData.thisElement,
                                         HType.NON_NULL);
       builder.graph.thisInstruction = thisInstruction;
       builder.graph.entry.addAtEntry(thisInstruction);
       updateLocal(closureData.closureElement, thisInstruction);
-    } else if (element.isInstanceMember()
-               || element.isGenerativeConstructor()) {
+    } else if (element.isInstanceMember()) {
       // Once closures have been mapped to classes their instance members might
       // not have any thisElement if the closure was created inside a static
       // context.
       HThis thisInstruction = new HThis(
           closureData.thisElement, builder.getTypeOfThis());
       builder.graph.thisInstruction = thisInstruction;
       builder.graph.entry.addAtEntry(thisInstruction);
       directLocals[closureData.thisElement] = thisInstruction;
     }
 
@@ skipping 816 matching lines @@
         classElement.origin.addBackendMember(bodyElement.origin);
       }
       compiler.enqueuer.codegen.addToWorkList(bodyElement.declaration,
                                               treeElements);
     }
     assert(bodyElement.isGenerativeConstructorBody());
     return bodyElement;
   }
 
   HParameterValue addParameter(Element element) {
+    assert(inliningStack.isEmpty);
     HParameterValue result = new HParameterValue(element);
     if (lastAddedParameter == null) {
       graph.entry.addBefore(graph.entry.first, result);
     } else {
       graph.entry.addAfter(lastAddedParameter, result);
     }
     lastAddedParameter = result;
     return result;
   }
 
@@ skipping 42 matching lines @@
       assert(succeeded);
     } else {
       assert(providedArguments != null);
       compiledArguments = providedArguments;
     }
 
     // Create the inlining state after evaluating the arguments, that
     // may have an impact on the state of the current method.
     InliningState state = new InliningState(
         function, returnElement, returnType, elements, stack, localsHandler);
-    LocalsHandler newLocalsHandler = new LocalsHandler.from(localsHandler);
+    LocalsHandler newLocalsHandler = new LocalsHandler(this);
     newLocalsHandler.closureData =
         compiler.closureToClassMapper.computeClosureToClassMapping(
             function, function.parseNode(compiler), elements);
     int argumentIndex = 0;
     if (isInstanceMember) {
       newLocalsHandler.updateLocal(newLocalsHandler.closureData.thisElement,
                                    compiledArguments[argumentIndex++]);
     }
 
     if (function.isConstructor()) {
@@ skipping 73 matching lines @@
     // Ensure that [element] is an implementation element.
     element = element.implementation;
     // TODO(floitsch): we should be able to inline inside lazy initializers.
     if (!currentElement.isFunction()) return false;
     // TODO(floitsch): find a cleaner way to know if the element is a function
     // containing nodes.
     // [PartialFunctionElement]s are [FunctionElement]s that have [Node]s.
     if (element is !PartialFunctionElement) return false;
     // TODO(ngeoffray): try to inline generative constructors. They
     // don't have any body, which make it more difficult.
-    if (element.isGenerativeConstructor()) return false;
     if (inliningStack.length > MAX_INLINING_DEPTH) return false;
     // Don't inline recursive calls. We use the same elements for the inlined
     // functions and would thus clobber our local variables.
     // Use [:element.declaration:] since [work.element] is always a declaration.
     if (currentElement == element.declaration) return false;
     for (int i = 0; i < inliningStack.length; i++) {
       if (inliningStack[i].function == element) return false;
     }
 
     PartialFunctionElement function = element;
@@ skipping 37 matching lines @@
     // inlining. We use [element] to get the same name in the NoSuchMethodError
     // message as if we had called it.
     if (element.isInstanceMember()
         && (selector.mask == null || selector.mask.isNullable)) {
       addWithPosition(
           new HFieldGet(element, providedArguments[0]), currentNode);
     }
     InliningState state = enterInlinedMethod(
         function, selector, argumentsNodes, providedArguments, currentNode);
     inlinedFrom(element, () {
-      functionExpression.body.accept(this);
+      element.isGenerativeConstructor()
+          ? buildFactory(element)
+          : functionExpression.body.accept(this);
     });
     leaveInlinedMethod(state);
     return true;
   }
 
   inlinedFrom(Element element, f()) {
     assert(element is FunctionElement || element is VariableElement);
     return compiler.withCurrentElement(element, () {
       sourceElementStack.add(element);
       var result = f();
@@ skipping 85 matching lines @@
       if (constructor.isForwardingConstructor) {
         constructor = constructor.targetConstructor;
       }
       elements =
           compiler.enqueuer.resolution.getCachedElements(constructor);
       ClosureClassMap oldClosureData = localsHandler.closureData;
       Node node = constructor.parseNode(compiler);
       ClosureClassMap newClosureData =
           compiler.closureToClassMapper.computeClosureToClassMapping(
               constructor, node, elements);
-      // The [:this:] element now refers to the one in the new closure
-      // data, that is the [:this:] of the super constructor. We
-      // update the element to refer to the current [:this:].
-      localsHandler.updateLocal(newClosureData.thisElement,
-                                localsHandler.readThis());
       localsHandler.closureData = newClosureData;
 
       params.orderedForEachParameter((Element parameterElement) {
         if (elements.isParameterChecked(parameterElement)) {
           addParameterCheckInstruction(parameterElement);
         }
       });
       localsHandler.enterScope(node, constructor);
       buildInitializers(constructor, constructors, fieldValues);
       localsHandler.closureData = oldClosureData;
@@ skipping 115 matching lines @@
 
 
   /**
    * Build the factory function corresponding to the constructor
    * [functionElement]:
    *  - Initialize fields with the values of the field initializers of the
    *    current constructor and super constructors or constructors redirected
    *    to, starting from the current constructor.
    *  - Call the the constructor bodies, starting from the constructor(s) in the
    *    super class(es).
-   *
-   * Invariant: Both [classElement] and [functionElement] must be
-   * implementation elements.
    */
-  HGraph buildFactory(ClassElement classElement,
-                      FunctionElement functionElement) {
-    assert(invariant(classElement, classElement.isImplementation));
-    assert(invariant(functionElement, functionElement.isImplementation));
+  HGraph buildFactory(FunctionElement functionElement) {
+    functionElement = functionElement.implementation;
+    ClassElement classElement =
+        functionElement.getEnclosingClass().implementation;
     FunctionExpression function = functionElement.parseNode(compiler);
     // Note that constructors (like any other static function) do not need
     // to deal with optional arguments. It is the callers job to provide all
     // arguments as if they were positional.
 
-    // The initializer list could contain closures.
-    openFunction(functionElement, function);
+    if (inliningStack.isEmpty) {
+      // The initializer list could contain closures.
+      openFunction(functionElement, function);
+    }
 
     Map<Element, HInstruction> fieldValues = new Map<Element, HInstruction>();
 
     // Compile the possible initialization code for local fields and
     // super fields.
     buildFieldInitializers(classElement, fieldValues);
 
     // Compile field-parameters such as [:this.x:].
     FunctionSignature params = functionElement.computeSignature(compiler);
     params.orderedForEachParameter((Element element) {
@@ skipping 87 matching lines @@
       ClosureScope scopeData = parameterClosureData.capturingScopes[node];
       if (scopeData != null) {
         bodyCallInputs.add(localsHandler.readLocal(scopeData.boxElement));
       }
 
       HInvokeConstructorBody invoke =
           new HInvokeConstructorBody(body, bodyCallInputs);
       invoke.sideEffects = compiler.world.getSideEffectsOfElement(constructor);
       add(invoke);
     }
-    closeAndGotoExit(new HReturn(newObject));
-    return closeFunction();
+    if (inliningStack.isEmpty) {
+      closeAndGotoExit(new HReturn(newObject));
+      return closeFunction();
+    } else {
+      localsHandler.updateLocal(returnElement, newObject);
+      return null;
+    }
   }
 
   void addParameterCheckInstruction(Element element) {
     HInstruction check;
     Element checkResultElement =
         localsHandler.closureData.parametersWithSentinel[element];
     if (currentElement.isGenerativeConstructorBody()) {
       // A generative constructor body receives extra parameters that
       // indicate if a parameter was passed to the factory.
       check = addParameter(checkResultElement);
@@ skipping 3337 matching lines @@
 
   bool seenReturn = false;
   bool tooDifficult = false;
   int nodeCount = 0;
 
   InlineWeeder(this.elements);
 
   static bool canBeInlined(FunctionExpression functionExpression,
                            TreeElements elements) {
     InlineWeeder weeder = new InlineWeeder(elements);
+    weeder.visit(functionExpression.initializers);
     weeder.visit(functionExpression.body);
     if (weeder.tooDifficult) return false;
     return true;
   }
 
   bool registerNode() {
     if (nodeCount++ > SsaBuilder.MAX_INLINING_NODES) {
       tooDifficult = true;
       return false;
     } else {
       return true;
     }
   }
 
   void visit(Node node) {
-    node.accept(this);
+    if (node != null) node.accept(this);
   }
 
   void visitNode(Node node) {
     if (!registerNode()) return;
     if (seenReturn) {
       tooDifficult = true;
     } else {
       node.visitChildren(this);
     }
   }
@@ skipping 305 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }