Get rid of ast node ids.

runtime/vm/code_generator.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/code_generator.h"
 
 #include "vm/assembler_macros.h"
 #include "vm/ast.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
@@ skipping 130 matching lines @@
 static intptr_t GetCallerLocation() {
   DartFrameIterator iterator;
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
   const Code& code = Code::Handle(caller_frame->LookupDartCode());
   const PcDescriptors& descriptors =
       PcDescriptors::Handle(code.pc_descriptors());
   ASSERT(!descriptors.IsNull());
   for (int i = 0; i < descriptors.Length(); i++) {
     if (static_cast<uword>(descriptors.PC(i)) == caller_frame->pc()) {
-      return descriptors.TokenIndex(i);
+      return descriptors.TokenPos(i);
     }
   }
   return -1;
 }
 
 
 // Allocate a new object of a generic type and check that the instantiated type
 // arguments are within the declared bounds or throw a dynamic type error.
 // Arg0: class of the object that needs to be allocated.
 // Arg1: type arguments of the object that needs to be allocated.
@@ skipping 265 matching lines @@
 
 
 // This updates the type test cache, an array containing 4-value elements
 // (instance class, instance type arguments, instantiator type arguments and
 // test_result). It can be applied to classes with type arguments in which
 // case it contains just the result of the class subtype test, not including
 // the evaluation of type arguments.
 // This operation is currently very slow (lookup of code is not efficient yet).
 // 'instantiator' can be null, in which case inst_targ
 static void UpdateTypeTestCache(
-    intptr_t node_id,
     const Instance& instance,
     const AbstractType& type,
     const Instance& instantiator,
     const AbstractTypeArguments& incoming_instantiator_type_arguments,
     const Bool& result,
     const SubtypeTestCache& new_cache) {
   // Since the test is expensive, don't do it unless necessary.
   // The list of disallowed cases will decrease as they are implemented in
   // inlined assembly.
   if (new_cache.IsNull()) return;
@@ skipping 91 matching lines @@
         Class::Handle(test_type.type_class()).id(),
         instantiator_type_arguments.raw(),
         instantiator_type_arguments.ToCString(),
         result.ToCString());
   }
 }
 
 
 // Check that the given instance is an instance of the given type.
 // Tested instance may not be null, because the null test is inlined.
-// Arg0: node id of the instanceof node.
-// Arg1: instance being checked.
-// Arg2: type.
-// Arg3: instantiator (or null).
-// Arg4: type arguments of the instantiator of the type.
-// Arg5: SubtypeTestCache.
+// Arg0: instance being checked.
+// Arg1: type.
+// Arg2: instantiator (or null).
+// Arg3: type arguments of the instantiator of the type.
+// Arg4: SubtypeTestCache.
 // Return value: true or false, or may throw a type error in checked mode.
-DEFINE_RUNTIME_ENTRY(Instanceof, 6) {
+DEFINE_RUNTIME_ENTRY(Instanceof, 5) {
   ASSERT(arguments.Count() == kInstanceofRuntimeEntry.argument_count());
-  intptr_t node_id = Smi::CheckedHandle(arguments.At(0)).Value();
-  const Instance& instance = Instance::CheckedHandle(arguments.At(1));
-  const AbstractType& type = AbstractType::CheckedHandle(arguments.At(2));
-  const Instance& instantiator = Instance::CheckedHandle(arguments.At(3));
+  const Instance& instance = Instance::CheckedHandle(arguments.At(0));
+  const AbstractType& type = AbstractType::CheckedHandle(arguments.At(1));
+  const Instance& instantiator = Instance::CheckedHandle(arguments.At(2));
   const AbstractTypeArguments& instantiator_type_arguments =
-      AbstractTypeArguments::CheckedHandle(arguments.At(4));
+      AbstractTypeArguments::CheckedHandle(arguments.At(3));
   const SubtypeTestCache& cache =
-      SubtypeTestCache::CheckedHandle(arguments.At(5));
+      SubtypeTestCache::CheckedHandle(arguments.At(4));
   ASSERT(type.IsFinalized());
   Error& malformed_error = Error::Handle();
   const Bool& result = Bool::Handle(
       instance.IsInstanceOf(type,
                             instantiator_type_arguments,
                             &malformed_error) ?
       Bool::True() : Bool::False());
   if (FLAG_trace_type_checks) {
     PrintTypeCheck("InstanceOf",
         instance, type, instantiator_type_arguments, result);
   }
   if (!result.value() && !malformed_error.IsNull()) {
     // Throw a dynamic type error only if the instanceof test fails.
     const intptr_t location = GetCallerLocation();
     String& malformed_error_message =  String::Handle(
         String::New(malformed_error.ToErrorCString()));
     const String& no_name = String::Handle(Symbols::Empty());
     Exceptions::CreateAndThrowTypeError(
         location, no_name, no_name, no_name, malformed_error_message);
     UNREACHABLE();
   }
-  UpdateTypeTestCache(node_id, instance, type, instantiator,
+  UpdateTypeTestCache(instance, type, instantiator,
                       instantiator_type_arguments, result, cache);
   arguments.SetReturn(result);
 }
 
 
 // Check that the type of the given instance is a subtype of the given type and
 // can therefore be assigned.
-// Arg0: node-id of the assignment.
-// Arg1: instance being assigned.
-// Arg2: type being assigned to.
-// Arg3: instantiator (or null).
-// Arg4: type arguments of the instantiator of the type being assigned to.
-// Arg5: name of variable being assigned to.
-// Arg6: SubtypeTestCache.
+// Arg0: instance being assigned.
+// Arg1: type being assigned to.
+// Arg2: instantiator (or null).
+// Arg3: type arguments of the instantiator of the type being assigned to.
+// Arg4: name of variable being assigned to.
+// Arg5: SubtypeTestCache.
 // Return value: instance if a subtype, otherwise throw a TypeError.
-DEFINE_RUNTIME_ENTRY(TypeCheck, 7) {
+DEFINE_RUNTIME_ENTRY(TypeCheck, 6) {
   ASSERT(arguments.Count() == kTypeCheckRuntimeEntry.argument_count());
-  intptr_t node_id = Smi::CheckedHandle(arguments.At(0)).Value();
-  const Instance& src_instance = Instance::CheckedHandle(arguments.At(1));
-  const AbstractType& dst_type = AbstractType::CheckedHandle(arguments.At(2));
-  const Instance& dst_instantiator = Instance::CheckedHandle(arguments.At(3));
+  const Instance& src_instance = Instance::CheckedHandle(arguments.At(0));
+  const AbstractType& dst_type = AbstractType::CheckedHandle(arguments.At(1));
+  const Instance& dst_instantiator = Instance::CheckedHandle(arguments.At(2));
   const AbstractTypeArguments& instantiator_type_arguments =
-      AbstractTypeArguments::CheckedHandle(arguments.At(4));
-  const String& dst_name = String::CheckedHandle(arguments.At(5));
+      AbstractTypeArguments::CheckedHandle(arguments.At(3));
+  const String& dst_name = String::CheckedHandle(arguments.At(4));
   const SubtypeTestCache& cache =
-      SubtypeTestCache::CheckedHandle(arguments.At(6));
+      SubtypeTestCache::CheckedHandle(arguments.At(5));
   ASSERT(!dst_type.IsDynamicType());  // No need to check assignment.
   ASSERT(!dst_type.IsMalformed());  // Already checked in code generator.
   ASSERT(!src_instance.IsNull());  // Already checked in inlined code.
 
   Error& malformed_error = Error::Handle();
   const bool is_instance_of = src_instance.IsInstanceOf(
       dst_type, instantiator_type_arguments, &malformed_error);
 
   if (FLAG_trace_type_checks) {
     PrintTypeCheck("TypeCheck",
@@ skipping 16 matching lines @@
     }
     String& malformed_error_message =  String::Handle();
     if (!malformed_error.IsNull()) {
       ASSERT(FLAG_enable_type_checks);
       malformed_error_message = String::New(malformed_error.ToErrorCString());
     }
     Exceptions::CreateAndThrowTypeError(location, src_type_name, dst_type_name,
                                         dst_name, malformed_error_message);
     UNREACHABLE();
   }
-  UpdateTypeTestCache(node_id, src_instance, dst_type,
+  UpdateTypeTestCache(src_instance, dst_type,
                       dst_instantiator, instantiator_type_arguments,
                       Bool::ZoneHandle(Bool::True()), cache);
   arguments.SetReturn(src_instance);
 }
 
 
 // Report that the type of the given object is not bool in conditional context.
 // Arg0: bad object.
 // Return value: none, throws a TypeError.
 DEFINE_RUNTIME_ENTRY(ConditionTypeError, 1) {
@@ skipping 733 matching lines @@
 }
 
 
 static intptr_t GetDeoptInfo(const Code& code, uword pc) {
   const PcDescriptors& descriptors =
       PcDescriptors::Handle(code.pc_descriptors());
   ASSERT(!descriptors.IsNull());
   // Locate deopt id at deoptimization point inside optimized code.
   for (int i = 0; i < descriptors.Length(); i++) {
     if (static_cast<uword>(descriptors.PC(i)) == pc) {
-      return descriptors.NodeId(i);
+      return descriptors.DeoptId(i);
     }
   }
-  return Computation::kNoCid;
+  return Isolate::kNoDeoptId;
 }
 
 
 // Copy saved registers and caller's frame into temporary buffers.
 // Access the deopt information for the deoptimization point.
 // Return the new stack size (including PC marker and deopt return address,
 // excluding FP).
 DEFINE_LEAF_RUNTIME_ENTRY(intptr_t, DeoptimizeCopyFrame,
                           intptr_t deopt_reason,
                           intptr_t* saved_registers_address) {
@@ skipping 13 matching lines @@
   }
   isolate->set_deopt_registers_copy(registers_copy);
   ASSERT(reinterpret_cast<uword>(saved_registers_address) == last_fp);
   DartFrameIterator iterator(last_fp);
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
   const Code& optimized_code = Code::Handle(caller_frame->LookupDartCode());
   ASSERT(optimized_code.is_optimized());
 
   const intptr_t deopt_id = GetDeoptInfo(optimized_code, caller_frame->pc());
-  ASSERT(deopt_id != Computation::kNoCid);
+  ASSERT(deopt_id != Isolate::kNoDeoptId);
 
   // Add incoming arguments.
   const Function& function = Function::Handle(optimized_code.function());
   // Think of copied arguments.
   const intptr_t num_args = (function.num_optional_parameters() > 0) ?
       0 : function.num_fixed_parameters();
   // FP, PC marker and return address will all be copied.
   const intptr_t frame_copy_size =
       1  // Deoptimized function's return address: caller_frame->pc().
       + ((caller_frame->fp() - caller_frame->sp()) / kWordSize)
@@ skipping 39 matching lines @@
   const Function& function = Function::Handle(optimized_code.function());
   ASSERT(!function.IsNull());
   const Code& unoptimized_code = Code::Handle(function.unoptimized_code());
   ASSERT(!optimized_code.IsNull() && optimized_code.is_optimized());
   ASSERT(!unoptimized_code.IsNull() && !unoptimized_code.is_optimized());
 
   intptr_t* frame_copy = isolate->deopt_frame_copy();
   intptr_t* registers_copy = isolate->deopt_registers_copy();
 
   intptr_t deopt_id = GetDeoptInfo(optimized_code, caller_frame->pc());
-  ASSERT(deopt_id != Computation::kNoCid);
-  uword continue_at_pc = unoptimized_code.GetDeoptPcAtNodeId(deopt_id);
+  ASSERT(deopt_id != Isolate::kNoDeoptId);
+  uword continue_at_pc = unoptimized_code.GetDeoptPcAtDeoptId(deopt_id);
   if (FLAG_trace_deopt) {
     OS::Print("  -> continue at 0x%x\n", continue_at_pc);
     // TODO(srdjan): If we could allow GC, we could print the line where
     // deoptimization occured.
   }
   const intptr_t deopt_frame_copy_size = isolate->deopt_frame_copy_size();
   // TODO(srdjan): Use deopt info to copy the values to right place.
   const intptr_t pc_marker_index =
       ((caller_frame->fp() - caller_frame->sp()) / kWordSize);
   // Patch the return PC and saved PC marker in frame to point to the
@@ skipping 103 matching lines @@
       }
     }
   }
   // The cache is null terminated, therefore the loop above should never
   // terminate by itself.
   UNREACHABLE();
   return Code::null();
 }
 
 }  // namespace dart