--- a/js/public/GCPolicyAPI.h
+++ b/js/public/GCPolicyAPI.h
@@ -49,28 +49,30 @@
 // referent type T.
 
 #ifndef GCPolicyAPI_h
 #define GCPolicyAPI_h
 
 #include "mozilla/Maybe.h"
 #include "mozilla/UniquePtr.h"
 
+#include <type_traits>
+
 #include "js/GCTypeMacros.h"  // JS_FOR_EACH_PUBLIC_GC_POINTER_TYPE
 #include "js/TraceKind.h"
 #include "js/TracingAPI.h"
 #include "js/TypeDecls.h"
 
 namespace JS {
 
 // Defines a policy for container types with non-GC, i.e. C storage. This
 // policy dispatches to the underlying struct for GC interactions.
 template <typename T>
 struct StructGCPolicy {
-  static_assert(!mozilla::IsPointer<T>::value,
+  static_assert(!std::is_pointer_v<T>,
                 "Pointer type not allowed for StructGCPolicy");
 
   static void trace(JSTracer* trc, T* tp, const char* name) { tp->trace(trc); }
 
   static void sweep(T* tp) { return tp->sweep(); }
 
   static bool needsSweep(T* tp) { return tp->needsSweep(); }
 
@@ -96,17 +98,17 @@ struct IgnoreGCPolicy {
 };
 template <>
 struct GCPolicy<uint32_t> : public IgnoreGCPolicy<uint32_t> {};
 template <>
 struct GCPolicy<uint64_t> : public IgnoreGCPolicy<uint64_t> {};
 
 template <typename T>
 struct GCPointerPolicy {
-  static_assert(mozilla::IsPointer<T>::value,
+  static_assert(std::is_pointer_v<T>,
                 "Non-pointer type not allowed for GCPointerPolicy");
 
   static void trace(JSTracer* trc, T* vp, const char* name) {
     // It's not safe to trace unbarriered pointers except as part of root
     // marking.
     UnsafeTraceRoot(trc, vp, name);
   }
   static bool needsSweep(T* vp) {

--- a/js/public/RootingAPI.h
+++ b/js/public/RootingAPI.h
@@ -6,17 +6,16 @@
 
 #ifndef js_RootingAPI_h
 #define js_RootingAPI_h
 
 #include "mozilla/Attributes.h"
 #include "mozilla/DebugOnly.h"
 #include "mozilla/GuardObjects.h"
 #include "mozilla/LinkedList.h"
-#include "mozilla/TypeTraits.h"
 
 #include <type_traits>
 #include <utility>
 
 #include "jspubtd.h"
 
 #include "js/ComparisonOperators.h"  // JS::detail::DefineComparisonOps
 #include "js/GCAnnotations.h"
@@ -588,17 +587,17 @@ class MOZ_NONHEAP_CLASS Handle : public 
       Handle<S> handle,
       std::enable_if_t<std::is_convertible_v<S, T>, int> dummy = 0) {
     static_assert(sizeof(Handle<T>) == sizeof(T*),
                   "Handle must be binary compatible with T*.");
     ptr = reinterpret_cast<const T*>(handle.address());
   }
 
   MOZ_IMPLICIT Handle(decltype(nullptr)) {
-    static_assert(mozilla::IsPointer<T>::value,
+    static_assert(std::is_pointer_v<T>,
                   "nullptr_t overload not valid for non-pointer types");
     static void* const ConstNullValue = nullptr;
     ptr = reinterpret_cast<const T*>(&ConstNullValue);
   }
 
   MOZ_IMPLICIT Handle(MutableHandle<T> handle) { ptr = handle.address(); }
 
   /*

--- a/js/src/vm/SharedMem.h
+++ b/js/src/vm/SharedMem.h
@@ -6,18 +6,17 @@
 
 #ifndef vm_SharedMem_h
 #define vm_SharedMem_h
 
 #include <type_traits>
 
 template <typename T>
 class SharedMem {
-  // static_assert(mozilla::IsPointer<T>::value,
-  //               "SharedMem encapsulates pointer types");
+  static_assert(std::is_pointer_v<T>, "SharedMem encapsulates pointer types");
 
   enum Sharedness { IsUnshared, IsShared };
 
   T ptr_;
 #ifdef DEBUG
   Sharedness sharedness_;
 #endif