Support compilation of ArrayNode.

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 47 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(CreateArray, CreateArrayComp)                                              \
 
 
 #define FORWARD_DECLARATION(ShortName, ClassName) class ClassName;
 FOR_EACH_COMPUTATION(FORWARD_DECLARATION)
 #undef FORWARD_DECLARATION
 
 class Computation : public ZoneAllocated {
  public:
   Computation() { }
 
@@ skipping 219 matching lines @@
 };
 
 
 class LoadInstanceFieldComp : public Computation {
  public:
   LoadInstanceFieldComp(LoadInstanceFieldNode* ast_node, Value* instance)
       : ast_node_(*ast_node), instance_(instance) {
     ASSERT(instance_ != NULL);
   }
 
-  DECLARE_COMPUTATION(LoadInstanceFieldComp)
+  DECLARE_COMPUTATION(LoadInstanceField)
 
   const Field& field() const { return ast_node_.field(); }
 
   Value* instance() const { return instance_; }
 
  private:
   const LoadInstanceFieldNode& ast_node_;
   Value* instance_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadInstanceFieldComp);
 };
 
 
 class StoreInstanceFieldComp : public Computation {
  public:
   StoreInstanceFieldComp(StoreInstanceFieldNode* ast_node,
                          Value* instance,
                          Value* value)
       : ast_node_(*ast_node), instance_(instance), value_(value) {
     ASSERT(instance_ != NULL);
     ASSERT(value_ != NULL);
   }
 
-  DECLARE_COMPUTATION(StoreInstanceFieldComp)
+  DECLARE_COMPUTATION(StoreInstanceField)
 
   intptr_t node_id() const { return ast_node_.id(); }
   intptr_t token_index() const { return ast_node_.token_index(); }
   const Field& field() const { return ast_node_.field(); }
 
   Value* instance() const { return instance_; }
   Value* value() const { return value_; }
 
  private:
   const StoreInstanceFieldNode& ast_node_;
   Value* instance_;
   Value* value_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreInstanceFieldComp);
 };
 
 
 class LoadStaticFieldComp : public Computation {
  public:
   explicit LoadStaticFieldComp(const Field& field) : field_(field) {}
 
-  DECLARE_COMPUTATION(LoadStaticFieldComp);
+  DECLARE_COMPUTATION(LoadStaticField);
 
   const Field& field() const { return field_; }
 
  private:
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadStaticFieldComp);
 };
 
 
 class StoreStaticFieldComp : public Computation {
  public:
   StoreStaticFieldComp(const Field& field, Value* value)
       : field_(field),
         value_(value) {
     ASSERT(field.IsZoneHandle());
     ASSERT(value != NULL);
   }
 
-  DECLARE_COMPUTATION(StoreStaticFieldComp);
+  DECLARE_COMPUTATION(StoreStaticField);
 
   const Field& field() const { return field_; }
   Value* value() const { return value_; }
 
  private:
   const Field& field_;
   Value* const value_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreStaticFieldComp);
 };
@@ skipping 65 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(InstanceSetterComp);
 };
 
 
 // Note overrideable, built-in: value? false : true.
 class BooleanNegateComp : public Computation {
  public:
   explicit BooleanNegateComp(Value* value) : value_(value) {}
 
-  DECLARE_COMPUTATION(BooleanNegateComp)
+  DECLARE_COMPUTATION(BooleanNegate)
 
   Value* value() const { return value_; }
 
  private:
   Value* value_;
 
   DISALLOW_COPY_AND_ASSIGN(BooleanNegateComp);
 };
 
 
 class InstanceOfComp : public Computation {
  public:
   InstanceOfComp(intptr_t node_id,
                  intptr_t token_index,
                  Value* value,
                  const AbstractType& type,
                  bool negate_result)
       : node_id_(node_id),
         token_index_(token_index),
         value_(value),
         type_(type),
         negate_result_(negate_result) {}
 
-  DECLARE_COMPUTATION(InstanceOfComp)
+  DECLARE_COMPUTATION(InstanceOf)
 
   Value* value() const { return value_; }
   bool negate_result() const { return negate_result_; }
   const AbstractType& type() const { return type_; }
 
  private:
   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 CreateArrayComp : public Computation {
+ public:
+  CreateArrayComp(ArrayNode* node, ZoneGrowableArray<Value*>* elements)
+      : ast_node_(*node), elements_(elements) { }
+
+  DECLARE_COMPUTATION(CreateArray)
+
+  intptr_t token_index() const { return ast_node_.token_index(); }
+  const AbstractTypeArguments& type_arguments() const {
+    return ast_node_.type_arguments();
+  }
+  intptr_t ElementCount() const { return elements_->length(); }
+  Value* ElementAt(intptr_t i) const { return (*elements_)[i]; }
+
+ private:
+  const ArrayNode& ast_node_;
+  ZoneGrowableArray<Value*>* const elements_;
+
+  DISALLOW_COPY_AND_ASSIGN(CreateArrayComp);
+};
+
+
 #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_