Switch from AST node ids to computation ids (cid). In addition to computations,…

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/ast_printer.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
@@ skipping 144 matching lines @@
       new DoInstr(new StoreContextComp(new UseVal(load_saved_context)));
   AddInstruction(store_context);
 }
 
 
 
 void TestGraphVisitor::ReturnValue(Value* value) {
   if (FLAG_enable_type_checks) {
     BindInstr* assert_boolean =
         new BindInstr(temp_index(),
-                      new AssertBooleanComp(condition_node_id(),
-                                            condition_token_index(),
+                      new AssertBooleanComp(condition_token_index(),
                                             owner()->try_index(),
                                             value));
     AddInstruction(assert_boolean);
     value = new UseVal(assert_boolean);
   }
   BranchInstr* branch = new BranchInstr(value);
   AddInstruction(branch);
   CloseFragment();
   true_successor_address_ = branch->true_successor_address();
   false_successor_address_ = branch->false_successor_address();
@@ skipping 27 matching lines @@
         (kind == RawFunction::kConstImplicitGetter);
     const bool is_static = owner()->parsed_function().function().is_static();
     // Implicit getters do not need a type check at return, unless they compute
     // the initial value of a static field.
     if (is_static || !is_implicit_getter) {
       const AbstractType& dst_type =
           AbstractType::ZoneHandle(
               owner()->parsed_function().function().result_type());
       const String& dst_name =
           String::ZoneHandle(String::NewSymbol("function result"));
-      return_value = BuildAssignableValue(node->id(),
-                                          node->value(),
+      return_value = BuildAssignableValue(node->value(),
                                           return_value,
                                           dst_type,
                                           dst_name,
                                           temp_index());
     }
   }
 
   intptr_t current_context_level = owner()->context_level();
   ASSERT(current_context_level >= 0);
   if (owner()->parsed_function().saved_context_var() != NULL) {
     // CTX on entry was saved, but not linked as context parent.
     BuildLoadContext(*owner()->parsed_function().saved_context_var());
   } else {
     while (current_context_level-- > 0) {
       UnchainContext();
     }
   }
 
   AddInstruction(
-      new ReturnInstr(node->id(), node->token_index(), return_value));
+      new ReturnInstr(node->token_index(), return_value));
   CloseFragment();
 }
 
 
 // <Expression> ::= Literal { literal: Instance }
 void EffectGraphVisitor::VisitLiteralNode(LiteralNode* node) {
   return;
 }
 
 void ValueGraphVisitor::VisitLiteralNode(LiteralNode* node) {
@@ skipping 64 matching lines @@
 //                              dst_name: String }
 void EffectGraphVisitor::VisitAssignableNode(AssignableNode* node) {
   UNREACHABLE();
 }
 
 
 void ValueGraphVisitor::VisitAssignableNode(AssignableNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
   node->expr()->Visit(&for_value);
   Append(for_value);
-  ReturnValue(BuildAssignableValue(node->id(),
-                                   node->expr(),
+  ReturnValue(BuildAssignableValue(node->expr(),
                                    for_value.value(),
                                    node->type(),
                                    node->dst_name(),
                                    temp_index()));
 }
 
 
 // <Expression> :: BinaryOp { kind:  Token::Kind
 //                            left:  <Expression>
 //                            right: <Expression> }
 void EffectGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
   // Operators "&&" and "||" cannot be overloaded therefore do not call
   // operator.
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     // See ValueGraphVisitor::VisitBinaryOpNode.
     TestGraphVisitor for_left(owner(),
                               temp_index(),
-                              node->left()->id(),
                               node->left()->token_index());
     node->left()->Visit(&for_left);
     EffectGraphVisitor for_right(owner(), temp_index());
     node->right()->Visit(&for_right);
     EffectGraphVisitor empty(owner(), temp_index());
     if (node->kind() == Token::kAND) {
       Join(for_left, for_right, empty);
     } else {
       Join(for_left, empty, for_right);
     }
     return;
   }
   ValueGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   ValueGraphVisitor for_right_value(owner(), for_left_value.temp_index());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
   arguments->Add(for_left_value.value());
   arguments->Add(for_right_value.value());
   const String& name = String::ZoneHandle(String::NewSymbol(node->Name()));
-  InstanceCallComp* call = new InstanceCallComp(node->id(),
-                                                node->token_index(),
+  InstanceCallComp* call = new InstanceCallComp(node->token_index(),
                                                 owner()->try_index(),
                                                 name,
                                                 arguments,
                                                 Array::ZoneHandle(),
                                                 2);
   ReturnComputation(call);
 }
 
 
 // Special handling for AND/OR.
 void ValueGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
   // Operators "&&" and "||" cannot be overloaded therefore do not call
   // operator.
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     // Implement short-circuit logic: do not evaluate right if evaluation
     // of left is sufficient.
     // AND:  left ? right === true : false;
     // OR:   left ? true : right === true;
     const Bool& bool_true = Bool::ZoneHandle(Bool::True());
     const Bool& bool_false = Bool::ZoneHandle(Bool::False());
 
     TestGraphVisitor for_test(owner(),
                               temp_index(),
-                              node->left()->id(),
                               node->left()->token_index());
     node->left()->Visit(&for_test);
 
     ValueGraphVisitor for_right(owner(), temp_index());
     node->right()->Visit(&for_right);
     Value* right_value = for_right.value();
     if (FLAG_enable_type_checks) {
       BindInstr* assert_boolean =
           new BindInstr(temp_index(),
-                        new AssertBooleanComp(node->right()->id(),
-                                              node->right()->token_index(),
+                        new AssertBooleanComp(node->right()->token_index(),
                                               owner()->try_index(),
                                               right_value));
       for_right.AddInstruction(assert_boolean);
       right_value = new UseVal(assert_boolean);
     }
     BindInstr* constant_true =
         new BindInstr(temp_index(), new ConstantVal(bool_true));
     for_right.AddInstruction(constant_true);
     StrictCompareComp* comp = new StrictCompareComp(Token::kEQ_STRICT,
         right_value, new UseVal(constant_true));
@@ skipping 86 matching lines @@
   StaticCallComp* call =
       new StaticCallComp(node->token_index(),
                          owner()->try_index(),
                          interpol_func,
                          interpol_arg->names(),
                          values);
   ReturnComputation(call);
 }
 
 
-void EffectGraphVisitor::BuildAssertAssignable(intptr_t node_id,
-                                               intptr_t token_index,
+void EffectGraphVisitor::BuildAssertAssignable(intptr_t token_index,
                                                Value* value,
                                                const AbstractType& dst_type,
                                                const String& dst_name,
                                                intptr_t start_index) {
   // Build the type check computation.
   Value* instantiator_type_arguments = NULL;
   if (!dst_type.IsInstantiated()) {
     instantiator_type_arguments =
         BuildInstantiatorTypeArguments(token_index, start_index + 1);
   }
   AssertAssignableComp* assert_assignable =
-      new AssertAssignableComp(node_id,
-                               token_index,
+      new AssertAssignableComp(token_index,
                                owner()->try_index(),
                                value,
                                instantiator_type_arguments,
                                dst_type,
                                dst_name);
   AddInstruction(new DoInstr(assert_assignable));
 }
 
 
-Value* EffectGraphVisitor::BuildAssignableValue(intptr_t node_id,
-                                                AstNode* value_node,
+Value* EffectGraphVisitor::BuildAssignableValue(AstNode* value_node,
                                                 Value* value,
                                                 const AbstractType& dst_type,
                                                 const String& dst_name,
                                                 intptr_t start_index) {
   if (CanSkipTypeCheck(value_node, dst_type)) {
     return value;
   }
 
   // Build the type check computation.
   Value* instantiator_type_arguments = NULL;
   if (!dst_type.IsInstantiated()) {
     instantiator_type_arguments =
         BuildInstantiatorTypeArguments(value_node->token_index(),
                                        start_index + 1);
   }
   BindInstr* assert_assignable =
       new BindInstr(start_index,
-                    new AssertAssignableComp(node_id,
-                                             value_node->token_index(),
+                    new AssertAssignableComp(value_node->token_index(),
                                              owner()->try_index(),
                                              value,
                                              instantiator_type_arguments,
                                              dst_type,
                                              dst_name));
   AddInstruction(assert_assignable);
   return new UseVal(assert_assignable);
 }
 
 
@@ skipping 57 matching lines @@
   ValueGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   Value* type_arguments = NULL;
   if (!type.IsInstantiated()) {
     type_arguments =
         BuildInstantiatorTypeArguments(node->token_index(),
                                        for_left_value.temp_index());
   }
   InstanceOfComp* instance_of =
-      new InstanceOfComp(node->id(),
-                         node->token_index(),
+      new InstanceOfComp(node->token_index(),
                          owner()->try_index(),
                          for_left_value.value(),
                          type_arguments,
                          node->right()->AsTypeNode()->type(),
                          (node->kind() == Token::kISNOT));
   ReturnComputation(instance_of);
 }
 
 
 // <Expression> :: Comparison { kind:  Token::Kind
@@ skipping 20 matching lines @@
   }
 
   if ((node->kind() == Token::kEQ) || (node->kind() == Token::kNE)) {
     ValueGraphVisitor for_left_value(owner(), temp_index());
     node->left()->Visit(&for_left_value);
     Append(for_left_value);
     ValueGraphVisitor for_right_value(owner(), for_left_value.temp_index());
     node->right()->Visit(&for_right_value);
     Append(for_right_value);
     EqualityCompareComp* comp = new EqualityCompareComp(
-        node->id(), node->token_index(), owner()->try_index(),
+        node->token_index(), owner()->try_index(),
         for_left_value.value(), for_right_value.value());
     if (node->kind() == Token::kEQ) {
       ReturnComputation(comp);
     } else {
       Definition* eq_result = new BindInstr(temp_index(), comp);
       AddInstruction(eq_result);
       if (FLAG_enable_type_checks) {
         eq_result =
             new BindInstr(temp_index(),
-                          new AssertBooleanComp(node->id(),
-                                                node->token_index(),
+                          new AssertBooleanComp(node->token_index(),
                                                 owner()->try_index(),
                                                 new UseVal(eq_result)));
         AddInstruction(eq_result);
       }
       BooleanNegateComp* negate = new BooleanNegateComp(new UseVal(eq_result));
       ReturnComputation(negate);
     }
     return;
   }
 
   ValueGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   ValueGraphVisitor for_right_value(owner(), for_left_value.temp_index());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
   arguments->Add(for_left_value.value());
   arguments->Add(for_right_value.value());
   const String& name = String::ZoneHandle(String::NewSymbol(node->Name()));
   InstanceCallComp* call = new InstanceCallComp(
-      node->id(), node->token_index(), owner()->try_index(), name,
+      node->token_index(), owner()->try_index(), name,
       arguments, Array::ZoneHandle(), 2);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitUnaryOpNode(UnaryOpNode* node) {
   // "!" cannot be overloaded, therefore do not call operator.
   if (node->kind() == Token::kNOT) {
     ValueGraphVisitor for_value(owner(), temp_index());
     node->operand()->Visit(&for_value);
     Append(for_value);
     Value* value = for_value.value();
     if (FLAG_enable_type_checks) {
       BindInstr* assert_boolean =
           new BindInstr(temp_index(),
-                        new AssertBooleanComp(node->operand()->id(),
-                                              node->operand()->token_index(),
+                        new AssertBooleanComp(node->operand()->token_index(),
                                               owner()->try_index(),
                                               value));
       AddInstruction(assert_boolean);
       value = new UseVal(assert_boolean);
     }
     BooleanNegateComp* negate = new BooleanNegateComp(value);
     ReturnComputation(negate);
     return;
   }
   ValueGraphVisitor for_value(owner(), temp_index());
   node->operand()->Visit(&for_value);
   Append(for_value);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(1);
   arguments->Add(for_value.value());
   const String& name =
       String::ZoneHandle(String::NewSymbol((node->kind() == Token::kSUB)
                                                ? Token::Str(Token::kNEGATE)
                                                : node->Name()));
   InstanceCallComp* call = new InstanceCallComp(
-      node->id(), node->token_index(), owner()->try_index(), name,
+      node->token_index(), owner()->try_index(), name,
       arguments, Array::ZoneHandle(), 1);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitIncrOpLocalNode(IncrOpLocalNode* node) {
   ASSERT((node->kind() == Token::kINCR) || (node->kind() == Token::kDECR));
   // In an effect context, treat postincrement as if it were preincrement
   // because its value is not needed.
 
   // 1. Load the value.
   BindInstr* load =
       new BindInstr(temp_index(),
                     new LoadLocalComp(node->local(), owner()->context_level()));
   AddInstruction(load);
   AllocateTempIndex();
   // 2. Increment.
   Definition* incr =
-      BuildIncrOpIncrement(node->kind(), node->id(), node->token_index(),
-                           new UseVal(load));
+      BuildIncrOpIncrement(node->kind(), node->token_index(), new UseVal(load));
   // 3. Perform the store, resulting in the new value.
   DeallocateTempIndex();  // Consuming incr.
   StoreLocalComp* store = new StoreLocalComp(
       node->local(), new UseVal(incr), owner()->context_level());
   ReturnComputation(store);
 }
 
 
 void ValueGraphVisitor::VisitIncrOpLocalNode(IncrOpLocalNode* node) {
   ASSERT((node->kind() == Token::kINCR) || (node->kind() == Token::kDECR));
@@ skipping 11 matching lines @@
                     new LoadLocalComp(node->local(), owner()->context_level()));
   AddInstruction(load);
   AllocateTempIndex();
   // 2. Duplicate it to increment.
   PickTempInstr* duplicate =
       new PickTempInstr(temp_index(), load->temp_index());
   AddInstruction(duplicate);
   AllocateTempIndex();
   // 3. Increment.
   Definition* incr =
-      BuildIncrOpIncrement(node->kind(), node->id(), node->token_index(),
+      BuildIncrOpIncrement(node->kind(), node->token_index(),
                            new UseVal(duplicate));
   // 4. Perform the store and return the original value.
   DeallocateTempIndex();  // Consuming incr.
   StoreLocalComp* store = new StoreLocalComp(
       node->local(), new UseVal(incr), owner()->context_level());
   AddInstruction(new DoInstr(store));
   ReturnValue(new UseVal(load));
 }
 
 
@@ skipping 14 matching lines @@
 
   // Load the value.
   //   t_n+1 <- InstanceCall(get:name, t_n+1)
   const String& getter_name =
       String::ZoneHandle(Field::GetterSymbol(node->field_name()));
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(1);
   arguments->Add(new UseVal(duplicate));
   BindInstr* load =
       new BindInstr(temp_index(),
                     new InstanceCallComp(
-                        node->getter_id(), node->token_index(),
+                        node->token_index(),
                         owner()->try_index(), getter_name, arguments,
                         Array::ZoneHandle(), 1));
   AddInstruction(load);
   AllocateTempIndex();
 
   *receiver = for_receiver.value();
   return load;
 }
 
 
 Definition* EffectGraphVisitor::BuildIncrOpIncrement(Token::Kind kind,
-                                                     intptr_t node_id,
                                                      intptr_t token_index,
                                                      Value* original) {
   ASSERT((kind == Token::kINCR) || (kind == Token::kDECR));
   // Assumed that t_n-1 (where n is start_index) is the field value.
   //   t_n   <- #1
   //   t_n-1 <- InstanceCall(op, t_n-1, t_n)
   BindInstr* one =
       new BindInstr(temp_index(),
                     new ConstantVal(Smi::ZoneHandle(Smi::New(1))));
   AddInstruction(one);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
   arguments->Add(original);
   arguments->Add(new UseVal(one));
   const String& op_name =
       String::ZoneHandle(String::NewSymbol((kind == Token::kINCR) ? "+" : "-"));
   DeallocateTempIndex();  // Consuming original.
   BindInstr* add =
       new BindInstr(temp_index(),
                     new InstanceCallComp(
-                        node_id, token_index, owner()->try_index(), op_name,
+                        token_index, owner()->try_index(), op_name,
                         arguments, Array::ZoneHandle(), 2));
   AddInstruction(add);
   AllocateTempIndex();
   return add;
 }
 
 
 void EffectGraphVisitor::VisitIncrOpInstanceFieldNode(
     IncrOpInstanceFieldNode* node) {
   ASSERT((node->kind() == Token::kINCR) || (node->kind() == Token::kDECR));
   // In an effect context, treat postincrement as if it were preincrement
   // because its value is not needed.
 
   // 1. Load the value.
   Value* receiver = NULL;
   Definition* load = BuildIncrOpFieldLoad(node, &receiver);
   // 2. Increment.
   Definition* incr =
-      BuildIncrOpIncrement(node->kind(), node->operator_id(),
-                           node->token_index(), new UseVal(load));
+      BuildIncrOpIncrement(node->kind(), node->token_index(), new UseVal(load));
   // 3. Perform the store, returning the stored value.
   InstanceSetterComp* store =
-      new InstanceSetterComp(node->setter_id(),
-                             node->token_index(),
+      new InstanceSetterComp(node->token_index(),
                              owner()->try_index(),
                              node->field_name(),
                              receiver,
                              new UseVal(incr));
   DeallocateTempIndex();  // Consuming incr.
   DeallocateTempIndex();  // Consuming receiver.
   ReturnComputation(store);
 }
 
 
@@ skipping 15 matching lines @@
   AddInstruction(placeholder);
   AllocateTempIndex();
   // 2. Load the value.
   Value* receiver = NULL;
   Definition* load = BuildIncrOpFieldLoad(node, &receiver);
   // 3. Preserve the original value.
   AddInstruction(new TuckTempInstr(placeholder->temp_index(),
                                    load->temp_index()));
   // 4. Increment.
   Definition* incr =
-      BuildIncrOpIncrement(node->kind(), node->operator_id(),
-                           node->token_index(), new UseVal(load));
+      BuildIncrOpIncrement(node->kind(), node->token_index(), new UseVal(load));
   // 5. Perform the store and return the original value.
   const String& setter_name =
       String::ZoneHandle(Field::SetterSymbol(node->field_name()));
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
   arguments->Add(receiver);
   arguments->Add(new UseVal(incr));
   InstanceCallComp* store = new InstanceCallComp(
-      node->setter_id(), node->token_index(), owner()->try_index(),
+      node->token_index(), owner()->try_index(),
       setter_name, arguments, Array::ZoneHandle(), 1);
   DeallocateTempIndex();  // Consuming incr.
   DeallocateTempIndex();  // Consuming receiver.
   AddInstruction(new DoInstr(store));
   ReturnValue(new UseVal(placeholder));
 }
 
 
 Definition* EffectGraphVisitor::BuildIncrOpIndexedLoad(
     IncrOpIndexedNode* node,
@@ skipping 25 matching lines @@
       new PickTempInstr(temp_index() + 1, temp_index() - 1);
   AddInstruction(duplicate_index);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
   arguments->Add(new UseVal(duplicate_receiver));
   arguments->Add(new UseVal(duplicate_index));
   const String& load_name =
       String::ZoneHandle(String::NewSymbol(Token::Str(Token::kINDEX)));
   BindInstr* load =
       new BindInstr(temp_index(),
                     new InstanceCallComp(
-                        node->load_id(), node->token_index(),
+                        node->token_index(),
                         owner()->try_index(), load_name, arguments,
                         Array::ZoneHandle(), 1));
   AddInstruction(load);
   AllocateTempIndex();
 
   *receiver = for_receiver.value();
   *index = for_index.value();
   return load;
 }
 
 
 void EffectGraphVisitor::VisitIncrOpIndexedNode(IncrOpIndexedNode* node) {
   ASSERT((node->kind() == Token::kINCR) || (node->kind() == Token::kDECR));
   // In an effect context, treat postincrement as if it were preincrement
   // because its value is not needed.
 
   // 1. Load the value.
   Value* receiver = NULL;
   Value* index = NULL;
   Definition* load = BuildIncrOpIndexedLoad(node, &receiver, &index);
   // 2. Increment.
   Definition* incr =
-      BuildIncrOpIncrement(node->kind(), node->operator_id(),
-                           node->token_index(), new UseVal(load));
+      BuildIncrOpIncrement(node->kind(), node->token_index(), new UseVal(load));
   // 3. Perform the store, returning the stored value.
-  StoreIndexedComp* store = new StoreIndexedComp(node->store_id(),
-                                                 node->token_index(),
+  StoreIndexedComp* store = new StoreIndexedComp(node->token_index(),
                                                  owner()->try_index(),
                                                  receiver,
                                                  index,
                                                  new UseVal(incr));
   DeallocateTempIndex();  // Consuming incr.
   DeallocateTempIndex();  // Consuming index.
   DeallocateTempIndex();  // Consuming receiver.
   ReturnComputation(store);
 }
 
@@ skipping 16 matching lines @@
   AllocateTempIndex();
   // 2. Load the value.
   Value* receiver = NULL;
   Value* index = NULL;
   Definition* load = BuildIncrOpIndexedLoad(node, &receiver, &index);
   // 3. Preserve the original value.
   AddInstruction(new TuckTempInstr(placeholder->temp_index(),
                                    load->temp_index()));
   // 4. Increment.
   Definition* incr =
-      BuildIncrOpIncrement(node->kind(), node->operator_id(),
-                           node->token_index(), new UseVal(load));
+      BuildIncrOpIncrement(node->kind(), node->token_index(), new UseVal(load));
   // 5. Perform the store and return the original value.
   const String& store_name =
       String::ZoneHandle(String::NewSymbol(Token::Str(Token::kASSIGN_INDEX)));
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(3);
   arguments->Add(receiver);
   arguments->Add(index);
   arguments->Add(new UseVal(incr));
   InstanceCallComp* store = new InstanceCallComp(
-      node->store_id(), node->token_index(), owner()->try_index(),
+      node->token_index(), owner()->try_index(),
       store_name, arguments, Array::ZoneHandle(), 1);
   DeallocateTempIndex();  // Consuming incr.
   DeallocateTempIndex();  // Consuming index.
   DeallocateTempIndex();  // Consuming receiver.
   AddInstruction(new DoInstr(store));
   ReturnValue(new UseVal(placeholder));
 }
 
 
 void EffectGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
   TestGraphVisitor for_test(owner(),
                             temp_index(),
-                            node->condition()->id(),
                             node->condition()->token_index());
   node->condition()->Visit(&for_test);
 
   // Translate the subexpressions for their effects.
   EffectGraphVisitor for_true(owner(), temp_index());
   node->true_expr()->Visit(&for_true);
   EffectGraphVisitor for_false(owner(), temp_index());
   node->false_expr()->Visit(&for_false);
 
   Join(for_test, for_true, for_false);
 }
 
 
 void ValueGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
   TestGraphVisitor for_test(owner(),
                             temp_index(),
-                            node->condition()->id(),
                             node->condition()->token_index());
   node->condition()->Visit(&for_test);
 
   // Ensure that the value of the true/false subexpressions are named with
   // the same temporary name.
   ValueGraphVisitor for_true(owner(), temp_index());
   node->true_expr()->Visit(&for_true);
   ASSERT(for_true.is_open());
   if (for_true.value()->IsTemp()) {
     ASSERT(for_true.value()->AsTemp()->index() == temp_index());
@@ skipping 14 matching lines @@
   ReturnValue(new TempVal(AllocateTempIndex()));
 }
 
 
 // <Statement> ::= If { condition: <Expression>
 //                      true_branch: <Sequence>
 //                      false_branch: <Sequence> }
 void EffectGraphVisitor::VisitIfNode(IfNode* node) {
   TestGraphVisitor for_test(owner(),
                             temp_index(),
-                            node->condition()->id(),
                             node->condition()->token_index());
   node->condition()->Visit(&for_test);
 
   EffectGraphVisitor for_true(owner(), temp_index());
   EffectGraphVisitor for_false(owner(), temp_index());
 
   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);
@@ skipping 70 matching lines @@
 
   // Generate instructions for all case expressions and collect data to
   // connect them.
   GrowableArray<TargetEntryInstr**> case_true_addresses;
   GrowableArray<TargetEntryInstr**> case_false_addresses;
   GrowableArray<TargetEntryInstr*> case_entries;
   for (intptr_t i = 0; i < len; i++) {
     AstNode* case_expr = node->case_expressions()->NodeAt(i);
     TestGraphVisitor for_case_expression(owner(),
                                          temp_index(),
-                                         case_expr->id(),
                                          case_expr->token_index());
     if (i == 0) {
       case_entries.Add(NULL);  // Not to be used
       case_expr->Visit(&for_case_expression);
       // Append only the first one, everything else is connected from it.
       Append(for_case_expression);
     } else {
       TargetEntryInstr* case_entry_target = new TargetEntryInstr();
       case_entries.Add(case_entry_target);
       for_case_expression.AddInstruction(case_entry_target);
@@ skipping 62 matching lines @@
 // a) continue-join (optional)
 // b) loop-join
 // c) [ test ] -> (body-entry-target, loop-exit-target)
 // d) body-entry-target
 // e) [ body ] -> (loop-join)
 // f) loop-exit-target
 // g) break-join (optional)
 void EffectGraphVisitor::VisitWhileNode(WhileNode* node) {
   TestGraphVisitor for_test(owner(),
                             temp_index(),
-                            node->condition()->id(),
                             node->condition()->token_index());
   node->condition()->Visit(&for_test);
   ASSERT(!for_test.is_empty());  // Language spec.
 
   EffectGraphVisitor for_body(owner(), temp_index());
   node->body()->Visit(&for_body);
 
   // Labels are set after body traversal.
   SourceLabel* lbl = node->label();
   ASSERT(lbl != NULL);
@@ skipping 15 matching lines @@
 // e) back-target -> (body-entry-join)
 // f) loop-exit-target
 // g) break-join
 void EffectGraphVisitor::VisitDoWhileNode(DoWhileNode* node) {
   // Traverse body first in order to generate continue and break labels.
   EffectGraphVisitor for_body(owner(), temp_index());
   node->body()->Visit(&for_body);
 
   TestGraphVisitor for_test(owner(),
                             temp_index(),
-                            node->condition()->id(),
                             node->condition()->token_index());
   node->condition()->Visit(&for_test);
   ASSERT(is_open());
 
   // Tie do-while loop (test is after the body).
   JoinEntryInstr* body_entry_join = new JoinEntryInstr();
   AddInstruction(body_entry_join);
   body_entry_join->SetSuccessor(for_body.entry());
   Instruction* body_exit =
       for_body.is_empty() ? body_entry_join : for_body.exit();
@@ skipping 88 matching lines @@
     if (node->label()->join_for_break() == NULL) {
       CloseFragment();
     } else {
       // Control flow of ForLoop continues into join_for_break.
       exit_ = node->label()->join_for_break();
     }
   } else {
     TargetEntryInstr* loop_exit = new TargetEntryInstr();
     TestGraphVisitor for_test(owner(),
                               temp_index(),
-                              node->condition()->id(),
                               node->condition()->token_index());
     node->condition()->Visit(&for_test);
     Append(for_test);
     *for_test.true_successor_address() = body_entry;
     *for_test.false_successor_address() = loop_exit;
     if (node->label()->join_for_break() == NULL) {
       exit_ = loop_exit;
     } else {
       loop_exit->SetSuccessor(node->label()->join_for_break());
       exit_ = node->label()->join_for_break();
@@ skipping 136 matching lines @@
   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);
   values->Add(for_receiver.value());
 
   TranslateArgumentList(*arguments, for_receiver.temp_index(), values);
   InstanceCallComp* call = new InstanceCallComp(
-      node->id(), node->token_index(), owner()->try_index(),
+      node->token_index(), owner()->try_index(),
       node->function_name(), values,
                            arguments->names(), 1);
   ReturnComputation(call);
 }
 
 
 // <Expression> ::= StaticCall { function: Function
 //                               arguments: <ArgumentList> }
 void EffectGraphVisitor::VisitStaticCallNode(StaticCallNode* node) {
   int length = node->arguments()->length();
@@ skipping 30 matching lines @@
                                                arguments);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitCloneContextNode(CloneContextNode* node) {
   BindInstr* context = new BindInstr(temp_index(), new CurrentContextComp());
   AddInstruction(context);
   BindInstr* clone =
       new BindInstr(temp_index(),
-                    new CloneContextComp(node->id(),
-                                         node->token_index(),
+                    new CloneContextComp(node->token_index(),
                                          owner()->try_index(),
                                          new UseVal(context)));
   AddInstruction(clone);
   ReturnComputation(new StoreContextComp(new UseVal(clone)));
 }
 
 
 Definition* EffectGraphVisitor::BuildObjectAllocation(
     ConstructorCallNode* node) {
   const Class& cls = Class::ZoneHandle(node->constructor().owner());
@@ skipping 224 matching lines @@
 
 void EffectGraphVisitor::VisitInstanceGetterNode(InstanceGetterNode* node) {
   ValueGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(1);
   arguments->Add(for_receiver.value());
   const String& name =
       String::ZoneHandle(Field::GetterSymbol(node->field_name()));
   InstanceCallComp* call = new InstanceCallComp(
-      node->id(), node->token_index(), owner()->try_index(), name,
+      node->token_index(), owner()->try_index(), name,
       arguments, Array::ZoneHandle(), 1);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
   ValueGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   ValueGraphVisitor for_value(owner(), for_receiver.temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   InstanceSetterComp* setter =
-      new InstanceSetterComp(node->id(),
-                             node->token_index(),
+      new InstanceSetterComp(node->token_index(),
                              owner()->try_index(),
                              node->field_name(),
                              for_receiver.value(),
                              for_value.value());
   ReturnComputation(setter);
 }
 
 
 void EffectGraphVisitor::VisitStaticGetterNode(StaticGetterNode* node) {
   const String& getter_name =
@@ skipping 55 matching lines @@
 
 
 // <Expression> ::= StoreLocal { local: LocalVariable
 //                               value: <Expression> }
 void EffectGraphVisitor::VisitStoreLocalNode(StoreLocalNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (FLAG_enable_type_checks) {
-    store_value = BuildAssignableValue(node->id(),
-                                       node->value(),
+    store_value = BuildAssignableValue(node->value(),
                                        store_value,
                                        node->local().type(),
                                        node->local().name(),
                                        temp_index());
   }
   StoreLocalComp* store =
       new StoreLocalComp(node->local(), store_value, owner()->context_level());
   ReturnComputation(store);
 }
 
@@ skipping 14 matching lines @@
   ValueGraphVisitor for_instance(owner(), temp_index());
   node->instance()->Visit(&for_instance);
   Append(for_instance);
   ValueGraphVisitor for_value(owner(), for_instance.temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (FLAG_enable_type_checks) {
     const AbstractType& type = AbstractType::ZoneHandle(node->field().type());
     const String& dst_name = String::ZoneHandle(node->field().name());
-    store_value = BuildAssignableValue(node->id(),
-                                       node->value(),
+    store_value = BuildAssignableValue(node->value(),
                                        store_value,
                                        type,
                                        dst_name,
                                        for_instance.temp_index());
   }
   StoreInstanceFieldComp* store =
       new StoreInstanceFieldComp(node, for_instance.value(), store_value);
   ReturnComputation(store);
 }
 
 
 void EffectGraphVisitor::VisitLoadStaticFieldNode(LoadStaticFieldNode* node) {
   LoadStaticFieldComp* load = new LoadStaticFieldComp(node->field());
   ReturnComputation(load);
 }
 
 
 void EffectGraphVisitor::VisitStoreStaticFieldNode(StoreStaticFieldNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (FLAG_enable_type_checks) {
     const AbstractType& type = AbstractType::ZoneHandle(node->field().type());
     const String& dst_name = String::ZoneHandle(node->field().name());
-    store_value = BuildAssignableValue(node->id(),
-                                       node->value(),
+    store_value = BuildAssignableValue(node->value(),
                                        store_value,
                                        type,
                                        dst_name,
                                        temp_index());
   }
   StoreStaticFieldComp* store =
       new StoreStaticFieldComp(node->field(), store_value);
   ReturnComputation(store);
 }
 
 
 void EffectGraphVisitor::VisitLoadIndexedNode(LoadIndexedNode* node) {
   ValueGraphVisitor for_array(owner(), temp_index());
   node->array()->Visit(&for_array);
   Append(for_array);
   ValueGraphVisitor for_index(owner(), for_array.temp_index());
   node->index_expr()->Visit(&for_index);
   Append(for_index);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
   arguments->Add(for_array.value());
   arguments->Add(for_index.value());
   const String& name =
       String::ZoneHandle(String::NewSymbol(Token::Str(Token::kINDEX)));
   InstanceCallComp* call = new InstanceCallComp(
-      node->id(), node->token_index(), owner()->try_index(), name,
+      node->token_index(), owner()->try_index(), name,
       arguments, Array::ZoneHandle(), 1);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitStoreIndexedNode(StoreIndexedNode* node) {
   ValueGraphVisitor for_array(owner(), temp_index());
   node->array()->Visit(&for_array);
   Append(for_array);
   ValueGraphVisitor for_index(owner(), for_array.temp_index());
   node->index_expr()->Visit(&for_index);
   Append(for_index);
   ValueGraphVisitor for_value(owner(), for_index.temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
-  StoreIndexedComp* store = new StoreIndexedComp(node->id(),
-                                                 node->token_index(),
+  StoreIndexedComp* store = new StoreIndexedComp(node->token_index(),
                                                  owner()->try_index(),
                                                  for_array.value(),
                                                  for_index.value(),
                                                  for_value.value());
   ReturnComputation(store);
 }
 
 
 bool EffectGraphVisitor::MustSaveRestoreContext(SequenceNode* node) const {
   return (node == owner()->parsed_function().node_sequence()) &&
@@ skipping 114 matching lines @@
         owner()->parsed_function().function().NumberOfParameters();
     for (int pos = 0; pos < num_params; pos++) {
       const LocalVariable& parameter = *scope->VariableAt(pos);
       ASSERT(parameter.owner() == scope);
       if (!CanSkipTypeCheck(NULL, parameter.type())) {
         BindInstr* load =
             new BindInstr(temp_index(),
                           new LoadLocalComp(parameter,
                                             owner()->context_level()));
         AddInstruction(load);
-        BuildAssertAssignable(node->ParameterIdAt(pos),
-                              parameter.token_index(),
+        BuildAssertAssignable(parameter.token_index(),
                               new UseVal(load),
                               parameter.type(),
                               parameter.name(),
                               temp_index());
       }
     }
   }
 
   intptr_t i = 0;
   while (is_open() && (i < node->length())) {
@@ skipping 95 matching lines @@
   }
 }
 
 
 void EffectGraphVisitor::BuildThrowNode(ThrowNode* node) {
   ValueGraphVisitor for_exception(owner(), temp_index());
   node->exception()->Visit(&for_exception);
   Append(for_exception);
   Instruction* instr = NULL;
   if (node->stacktrace() == NULL) {
-    instr = new ThrowInstr(node->id(),
-                           node->token_index(),
+    instr = new ThrowInstr(node->token_index(),
                            owner()->try_index(),
                            for_exception.value());
   } else {
     ValueGraphVisitor for_stack_trace(owner(), temp_index() + 1);
     node->stacktrace()->Visit(&for_stack_trace);
     Append(for_stack_trace);
-    instr = new ReThrowInstr(node->id(),
-                             node->token_index(),
+    instr = new ReThrowInstr(node->token_index(),
                              owner()->try_index(),
                              for_exception.value(),
                              for_stack_trace.value());
   }
   AddInstruction(instr);
 }
 
 
 void EffectGraphVisitor::VisitThrowNode(ThrowNode* node) {
   BuildThrowNode(node);
@@ skipping 575 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