Get rid of ast node ids.

runtime/vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
@@ skipping 6521 matching lines @@
 PcDescriptors::Kind PcDescriptors::DescriptorKind(intptr_t index) const {
   return static_cast<PcDescriptors::Kind>(*(EntryAddr(index, kKindEntry)));
 }
 
 
 void PcDescriptors::SetKind(intptr_t index, PcDescriptors::Kind value) const {
   *(EntryAddr(index, kKindEntry)) = value;
 }
 
 
-intptr_t PcDescriptors::NodeId(intptr_t index) const {
-  return Smi::Value(*SmiAddr(index, kNodeIdEntry));
+intptr_t PcDescriptors::DeoptId(intptr_t index) const {
+  return Smi::Value(*SmiAddr(index, kDeoptIdEntry));
 }
 
 
-void PcDescriptors::SetNodeId(intptr_t index, intptr_t value) const {
-  *SmiAddr(index, kNodeIdEntry) = Smi::New(value);
+void PcDescriptors::SetDeoptId(intptr_t index, intptr_t value) const {
+  *SmiAddr(index, kDeoptIdEntry) = Smi::New(value);
 }
 
 
-intptr_t PcDescriptors::TokenIndex(intptr_t index) const {
-  return Smi::Value(*SmiAddr(index, kTokenIndexEntry));
+intptr_t PcDescriptors::TokenPos(intptr_t index) const {
+  return Smi::Value(*SmiAddr(index, kTokenPosEntry));
 }
 
 
-void PcDescriptors::SetTokenIndex(intptr_t index, intptr_t value) const {
-  *SmiAddr(index, kTokenIndexEntry) = Smi::New(value);
+void PcDescriptors::SetTokenPos(intptr_t index, intptr_t value) const {
+  *SmiAddr(index, kTokenPosEntry) = Smi::New(value);
 }
 
 
 intptr_t PcDescriptors::TryIndex(intptr_t index) const {
   ASSERT(DescriptorKind(index) != kDeoptIndex);
   return *(EntryAddr(index, kTryIndexEntry));
 }
 
 
 intptr_t PcDescriptors::DeoptIndex(intptr_t index) const {
@@ skipping 47 matching lines @@
   if (Length() == 0) {
     return "No pc descriptors\n";
   }
   const char* kFormat = "0x%x\t%s\t%ld\t%ld\t%ld\n";
   // First compute the buffer size required.
   intptr_t len = 0;
   for (intptr_t i = 0; i < Length(); i++) {
     const intptr_t multi_purpose_index = DescriptorKind(i) == kDeoptIndex ?
         DeoptIndex(i) : TryIndex(i);
     len += OS::SNPrint(NULL, 0, kFormat,
-        PC(i), KindAsStr(i), NodeId(i), TokenIndex(i), multi_purpose_index);
+        PC(i), KindAsStr(i), DeoptId(i), TokenPos(i), multi_purpose_index);
   }
   // Allocate the buffer.
   char* buffer = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
   // Layout the fields in the buffer.
   intptr_t index = 0;
   for (intptr_t i = 0; i < Length(); i++) {
     const intptr_t multi_purpose_index = DescriptorKind(i) == kDeoptIndex ?
         DeoptIndex(i) : TryIndex(i);
     index += OS::SNPrint((buffer + index), (len - index), kFormat,
-        PC(i), KindAsStr(i), NodeId(i), TokenIndex(i), multi_purpose_index);
+        PC(i), KindAsStr(i), DeoptId(i), TokenPos(i), multi_purpose_index);
   }
   return buffer;
 }
 
 
 // Verify assumptions (in debug mode only).
 // - No two deopt descriptors have the same node id (deoptimization).
 // - No two ic-call descriptors have the same node id (type feedback).
 // - No two descriptors of same kind have the same PC.
 // A function without unique ids is marked as non-optimizable (e.g., because of
 // finally blocks).
 void PcDescriptors::Verify(bool check_ids) const {
 #if defined(DEBUG)
   // TODO(srdjan): Implement a more efficient way to check, currently drop
   // the check for too large number of descriptors.
   if (Length() > 3000) {
     if (FLAG_trace_compiler) {
       OS::Print("Not checking pc decriptors, length %d\n", Length());
     }
     return;
   }
   for (intptr_t i = 0; i < Length(); i++) {
     uword pc = PC(i);
     PcDescriptors::Kind kind = DescriptorKind(i);
-    // 'node_id' is set for kDeopt and kIcCall and must be unique for one kind.
-    intptr_t node_id = AstNode::kNoId;
+    // 'deopt_id' is set for kDeopt and kIcCall and must be unique for one kind.
+    intptr_t deopt_id = Isolate::kNoDeoptId;
     if (check_ids) {
       if ((DescriptorKind(i) == PcDescriptors::kDeopt) ||
           (DescriptorKind(i) == PcDescriptors::kIcCall)) {
-        node_id = NodeId(i);
+        deopt_id = DeoptId(i);
       }
     }
     for (intptr_t k = i + 1; k < Length(); k++) {
       if (kind == DescriptorKind(k)) {
-        if (node_id != AstNode::kNoId) {
-          ASSERT(NodeId(k) != node_id);
+        if (deopt_id != Isolate::kNoDeoptId) {
+          ASSERT(DeoptId(k) != deopt_id);
         }
         ASSERT(pc != PC(k));
       }
     }
   }
 #endif  // DEBUG
 }
 
 
 void Stackmap::SetCode(const Code& code) const {
@@ skipping 506 matching lines @@
   }
   return Code::null();
 }
 
 
 intptr_t Code::GetTokenIndexOfPC(uword pc) const {
   intptr_t token_pos = -1;
   const PcDescriptors& descriptors = PcDescriptors::Handle(pc_descriptors());
   for (intptr_t i = 0; i < descriptors.Length(); i++) {
     if (descriptors.PC(i) == pc) {
-      token_pos = descriptors.TokenIndex(i);
+      token_pos = descriptors.TokenPos(i);
       break;
     }
   }
   return token_pos;
 }
 
 
-uword Code::GetDeoptPcAtNodeId(intptr_t node_id) const {
+uword Code::GetDeoptPcAtDeoptId(intptr_t deopt_id) const {
   const PcDescriptors& descriptors = PcDescriptors::Handle(pc_descriptors());
   for (intptr_t i = 0; i < descriptors.Length(); i++) {
-    if ((descriptors.NodeId(i) == node_id) &&
+    if ((descriptors.DeoptId(i) == deopt_id) &&
         (descriptors.DescriptorKind(i) == PcDescriptors::kDeopt)) {
       return descriptors.PC(i);
     }
   }
   return 0;
 }
 
 
 const char* Code::ToCString() const {
   const char* kFormat = "Code entry:0x%d";
@@ skipping 31 matching lines @@
     GrowableArray<intptr_t>* node_ids,
     const GrowableObjectArray& ic_data_objs) const {
   ASSERT(node_ids != NULL);
   ASSERT(!ic_data_objs.IsNull());
   const PcDescriptors& descriptors =
       PcDescriptors::Handle(this->pc_descriptors());
   ICData& ic_data_obj = ICData::Handle();
   intptr_t max_id = -1;
   for (intptr_t i = 0; i < descriptors.Length(); i++) {
     if (descriptors.DescriptorKind(i) == PcDescriptors::kIcCall) {
-      intptr_t node_id = descriptors.NodeId(i);
-      if (node_id > max_id) {
-        max_id = node_id;
+      intptr_t deopt_id = descriptors.DeoptId(i);
+      if (deopt_id > max_id) {
+        max_id = deopt_id;
       }
-      node_ids->Add(node_id);
+      node_ids->Add(deopt_id);
       ic_data_obj = CodePatcher::GetInstanceCallIcDataAt(descriptors.PC(i));
       ic_data_objs.Add(ic_data_obj);
     }
   }
   return max_id;
 }
 
 
 RawStackmap* Code::GetStackmap(uword pc, Array* maps, Stackmap* map) const {
   // This code is used during iterating frames during a GC and hence it
@@ skipping 3768 matching lines @@
 const char* JSRegExp::ToCString() const {
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart