Implement StaticCall and InstanceCall in the new code generator.

runtime/vm/flow_graph_builder.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_FLOW_GRAPH_BUILDER_H_
 #define VM_FLOW_GRAPH_BUILDER_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 73 matching lines @@
 
   // Append a 'while loop' test and back edge to this graph, depending on
   // which parts are reachable.  Afterward, the graph exit is the false
   // successor of the loop condition.
   void TieLoop(const TestGraphVisitor& test_fragment,
                const EffectGraphVisitor& body_fragment);
 
  protected:
   // Helpers for translating parts of the AST.
   void TranslateArgumentList(const ArgumentListNode& node,
+                             intptr_t next_temp_index,
                              ZoneGrowableArray<Value*>* values);
 
   void CloseFragment() { exit_ = NULL; }
   intptr_t AllocateTempIndex() { return temp_index_++; }
 
  private:
   // Specify a computation as the final result.  Adds a Do instruction to
   // the graph, but normally overridden in subclasses.
   virtual void ReturnComputation(Computation* computation) {
     AddInstruction(new DoInstr(computation));
@@ skipping 20 matching lines @@
  public:
   ValueGraphVisitor(FlowGraphBuilder* owner, intptr_t temp_index)
       : EffectGraphVisitor(owner, temp_index), value_(NULL) { }
 
   // Visit functions overridden by this class.
   virtual void VisitLiteralNode(LiteralNode* node);
   virtual void VisitLoadLocalNode(LoadLocalNode* node);
 
   Value* value() const { return value_; }
 
+ protected:
+  // Output parameters.
+  Value* value_;
+
  private:
   // Helper to set the output state to return a Value.
-  void ReturnValue(Value* value) { value_ = value; }
+  virtual void ReturnValue(Value* value) { value_ = value; }
 
   // Specify a computation as the final result.  Adds a Bind instruction to
   // the graph and returns its temporary value (i.e., set the output
   // parameters).
   virtual void ReturnComputation(Computation* computation) {
     AddInstruction(new BindInstr(temp_index(), computation));
     value_ = new TempVal(AllocateTempIndex());
   }
-
-  // Output parameters.
-  Value* value_;
 };
 
 
+// Translate an AstNode to a control-flow graph fragment for both its effects
+// and value as an outgoing argument.  Implements a function from an AstNode
+// and next temporary index to a graph fragment (as in the
+// EffectGraphBuilder), an updated temporary index, and an intermediate
+// language Value.

[srdjan, 2012/03/01 17:50:12]

Why do we need both ArgumentGraphVisitor and ValueGraphVisitor? The only
difference is that one materializes a constant and the other one does not.
Please explain when we should not materialize a constant. It seems simpler to me
if we always deal with temporary values only.

+class ArgumentGraphVisitor : public ValueGraphVisitor {
+ public:
+  ArgumentGraphVisitor(FlowGraphBuilder* owner, intptr_t temp_index)
+      : ValueGraphVisitor(owner, temp_index) { }
+
+ private:
+  // Override the returning of constants to ensure they are materialized.
+  virtual void ReturnValue(Value* value);
+};
+
+
 // Translate an AstNode to a control-flow graph fragment for both its
 // effects and true/false control flow (e.g., for an expression in a test
 // context).  The resulting graph is always closed (even if it is empty)
 // Successor control flow is explicitly set by a pair of pointers to
 // TargetEntryInstr*.
 //
 // To distinguish between the graphs with only nonlocal exits and graphs
 // with both true and false exits, there are a pair of TargetEntryInstr**:
 //
 //   - Both NULL: only non-local exits, truly closed
@@ skipping 48 matching lines @@
   }
 
   // Output parameters.
   TargetEntryInstr** true_successor_address_;
   TargetEntryInstr** false_successor_address_;
 };
 
 }  // namespace dart
 
 #endif  // VM_FLOW_GRAPH_BUILDER_H_