Introduce a VM type cast to avoid repeating a type test and spare a handle.

runtime/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 74 matching lines @@
         VMHandles::AllocateZoneHandle(isolate));                               \
     initializeHandle(obj, raw_ptr);                                            \
     if (!obj->Is##object()) {                                                  \
       FATAL("Handle check failed.");                                           \
     }                                                                          \
     return *obj;                                                               \
   }                                                                            \
   static object& CheckedZoneHandle(RawObject* raw_ptr) {                       \
     return CheckedZoneHandle(Isolate::Current(), raw_ptr);                     \
   }                                                                            \
+  static const object* Cast(const Object& obj) {                               \
+    ASSERT(obj.Is##object());                                                  \
+    return reinterpret_cast<const object*>(&obj);                              \
+  }                                                                            \

[siva, 2012/06/28 17:02:51]

Do you think 
static const object& Cast(const Object& obj) {
  ASSERT(obj.Is##object());
  return *(reinterpret_cast<const object*>(&obj));
}
would make the caller code a lot more uniform? i.e we 
would be using the returned handle as 'handle.' like how we do in most of our
code instead of a '(*handle).' or 'handle->'

[Ivan Posva, 2012/06/28 17:35:58]

I really like this suggestion because it keeps the code uniform on the outside.

Also, one reason why we have not been doing this casting in the past is that you
now suddenly have aliased handles. This should not be a problem for const
handles, but we should watch out if we start making mistakes as they will be
hard to find.

[regis, 2012/06/28 18:44:51]

I like it. Done.

[regis, 2012/06/28 18:44:51]

Done.

   static Raw##object* null() {                                                 \
     return reinterpret_cast<Raw##object*>(Object::null());                     \
   }                                                                            \
   virtual const char* ToCString() const;                                       \
   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) {              \
@@ skipping 4982 matching lines @@
 }
 
 
 intptr_t Stackmap::SizeInBits() const {
   return (Smi::Value(raw_ptr()->bitmap_size_in_bytes_) * kBitsPerByte);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_