Support instance getters and setters, indexed loads and stores.

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"
 #include "vm/handles_impl.h"
 #include "vm/object.h"
 
 namespace dart {
 
 class FlowGraphVisitor;
 class LocalVariable;
 
 // Computations and values.
 //
-// <Computation> ::= <Value>
-//                 | AssertAssignable <Value> <AbstractType>
-//                 | InstanceCall <cstring> <Value> ...
-//                 | StaticCall <Function> <Value> ...
-//                 | LoadLocal <LocalVariable>
-//                 | StoreLocal <LocalVariable> <Value>
-//                 | StrictCompare <Token::kind> <Value> <Value>
+// <Computation> ::=
+//   <Value>
+// | AssertAssignable <Value> <AbstractType>
+// | InstanceCall <AstNode> <String> <Value> ...
+// | StaticCall <StaticCallNode> <Value> ...
+// | LoadLocal <LocalVariable>
+// | StoreLocal <LocalVariable> <Value>
+// | StoreIndexed <Value> <Value> <Value> <Value>
+// | StrictCompare <Token::kind> <Value> <Value>
 //
-// <Value> ::= Temp <int>
-//           | Constant <Instance>
+// <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)
+  M(Constant, ConstantVal)                                                     \
+
 
 // M is a two argument macro.  It is applied to each concrete instruction's
 // (including the values) typename and classname.
 #define FOR_EACH_COMPUTATION(M)                                                \
   FOR_EACH_VALUE(M)                                                            \
   M(AssertAssignable, AssertAssignableComp)                                    \
   M(InstanceCall, InstanceCallComp)                                            \
   M(StrictCompare, StrictCompareComp)                                          \
   M(StaticCall, StaticCallComp)                                                \
   M(LoadLocal, LoadLocalComp)                                                  \
-  M(StoreLocal, StoreLocalComp)
+  M(StoreLocal, StoreLocalComp)                                                \
+  M(StoreIndexed, StoreIndexedComp)                                            \
+  M(InstanceSetter, InstanceSetterComp)                                        \
 
 
 #define FORWARD_DECLARATION(ShortName, ClassName) class ClassName;
 FOR_EACH_COMPUTATION(FORWARD_DECLARATION)
 #undef FORWARD_DECLARATION
 
 class Computation : public ZoneAllocated {
  public:
   Computation() { }
 
@@ skipping 78 matching lines @@
  private:
   Value* value_;
   const AbstractType& type_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertAssignableComp);
 };
 
 
 class InstanceCallComp : public Computation {
  public:
-  InstanceCallComp(const char* name, ZoneGrowableArray<Value*>* arguments)
-      : name_(name), arguments_(arguments) {
+  InstanceCallComp(AstNode* node,
+                   const String& function_name,
+                   ZoneGrowableArray<Value*>* arguments,
+                   const Array& argument_names,
+                   intptr_t checked_argument_count)
+      : ast_node_(*node),
+        function_name_(function_name),
+        arguments_(arguments),
+        argument_names_(argument_names),
+        checked_argument_count_(checked_argument_count) {
+    ASSERT(function_name.IsZoneHandle());
     ASSERT(!arguments->is_empty());
+    ASSERT(argument_names.IsZoneHandle());
   }
 
   DECLARE_COMPUTATION(InstanceCall)
 
-  const char* name() const { return name_; }
+  // Accessors forwarded to the AST node.
+  intptr_t node_id() const { return ast_node_.id(); }
+  intptr_t token_index() const { return ast_node_.token_index(); }
+
+  const String& function_name() const { return function_name_; }
   int ArgumentCount() const { return arguments_->length(); }
   Value* ArgumentAt(int index) const { return (*arguments_)[index]; }
+  const Array& argument_names() const { return argument_names_; }
+  intptr_t checked_argument_count() const { return checked_argument_count_; }
 
  private:
-  const char* name_;
-  ZoneGrowableArray<Value*>* arguments_;
+  const AstNode& ast_node_;
+  const String& function_name_;
+  ZoneGrowableArray<Value*>* const arguments_;
+  const Array& argument_names_;
+  const intptr_t checked_argument_count_;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceCallComp);
 };
 
 
 class StrictCompareComp : public Computation {
  public:
   StrictCompareComp(Token::Kind kind, Value* left, Value* right)
       : kind_(kind), left_(left), right_(right) {
     ASSERT((kind_ == Token::kEQ_STRICT) || (kind_ == Token::kNE_STRICT));
   }
 
   DECLARE_COMPUTATION(StrictCompare)
 
   Token::Kind kind() const { return kind_; }
   Value* left() const { return left_; }
   Value* right() const { return right_; }
 
  private:
   const Token::Kind kind_;
   Value* left_;
   Value* right_;
 
   DISALLOW_COPY_AND_ASSIGN(StrictCompareComp);
 };
 
 
 class StaticCallComp : public Computation {
  public:
-  StaticCallComp(const Function& function, ZoneGrowableArray<Value*>* arguments)
-      : function_(function), arguments_(arguments) {
-    ASSERT(function.IsZoneHandle());
-  }
+  StaticCallComp(StaticCallNode* node, ZoneGrowableArray<Value*>* arguments)
+      : ast_node_(*node), arguments_(arguments) { }
 
   DECLARE_COMPUTATION(StaticCall)
 
-  const Function& function() const { return function_; }
+  // 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(); }
+
   int ArgumentCount() const { return arguments_->length(); }
   Value* ArgumentAt(int index) const { return (*arguments_)[index]; }
 
  private:
-  const Function& function_;
+  const StaticCallNode& ast_node_;
   ZoneGrowableArray<Value*>* arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticCallComp);
 };
 
 
 class LoadLocalComp : public Computation {
  public:
   explicit LoadLocalComp(const LocalVariable& local) : local_(local) { }
 
@@ skipping 18 matching lines @@
   const LocalVariable& local() const { return local_; }
   Value* value() const { return value_; }
 
  private:
   const LocalVariable& local_;
   Value* value_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreLocalComp);
 };
 
+
+// Not simply an InstanceCall because it has somewhat more complicated
+// semantics: the value operand is preserved in a placeholder (the first
+// operand is a preallocated slot that can be used).
+class StoreIndexedComp : public Computation {
+ public:
+  StoreIndexedComp(StoreIndexedNode* node,
+                   Value* placeholder,
+                   Value* array,
+                   Value* index,
+                   Value* value)
+      : ast_node_(*node),
+        placeholder_(placeholder),
+        array_(array),
+        index_(index),
+        value_(value) { }
+
+  DECLARE_COMPUTATION(StoreIndexed)
+
+  // Accessors forwarded to the AST node.
+  intptr_t node_id() const { return ast_node_.id(); }
+  intptr_t token_index() const { return ast_node_.token_index(); }
+
+  Value* placeholder() const { return placeholder_; }
+  Value* array() const { return array_; }
+  Value* index() const { return index_; }
+  Value* value() const { return value_; }
+
+ private:
+  const StoreIndexedNode& ast_node_;
+  Value* placeholder_;
+  Value* array_;
+  Value* index_;
+  Value* value_;
+
+  DISALLOW_COPY_AND_ASSIGN(StoreIndexedComp);
+};
+
+
+// Not simply an InstanceCall because it has somewhat more complicated
+// semantics: the value operand is preserved in a placeholder (the first
+// operand is a preallocate slot that can be used).
+class InstanceSetterComp : public Computation {
+ public:
+  InstanceSetterComp(InstanceSetterNode* node,
+                     Value* placeholder,
+                     Value* receiver,
+                     Value* value)
+      : ast_node_(*node),
+        placeholder_(placeholder),
+        receiver_(receiver),
+        value_(value) { }
+
+  DECLARE_COMPUTATION(InstanceSetter)
+
+  // Accessors forwarded to the AST node.
+  intptr_t node_id() const { return ast_node_.id(); }
+  intptr_t token_index() const { return ast_node_.token_index(); }
+  const String& field_name() const { return ast_node_.field_name(); }
+
+  Value* placeholder() const { return placeholder_; }
+  Value* receiver() const { return receiver_; }
+  Value* value() const { return value_; }
+
+ private:
+  const InstanceSetterNode& ast_node_;
+  Value* placeholder_;
+  Value* receiver_;
+  Value* value_;
+
+  DISALLOW_COPY_AND_ASSIGN(InstanceSetterComp);
+};
+
+
 #undef DECLARE_COMPUTATION
 
 
 // Instructions.
 //
 // <Instruction> ::= Do <Computation> <Instruction>
 //                 | Bind <int> <Computation> <Instruction>
 //                 | Return <Value>
 //                 | Branch <Value> <Instruction> <Instruction>
 //                 | Empty <Instruction>
@@ skipping 258 matching lines @@
 #undef DECLARE_VISIT_INSTRUCTION
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_