Remove non-useful duplicated code from the flow graph builder.

runtime/vm/flow_graph_builder.cc

 // 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.
 
 #include "vm/flow_graph_builder.h"
 
 #include "vm/flags.h"
 #include "vm/intermediate_language.h"
 #include "vm/longjump.h"
 #include "vm/os.h"
@@ skipping 160 matching lines @@
           new AssertAssignableComp(return_value, type);
       AddInstruction(new BindInstr(temp_index(), assert));
       return_value = new TempVal(temp_index());
     }
   }
 
   AddInstruction(new ReturnInstr(return_value, node->token_index()));
   CloseFragment();
 }
 
-void ValueGraphVisitor::VisitReturnNode(ReturnNode* node) { UNREACHABLE(); }
-void TestGraphVisitor::VisitReturnNode(ReturnNode* node) { UNREACHABLE(); }
-
 
 // <Expression> ::= Literal { literal: Instance }
 void EffectGraphVisitor::VisitLiteralNode(LiteralNode* node) {
   return;
 }
 
 void ValueGraphVisitor::VisitLiteralNode(LiteralNode* node) {
   ReturnValue(new ConstantVal(node->literal()));
 }
 
 void TestGraphVisitor::VisitLiteralNode(LiteralNode* node) {
   BranchOnValue(new ConstantVal(node->literal()));
 }
 
 
 // Type nodes only occur as the right-hand side of instanceof comparisons,
 // and they are handled specially in that context.
 void EffectGraphVisitor::VisitTypeNode(TypeNode* node) { UNREACHABLE(); }
-void ValueGraphVisitor::VisitTypeNode(TypeNode* node) { UNREACHABLE(); }
-void TestGraphVisitor::VisitTypeNode(TypeNode* node) { UNREACHABLE(); }
 
 
 // <Expression> :: Assignable { expr:     <Expression>
 //                              type:     AbstractType
 //                              dst_name: String }
-AssertAssignableComp* EffectGraphVisitor::TranslateAssignable(
-    const AssignableNode& node) {
+void EffectGraphVisitor::VisitAssignableNode(AssignableNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
-  node.expr()->Visit(&for_value);
+  node->expr()->Visit(&for_value);
   Append(for_value);
-  CHECK_ALIVE(return NULL);
+  CHECK_ALIVE(return);
 
-  return new AssertAssignableComp(for_value.value(), node.type());
-}
-
-void EffectGraphVisitor::VisitAssignableNode(AssignableNode* node) {
-  AssertAssignableComp* assert = TranslateAssignable(*node);
-  CHECK_ALIVE(return);
-  DoComputation(assert);
-}
-
-void ValueGraphVisitor::VisitAssignableNode(AssignableNode* node) {
-  AssertAssignableComp* assert = TranslateAssignable(*node);
-  CHECK_ALIVE(return);
-  ReturnValueOf(assert);
-}
-
-
-void TestGraphVisitor::VisitAssignableNode(AssignableNode* node) {
-  AssertAssignableComp* assert = TranslateAssignable(*node);
-  CHECK_ALIVE(return);
-  BranchOnValueOf(assert);
+  AssertAssignableComp* assert =
+      new AssertAssignableComp(for_value.value(), node->type());
+  ReturnComputation(assert);
 }
 
 
 // <Expression> :: BinaryOp { kind:  Token::Kind
 //                            left:  <Expression>
 //                            right: <Expression> }
-InstanceCallComp* EffectGraphVisitor::TranslateBinaryOp(
-    const BinaryOpNode& node) {
+void EffectGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
   // Operators "&&" and "||" cannot be overloaded therefore do not call
   // operator.
-  if ((node.kind() == Token::kAND) || (node.kind() == Token::kOR)) {
+  if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     Bailout("EffectGraphVisitor::VisitBinaryOpNode AND/OR");
   }
   ValueGraphVisitor for_left_value(owner(), temp_index());
-  node.left()->Visit(&for_left_value);
+  node->left()->Visit(&for_left_value);
   Append(for_left_value);
-  CHECK_ALIVE(return NULL);
+  CHECK_ALIVE(return);
   ValueGraphVisitor for_right_value(owner(), for_left_value.temp_index());
-  node.right()->Visit(&for_right_value);
+  node->right()->Visit(&for_right_value);
   Append(for_right_value);
-  CHECK_ALIVE(return NULL);
+  CHECK_ALIVE(return);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
   arguments->Add(for_left_value.value());
   arguments->Add(for_right_value.value());
-  return new InstanceCallComp(node.Name(), arguments);
-}
-
-void EffectGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
-  InstanceCallComp* call = TranslateBinaryOp(*node);
-  CHECK_ALIVE(return);
-  DoComputation(call);
-}
-
-void ValueGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
-  InstanceCallComp* call = TranslateBinaryOp(*node);
-  CHECK_ALIVE(return);
-  ReturnValueOf(call);
-}
-
-void TestGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
-  InstanceCallComp* call = TranslateBinaryOp(*node);
-  CHECK_ALIVE(return);
-  BranchOnValueOf(call);
+  InstanceCallComp* call = new InstanceCallComp(node->Name(), arguments);
+  ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitStringConcatNode(StringConcatNode* node) {
   Bailout("EffectGraphVisitor::VisitStringConcatNode");
 }
-void ValueGraphVisitor::VisitStringConcatNode(StringConcatNode* node) {
-  Bailout("ValueGraphVisitor::VisitStringConcatNode");
-}
-void TestGraphVisitor::VisitStringConcatNode(StringConcatNode* node) {
-  Bailout("TestGraphVisitor::VisitStringConcatNode");
-}
 
 
 // <Expression> :: Comparison { kind:  Token::Kind
 //                              left:  <Expression>
 //                              right: <Expression> }
-Computation* EffectGraphVisitor::TranslateComparison(
-    const ComparisonNode& node) {
-  if (Token::IsInstanceofOperator(node.kind())) {
+void EffectGraphVisitor::VisitComparisonNode(ComparisonNode* node) {
+  if (Token::IsInstanceofOperator(node->kind())) {
     Bailout("instanceof not yet implemented");
-  } else if ((node.kind() == Token::kEQ) || (node.kind() == Token::kNE)) {
+  } else if ((node->kind() == Token::kEQ) || (node->kind() == Token::kNE)) {
     Bailout("'==' or '!=' comparison not yet implemented");
   }
   ValueGraphVisitor for_left_value(owner(), temp_index());
-  node.left()->Visit(&for_left_value);
+  node->left()->Visit(&for_left_value);
   Append(for_left_value);
-  CHECK_ALIVE(return NULL);
+  CHECK_ALIVE(return);
   ValueGraphVisitor for_right_value(owner(), for_left_value.temp_index());
-  node.right()->Visit(&for_right_value);
+  node->right()->Visit(&for_right_value);
   Append(for_right_value);
-  CHECK_ALIVE(return NULL);
-  if ((node.kind() == Token::kEQ_STRICT) ||
-      (node.kind() == Token::kNE_STRICT)) {
-    return new StrictCompareComp(
-        node.kind(), for_left_value.value(), for_right_value.value());
+  CHECK_ALIVE(return);
+  if ((node->kind() == Token::kEQ_STRICT) ||
+      (node->kind() == Token::kNE_STRICT)) {
+    StrictCompareComp* comp = new StrictCompareComp(
+        node->kind(), for_left_value.value(), for_right_value.value());
+    ReturnComputation(comp);
+    return;
   }
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
   arguments->Add(for_left_value.value());
   arguments->Add(for_right_value.value());
-  return new InstanceCallComp(node.Name(), arguments);
-}
-
-void EffectGraphVisitor::VisitComparisonNode(ComparisonNode* node) {
-  Computation* call = TranslateComparison(*node);
-  CHECK_ALIVE(return);
-  DoComputation(call);
-}
-
-void ValueGraphVisitor::VisitComparisonNode(ComparisonNode* node) {
-  Computation* call = TranslateComparison(*node);
-  CHECK_ALIVE(return);
-  ReturnValueOf(call);
-}
-
-void TestGraphVisitor::VisitComparisonNode(ComparisonNode* node) {
-  Computation* call = TranslateComparison(*node);
-  CHECK_ALIVE(return);
-  BranchOnValueOf(call);
-}
-
-
-
-InstanceCallComp* EffectGraphVisitor::TranslateUnaryOp(
-    const UnaryOpNode& node) {
-  // "!" cannot be overloaded, therefore do not call operator.
-  if (node.kind() == Token::kNOT) {
-    Bailout("EffectGraphVisitor::VisitUnaryOpNode NOT");
-  }
-  ValueGraphVisitor for_value(owner(), temp_index());
-  node.operand()->Visit(&for_value);
-  Append(for_value);
-  ZoneGrowableArray<Value*>* argument = new ZoneGrowableArray<Value*>(1);
-  argument->Add(for_value.value());
-  return new InstanceCallComp(node.Name(), argument);
+  InstanceCallComp* call = new InstanceCallComp(node->Name(), arguments);
+  ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitUnaryOpNode(UnaryOpNode* node) {
-  InstanceCallComp* call = TranslateUnaryOp(*node);
-  DoComputation(call);
-}
-void ValueGraphVisitor::VisitUnaryOpNode(UnaryOpNode* node) {
-  InstanceCallComp* call = TranslateUnaryOp(*node);
-  ReturnValueOf(call);
-}
-void TestGraphVisitor::VisitUnaryOpNode(UnaryOpNode* node) {
-  InstanceCallComp* call = TranslateUnaryOp(*node);
-  BranchOnValueOf(call);
+  // "!" cannot be overloaded, therefore do not call operator.
+  if (node->kind() == Token::kNOT) {
+    Bailout("EffectGraphVisitor::VisitUnaryOpNode NOT");
+  }
+  ValueGraphVisitor for_value(owner(), temp_index());
+  node->operand()->Visit(&for_value);
+  Append(for_value);
+  ZoneGrowableArray<Value*>* argument = new ZoneGrowableArray<Value*>(1);
+  argument->Add(for_value.value());
+  InstanceCallComp* call = new InstanceCallComp(node->Name(), argument);
+  ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitIncrOpLocalNode(IncrOpLocalNode* node) {
   Bailout("EffectGraphVisitor::VisitIncrOpLocalNode");
 }
-void ValueGraphVisitor::VisitIncrOpLocalNode(IncrOpLocalNode* node) {
-  Bailout("ValueGraphVisitor::VisitIncrOpLocalNode");
-}
-void TestGraphVisitor::VisitIncrOpLocalNode(IncrOpLocalNode* node) {
-  Bailout("TestGraphVisitor::VisitIncrOpLocalNode");
-}
 
 
 void EffectGraphVisitor::VisitIncrOpInstanceFieldNode(
     IncrOpInstanceFieldNode* node) {
   Bailout("EffectGraphVisitor::VisitIncrOpInstanceFieldNode");
 }
-void ValueGraphVisitor::VisitIncrOpInstanceFieldNode(
-    IncrOpInstanceFieldNode* node) {
-  Bailout("ValueGraphVisitor::VisitIncrOpInstanceFieldNode");
-}
-void TestGraphVisitor::VisitIncrOpInstanceFieldNode(
-    IncrOpInstanceFieldNode* node) {
-  Bailout("TestGraphVisitor::VisitIncrOpInstanceFieldNode");
-}
 
 
 void EffectGraphVisitor::VisitIncrOpStaticFieldNode(
     IncrOpStaticFieldNode* node) {
   Bailout("EffectGraphVisitor::VisitIncrOpStaticFieldNode");
 }
-void ValueGraphVisitor::VisitIncrOpStaticFieldNode(
-    IncrOpStaticFieldNode* node) {
-  Bailout("ValueGraphVisitor::VisitIncrOpStaticFieldNode");
-}
-void TestGraphVisitor::VisitIncrOpStaticFieldNode(IncrOpStaticFieldNode* node) {
-  Bailout("TestGraphVisitor::VisitIncrOpStaticFieldNode");
-}
 
 
 void EffectGraphVisitor::VisitIncrOpIndexedNode(IncrOpIndexedNode* node) {
   Bailout("EffectGraphVisitor::VisitIncrOpIndexedNode");
 }
-void ValueGraphVisitor::VisitIncrOpIndexedNode(IncrOpIndexedNode* node) {
-  Bailout("ValueGraphVisitor::VisitIncrOpIndexedNode");
-}
-void TestGraphVisitor::VisitIncrOpIndexedNode(IncrOpIndexedNode* node) {
-  Bailout("TestGraphVisitor::VisitIncrOpIndexedNode");
-}
 
 
 void EffectGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
   Bailout("EffectGraphVisitor::VisitConditionalExprNode");
 }
-void ValueGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
-  Bailout("ValueGraphVisitor::VisitConditionalExprNode");
-}
-void TestGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
-  Bailout("TestGraphVisitor::VisitConditionalExprNode");
-}
 
 
 // <Statement> ::= If { condition: <Expression>
 //                      true_branch: <Sequence>
 //                      false_branch: <Sequence> }
 void EffectGraphVisitor::VisitIfNode(IfNode* node) {
   TestGraphVisitor for_test(owner(), temp_index());
   node->condition()->Visit(&for_test);
 
   EffectGraphVisitor for_true(owner(), temp_index());
   EffectGraphVisitor for_false(owner(), temp_index());
 
   if (for_test.can_be_true()) {
     node->true_branch()->Visit(&for_true);
     // The for_false graph fragment will be empty (default graph fragment)
     // if we do not call Visit.
     if (node->false_branch() != NULL) node->false_branch()->Visit(&for_false);
   }
   Join(for_test, for_true, for_false);
 }
 
-void ValueGraphVisitor::VisitIfNode(IfNode* node) { UNREACHABLE(); }
-void TestGraphVisitor::VisitIfNode(IfNode* node) { UNREACHABLE(); }
-
 
 void EffectGraphVisitor::VisitSwitchNode(SwitchNode* node) {
   Bailout("EffectGraphVisitor::VisitSwitchNode");
 }
-void ValueGraphVisitor::VisitSwitchNode(SwitchNode* node) {
-  Bailout("ValueGraphVisitor::VisitSwitchNode");
-}
-void TestGraphVisitor::VisitSwitchNode(SwitchNode* node) {
-  Bailout("TestGraphVisitor::VisitSwitchNode");
-}
 
 
 void EffectGraphVisitor::VisitCaseNode(CaseNode* node) {
   Bailout("EffectGraphVisitor::VisitCaseNode");
 }
-void ValueGraphVisitor::VisitCaseNode(CaseNode* node) {
-  Bailout("ValueGraphVisitor::VisitCaseNode");
-}
-void TestGraphVisitor::VisitCaseNode(CaseNode* node) {
-  Bailout("TestGraphVisitor::VisitCaseNode");
-}
 
 
 // <Statement> ::= While { label:     SourceLabel
 //                         condition: <Expression>
 //                         body:      <Sequence> }
 void EffectGraphVisitor::VisitWhileNode(WhileNode* node) {
   TestGraphVisitor for_test(owner(), temp_index());
   node->condition()->Visit(&for_test);
 
   EffectGraphVisitor for_body(owner(), temp_index());
   if (for_test.can_be_true()) node->body()->Visit(&for_body);
   TieLoop(for_test, for_body);
 }
 
-void ValueGraphVisitor::VisitWhileNode(WhileNode* node) { UNREACHABLE(); }
-void TestGraphVisitor::VisitWhileNode(WhileNode* node) { UNREACHABLE(); }
-
 
 void EffectGraphVisitor::VisitDoWhileNode(DoWhileNode* node) {
   Bailout("EffectGraphVisitor::VisitDoWhileNode");
 }
-void ValueGraphVisitor::VisitDoWhileNode(DoWhileNode* node) {
-  Bailout("ValueGraphVisitor::VisitDoWhileNode");
-}
-void TestGraphVisitor::VisitDoWhileNode(DoWhileNode* node) {
-  Bailout("TestGraphVisitor::VisitDoWhileNode");
-}
 
 
 void EffectGraphVisitor::VisitForNode(ForNode* node) {
   Bailout("EffectGraphVisitor::VisitForNode");
 }
-void ValueGraphVisitor::VisitForNode(ForNode* node) {
-  Bailout("ValueGraphVisitor::VisitForNode");
-}
-void TestGraphVisitor::VisitForNode(ForNode* node) {
-  Bailout("TestGraphVisitor::VisitForNode");
-}
 
 
 void EffectGraphVisitor::VisitJumpNode(JumpNode* node) {
   Bailout("EffectGraphVisitor::VisitJumpNode");
 }
-void ValueGraphVisitor::VisitJumpNode(JumpNode* node) {
-  Bailout("ValueGraphVisitor::VisitJumpNode");
-}
-void TestGraphVisitor::VisitJumpNode(JumpNode* node) {
-  Bailout("TestGraphVisitor::VisitJumpNode");
-}
 
 
 void EffectGraphVisitor::VisitArgumentListNode(ArgumentListNode* node) {
   UNREACHABLE();
 }
-void ValueGraphVisitor::VisitArgumentListNode(ArgumentListNode* node) {
-  UNREACHABLE();
-}
-void TestGraphVisitor::VisitArgumentListNode(ArgumentListNode* node) {
-  UNREACHABLE();
-}
 
 
 void EffectGraphVisitor::VisitArrayNode(ArrayNode* node) {
   Bailout("EffectGraphVisitor::VisitArrayNode");
 }
-void ValueGraphVisitor::VisitArrayNode(ArrayNode* node) {
-  Bailout("ValueGraphVisitor::VisitArrayNode");
-}
-void TestGraphVisitor::VisitArrayNode(ArrayNode* node) {
-  Bailout("TestGraphVisitor::VisitArrayNode");
-}
 
 
 void EffectGraphVisitor::VisitClosureNode(ClosureNode* node) {
   Bailout("EffectGraphVisitor::VisitClosureNode");
 }
-void ValueGraphVisitor::VisitClosureNode(ClosureNode* node) {
-  Bailout("ValueGraphVisitor::VisitClosureNode");
-}
-void TestGraphVisitor::VisitClosureNode(ClosureNode* node) {
-  Bailout("TestGraphVisitor::VisitClosureNode");
+
+
+void EffectGraphVisitor::VisitInstanceCallNode(InstanceCallNode* node) {
+  ArgumentListNode* arguments = node->arguments();
+  int length = arguments->length();
+  ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>(length + 1);
+
+  ValueGraphVisitor for_receiver(owner(), temp_index());
+  node->receiver()->Visit(&for_receiver);
+  Append(for_receiver);
+  CHECK_ALIVE(return);
+  Value* receiver_value = for_receiver.value();
+  temp_index_ = for_receiver.temp_index();
+  if (receiver_value->IsConstant()) {
+    AddInstruction(new BindInstr(temp_index(), receiver_value));
+    receiver_value = new TempVal(AllocateTempIndex());
+  }
+  values->Add(receiver_value);
+
+  TranslateArgumentList(*arguments, values);
+  CHECK_ALIVE(return);
+  InstanceCallComp* call =
+      new InstanceCallComp(node->function_name().ToCString(), values);
+  ReturnComputation(call);
 }
 
 
-InstanceCallComp* EffectGraphVisitor::TranslateInstanceCall(
-    const InstanceCallNode& node) {
-  ArgumentListNode* arguments = node.arguments();
-  int length = arguments->length();
-  ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>(length + 1);
-  ValueGraphVisitor for_receiver(owner(), temp_index());
-  node.receiver()->Visit(&for_receiver);
-  Append(for_receiver);
-  CHECK_ALIVE(return NULL);
-  values->Add(for_receiver.value());
-  int index = temp_index();
-  for (intptr_t i = 0; i < length; ++i) {
-    ValueGraphVisitor for_value(owner(), index);
-    arguments->NodeAt(i)->Visit(&for_value);
-    Append(for_value);
-    CHECK_ALIVE(return NULL);
-    values->Add(for_value.value());
-    index = for_value.temp_index();
-  }
-  return new InstanceCallComp(node.function_name().ToCString(), values);
-}
-
-
-void EffectGraphVisitor::VisitInstanceCallNode(InstanceCallNode* node) {
-  InstanceCallComp* call = TranslateInstanceCall(*node);
-  CHECK_ALIVE(return);
-  DoComputation(call);
-}
-void ValueGraphVisitor::VisitInstanceCallNode(InstanceCallNode* node) {
-  InstanceCallComp* call = TranslateInstanceCall(*node);
-  CHECK_ALIVE(return);
-  ReturnValueOf(call);
-}
-void TestGraphVisitor::VisitInstanceCallNode(InstanceCallNode* node) {
-  InstanceCallComp* call = TranslateInstanceCall(*node);
-  CHECK_ALIVE(return);
-  BranchOnValueOf(call);
-}
-
-
 void EffectGraphVisitor::TranslateArgumentList(
     const ArgumentListNode& node, ZoneGrowableArray<Value*>* values) {
   int index = temp_index();
   for (intptr_t i = 0; i < node.length(); ++i) {
     ValueGraphVisitor for_value(owner(), index);
     node.NodeAt(i)->Visit(&for_value);
     Append(for_value);
     CHECK_ALIVE(return);
     Value* argument_value = for_value.value();
     index = for_value.temp_index();
     if (argument_value->IsConstant()) {
       AddInstruction(new BindInstr(index, argument_value));
       argument_value = new TempVal(index++);
     }
     values->Add(argument_value);
   }
 }
 
 // <Expression> ::= StaticCall { function: Function
 //                               arguments: <ArgumentList> }
-StaticCallComp* EffectGraphVisitor::TranslateStaticCall(
-    const StaticCallNode& node) {
-  int length = node.arguments()->length();
+void EffectGraphVisitor::VisitStaticCallNode(StaticCallNode* node) {
+  int length = node->arguments()->length();
   ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>(length);
-  TranslateArgumentList(*node.arguments(), values);
-  CHECK_ALIVE(return NULL);
-  return new StaticCallComp(node.function(), values);
-}
-
-void EffectGraphVisitor::VisitStaticCallNode(StaticCallNode* node) {
-  StaticCallComp* call = TranslateStaticCall(*node);
+  TranslateArgumentList(*node->arguments(), values);
   CHECK_ALIVE(return);
-  DoComputation(call);
-}
-
-void ValueGraphVisitor::VisitStaticCallNode(StaticCallNode* node) {
-  StaticCallComp* call = TranslateStaticCall(*node);
-  CHECK_ALIVE(return);
-  ReturnValueOf(call);
-}
-
-void TestGraphVisitor::VisitStaticCallNode(StaticCallNode* node) {
-  StaticCallComp* call = TranslateStaticCall(*node);
-  CHECK_ALIVE(return);
-  BranchOnValueOf(call);
+  StaticCallComp* call = new StaticCallComp(node->function(), values);
+  ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
   Bailout("EffectGraphVisitor::VisitClosureCallNode");
 }
-void ValueGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
-  Bailout("ValueGraphVisitor::VisitClosureCallNode");
-}
-void TestGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
-  Bailout("TestGraphVisitor::VisitClosureCallNode");
-}
 
 
 void EffectGraphVisitor::VisitCloneContextNode(CloneContextNode* node) {
   Bailout("EffectGraphVisitor::VisitCloneContextNode");
 }
-void ValueGraphVisitor::VisitCloneContextNode(CloneContextNode* node) {
-  Bailout("ValueGraphVisitor::VisitCloneContextNode");
-}
-void TestGraphVisitor::VisitCloneContextNode(CloneContextNode* node) {
-  Bailout("TestGraphVisitor::VisitCloneContextNode");
-}
 
 
 void EffectGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
   Bailout("EffectGraphVisitor::VisitConstructorCallNode");
 }
-void ValueGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
-  Bailout("ValueGraphVisitor::VisitConstructorCallNode");
-}
-void TestGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
-  Bailout("TestGraphVisitor::VisitConstructorCallNode");
-}
 
 
 void EffectGraphVisitor::VisitInstanceGetterNode(InstanceGetterNode* node) {
   Bailout("EffectGraphVisitor::VisitInstanceGetterNode");
 }
-void ValueGraphVisitor::VisitInstanceGetterNode(InstanceGetterNode* node) {
-  Bailout("ValueGraphVisitor::VisitInstanceGetterNode");
-}
-void TestGraphVisitor::VisitInstanceGetterNode(InstanceGetterNode* node) {
-  Bailout("TestGraphVisitor::VisitInstanceGetterNode");
-}
 
 
 void EffectGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
   Bailout("EffectGraphVisitor::VisitInstanceSetterNode");
 }
-void ValueGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
-  Bailout("ValueGraphVisitor::VisitInstanceSetterNode");
-}
-void TestGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
-  Bailout("TestGraphVisitor::VisitInstanceSetterNode");
-}
 
 
 void EffectGraphVisitor::VisitStaticGetterNode(StaticGetterNode* node) {
   Bailout("EffectGraphVisitor::VisitStaticGetterNode");
 }
-void ValueGraphVisitor::VisitStaticGetterNode(StaticGetterNode* node) {
-  Bailout("ValueGraphVisitor::VisitStaticGetterNode");
-}
-void TestGraphVisitor::VisitStaticGetterNode(StaticGetterNode* node) {
-  Bailout("TestGraphVisitor::VisitStaticGetterNode");
-}
 
 
 void EffectGraphVisitor::VisitStaticSetterNode(StaticSetterNode* node) {
   Bailout("EffectGraphVisitor::VisitStaticSetterNode");
 }
-void ValueGraphVisitor::VisitStaticSetterNode(StaticSetterNode* node) {
-  Bailout("ValueGraphVisitor::VisitStaticSetterNode");
-}
-void TestGraphVisitor::VisitStaticSetterNode(StaticSetterNode* node) {
-  Bailout("TestGraphVisitor::VisitStaticSetterNode");
-}
 
 
 void EffectGraphVisitor::VisitNativeBodyNode(NativeBodyNode* node) {
   Bailout("EffectGraphVisitor::VisitNativeBodyNode");
 }
-void ValueGraphVisitor::VisitNativeBodyNode(NativeBodyNode* node) {
-  Bailout("ValueGraphVisitor::VisitNativeBodyNode");
-}
-void TestGraphVisitor::VisitNativeBodyNode(NativeBodyNode* node) {
-  Bailout("TestGraphVisitor::VisitNativeBodyNode");
-}
 
 
 void EffectGraphVisitor::VisitPrimaryNode(PrimaryNode* node) {
   Bailout("EffectGraphVisitor::VisitPrimaryNode");
 }
-void ValueGraphVisitor::VisitPrimaryNode(PrimaryNode* node) {
-  Bailout("ValueGraphVisitor::VisitPrimaryNode");
-}
-void TestGraphVisitor::VisitPrimaryNode(PrimaryNode* node) {
-  Bailout("TestGraphVisitor::VisitPrimaryNode");
-}
 
 
 // <Expression> ::= LoadLocal { local: LocalVariable }
 void EffectGraphVisitor::VisitLoadLocalNode(LoadLocalNode* node) {
   return;
 }
 
 void ValueGraphVisitor::VisitLoadLocalNode(LoadLocalNode* node) {
   LoadLocalComp* load = new LoadLocalComp(node->local());
-  ReturnValueOf(load);
+  ReturnComputation(load);
 }
 
 void TestGraphVisitor::VisitLoadLocalNode(LoadLocalNode* node) {
   LoadLocalComp* load = new LoadLocalComp(node->local());
-  BranchOnValueOf(load);
+  ReturnComputation(load);
 }
 
 
 // <Expression> ::= StoreLocal { local: LocalVariable
 //                               value: <Expression> }
-StoreLocalComp* EffectGraphVisitor::TranslateStoreLocal(
-    const StoreLocalNode& node) {
+void EffectGraphVisitor::VisitStoreLocalNode(StoreLocalNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
-  node.value()->Visit(&for_value);
+  node->value()->Visit(&for_value);
   Append(for_value);
-  CHECK_ALIVE(return NULL);
-  return new StoreLocalComp(node.local(), for_value.value());
-}
-
-void EffectGraphVisitor::VisitStoreLocalNode(StoreLocalNode* node) {
-  StoreLocalComp* store = TranslateStoreLocal(*node);
   CHECK_ALIVE(return);
-  DoComputation(store);
-}
-
-void ValueGraphVisitor::VisitStoreLocalNode(StoreLocalNode* node) {
-  StoreLocalComp* store = TranslateStoreLocal(*node);
-  CHECK_ALIVE(return);
-  ReturnValueOf(store);
-}
-
-void TestGraphVisitor::VisitStoreLocalNode(StoreLocalNode* node) {
-  StoreLocalComp* store = TranslateStoreLocal(*node);
-  CHECK_ALIVE(return);
-  BranchOnValueOf(store);
+  StoreLocalComp* store = new StoreLocalComp(node->local(), for_value.value());
+  ReturnComputation(store);
 }
 
 
 void EffectGraphVisitor::VisitLoadInstanceFieldNode(
     LoadInstanceFieldNode* node) {
   Bailout("EffectGraphVisitor::VisitLoadInstanceFieldNode");
 }
-void ValueGraphVisitor::VisitLoadInstanceFieldNode(
-    LoadInstanceFieldNode* node) {
-  Bailout("ValueGraphVisitor::VisitLoadInstanceFieldNode");
-}
-void TestGraphVisitor::VisitLoadInstanceFieldNode(LoadInstanceFieldNode* node) {
-  Bailout("TestGraphVisitor::VisitLoadInstanceFieldNode");
-}
 
 
 void EffectGraphVisitor::VisitStoreInstanceFieldNode(
     StoreInstanceFieldNode* node) {
   Bailout("EffectGraphVisitor::VisitStoreInstanceFieldNode");
 }
-void ValueGraphVisitor::VisitStoreInstanceFieldNode(
-    StoreInstanceFieldNode* node) {
-  Bailout("ValueGraphVisitor::VisitStoreInstanceFieldNode");
-}
-void TestGraphVisitor::VisitStoreInstanceFieldNode(
-    StoreInstanceFieldNode* node) {
-  Bailout("TestGraphVisitor::VisitStoreInstanceFieldNode");
-}
 
 
 void EffectGraphVisitor::VisitLoadStaticFieldNode(LoadStaticFieldNode* node) {
   Bailout("EffectGraphVisitor::VisitLoadStaticFieldNode");
 }
-void ValueGraphVisitor::VisitLoadStaticFieldNode(LoadStaticFieldNode* node) {
-  Bailout("ValueGraphVisitor::VisitLoadStaticFieldNode");
-}
-void TestGraphVisitor::VisitLoadStaticFieldNode(LoadStaticFieldNode* node) {
-  Bailout("TestGraphVisitor::VisitLoadStaticFieldNode");
-}
 
 
 void EffectGraphVisitor::VisitStoreStaticFieldNode(StoreStaticFieldNode* node) {
   Bailout("EffectGraphVisitor::VisitStoreStaticFieldNode");
 }
-void ValueGraphVisitor::VisitStoreStaticFieldNode(StoreStaticFieldNode* node) {
-  Bailout("ValueGraphVisitor::VisitStoreStaticFieldNode");
-}
-void TestGraphVisitor::VisitStoreStaticFieldNode(StoreStaticFieldNode* node) {
-  Bailout("TestGraphVisitor::VisitStoreStaticFieldNode");
-}
 
 
 void EffectGraphVisitor::VisitLoadIndexedNode(LoadIndexedNode* node) {
   Bailout("EffectGraphVisitor::VisitLoadIndexedNode");
 }
-void ValueGraphVisitor::VisitLoadIndexedNode(LoadIndexedNode* node) {
-  Bailout("ValueGraphVisitor::VisitLoadIndexedNode");
-}
-void TestGraphVisitor::VisitLoadIndexedNode(LoadIndexedNode* node) {
-  Bailout("TestGraphVisitor::VisitLoadIndexedNode");
-}
 
 
 void EffectGraphVisitor::VisitStoreIndexedNode(StoreIndexedNode* node) {
   Bailout("EffectGraphVisitor::VisitStoreIndexedNode");
 }
-void ValueGraphVisitor::VisitStoreIndexedNode(StoreIndexedNode* node) {
-  Bailout("ValueGraphVisitor::VisitStoreIndexedNode");
-}
-void TestGraphVisitor::VisitStoreIndexedNode(StoreIndexedNode* node) {
-  Bailout("TestGraphVisitor::VisitStoreIndexedNode");
-}
 
 
 // <Statement> ::= Sequence { scope: LocalScope
 //                            nodes: <Statement>*
 //                            label: SourceLabel }
 void EffectGraphVisitor::VisitSequenceNode(SequenceNode* node) {
   if ((node->scope() != NULL) &&
       (node->scope()->num_context_variables() != 0)) {
     Bailout("Sequence needs a context.  Gotta have a context.");
   }
   for (intptr_t i = 0; i < node->length(); ++i) {
     EffectGraphVisitor for_effect(owner(), temp_index());
     node->NodeAt(i)->Visit(&for_effect);
     Append(for_effect);
     CHECK_ALIVE(return);
   }
 }
 
-void ValueGraphVisitor::VisitSequenceNode(SequenceNode* node) { UNREACHABLE(); }
-void TestGraphVisitor::VisitSequenceNode(SequenceNode* node) { UNREACHABLE(); }
-
 
 void EffectGraphVisitor::VisitCatchClauseNode(CatchClauseNode* node) {
   Bailout("EffectGraphVisitor::VisitCatchClauseNode");
 }
-void ValueGraphVisitor::VisitCatchClauseNode(CatchClauseNode* node) {
-  Bailout("ValueGraphVisitor::VisitCatchClauseNode");
-}
-void TestGraphVisitor::VisitCatchClauseNode(CatchClauseNode* node) {
-  Bailout("TestGraphVisitor::VisitCatchClauseNode");
-}
 
 
 void EffectGraphVisitor::VisitTryCatchNode(TryCatchNode* node) {
   Bailout("EffectGraphVisitor::VisitTryCatchNode");
 }
-void ValueGraphVisitor::VisitTryCatchNode(TryCatchNode* node) {
-  Bailout("ValueGraphVisitor::VisitTryCatchNode");
-}
-void TestGraphVisitor::VisitTryCatchNode(TryCatchNode* node) {
-  Bailout("TestGraphVisitor::VisitTryCatchNode");
-}
 
 
 void EffectGraphVisitor::VisitThrowNode(ThrowNode* node) {
   Bailout("EffectGraphVisitor::VisitThrowNode");
 }
-void ValueGraphVisitor::VisitThrowNode(ThrowNode* node) {
-  Bailout("ValueGraphVisitor::VisitThrowNode");
-}
-void TestGraphVisitor::VisitThrowNode(ThrowNode* node) {
-  Bailout("TestGraphVisitor::VisitThrowNode");
-}
 
 
 void EffectGraphVisitor::VisitInlinedFinallyNode(InlinedFinallyNode* node) {
   Bailout("EffectGraphVisitor::VisitInlinedFinallyNode");
 }
-void ValueGraphVisitor::VisitInlinedFinallyNode(InlinedFinallyNode* node) {
-  Bailout("ValueGraphVisitor::VisitInlinedFinallyNode");
-}
-void TestGraphVisitor::VisitInlinedFinallyNode(InlinedFinallyNode* node) {
-  Bailout("TestGraphVisitor::VisitInlinedFinallyNode");
-}
 
 
 // Graph printing.
 class FlowGraphPrinter : public FlowGraphVisitor {
  public:
   explicit FlowGraphPrinter(const Function& function) : function_(function) { }
 
   virtual ~FlowGraphPrinter() {}
 
   // Print the instructions in a block terminated by newlines.  Add "goto N"
@@ skipping 167 matching lines @@
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len));
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart