From 75dca629df6bbcb051cf1daf4606cf53654b2494 Mon Sep 17 00:00:00 2001
From: Andreas Kling <kling@serenityos.org>
Date: Sat, 7 May 2022 12:50:54 +0200
Subject: [PATCH] AK+Kernel: Remove RefPtrTraits template param in userspace
 code

Only the kernel actually uses RefPtrTraits, so let's not burden
userspace builds with the complexity.
---
 AK/Forward.h       |  5 +++++
 AK/NonnullOwnPtr.h | 12 ++++--------
 AK/NonnullRefPtr.h |  4 ++--
 AK/RefPtr.h        | 32 ++++++++++++++++----------------
 AK/Weakable.h      |  6 +++---
 5 files changed, 30 insertions(+), 29 deletions(-)

diff --git a/AK/Forward.h b/AK/Forward.h
index 938c9fcb8f2..cced16c5bf0 100644
--- a/AK/Forward.h
+++ b/AK/Forward.h
@@ -115,11 +115,16 @@ class NonnullOwnPtrVector;
 template<typename T>
 class Optional;
 
+#ifdef KERNEL
 template<typename T>
 struct RefPtrTraits;
 
 template<typename T, typename PtrTraits = RefPtrTraits<T>>
 class RefPtr;
+#else
+template<typename T>
+class RefPtr;
+#endif
 
 template<typename T>
 class OwnPtr;
diff --git a/AK/NonnullOwnPtr.h b/AK/NonnullOwnPtr.h
index ad374dcad58..b10ac3ddc7c 100644
--- a/AK/NonnullOwnPtr.h
+++ b/AK/NonnullOwnPtr.h
@@ -17,10 +17,6 @@
 
 namespace AK {
 
-template<typename T, typename PtrTraits>
-class RefPtr;
-template<typename T>
-class NonnullRefPtr;
 template<typename T>
 class WeakPtr;
 
@@ -64,14 +60,14 @@ public:
     template<typename U>
     NonnullOwnPtr& operator=(NonnullOwnPtr<U> const&) = delete;
 
-    template<typename U, typename PtrTraits = RefPtrTraits<U>>
-    NonnullOwnPtr(RefPtr<U, PtrTraits> const&) = delete;
+    template<typename U>
+    NonnullOwnPtr(RefPtr<U> const&) = delete;
     template<typename U>
     NonnullOwnPtr(NonnullRefPtr<U> const&) = delete;
     template<typename U>
     NonnullOwnPtr(WeakPtr<U> const&) = delete;
-    template<typename U, typename PtrTraits = RefPtrTraits<U>>
-    NonnullOwnPtr& operator=(RefPtr<U, PtrTraits> const&) = delete;
+    template<typename U>
+    NonnullOwnPtr& operator=(RefPtr<U> const&) = delete;
     template<typename U>
     NonnullOwnPtr& operator=(NonnullRefPtr<U> const&) = delete;
     template<typename U>
diff --git a/AK/NonnullRefPtr.h b/AK/NonnullRefPtr.h
index 2aab1d65ead..021b72eb0a4 100644
--- a/AK/NonnullRefPtr.h
+++ b/AK/NonnullRefPtr.h
@@ -21,7 +21,7 @@ namespace AK {
 
 template<typename T>
 class OwnPtr;
-template<typename T, typename PtrTraits>
+template<typename T>
 class RefPtr;
 
 template<typename T>
@@ -40,7 +40,7 @@ ALWAYS_INLINE void unref_if_not_null(T* ptr)
 
 template<typename T>
 class [[nodiscard]] NonnullRefPtr {
-    template<typename U, typename P>
+    template<typename U>
     friend class RefPtr;
     template<typename U>
     friend class NonnullRefPtr;
diff --git a/AK/RefPtr.h b/AK/RefPtr.h
index 53a2fc2a8f7..01892e85271 100644
--- a/AK/RefPtr.h
+++ b/AK/RefPtr.h
@@ -26,9 +26,9 @@ namespace AK {
 template<typename T>
 class OwnPtr;
 
-template<typename T, typename PtrTraits>
+template<typename T>
 class [[nodiscard]] RefPtr {
-    template<typename U, typename P>
+    template<typename U>
     friend class RefPtr;
     template<typename U>
     friend class WeakPtr;
@@ -80,8 +80,8 @@ public:
     {
     }
 
-    template<typename U, typename P = RefPtrTraits<U>>
-    RefPtr(RefPtr<U, P>&& other) requires(IsConvertible<U*, T*>)
+    template<typename U>
+    RefPtr(RefPtr<U>&& other) requires(IsConvertible<U*, T*>)
         : m_ptr(static_cast<T*>(other.leak_ref()))
     {
     }
@@ -92,8 +92,8 @@ public:
         ref_if_not_null(m_ptr);
     }
 
-    template<typename U, typename P = RefPtrTraits<U>>
-    RefPtr(RefPtr<U, P> const& other) requires(IsConvertible<U*, T*>)
+    template<typename U>
+    RefPtr(RefPtr<U> const& other) requires(IsConvertible<U*, T*>)
         : m_ptr(const_cast<T*>(static_cast<T const*>(other.ptr())))
     {
         ref_if_not_null(m_ptr);
@@ -117,8 +117,8 @@ public:
         AK::swap(m_ptr, other.m_ptr);
     }
 
-    template<typename U, typename P = RefPtrTraits<U>>
-    void swap(RefPtr<U, P>& other) requires(IsConvertible<U*, T*>)
+    template<typename U>
+    void swap(RefPtr<U>& other) requires(IsConvertible<U*, T*>)
     {
         AK::swap(m_ptr, other.m_ptr);
     }
@@ -130,8 +130,8 @@ public:
         return *this;
     }
 
-    template<typename U, typename P = RefPtrTraits<U>>
-    ALWAYS_INLINE RefPtr& operator=(RefPtr<U, P>&& other) requires(IsConvertible<U*, T*>)
+    template<typename U>
+    ALWAYS_INLINE RefPtr& operator=(RefPtr<U>&& other) requires(IsConvertible<U*, T*>)
     {
         RefPtr tmp { move(other) };
         swap(tmp);
@@ -204,8 +204,8 @@ public:
         return true;
     }
 
-    template<typename U, typename P = RefPtrTraits<U>>
-    ALWAYS_INLINE bool assign_if_null(RefPtr<U, P>&& other)
+    template<typename U>
+    ALWAYS_INLINE bool assign_if_null(RefPtr<U>&& other)
     {
         if (this == &other)
             return is_null();
@@ -315,14 +315,14 @@ inline NonnullRefPtr<T> static_ptr_cast(NonnullRefPtr<U> const& ptr)
     return NonnullRefPtr<T>(static_cast<const T&>(*ptr));
 }
 
-template<typename T, typename U, typename PtrTraits = RefPtrTraits<T>>
+template<typename T, typename U>
 inline RefPtr<T> static_ptr_cast(RefPtr<U> const& ptr)
 {
-    return RefPtr<T, PtrTraits>(static_cast<const T*>(ptr.ptr()));
+    return RefPtr<T>(static_cast<const T*>(ptr.ptr()));
 }
 
-template<typename T, typename PtrTraitsT, typename U, typename PtrTraitsU>
-inline void swap(RefPtr<T, PtrTraitsT>& a, RefPtr<U, PtrTraitsU>& b) requires(IsConvertible<U*, T*>)
+template<typename T, typename U>
+inline void swap(RefPtr<T>& a, RefPtr<U>& b) requires(IsConvertible<U*, T*>)
 {
     a.swap(b);
 }
diff --git a/AK/Weakable.h b/AK/Weakable.h
index ee784aa0903..af9469ca4ed 100644
--- a/AK/Weakable.h
+++ b/AK/Weakable.h
@@ -30,11 +30,11 @@ class WeakLink : public RefCounted<WeakLink> {
     friend class WeakPtr;
 
 public:
-    template<typename T, typename PtrTraits = RefPtrTraits<T>>
-    RefPtr<T, PtrTraits> strong_ref() const
+    template<typename T>
+    RefPtr<T> strong_ref() const
         requires(IsBaseOf<RefCountedBase, T>)
     {
-        RefPtr<T, PtrTraits> ref;
+        RefPtr<T> ref;
 
         {
             if (!(m_consumers.fetch_add(1u << 1, AK::MemoryOrder::memory_order_acquire) & 1u)) {