Improve the error message for handle check failure to list the actual

vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 44 matching lines @@
     return Handle(isolate, object::null());                                    \
   }                                                                            \
   static object& Handle(Raw##object* raw_ptr) {                                \
     return Handle(Isolate::Current(), raw_ptr);                                \
   }                                                                            \
   static object& CheckedHandle(Isolate* isolate, RawObject* raw_ptr) {         \
     object* obj =                                                              \
         reinterpret_cast<object*>(VMHandles::AllocateHandle(isolate));         \
     initializeHandle(obj, raw_ptr);                                            \
     if (!obj->Is##object()) {                                                  \
-      FATAL("Handle check failed.");                                           \
+      FATAL2("Handle check failed: saw %s expected %s",                        \
+             obj->GetClassName(), #object);                                    \

[Ivan Posva, 2012/08/03 20:13:10]

What would happen if you used ToCString() here, instead of adding
GetClassName()?

     }                                                                          \
     return *obj;                                                               \
   }                                                                            \
   static object& CheckedHandle(RawObject* raw_ptr) {                           \
     return CheckedHandle(Isolate::Current(), raw_ptr);                         \
   }                                                                            \
   static object& ZoneHandle(Isolate* isolate, Raw##object* raw_ptr) {          \
     object* obj = reinterpret_cast<object*>(                                   \
         VMHandles::AllocateZoneHandle(isolate));                               \
     initializeHandle(obj, raw_ptr);                                            \
     return *obj;                                                               \
   }                                                                            \
   static object& ZoneHandle() {                                                \
     return ZoneHandle(Isolate::Current(), object::null());                     \
   }                                                                            \
   static object& ZoneHandle(Raw##object* raw_ptr) {                            \
     return ZoneHandle(Isolate::Current(), raw_ptr);                            \
   }                                                                            \
   static object& CheckedZoneHandle(Isolate* isolate, RawObject* raw_ptr) {     \
     object* obj = reinterpret_cast<object*>(                                   \
         VMHandles::AllocateZoneHandle(isolate));                               \
     initializeHandle(obj, raw_ptr);                                            \
     if (!obj->Is##object()) {                                                  \
-      FATAL("Handle check failed.");                                           \
+      FATAL2("Handle check failed: saw %s expected %s",                        \
+             obj->GetClassName(), #object);                                    \
     }                                                                          \
     return *obj;                                                               \
   }                                                                            \
   static object& CheckedZoneHandle(RawObject* raw_ptr) {                       \
     return CheckedZoneHandle(Isolate::Current(), raw_ptr);                     \
   }                                                                            \
   /* T::Cast cannot be applied to a null Object, because the object vtable */  \
   /* is not setup for type T, although some methods are supposed to work   */  \
   /* with null, for example Instance::Equals().                            */  \
   static const object& Cast(const Object& obj) {                               \
     ASSERT(obj.Is##object());                                                  \
     return reinterpret_cast<const object&>(obj);                               \
   }                                                                            \
   static Raw##object* null() {                                                 \
     return reinterpret_cast<Raw##object*>(Object::null());                     \
   }                                                                            \
   virtual const char* ToCString() const;                                       \
+  virtual const char* GetClassName() const { return #object; }                 \
   static const ObjectKind kInstanceKind = k##object;                           \
  protected:  /* NOLINT */                                                      \
   object() : super() {}                                                        \
  private:  /* NOLINT */                                                        \
   /* Initialize the handle based on the raw_ptr in the presence of null. */    \
   static void initializeHandle(object* obj, RawObject* raw_ptr) {              \
     if (raw_ptr != Object::null()) {                                           \
       obj->SetRaw(raw_ptr);                                                    \
     } else {                                                                   \
       obj->raw_ = Object::null();                                              \
@@ skipping 101 matching lines @@
 
   bool IsNull() const { return raw_ == null_; }
 
   virtual const char* ToCString() const {
     if (IsNull()) {
       return "null";
     } else {
       return "Object";
     }
   }
+  virtual const char* GetClassName() const {
+    return "Object";
+  }
 
   bool IsNew() const { return raw()->IsNewObject(); }
   bool IsOld() const { return raw()->IsOldObject(); }
 
   // Print the object on stdout for debugging.
   void Print() const;
 
   bool IsZoneHandle() const {
     return VMHandles::IsZoneHandle(reinterpret_cast<uword>(this));
   }
@@ skipping 5131 matching lines @@
     if (this->CharAt(i) != str.CharAt(begin_index + i)) {
       return false;
     }
   }
   return true;
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_