Second try for instantiation of objects.

frog/leg/ssa/builder.dart

 // Copyright (c) 2011, 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.
 
 class SsaBuilderTask extends CompilerTask {
   SsaBuilderTask(Compiler compiler) : super(compiler);
   String get name() => 'SSA builder';
 
   HGraph build(FunctionElement element, TreeElements elements) {
     return measure(() {
       FunctionExpression function = element.node;
       HInstruction.idCounter = 0;
-      HGraph graph =
-          compileMethod(function.parameters, function.body, elements);
+      SsaBuilder builder = new SsaBuilder(compiler, elements);
+      HGraph graph;
+      switch (element.kind) {
+        case ElementKind.CONSTRUCTOR:
+          graph = compileConstructor(builder, function, element, elements);
+          break;
+        case ElementKind.CONSTRUCTOR_BODY:
+          graph = compileConstructorBody(builder, function, element, elements);
+          break;
+        case ElementKind.FUNCTION:
+          graph = compileMethod(builder, function, element, elements);
+          break;
+      }
       assert(graph.isValid());
       if (GENERATE_SSA_TRACE) {
         Identifier name = function.name;
         new HTracer.singleton().traceCompilation(name.source.toString());
         new HTracer.singleton().traceGraph('builder', graph);
       }
       return graph;
     });
   }
 
-  HGraph compileMethod(NodeList parameters,
-                       Node body,
+  HGraph compileConstructor(SsaBuilder builder,
+                            FunctionExpression function,
+                            FunctionElement element,
+                            TreeElements elements) {
+    // The body of the constructor will be generated in a separate function.
+    ConstructorBodyElement bodyElement = new ConstructorBodyElement(element);
+    compiler.worklist.add(new WorkElement.toCodegen(bodyElement, elements));
+    ClassElement classElement = element.enclosingElement;
+    classElement.backendMembers =
+        classElement.backendMembers.prepend(bodyElement);
+    // TODO(floitsch): pass initializer-list to builder.
+    return builder.buildFactory(classElement, bodyElement, function.parameters);
+  }
+
+  HGraph compileConstructorBody(SsaBuilder builder,
+                                FunctionExpression function,
+                                FunctionElement element,
+                                TreeElements elements) {
+    // TODO(floitsch): find super call and pass it to the builder.
+    return builder.buildConstructorBody(null,
+                                        function.parameters,
+                                        function.body);
+  }
+
+  HGraph compileMethod(SsaBuilder builder,
+                       FunctionExpression function,
+                       FunctionElement element,
                        TreeElements elements) {
-    SsaBuilder builder = new SsaBuilder(compiler, elements);
-    HGraph graph = builder.build(parameters, body);
-    return graph;
+    return builder.buildMethod(function.parameters, function.body);
   }
 }
 
 class SsaBuilder implements Visitor {
   final Compiler compiler;
   final TreeElements elements;
   HGraph graph;
 
   // We build the Ssa graph by simulating a stack machine.
   List<HInstruction> stack;
 
   Map<Element, HInstruction> definitions;
 
   // The current block to add instructions to. Might be null, if we are
   // visiting dead code.
   HBasicBlock current;
   // Whether we are currently processing a condition expression (e.g., from
   // an if, while, do-while, or for statement, or the conditional expression.
   // (Currently, only if-statements are processed this way).
   bool isConditionExpression = false;
 
   SsaBuilder(this.compiler, this.elements);
 
-  HGraph build(NodeList parameters, Node body) {
+  HGraph buildMethod(NodeList parameters, Node body) {
+    openFunction(parameters);
+    body.accept(this);
+    return closeFunction();
+  }
+
+  HGraph buildFactory(ClassElement classElement,
+                      ConstructorBodyElement bodyElement,
+                      NodeList parameters) {
+    openFunction(parameters);
+    HForeignNew newObject = new HForeignNew(classElement, []);
+    add(newObject);
+    String methodName = compiler.namer.getName(bodyElement);
+    List bodyCallInputs = <HInstruction>[];
+    bodyCallInputs.add(newObject);
+    Link link = parameters.nodes;
+    for (; !link.isEmpty(); link = link.tail) {
+      Element parameterElement = elements[link.head];
+      HInstruction currentValue = definitions[parameterElement];
+      bodyCallInputs.add(currentValue);
+    }
+    add(new HInvokeDynamic(methodName, bodyCallInputs));
+    close(new HReturn(newObject)).addSuccessor(graph.exit);
+    return closeFunction();
+  }
+
+  HGraph buildConstructorBody(Send superInvocation,
+                              NodeList parameters,
+                              Node body) {
+    openFunction(parameters);
+    if (superInvocation !== null) {
+      compiler.unimplemented('SsaBuilder.buildConstructorBody');
+      Element superElement = elements[superInvocation];
+      String methodName = compiler.namer.constructorBodyName(superElement);
+      List superInputs = <HInstruction>[];
+      superInputs.add(new HThis());
+      Link link = superInvocation.arguments.head;
+      for (; !link.isEmpty(); link = link.tail) {
+        visit(link.head);
+        superInputs.add(pop());
+      }
+      add(new HInvokeDynamic(methodName, superInputs));
+    }
+    body.accept(this);
+    return closeFunction();    
+  }
+
+  void openFunction(NodeList parameters) {
     stack = new List<HInstruction>();
     definitions = new Map<Element, HInstruction>();
 
     graph = new HGraph();
     HBasicBlock block = graph.addNewBlock();
 
     open(graph.entry);
     visitParameterValues(parameters);
     close(new HGoto()).addSuccessor(block);
 
-    open(block);
-    body.accept(this);
+    open(block);    
+  }
 
+  HGraph closeFunction() {
     // TODO(kasperl): Make this goto an implicit return.
     if (!isAborted()) close(new HGoto()).addSuccessor(graph.exit);
     graph.finalize();
     return graph;
   }
 
   HBasicBlock addNewBlock() {
     HBasicBlock block = graph.addNewBlock();
     if (isConditionExpression) block.isCondition = true;
     return block;
@@ skipping 504 matching lines @@
       } else {
         HStatic target = new HStatic(element);
         add(target);
         List inputs = <HInstruction>[target];
         inputs.addAll(arguments);
         push(new HInvokeStatic(inputs));
       }
     }
   }
 
-  visitNewExpression(NewExpression node) {
-    compiler.unimplemented("SsaBuilder: new expression");
-  }
+  visitNewExpression(NewExpression node) => visitSend(node.send);
 
   HInstruction updateDefinition(Node node, HInstruction value) {
     VariableElement element = elements[node];
     value = guard(element.type, value);
     definitions[element] = value;
     return value;
   }
 
   visitSendSet(SendSet node) {
     Operator op = node.assignmentOperator;
@@ skipping 184 matching lines @@
     thenBlock.addSuccessor(joinBlock);
     elseBlock.addSuccessor(joinBlock);
     open(joinBlock);
 
     definitions = joinDefinitions(joinBlock, thenDefinitions, definitions);
     HPhi phi = new HPhi.manyInputs(null, [thenInstruction, elseInstruction]);
     joinBlock.addPhi(phi);
     stack.add(phi);
   }
 }