Ladybird/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-06-08 05:27:14 +09:00
Code Activity

AK: Disallow constness laundering in RefPtr and NonnullRefPtr

Browse source 
This is a re-application of 3c7a0ef1ac

Co-Authored-By: Andreas Kling <andreas@ladybird.org>
This commit is contained in:
Andrew Kaster 2025-04-15 16:05:25 -06:00 • committed by Andrew Kaster
parent 5e1b3cdeb9
commit ad00306daf
Notes: github-actions[bot] 2025-04-16 16:42:48 +00:00
2 changed files with 18 additions and 18 deletions
Download patch file Download diff file Expand all files Collapse all files

14
AK/NonnullRefPtr.h
View file

@ -46,16 +46,16 @@ public:
enum AdoptTag { Adopt }; enum AdoptTag { Adopt };
ALWAYS_INLINE NonnullRefPtr(T const& object) ALWAYS_INLINE NonnullRefPtr(T& object)
: m_ptr(const_cast<T*>(&object)) : m_ptr(&object)
{ {
m_ptr->ref(); m_ptr->ref();
} }
template<typename U> template<typename U>
requires(IsConvertible<U*, T*>) requires(IsConvertible<U*, T*>)
ALWAYS_INLINE NonnullRefPtr(U const& object) ALWAYS_INLINE NonnullRefPtr(U& object)
: m_ptr(const_cast<T*>(static_cast<T const*>(&object))) : m_ptr(static_cast<T*>(&object))
{ {
m_ptr->ref(); m_ptr->ref();
} }
@ -78,7 +78,7 @@ public:
} }
ALWAYS_INLINE NonnullRefPtr(NonnullRefPtr const& other) ALWAYS_INLINE NonnullRefPtr(NonnullRefPtr const& other)
: m_ptr(const_cast<T*>(other.ptr())) : m_ptr(other.ptr())
{ {
m_ptr->ref(); m_ptr->ref();
} }
@ -86,7 +86,7 @@ public:
template<typename U> template<typename U>
requires(IsConvertible<U*, T*>) requires(IsConvertible<U*, T*>)
ALWAYS_INLINE NonnullRefPtr(NonnullRefPtr<U> const& other) ALWAYS_INLINE NonnullRefPtr(NonnullRefPtr<U> const& other)
: m_ptr(const_cast<T*>(static_cast<T const*>(other.ptr()))) : m_ptr(static_cast<T*>(other.ptr()))
{ {
m_ptr->ref(); m_ptr->ref();
} }
@ -144,7 +144,7 @@ public:
return *this; return *this;
} }
NonnullRefPtr& operator=(T const& object) NonnullRefPtr& operator=(T& object)
{ {
NonnullRefPtr tmp { object }; NonnullRefPtr tmp { object };
swap(tmp); swap(tmp);

22
AK/RefPtr.h
View file

@ -34,14 +34,14 @@ public:
}; };
RefPtr() = default; RefPtr() = default;
RefPtr(T const* ptr) RefPtr(T* ptr)
: m_ptr(const_cast<T*>(ptr)) : m_ptr(ptr)
{ {
ref_if_not_null(m_ptr); ref_if_not_null(m_ptr);
} }
RefPtr(T const& object) RefPtr(T& object)
: m_ptr(const_cast<T*>(&object)) : m_ptr(&object)
{ {
m_ptr->ref(); m_ptr->ref();
} }
@ -57,7 +57,7 @@ public:
} }
ALWAYS_INLINE RefPtr(NonnullRefPtr<T> const& other) ALWAYS_INLINE RefPtr(NonnullRefPtr<T> const& other)
: m_ptr(const_cast<T*>(other.ptr())) : m_ptr(other.ptr())
{ {
m_ptr->ref(); m_ptr->ref();
} }
@ -65,7 +65,7 @@ public:
template<typename U> template<typename U>
requires(IsConvertible<U*, T*>) requires(IsConvertible<U*, T*>)
ALWAYS_INLINE RefPtr(NonnullRefPtr<U> const& other) ALWAYS_INLINE RefPtr(NonnullRefPtr<U> const& other)
: m_ptr(const_cast<T*>(static_cast<T const*>(other.ptr()))) : m_ptr(static_cast<T*>(other.ptr()))
{ {
m_ptr->ref(); m_ptr->ref();
} }
@ -93,7 +93,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(const_cast<T*>(static_cast<T const*>(other.ptr()))) : m_ptr(static_cast<T*>(other.ptr()))
{ {
ref_if_not_null(m_ptr); ref_if_not_null(m_ptr);
} }
@ -180,14 +180,14 @@ public:
return *this; return *this;
} }
ALWAYS_INLINE RefPtr& operator=(T const* ptr) ALWAYS_INLINE RefPtr& operator=(T* ptr)
{ {
RefPtr tmp { ptr }; RefPtr tmp { ptr };
swap(tmp); swap(tmp);
return *this; return *this;
} }
ALWAYS_INLINE RefPtr& operator=(T const& object) ALWAYS_INLINE RefPtr& operator=(T& object)
{ {
RefPtr tmp { object }; RefPtr tmp { object };
swap(tmp); swap(tmp);
@ -303,13 +303,13 @@ struct Traits<RefPtr<T>> : public DefaultTraits<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 const&>(*ptr)); return NonnullRefPtr<T>(static_cast<T&>(*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 const*>(ptr.ptr())); return RefPtr<T>(static_cast<T*>(ptr.ptr()));
} }
template<typename T> template<typename T>