RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-27 05:37:34 +00:00
Code Issues Activity Actions

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

Browse source 
This reverts commit 3c7a0ef1ac.

This broke Jakt, which will need some adjustments to its code generation
before we can commit to being this strict.
This commit is contained in:
Andreas Kling 2023-02-21 09:22:18 +01:00
parent f6eb155167
commit 7ac7a73758
2 changed files with 20 additions and 20 deletions
Download patch file Download diff file Expand all files Collapse all files

16
AK/NonnullRefPtr.h
View file

@ -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 * SPDX-License-Identifier: BSD-2-Clause
*/ */
@ -47,16 +47,16 @@ public:
enum AdoptTag { Adopt }; enum AdoptTag { Adopt };
ALWAYS_INLINE NonnullRefPtr(T& object) ALWAYS_INLINE NonnullRefPtr(T const& object)
: m_ptr(&object) : m_ptr(const_cast<T*>(&object))
{ {
m_ptr->ref(); m_ptr->ref();
} }
template<typename U> template<typename U>
ALWAYS_INLINE NonnullRefPtr(U& object) ALWAYS_INLINE NonnullRefPtr(U const& object)
requires(IsConvertible<U*, T*>) requires(IsConvertible<U*, T*>)
: m_ptr(static_cast<T*>(&object)) : m_ptr(const_cast<T*>(static_cast<T const*>(&object)))
{ {
m_ptr->ref(); m_ptr->ref();
} }
@ -79,7 +79,7 @@ public:
} }
ALWAYS_INLINE NonnullRefPtr(NonnullRefPtr const& other) ALWAYS_INLINE NonnullRefPtr(NonnullRefPtr const& other)
: m_ptr(other.ptr()) : m_ptr(const_cast<T*>(other.ptr()))
{ {
m_ptr->ref(); m_ptr->ref();
} }
@ -87,7 +87,7 @@ public:
template<typename U> template<typename U>
ALWAYS_INLINE NonnullRefPtr(NonnullRefPtr<U> const& other) ALWAYS_INLINE NonnullRefPtr(NonnullRefPtr<U> const& other)
requires(IsConvertible<U*, T*>) 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(); m_ptr->ref();
} }
@ -145,7 +145,7 @@ public:
return *this; return *this;
} }
NonnullRefPtr& operator=(T& object) NonnullRefPtr& operator=(T const& object)
{ {
NonnullRefPtr tmp { object }; NonnullRefPtr tmp { object };
swap(tmp); swap(tmp);

24
AK/RefPtr.h
View file

@ -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 * SPDX-License-Identifier: BSD-2-Clause
*/ */
@ -35,14 +35,14 @@ public:
}; };
RefPtr() = default; RefPtr() = default;
RefPtr(T* ptr) RefPtr(T const* ptr)
: m_ptr(ptr) : m_ptr(const_cast<T*>(ptr))
{ {
ref_if_not_null(m_ptr); ref_if_not_null(m_ptr);
} }
RefPtr(T& object) RefPtr(T const& object)
: m_ptr(&object) : m_ptr(const_cast<T*>(&object))
{ {
m_ptr->ref(); m_ptr->ref();
} }
@ -58,7 +58,7 @@ public:
} }
ALWAYS_INLINE RefPtr(NonnullRefPtr<T> const& other) ALWAYS_INLINE RefPtr(NonnullRefPtr<T> const& other)
: m_ptr(other.ptr()) : m_ptr(const_cast<T*>(other.ptr()))
{ {
m_ptr->ref(); m_ptr->ref();
} }
@ -66,7 +66,7 @@ public:
template<typename U> template<typename U>
ALWAYS_INLINE RefPtr(NonnullRefPtr<U> const& other) ALWAYS_INLINE RefPtr(NonnullRefPtr<U> const& other)
requires(IsConvertible<U*, T*>) 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(); m_ptr->ref();
} }
@ -94,7 +94,7 @@ public:
template<typename U> template<typename U>
RefPtr(RefPtr<U> const& other) RefPtr(RefPtr<U> const& other)
requires(IsConvertible<U*, T*>) 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); ref_if_not_null(m_ptr);
} }
@ -181,14 +181,14 @@ public:
return *this; return *this;
} }
ALWAYS_INLINE RefPtr& operator=(T* ptr) ALWAYS_INLINE RefPtr& operator=(T const* ptr)
{ {
RefPtr tmp { ptr }; RefPtr tmp { ptr };
swap(tmp); swap(tmp);
return *this; return *this;
} }
ALWAYS_INLINE RefPtr& operator=(T& object) ALWAYS_INLINE RefPtr& operator=(T const& object)
{ {
RefPtr tmp { object }; RefPtr tmp { object };
swap(tmp); swap(tmp);
@ -304,13 +304,13 @@ struct Traits<RefPtr<T>> : public GenericTraits<RefPtr<T>> {
template<typename T, typename U> template<typename T, typename U>
inline NonnullRefPtr<T> static_ptr_cast(NonnullRefPtr<U> const& ptr) 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> template<typename T, typename U>
inline RefPtr<T> static_ptr_cast(RefPtr<U> const& ptr) 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> template<typename T, typename U>