--- a/js/src/gc/Barrier.h
+++ b/js/src/gc/Barrier.h
@@ -1229,21 +1229,16 @@ struct DefaultHasher<js::WeakHeapPtr<T>>
 
 template <class T>
 struct DefaultHasher<js::UnsafeBarePtr<T>> : js::UnsafeBarePtrHasher<T> {};
 
 }  // namespace mozilla
 
 namespace js {
 
-namespace jit {
-class JitCode;
-}  // namespace jit
-
-using WeakHeapPtrJitCode = WeakHeapPtr<jit::JitCode*>;
 using WeakHeapPtrSymbol = WeakHeapPtr<JS::Symbol*>;
 
 using HeapPtrJitCode = HeapPtr<jit::JitCode*>;
 using HeapPtrObject = HeapPtr<JSObject*>;
 using HeapPtrValue = HeapPtr<Value>;
 
 } /* namespace js */
 

--- a/js/src/jit/Ion.cpp
+++ b/js/src/jit/Ion.cpp
@@ -291,17 +291,17 @@ static T PopNextBitmaskValue(uint32_t* b
 
   MOZ_ASSERT(index < uint32_t(T::Count));
   return T(index);
 }
 
 void JitRealm::performStubReadBarriers(uint32_t stubsToBarrier) const {
   while (stubsToBarrier) {
     auto stub = PopNextBitmaskValue<StubIndex>(&stubsToBarrier);
-    const WeakHeapPtrJitCode& jitCode = stubs_[stub];
+    const WeakHeapPtr<JitCode*>& jitCode = stubs_[stub];
     MOZ_ASSERT(jitCode);
     jitCode.get();
   }
 }
 
 static bool LinkCodeGen(JSContext* cx, CodeGenerator* codegen,
                         HandleScript script, const WarpSnapshot* snapshot) {
   TraceLoggerThread* logger = TraceLoggerForCurrentThread(cx);
@@ -409,17 +409,17 @@ void JitRuntime::TraceWeakJitcodeGlobalT
 }
 
 void JitRealm::traceWeak(JSTracer* trc, JS::Realm* realm) {
   // Any outstanding compilations should have been cancelled by the GC.
   MOZ_ASSERT(!HasOffThreadIonCompile(realm));
 
   stubCodes_->traceWeak(trc);
 
-  for (WeakHeapPtrJitCode& stub : stubs_) {
+  for (WeakHeapPtr<JitCode*>& stub : stubs_) {
     TraceWeakEdge(trc, &stub, "JitRealm::stubs_");
   }
 }
 
 bool JitZone::addInlinedCompilation(const RecompileInfo& info,
                                     JSScript* inlined) {
   MOZ_ASSERT(inlined != info.script());
 

--- a/js/src/jit/JitRealm.h
+++ b/js/src/jit/JitRealm.h
@@ -26,27 +26,28 @@ namespace js {
 
 MOZ_COLD void ReportOutOfMemory(JSContext* cx);
 
 namespace jit {
 
 class JitCode;
 
 struct IcStubCodeMapGCPolicy {
-  static bool traceWeak(JSTracer* trc, uint32_t*, WeakHeapPtrJitCode* value) {
+  static bool traceWeak(JSTracer* trc, uint32_t*,
+                        WeakHeapPtr<JitCode*>* value) {
     return TraceWeakEdge(trc, value, "traceWeak");
   }
 };
 
 class JitRealm {
   friend class JitActivation;
 
   // Map ICStub keys to ICStub shared code objects.
   using ICStubCodeMap =
-      GCHashMap<uint32_t, WeakHeapPtrJitCode, DefaultHasher<uint32_t>,
+      GCHashMap<uint32_t, WeakHeapPtr<JitCode*>, DefaultHasher<uint32_t>,
                 ZoneAllocPolicy, IcStubCodeMapGCPolicy>;
   ICStubCodeMap* stubCodes_;
 
   // The JitRealm stores stubs to concatenate strings inline and perform RegExp
   // calls inline. These bake in zone and realm specific pointers and can't be
   // stored in JitRuntime. They also are dependent on the value of
   // 'initialStringHeap' and must be flushed when its value changes.
   //
@@ -58,17 +59,17 @@ class JitRealm {
   enum StubIndex : uint32_t {
     StringConcat = 0,
     RegExpMatcher,
     RegExpSearcher,
     RegExpTester,
     Count
   };
 
-  mozilla::EnumeratedArray<StubIndex, StubIndex::Count, WeakHeapPtrJitCode>
+  mozilla::EnumeratedArray<StubIndex, StubIndex::Count, WeakHeapPtr<JitCode*>>
       stubs_;
 
   gc::InitialHeap initialStringHeap;
 
   JitCode* generateStringConcatStub(JSContext* cx);
   JitCode* generateRegExpMatcherStub(JSContext* cx);
   JitCode* generateRegExpSearcherStub(JSContext* cx);
   JitCode* generateRegExpTesterStub(JSContext* cx);
@@ -110,23 +111,23 @@ class JitRealm {
     }
     stubs_[StringConcat] = generateStringConcatStub(cx);
     return stubs_[StringConcat];
   }
 
   void traceWeak(JSTracer* trc, JS::Realm* realm);
 
   void discardStubs() {
-    for (WeakHeapPtrJitCode& stubRef : stubs_) {
+    for (WeakHeapPtr<JitCode*>& stubRef : stubs_) {
       stubRef = nullptr;
     }
   }
 
   bool hasStubs() const {
-    for (const WeakHeapPtrJitCode& stubRef : stubs_) {
+    for (const WeakHeapPtr<JitCode*>& stubRef : stubs_) {
       if (stubRef) {
         return true;
       }
     }
     return false;
   }
 
   void setStringsCanBeInNursery(bool allow) {

--- a/js/src/jit/JitZone.h
+++ b/js/src/jit/JitZone.h
@@ -71,33 +71,33 @@ struct CacheIRStubKey : public DefaultHa
 
   void operator=(CacheIRStubKey&& other) {
     stubInfo = std::move(other.stubInfo);
   }
 };
 
 struct BaselineCacheIRStubCodeMapGCPolicy {
   static bool traceWeak(JSTracer* trc, CacheIRStubKey*,
-                        WeakHeapPtrJitCode* value) {
+                        WeakHeapPtr<JitCode*>* value) {
     return TraceWeakEdge(trc, value, "traceWeak");
   }
 };
 
 class JitZone {
   // Allocated space for optimized baseline stubs.
   OptimizedICStubSpace optimizedStubSpace_;
 
   // Set of CacheIRStubInfo instances used by Ion stubs in this Zone.
   using IonCacheIRStubInfoSet =
       HashSet<CacheIRStubKey, CacheIRStubKey, SystemAllocPolicy>;
   IonCacheIRStubInfoSet ionCacheIRStubInfoSet_;
 
   // Map CacheIRStubKey to shared JitCode objects.
   using BaselineCacheIRStubCodeMap =
-      GCHashMap<CacheIRStubKey, WeakHeapPtrJitCode, CacheIRStubKey,
+      GCHashMap<CacheIRStubKey, WeakHeapPtr<JitCode*>, CacheIRStubKey,
                 SystemAllocPolicy, BaselineCacheIRStubCodeMapGCPolicy>;
   BaselineCacheIRStubCodeMap baselineCacheIRStubCodes_;
 
   // Executable allocator for all code except wasm code.
   MainThreadData<ExecutableAllocator> execAlloc_;
 
   // HashMap that maps scripts to compilations inlining those scripts.
   using InlinedScriptMap =