Implementing ConstructorCall. (part I)

runtime/vm/flow_graph_builder.cc

 // 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.
 
 #include "vm/flow_graph_builder.h"
 
 #include "vm/ast_printer.h"
 #include "vm/flags.h"
 #include "vm/intermediate_language.h"
 #include "vm/longjump.h"
@@ skipping 654 matching lines @@
   ReturnComputation(call);
 }
 
 
 // <Expression> ::= StaticCall { function: Function
 //                               arguments: <ArgumentList> }
 void EffectGraphVisitor::VisitStaticCallNode(StaticCallNode* node) {
   int length = node->arguments()->length();
   ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>(length);
   TranslateArgumentList(*node->arguments(), temp_index(), values);
-  StaticCallComp* call = new StaticCallComp(node, values);
+  StaticCallComp* call =
+      new StaticCallComp(node->token_index(),
+                         node->function(),
+                         node->arguments()->names(),
+                         values);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
   Bailout("EffectGraphVisitor::VisitClosureCallNode");
 }
 
 
 void EffectGraphVisitor::VisitCloneContextNode(CloneContextNode* node) {
   Bailout("EffectGraphVisitor::VisitCloneContextNode");
 }
 
 
 void EffectGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
   Bailout("EffectGraphVisitor::VisitConstructorCallNode");
 }
 
 
+void EffectGraphVisitor::BuildTypeArguments(ConstructorCallNode* node) {
+  const Class& cls = Class::ZoneHandle(node->constructor().owner());
+  ASSERT(cls.HasTypeArguments());
+  if (node->type_arguments().IsNull() ||
+      node->type_arguments().IsInstantiated()) {
+    AddInstruction(
+        new BindInstr(temp_index(), new ConstantVal(node->type_arguments())));
+    if (node->constructor().IsFactory()) {
+      UNIMPLEMENTED();
+    } else {
+      // Null instantiator.
+      AddInstruction(new BindInstr(
+          temp_index() + 1, new ConstantVal(Object::ZoneHandle())));
+    }
+    return;
+  }
+  Bailout("EffectGraphVisitor::BuildTypeArguments");
+}
+
+
+void ValueGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
+  if (node->constructor().IsFactory()) {
+    Bailout("EffectGraphVisitor::VisitConstructorCallNode Factory");
+  }
+
+  const Class& cls = Class::ZoneHandle(node->constructor().owner());
+  const bool requires_type_arguments = cls.HasTypeArguments();
+  if (requires_type_arguments) {
+    BuildTypeArguments(node);
+  }
+  // t_n contains the allocated and initialized object.
+  //   t_n      <- AllocateObject(class)
+  //   t_n+1    <- Pick(t_n)
+  //   t_n+2    <- ctor-arg
+  //   t_n+3... <- constructor arguments start here
+  //   StaticCall(constructor, t_n+1, t_n+2, ...)
+
+  AllocateObjectComp* alloc_comp = new AllocateObjectComp(node);
+  AddInstruction(new BindInstr(temp_index(), alloc_comp));
+  intptr_t result_index = AllocateTempIndex();
+  TempVal* alloc_value = new TempVal(result_index);
+  TempVal* dup_alloc_value = new TempVal(result_index + 1);
+  TempVal* ctor_arg_value = new TempVal(result_index + 2);
+  AddInstruction(
+      new PickTempInstr(dup_alloc_value->index(), alloc_value->index()));
+
+  ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>();
+  values->Add(dup_alloc_value);
+  const Smi& ctor_arg = Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll));
+  AddInstruction(
+      new BindInstr(ctor_arg_value->index(), new ConstantVal(ctor_arg)));
+  values->Add(ctor_arg_value);
+  TranslateArgumentList(*node->arguments(), result_index + 3, values);
+  StaticCallComp* call =
+      new StaticCallComp(node->token_index(),
+                         node->constructor(),
+                         node->arguments()->names(),
+                         values);
+  AddInstruction(new DoInstr(call));
+  ReturnValue(alloc_value);
+}
+
+
 void EffectGraphVisitor::VisitInstanceGetterNode(InstanceGetterNode* node) {
   ArgumentGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(1);
   arguments->Add(for_receiver.value());
   const String& name =
       String::ZoneHandle(Field::GetterSymbol(node->field_name()));
   InstanceCallComp* call =
       new InstanceCallComp(node->id(), node->token_index(), name,
@@ skipping 261 matching lines @@
   }
 }
 
 
 void FlowGraphPrinter::VisitTemp(TempVal* val) {
   OS::Print("t%d", val->index());
 }
 
 
 void FlowGraphPrinter::VisitConstant(ConstantVal* val) {
-  OS::Print("#%s", val->instance().ToCString());
+  OS::Print("#%s", val->value().ToCString());
 }
 
 
 void FlowGraphPrinter::VisitAssertAssignable(AssertAssignableComp* comp) {
   OS::Print("AssertAssignable(");
   comp->value()->Accept(this);
   OS::Print(", %s)", comp->type().ToCString());
 }
 
 
@@ skipping 103 matching lines @@
 }
 
 
 void FlowGraphPrinter::VisitInstanceOf(InstanceOfComp* comp) {
   comp->value()->Accept(this);
   OS::Print(" %s %s",
       comp->negate_result() ? "ISNOT" : "IS",
       String::Handle(comp->type().Name()).ToCString());
 }
 
+void FlowGraphPrinter::VisitAllocateObject(AllocateObjectComp* comp) {
+  OS::Print("AllocateObject(%s)",
+      Class::Handle(comp->constructor().owner()).ToCString());
+}
+
+
 void FlowGraphPrinter::VisitJoinEntry(JoinEntryInstr* instr) {
   OS::Print("%2d: [join]", instr->block_number());
 }
 
 
 void FlowGraphPrinter::VisitTargetEntry(TargetEntryInstr* instr) {
   OS::Print("%2d: [target]", instr->block_number());
 }
 
 
@@ skipping 66 matching lines @@
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len));
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart