Revert "AK: Disallow constness laundering in RefPtr and NonnullRefPtr"

This reverts commit 3c7a0ef1ac279c99bc4ee72085278ea70c210889.

This broke Jakt, which will need some adjustments to its code generation
before we can commit to being this strict.

2 files changed, 20 insertions, 20 deletions

diff --git a/AK/NonnullRefPtr.h b/AK/NonnullRefPtr.h
index e6a7a499b1..107aedc4a9 100644
--- a/AK/NonnullRefPtr.h
+++ b/AK/NonnullRefPtr.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018-2023, Andreas Kling <kling@serenityos.org>
+ * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */
@@ -47,16 +47,16 @@ public:
 
     enum AdoptTag { Adopt };
 
-    ALWAYS_INLINE NonnullRefPtr(T& object)
-        : m_ptr(&object)
+    ALWAYS_INLINE NonnullRefPtr(T const& object)
+        : m_ptr(const_cast<T*>(&object))
     {
         m_ptr->ref();
     }
 
     template<typename U>
-    ALWAYS_INLINE NonnullRefPtr(U& object)
+    ALWAYS_INLINE NonnullRefPtr(U const& object)
     requires(IsConvertible<U*, T*>)
-        : m_ptr(static_cast<T*>(&object))
+        : m_ptr(const_cast<T*>(static_cast<T const*>(&object)))
     {
         m_ptr->ref();
     }
@@ -79,7 +79,7 @@ public:
     }
 
     ALWAYS_INLINE NonnullRefPtr(NonnullRefPtr const& other)
-        : m_ptr(other.ptr())
+        : m_ptr(const_cast<T*>(other.ptr()))
     {
         m_ptr->ref();
     }
@@ -87,7 +87,7 @@ public:
     template<typename U>
     ALWAYS_INLINE NonnullRefPtr(NonnullRefPtr<U> const& other)
     requires(IsConvertible<U*, T*>)
-        : m_ptr(static_cast<T*>(other.ptr()))
+        : m_ptr(const_cast<T*>(static_cast<T const*>(other.ptr())))
     {
         m_ptr->ref();
     }
@@ -145,7 +145,7 @@ public:
         return *this;
     }
 
-    NonnullRefPtr& operator=(T& object)
+    NonnullRefPtr& operator=(T const& object)
     {
         NonnullRefPtr tmp { object };
         swap(tmp);
diff --git a/AK/RefPtr.h b/AK/RefPtr.h
index 661a345131..1c28a07d9a 100644
--- a/AK/RefPtr.h
+++ b/AK/RefPtr.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018-2023, Andreas Kling <kling@serenityos.org>
+ * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */
@@ -35,14 +35,14 @@ public:
     };
 
     RefPtr() = default;
-    RefPtr(T* ptr)
-        : m_ptr(ptr)
+    RefPtr(T const* ptr)
+        : m_ptr(const_cast<T*>(ptr))
     {
         ref_if_not_null(m_ptr);
     }
 
-    RefPtr(T& object)
-        : m_ptr(&object)
+    RefPtr(T const& object)
+        : m_ptr(const_cast<T*>(&object))
     {
         m_ptr->ref();
     }
@@ -58,7 +58,7 @@ public:
     }
 
     ALWAYS_INLINE RefPtr(NonnullRefPtr<T> const& other)
-        : m_ptr(other.ptr())
+        : m_ptr(const_cast<T*>(other.ptr()))
     {
         m_ptr->ref();
     }
@@ -66,7 +66,7 @@ public:
     template<typename U>
     ALWAYS_INLINE RefPtr(NonnullRefPtr<U> const& other)
     requires(IsConvertible<U*, T*>)
-        : m_ptr(static_cast<T*>(other.ptr()))
+        : m_ptr(const_cast<T*>(static_cast<T const*>(other.ptr())))
     {
         m_ptr->ref();
     }
@@ -94,7 +94,7 @@ public:
     template<typename U>
     RefPtr(RefPtr<U> const& other)
     requires(IsConvertible<U*, T*>)
-        : m_ptr(static_cast<T*>(other.ptr()))
+        : m_ptr(const_cast<T*>(static_cast<T const*>(other.ptr())))
     {
         ref_if_not_null(m_ptr);
     }
@@ -181,14 +181,14 @@ public:
         return *this;
     }
 
-    ALWAYS_INLINE RefPtr& operator=(T* ptr)
+    ALWAYS_INLINE RefPtr& operator=(T const* ptr)
     {
         RefPtr tmp { ptr };
         swap(tmp);
         return *this;
     }
 
-    ALWAYS_INLINE RefPtr& operator=(T& object)
+    ALWAYS_INLINE RefPtr& operator=(T const& object)
     {
         RefPtr tmp { object };
         swap(tmp);
@@ -304,13 +304,13 @@ struct Traits<RefPtr<T>> : public GenericTraits<RefPtr<T>> {
 template<typename T, typename U>
 inline NonnullRefPtr<T> static_ptr_cast(NonnullRefPtr<U> const& ptr)
 {
-    return NonnullRefPtr<T>(static_cast<T&>(*ptr));
+    return NonnullRefPtr<T>(static_cast<T const&>(*ptr));
 }
 
 template<typename T, typename U>
 inline RefPtr<T> static_ptr_cast(RefPtr<U> const& ptr)
 {
-    return RefPtr<T>(static_cast<T*>(ptr.ptr()));
+    return RefPtr<T>(static_cast<T const*>(ptr.ptr()));
 }
 
 template<typename T, typename U>