Cannot use Handle<T>::cast in Unique<T>::cast since it will try to do a T::cast (and its typecheck)…

src/unique.h

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_HYDROGEN_UNIQUE_H_
 #define V8_HYDROGEN_UNIQUE_H_
 
 #include <ostream>  // NOLINT(readability/streams)
 
 #include "src/base/functional.h"
@@ skipping 90 matching lines @@
   inline bool IsKnownGlobal(void* global) const {
     DCHECK(IsInitialized());
     return raw_address_ == reinterpret_cast<Address>(global);
   }
 
   inline Handle<T> handle() const {
     return handle_;
   }
 
   template <class S> static Unique<T> cast(Unique<S> that) {
-    return Unique<T>(that.raw_address_, Handle<T>::cast(that.handle_));
+    // Allow fetching location() to unsafe-cast the handle. This is necessary
+    // since we can't concurrently safe-cast. Safe-casting requires looking at
+    // the heap which may be moving concurrently to the compiler thread.
+    AllowHandleDereference allow_deref;
+    return Unique<T>(that.raw_address_,
+                     Handle<T>(reinterpret_cast<T**>(that.handle_.location())));
   }
 
   inline bool IsInitialized() const {
     return raw_address_ != NULL || handle_.is_null();
   }
 
   // TODO(titzer): this is a hack to migrate to Unique<T> incrementally.
   static Unique<T> CreateUninitialized(Handle<T> handle) {
     return Unique<T>(NULL, handle);
   }
@@ skipping 228 matching lines @@
       }
       capacity_ = new_capacity;
       array_ = new_array;
     }
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_UNIQUE_H_