Rename kDummyTokenIndex to kNoSourcePos

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/cpu.h"
@@ skipping 949 matching lines @@
   // Now that the symbol table is initialized and that the core dictionary as
   // well as the core implementation dictionary have been setup, preallocate
   // remaining classes and register them by name in the dictionaries.
   String& name = String::Handle();
   cls = object_store->array_class();  // Was allocated above.
   RegisterPrivateClass(cls, Symbols::_List(), core_lib);
   pending_classes.Add(cls);
   // We cannot use NewNonParameterizedType(cls), because Array is parameterized.
   type ^= Type::New(Object::Handle(cls.raw()),
                     TypeArguments::Handle(),
-                    Scanner::kDummyTokenIndex);
+                    Scanner::kNoSourcePos);
   type.SetIsFinalized();
   type ^= type.Canonicalize();
   object_store->set_array_type(type);
 
   cls = object_store->growable_object_array_class();  // Was allocated above.
   RegisterPrivateClass(cls, Symbols::_GrowableList(), core_lib);
   pending_classes.Add(cls);
 
   cls = Class::New<Array>(kImmutableArrayCid);
   object_store->set_immutable_array_class(cls);
@@ skipping 674 matching lines @@
   // Return the still unfinalized signature type.
   ASSERT(!signature_type.IsFinalized());
   return signature_type.raw();
 }
 
 
 RawAbstractType* Class::RareType() const {
   const Type& type = Type::Handle(Type::New(
       *this,
       Object::null_abstract_type_arguments(),
-      Scanner::kDummyTokenIndex));
+      Scanner::kNoSourcePos));
   return ClassFinalizer::FinalizeType(*this,
                                       type,
                                       ClassFinalizer::kCanonicalize);
 }
 
 
 RawAbstractType* Class::DeclarationType() const {
   const TypeArguments& args = TypeArguments::Handle(type_parameters());
   const Type& type = Type::Handle(Type::New(
       *this,
       args,
-      Scanner::kDummyTokenIndex));
+      Scanner::kNoSourcePos));
   return ClassFinalizer::FinalizeType(*this,
                                       type,
                                       ClassFinalizer::kCanonicalize);
 }
 
 
 template <class FakeObject>
 RawClass* Class::New() {
   ASSERT(Object::class_class() != Class::null());
   Class& result = Class::Handle();
@@ skipping 11 matching lines @@
   ASSERT((FakeObject::kClassId != kInstanceCid));
   result.set_id(FakeObject::kClassId);
   result.set_state_bits(0);
   // VM backed classes are almost ready: run checks and resolve class
   // references, but do not recompute size.
   result.set_is_prefinalized();
   result.set_type_arguments_field_offset_in_words(kNoTypeArguments);
   result.set_num_type_arguments(0);
   result.set_num_own_type_arguments(0);
   result.set_num_native_fields(0);
-  result.set_token_pos(Scanner::kDummyTokenIndex);
+  result.set_token_pos(Scanner::kNoSourcePos);
   result.InitEmptyFields();
   Isolate::Current()->RegisterClass(result);
   return result.raw();
 }
 
 
 
 static void ReportTooManyTypeArguments(const Class& cls) {
   const Error& error = Error::Handle(
       LanguageError::NewFormatted(
@@ skipping 775 matching lines @@
   // In order to tokenize the source, we need to get the key to mangle
   // private names from the library from which the object's class
   // originates.
   const Library& lib = Library::Handle(cls.library());
   ASSERT(!lib.IsNull());
   const String& lib_key = String::Handle(lib.private_key());
   script.Tokenize(lib_key);
 
   const String& src_class_name = String::Handle(Symbols::New(":internal"));
   const Class& src_class = Class::Handle(
-      Class::New(src_class_name, script, Scanner::kDummyTokenIndex));
+      Class::New(src_class_name, script, Scanner::kNoSourcePos));
   src_class.set_is_finalized();
   src_class.set_library(lib);
   return PatchClass::New(cls, src_class);
 }
 
 
 RawObject* Class::Evaluate(const String& expr) const {
   const PatchClass& temp_class =
       PatchClass::Handle(MakeTempPatchClass(*this, expr));
   const String& eval_func_name = String::Handle(Symbols::New(":eval"));
@@ skipping 104 matching lines @@
   ASSERT(fake.IsInstance());
   result.set_handle_vtable(fake.vtable());
   result.set_instance_size(FakeInstance::InstanceSize());
   result.set_next_field_offset(FakeInstance::NextFieldOffset());
   result.set_id(index);
   result.set_state_bits(0);
   result.set_type_arguments_field_offset_in_words(kNoTypeArguments);
   result.set_num_type_arguments(kUnknownNumTypeArguments);
   result.set_num_own_type_arguments(kUnknownNumTypeArguments);
   result.set_num_native_fields(0);
-  result.set_token_pos(Scanner::kDummyTokenIndex);
+  result.set_token_pos(Scanner::kNoSourcePos);
   result.InitEmptyFields();
   Isolate::Current()->RegisterClass(result);
   return result.raw();
 }
 
 
 RawClass* Class::New(const String& name,
                      const Script& script,
                      intptr_t token_pos) {
   Class& result = Class::Handle(New<Instance>(kIllegalCid));
@@ skipping 69 matching lines @@
   }
   set_is_prefinalized();
 }
 
 
 RawClass* Class::NewNativeWrapper(const Library& library,
                                   const String& name,
                                   int field_count) {
   Class& cls = Class::Handle(library.LookupClass(name));
   if (cls.IsNull()) {
-    cls = New(name, Script::Handle(), Scanner::kDummyTokenIndex);
+    cls = New(name, Script::Handle(), Scanner::kNoSourcePos);
     cls.SetFields(Object::empty_array());
     cls.SetFunctions(Object::empty_array());
     // Set super class to Object.
     cls.set_super_type(Type::Handle(Type::ObjectType()));
     // Compute instance size. First word contains a pointer to a properly
     // sized typed array once the first native field has been set.
     intptr_t instance_size = sizeof(RawInstance) + kWordSize;
     cls.set_instance_size(RoundedAllocationSize(instance_size));
     cls.set_next_field_offset(instance_size);
     cls.set_num_native_fields(field_count);
@@ skipping 8807 matching lines @@
   if (IsNull()) {
     return Type::NullType();
   }
   const Class& cls = Class::Handle(clazz());
   Type& type = Type::Handle(cls.CanonicalType());
   if (type.IsNull()) {
     AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
     if (cls.NumTypeArguments() > 0) {
       type_arguments = GetTypeArguments();
     }
-    type = Type::New(cls, type_arguments, Scanner::kDummyTokenIndex);
+    type = Type::New(cls, type_arguments, Scanner::kNoSourcePos);
     type.SetIsFinalized();
     type ^= type.Canonicalize();
   }
   return type.raw();
 }
 
 
 RawAbstractTypeArguments* Instance::GetTypeArguments() const {
   const Class& cls = Class::Handle(clazz());
   intptr_t field_offset = cls.type_arguments_field_offset();
@@ skipping 171 matching lines @@
       return Closure::ToCString(*this);
     }
     const char* kFormat = "Instance of '%s'";
     const Class& cls = Class::Handle(clazz());
     AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
     const intptr_t num_type_arguments = cls.NumTypeArguments();
     if (num_type_arguments > 0) {
       type_arguments = GetTypeArguments();
     }
     const Type& type =
-        Type::Handle(Type::New(cls, type_arguments, Scanner::kDummyTokenIndex));
+        Type::Handle(Type::New(cls, type_arguments, Scanner::kNoSourcePos));
     const String& type_name = String::Handle(type.UserVisibleName());
     // Calculate the size of the string.
     intptr_t len = OS::SNPrint(NULL, 0, kFormat, type_name.ToCString()) + 1;
     char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
     OS::SNPrint(chars, len, kFormat, type_name.ToCString());
     return chars;
   }
 }
 
 
@@ skipping 529 matching lines @@
     if (Object::dynamic_type() != reinterpret_cast<RawType*>(RAW_NULL)) {
       return Object::dynamic_type();
     }
     ASSERT(Isolate::Current() == Dart::vm_isolate());
   }
   Type& type = Type::Handle(type_class.CanonicalType());
   if (type.IsNull()) {
     const TypeArguments& no_type_arguments = TypeArguments::Handle();
     type ^= Type::New(Object::Handle(type_class.raw()),
                       no_type_arguments,
-                      Scanner::kDummyTokenIndex);
+                      Scanner::kNoSourcePos);
     type.SetIsFinalized();
     type ^= type.Canonicalize();
   }
   return type.raw();
 }
 
 
 void Type::SetIsFinalized() const {
   ASSERT(!IsFinalized());
   if (IsInstantiated()) {
@@ skipping 4690 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   Instance::PrintToJSONStream(stream, ref);
 }
 
 
 }  // namespace dart