Add virtual method to Object to ease dictionary code

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 1087 matching lines @@
   bool_value = Bool::New(false);
   object_store->set_false_value(bool_value);
 }
 
 
 void Object::Print() const {
   OS::Print("%s\n", ToCString());
 }
 
 
+RawString* Object::DictionaryName() const {
+  return String::null();
+}
+
+
 void Object::InitializeObject(uword address, intptr_t class_id, intptr_t size) {
   // TODO(iposva): Get a proper halt instruction from the assembler which
   // would be needed here for code objects.
   uword initial_value = reinterpret_cast<uword>(null_);
   uword cur = address;
   uword end = address + size;
   while (cur < end) {
     *reinterpret_cast<uword*>(cur) = initial_value;
     cur += kWordSize;
   }
@@ skipping 4874 matching lines @@
 void Library::GrowDictionary(const Array& dict, intptr_t dict_size) const {
   // TODO(iposva): Avoid exponential growth.
   intptr_t new_dict_size = dict_size * 2;
   const Array& new_dict =
       Array::Handle(Array::New(new_dict_size + 1, Heap::kOld));
   // Rehash all elements from the original dictionary
   // to the newly allocated array.
   Object& entry = Class::Handle();
   String& entry_name = String::Handle();
   Object& new_entry = Object::Handle();
-  Class& cls = Class::Handle();
-  Function& func = Function::Handle();
-  Field& field = Field::Handle();
-  LibraryPrefix& prefix = LibraryPrefix::Handle();
   for (intptr_t i = 0; i < dict_size; i++) {
     entry = dict.At(i);
     if (!entry.IsNull()) {
-      if (entry.IsClass()) {
-        cls ^= entry.raw();
-        entry_name = cls.Name();
-      } else if (entry.IsFunction()) {
-        func ^= entry.raw();
-        entry_name = func.name();
-      } else if (entry.IsField()) {
-        field ^= entry.raw();
-        entry_name = field.name();
-      } else if (entry.IsLibraryPrefix()) {
-        prefix ^= entry.raw();
-        entry_name = prefix.name();
-      } else {
-        UNREACHABLE();
-      }
+      entry_name = entry.DictionaryName();
+      ASSERT(!entry_name.IsNull());
       intptr_t hash = entry_name.Hash();
       intptr_t index = hash % new_dict_size;
       new_entry = new_dict.At(index);
       while (!new_entry.IsNull()) {
         index = (index + 1) % new_dict_size;  // Move to next element.
         new_entry = new_dict.At(index);
       }
       new_dict.SetAt(index, entry);
     }
   }
   // Copy used count.
   new_entry = dict.At(dict_size);
   new_dict.SetAt(new_dict_size, new_entry);
   // Remember the new dictionary now.
   StorePointer(&raw_ptr()->dictionary_, new_dict.raw());
 }
 
 
 void Library::AddObject(const Object& obj, const String& name) const {
   ASSERT(obj.IsClass() ||
          obj.IsFunction() ||
          obj.IsField() ||
          obj.IsLibraryPrefix());
-  ASSERT((LookupLocalObject(name) == Object::null()) ||
-         ((obj.IsLibraryPrefix() ||
-           (obj.IsClass() &&
-            Class::CheckedHandle(obj.raw()).IsCanonicalSignatureClass())) &&
-          (LookupLocalObject(name) == Object::null())));
+  ASSERT(name.Equals(String::Handle(obj.DictionaryName())));
+  ASSERT(LookupLocalObject(name) == Object::null());
   const Array& dict = Array::Handle(dictionary());
   intptr_t dict_size = dict.Length() - 1;
   intptr_t index = name.Hash() % dict_size;
 
   Object& entry = Object::Handle();
   entry = dict.At(index);
   // An empty spot will be found because we keep the hash set at most 75% full.
   while (!entry.IsNull()) {
     index = (index + 1) % dict_size;
     entry = dict.At(index);
@@ skipping 23 matching lines @@
   Isolate* isolate = Isolate::Current();
   const Array& dict = Array::Handle(isolate, dictionary());
   intptr_t dict_size = dict.Length() - 1;
   *index = name.Hash() % dict_size;
 
   Object& entry = Object::Handle(isolate);
   String& entry_name = String::Handle(isolate);
   entry = dict.At(*index);
   // Search the entry in the hash set.
   while (!entry.IsNull()) {
-    if (entry.IsClass()) {
-      entry_name = Class::Cast(entry).Name();
-    } else if (entry.IsFunction()) {
-      entry_name = Function::Cast(entry).name();
-    } else if (entry.IsField()) {
-      entry_name = Field::Cast(entry).name();
-    } else if (entry.IsLibraryPrefix()) {
-      entry_name = LibraryPrefix::Cast(entry).name();
-    } else {
-      UNREACHABLE();
-    }
-    if (entry_name.Equals(name)) {
+    entry_name = entry.DictionaryName();
+    ASSERT(!entry_name.IsNull());
+     if (entry_name.Equals(name)) {
       return entry.raw();
     }
     *index = (*index + 1) % dict_size;
     entry = dict.At(*index);
   }
   return Object::null();
 }
 
 
 void Library::ReplaceObject(const Object& obj, const String& name) const {
@@ skipping 5690 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart