Add a new operator |= which does a simple assignment of the raw pointer into

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 15 matching lines @@
 CLASS_LIST(DEFINE_FORWARD_DECLARATION)
 #undef DEFINE_FORWARD_DECLARATION
 class Api;
 class Assembler;
 class Closure;
 class Code;
 class DeoptInstr;
 class LocalScope;
 class Symbols;
 
+#if defined(DEBUG)
+#define CHECK_HANDLE() CheckHandle();
+#else
+#define CHECK_HANDLE()
+#endif
+
 #define OBJECT_IMPLEMENTATION(object, super)                                   \
  public:  /* NOLINT */                                                         \
   Raw##object* raw() const { return reinterpret_cast<Raw##object*>(raw_); }    \
   void operator=(Raw##object* value) {                                         \
     initializeHandle(this, value);                                             \
   }                                                                            \
   bool Is##object() const { return true; }                                     \
   void operator^=(RawObject* value) {                                          \
     initializeHandle(this, value);                                             \
     ASSERT(IsNull() || Is##object());                                          \
   }                                                                            \
+  void operator|=(RawObject* value) {                                          \
+    raw_ = value;                                                              \
+    CHECK_HANDLE();                                                            \
+  }                                                                            \
   static object& Handle(Isolate* isolate, Raw##object* raw_ptr) {              \
     object* obj =                                                              \
         reinterpret_cast<object*>(VMHandles::AllocateHandle(isolate));         \
     initializeHandle(obj, raw_ptr);                                            \
     return *obj;                                                               \
   }                                                                            \
   static object& Handle() {                                                    \
     return Handle(Isolate::Current(), object::null());                         \
   }                                                                            \
   static object& Handle(Isolate* isolate) {                                    \
@@ skipping 302 matching lines @@
 
  protected:
   // Used for extracting the C++ vtable during bringup.
   Object() : raw_(null_) {}
 
   uword raw_value() const {
     return reinterpret_cast<uword>(raw());
   }
 
   inline void SetRaw(RawObject* value);
+  void CheckHandle() const;
 
   cpp_vtable vtable() const { return bit_copy<cpp_vtable>(*this); }
   void set_vtable(cpp_vtable value) { *vtable_address() = value; }
 
   static RawObject* Allocate(intptr_t cls_id,
                              intptr_t size,
                              Heap::Space space);
 
   static intptr_t RoundedAllocationSize(intptr_t size) {
     return Utils::RoundUp(size, kObjectAlignment);
@@ skipping 5873 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_