Implementing ConstructorCall. (part I)

runtime/vm/intermediate_language.h

 // 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.
 
 #ifndef VM_INTERMEDIATE_LANGUAGE_H_
 #define VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 17 matching lines @@
 // | StrictCompare <Token::kind> <Value> <Value>
 // | NativeCall <NativeBodyNode>
 // | StoreIndexed <Value> <Value> <Value>
 // | InstanceSetter <String> <Value> <Value>
 // | LoadInstanceField <LoadInstanceFieldNode> <Value>
 // | StoreInstanceField <StoreInstanceFieldNode> <Value> <Value>
 // | LoadStaticField <Field>
 // | StoreStaticField <Field> <Value>
 // | BooleanNegate <Value>
 // | InstanceOf <Value> <Type>
+// | AllocateObject <ConstructorCallNode>
 //
 // <Value> ::=
 //   Temp <int>
 // | Constant <Instance>
 
 // M is a two argument macro.  It is applied to each concrete value's
 // typename and classname.
 #define FOR_EACH_VALUE(M)                                                      \
   M(Temp, TempVal)                                                             \
   M(Constant, ConstantVal)                                                     \
@@ skipping 10 matching lines @@
   M(StoreLocal, StoreLocalComp)                                                \
   M(StrictCompare, StrictCompareComp)                                          \
   M(NativeCall, NativeCallComp)                                                \
   M(StoreIndexed, StoreIndexedComp)                                            \
   M(InstanceSetter, InstanceSetterComp)                                        \
   M(LoadInstanceField, LoadInstanceFieldComp)                                  \
   M(StoreInstanceField, StoreInstanceFieldComp)                                \
   M(LoadStaticField, LoadStaticFieldComp)                                      \
   M(StoreStaticField, StoreStaticFieldComp)                                    \
   M(BooleanNegate, BooleanNegateComp)                                          \
-  M(InstanceOf, InstanceOfComp)
+  M(InstanceOf, InstanceOfComp)                                                \
+  M(AllocateObject, AllocateObjectComp)
 
 
 #define FORWARD_DECLARATION(ShortName, ClassName) class ClassName;
 FOR_EACH_COMPUTATION(FORWARD_DECLARATION)
 #undef FORWARD_DECLARATION
 
 class Computation : public ZoneAllocated {
  public:
   Computation() { }
 
@@ skipping 41 matching lines @@
 
  private:
   const intptr_t index_;
 
   DISALLOW_COPY_AND_ASSIGN(TempVal);
 };
 
 
 class ConstantVal: public Value {
  public:
-  explicit ConstantVal(const Instance& instance) : instance_(instance) {
-    ASSERT(instance.IsZoneHandle());
+  explicit ConstantVal(const Object& value) : value_(value) {
+    ASSERT(value.IsZoneHandle());

[srdjan, 2012/03/09 02:37:47]

This is needed in order to pass types as arguments

   }
 
   DECLARE_VALUE(Constant)
 
-  const Instance& instance() const { return instance_; }
+  const Object& value() const { return value_; }
 
  private:
-  const Instance& instance_;
+  const Object& value_;
 
   DISALLOW_COPY_AND_ASSIGN(ConstantVal);
 };
 
 #undef DECLARE_VALUE
 
 
 class AssertAssignableComp : public Computation {
  public:
   AssertAssignableComp(Value* value, const AbstractType& type)
@@ skipping 70 matching lines @@
   const Token::Kind kind_;
   Value* left_;
   Value* right_;
 
   DISALLOW_COPY_AND_ASSIGN(StrictCompareComp);
 };
 
 
 class StaticCallComp : public Computation {
  public:
-  StaticCallComp(StaticCallNode* node, ZoneGrowableArray<Value*>* arguments)
-      : ast_node_(*node), arguments_(arguments) { }
+  StaticCallComp(intptr_t token_index,
+                 const Function& function,
+                 const Array& argument_names,
+                 ZoneGrowableArray<Value*>* arguments)
+      : token_index_(token_index),
+        function_(function),
+        argument_names_(argument_names),
+        arguments_(arguments) {
+    ASSERT(function.IsZoneHandle());
+    ASSERT(argument_names.IsZoneHandle());
+  }
 
   DECLARE_COMPUTATION(StaticCall)
 
   // Accessors forwarded to the AST node.
-  const Function& function() const { return ast_node_.function(); }
-  const Array& argument_names() const { return ast_node_.arguments()->names(); }
-  intptr_t token_index() const { return ast_node_.token_index(); }
+  const Function& function() const { return function_; }
+  const Array& argument_names() const { return argument_names_; }
+  intptr_t token_index() const { return token_index_; }
 
   int ArgumentCount() const { return arguments_->length(); }
   Value* ArgumentAt(int index) const { return (*arguments_)[index]; }
 
  private:
-  const StaticCallNode& ast_node_;
+  const intptr_t token_index_;
+  const Function& function_;
+  const Array& argument_names_;
   ZoneGrowableArray<Value*>* arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticCallComp);
 };
 
 
 class LoadLocalComp : public Computation {
  public:
   explicit LoadLocalComp(const LocalVariable& local) : local_(local) { }
 
@@ skipping 248 matching lines @@
   const intptr_t node_id_;
   const intptr_t token_index_;
   Value* value_;
   const AbstractType& type_;
   const bool negate_result_;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceOfComp);
 };
 
 
+class AllocateObjectComp : public Computation {
+ public:
+  explicit AllocateObjectComp(ConstructorCallNode* node) : ast_node_(*node) {}

[srdjan, 2012/03/09 02:37:47]

Will add two Values: type arguments and instantiator. Will probably change the
allocation stub to always accept those two arguments (currently the allocation
stub for types without type arguments do not expect the two values)

[srdjan, 2012/03/09 22:40:48]

Changed opinion: adding an array of values (lebgth 0 or 2). Using same same
allocation stub as before.

+
+  DECLARE_COMPUTATION(AllocateObjectComp)
+
+  const Function& constructor() const { return ast_node_.constructor(); }
+  intptr_t token_index() const { return ast_node_.token_index(); }
+
+ private:
+  const ConstructorCallNode& ast_node_;
+
+  DISALLOW_COPY_AND_ASSIGN(AllocateObjectComp);
+};
+
+
 #undef DECLARE_COMPUTATION
 
 
 // Instructions.
 //
 // <Instruction> ::= JoinEntry <Instruction>
 //                 | TargetEntry <Instruction>
 //                 | PickTemp <int> <int> <Instruction>
 //                 | TuckTemp <int> <int> <Instruction>
 //                 | Do <Computation> <Instruction>
@@ skipping 329 matching lines @@
 #undef DECLARE_VISIT_INSTRUCTION
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_