From 7ac7a73758f7060bc19b48b973a496bd8486dbae Mon Sep 17 00:00:00 2001
From: Andreas Kling <kling@serenityos.org>
Date: Tue, 21 Feb 2023 09:22:18 +0100
Subject: [PATCH] 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.
---
 AK/NonnullRefPtr.h | 16 ++++++++--------
 AK/RefPtr.h        | 24 ++++++++++++------------
 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>