Revert "Remove classes Computation and BindInstr."

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 108 matching lines @@
   Instruction* exit() const { return exit_; }
 
   bool is_empty() const { return entry_ == NULL; }
   bool is_open() const { return is_empty() || exit_ != NULL; }
 
   void Bailout(const char* reason);
   void InlineBailout(const char* reason);
 
   // Append a graph fragment to this graph.  Assumes this graph is open.
   void Append(const EffectGraphVisitor& other_fragment);
-  // Append a definition that can have uses.  Assumes this graph is open.
-  Value* Bind(Definition* definition);
+  // Append a computation with one use.  Assumes this graph is open.
+  Value* Bind(Computation* computation);
   // Append a computation with no uses.  Assumes this graph is open.
-  void Do(Definition* definition);
+  void Do(Computation* computation);
   // Append a single (non-Definition, non-Entry) instruction.  Assumes this
   // graph is open.
   void AddInstruction(Instruction* instruction);
   // Append a Goto (unconditional control flow) instruction and close
   // the graph fragment.  Assumes this graph fragment is open.
   void Goto(JoinEntryInstr* join);
 
   // Append a 'diamond' branch and join to this graph, depending on which
   // parts are reachable.  Assumes this graph is open.
   void Join(const TestGraphVisitor& test_fragment,
@@ skipping 11 matching lines @@
   PushArgumentInstr* PushArgument(Value* value);
 
   // This implementation shares state among visitors by using the builder.
   // The implementation is incorrect if a visitor that hits a return is not
   // actually added to the graph.
   void AddReturnExit(ReturnInstr* return_instr) {
     owner()->AddReturnExit(return_instr);
   }
 
  protected:
-  Definition* BuildStoreLocal(const LocalVariable& local, Value* value);
-  Definition* BuildLoadLocal(const LocalVariable& local);
+  Computation* BuildStoreLocal(const LocalVariable& local, Value* value);
+  Computation* BuildLoadLocal(const LocalVariable& local);
 
   // Helpers for translating parts of the AST.
   void TranslateArgumentList(const ArgumentListNode& node,
                              ZoneGrowableArray<Value*>* values);
   void BuildPushArguments(const ArgumentListNode& node,
                           ZoneGrowableArray<PushArgumentInstr*>* values);
 
   // Creates an instantiated type argument vector used in preparation of an
   // allocation call.
   // May be called only if allocating an object of a parameterized class.
@@ skipping 12 matching lines @@
       ZoneGrowableArray<PushArgumentInstr*>* call_arguments);
 
   void BuildTypecheckArguments(intptr_t token_pos,
                                Value** instantiator,
                                Value** instantiator_type_arguments);
   Value* BuildInstantiator();
   Value* BuildInstantiatorTypeArguments(intptr_t token_pos,
                                         Value* instantiator);
 
   // Perform a type check on the given value.
-  AssertAssignableInstr* BuildAssertAssignable(intptr_t token_pos,
-                                               Value* value,
-                                               const AbstractType& dst_type,
-                                               const String& dst_name);
+  AssertAssignableComp* BuildAssertAssignable(intptr_t token_pos,
+                                              Value* value,
+                                              const AbstractType& dst_type,
+                                              const String& dst_name);
 
   // Perform a type check on the given value and return it.
   Value* BuildAssignableValue(intptr_t token_pos,
                               Value* value,
                               const AbstractType& dst_type,
                               const String& dst_name);
 
   enum ResultKind {
     kResultNotNeeded,
     kResultNeeded
   };
 
-  Definition* BuildStoreIndexedValues(StoreIndexedNode* node,
-                                      bool result_is_needed);
+  Computation* BuildStoreIndexedValues(StoreIndexedNode* node,
+                                       bool result_is_needed);
 
   void BuildInstanceSetterArguments(
       InstanceSetterNode* node,
       ZoneGrowableArray<PushArgumentInstr*>* arguments,
       bool result_is_needed);
 
   virtual void BuildTypeTest(ComparisonNode* node);
   virtual void BuildTypeCast(ComparisonNode* node);
 
   bool MustSaveRestoreContext(SequenceNode* node) const;
@@ skipping 12 matching lines @@
   void BuildConstructorCall(ConstructorCallNode* node,
                             PushArgumentInstr* alloc_value);
 
   void BuildStoreContext(const LocalVariable& variable);
   void BuildLoadContext(const LocalVariable& variable);
 
   void BuildThrowNode(ThrowNode* node);
 
   void BuildStaticSetter(StaticSetterNode* node, bool result_is_needed);
 
-  ClosureCallInstr* BuildClosureCall(ClosureCallNode* node);
+  ClosureCallComp* BuildClosureCall(ClosureCallNode* node);
 
   Value* BuildNullValue();
 
  private:
-  // Specify a definition of the final result.  Adds the definition to
+  // Specify a computation as the final result.  Adds a Do instruction to
   // the graph, but normally overridden in subclasses.
-  virtual void ReturnDefinition(Definition* definition) {
-    Do(definition);
+  virtual void ReturnComputation(Computation* computation) {
+    Do(computation);
   }
 
   // Returns true if the run-time type check can be eliminated.
   bool CanSkipTypeCheck(intptr_t token_pos,
                         Value* value,
                         const AbstractType& dst_type,
                         const String& dst_name);
 
   // Shared global state.
   FlowGraphBuilder* owner_;
@@ skipping 34 matching lines @@
   Value* value() const { return value_; }
 
  protected:
   // Output parameters.
   Value* value_;
 
  private:
   // Helper to set the output state to return a Value.
   virtual void ReturnValue(Value* value) { value_ = value; }
 
-  // Specify a definition of the final result.  Adds the definition to
-  // the graph and returns a use of it (i.e., set the visitor's output
+  // 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 ReturnDefinition(Definition* definition) {
-    ReturnValue(Bind(definition));
+  virtual void ReturnComputation(Computation* computation) {
+    ReturnValue(Bind(computation));
   }
 
   virtual void BuildTypeTest(ComparisonNode* node);
   virtual void BuildTypeCast(ComparisonNode* node);
 };
 
 
 // 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)
@@ skipping 30 matching lines @@
     return false_successor_address_;
   }
 
   intptr_t condition_token_pos() const { return condition_token_pos_; }
 
  private:
   // Construct and concatenate a Branch instruction to this graph fragment.
   // Closes the fragment and sets the output parameters.
   virtual void ReturnValue(Value* value);
 
-  // Either merges the definition into a BranchInstr (Comparison, BooleanNegate)
-  // or adds the definition to the graph and returns a use of its value.
-  virtual void ReturnDefinition(Definition* definition);
+  // Either merges the computation into BranchInstr (Comparison, BooleanNegate)
+  // or adds a Bind instruction to the graph and returns its temporary value.
+  virtual void ReturnComputation(Computation* computation);
 
-  void MergeBranchWithComparison(ComparisonInstr* comp);
-  void MergeBranchWithNegate(BooleanNegateInstr* comp);
+  void MergeBranchWithComparison(ComparisonComp* comp);
+  void MergeBranchWithNegate(BooleanNegateComp* comp);
 
   // Output parameters.
   TargetEntryInstr** true_successor_address_;
   TargetEntryInstr** false_successor_address_;
 
   intptr_t condition_token_pos_;
 };
 
 }  // namespace dart
 
 #endif  // VM_FLOW_GRAPH_BUILDER_H_