Use type tagging for OpaqueWrappable type checks

Avoids using dynamic_cast/RTTI by using unique type
tags for each type T.

Author: jasnell

src/workerd/jsg/promise.h

@@ -25,7 +25,23 @@ namespace workerd::jsg {
 template <typename T, bool = isGcVisitable<T>()>
 struct OpaqueWrappable;
 
+// Unique type tag for each type T. Used to implement fast type checking in OpaqueWrappable
+// without relying on dynamic_cast/RTTI. Each instantiation of this template variable has a
+// unique address that serves as a type identifier.
+template <typename T>
+inline const char opaqueTypeTag = 0;
+
+template <typename T>
+inline const void* getOpaqueTypeTag() {
+  return &opaqueTypeTag<T>;
+}
+
 struct OpaqueWrappableBase: public Wrappable {
+  // Type tag for fast type checking. Set by OpaqueWrappable<T> constructor.
+  const void* const typeTag;
+
+  explicit OpaqueWrappableBase(const void* tag): typeTag(tag) {}
+
   kj::StringPtr jsgGetMemoryName() const override final {
     return "OpaqueWrappable"_kjc;
   }
@@ -38,7 +54,7 @@ template <typename T>
 struct OpaqueWrappable<T, false>: public OpaqueWrappableBase {
   // Used to implement wrapOpaque().
 
-  OpaqueWrappable(T&& value): value(kj::mv(value)) {}
+  OpaqueWrappable(T&& value): OpaqueWrappableBase(getOpaqueTypeTag<T>()), value(kj::mv(value)) {}
 
   T value;
   bool movedAway = false;
@@ -95,8 +111,9 @@ T unwrapOpaque(v8::Isolate* isolate, v8::Local<v8::Value> handle) {
   static_assert(!isV8Local<T>(), "can't opaque-wrap non-persistent handles");
 
   Wrappable& wrappable = KJ_ASSERT_NONNULL(Wrappable::tryUnwrapOpaque(isolate, handle));
-  OpaqueWrappable<T>* holder = dynamic_cast<OpaqueWrappable<T>*>(&wrappable);
-  KJ_ASSERT(holder != nullptr);
+  auto* base = static_cast<OpaqueWrappableBase*>(&wrappable);
+  KJ_ASSERT(base->typeTag == getOpaqueTypeTag<T>());
+  auto* holder = static_cast<OpaqueWrappable<T>*>(base);
   KJ_ASSERT(!holder->movedAway);
   holder->movedAway = true;
   return kj::mv(holder->value);
@@ -111,8 +128,9 @@ T& unwrapOpaqueRef(v8::Isolate* isolate, v8::Local<v8::Value> handle) {
   static_assert(!isV8Local<T>(), "can't opaque-wrap non-persistent handles");
 
   Wrappable& wrappable = KJ_ASSERT_NONNULL(Wrappable::tryUnwrapOpaque(isolate, handle));
-  OpaqueWrappable<T>* holder = dynamic_cast<OpaqueWrappable<T>*>(&wrappable);
-  KJ_ASSERT(holder != nullptr);
+  auto* base = static_cast<OpaqueWrappableBase*>(&wrappable);
+  KJ_ASSERT(base->typeTag == getOpaqueTypeTag<T>());
+  auto* holder = static_cast<OpaqueWrappable<T>*>(base);
   KJ_ASSERT(!holder->movedAway);
   return holder->value;
 }
@@ -126,8 +144,9 @@ void dropOpaque(v8::Isolate* isolate, v8::Local<v8::Value> handle) {
   static_assert(!isV8Ref<T>());
 
   KJ_IF_SOME(wrappable, Wrappable::tryUnwrapOpaque(isolate, handle)) {
-    OpaqueWrappable<T>* holder = dynamic_cast<OpaqueWrappable<T>*>(&wrappable);
-    if (holder != nullptr) {
+    auto* base = static_cast<OpaqueWrappableBase*>(&wrappable);
+    if (base->typeTag == getOpaqueTypeTag<T>()) {
+      auto* holder = static_cast<OpaqueWrappable<T>*>(base);
       holder->movedAway = true;
       auto drop KJ_UNUSED = kj::mv(holder->value);
     }