system/serenity
system/serenity
1
0
Fork 0
mirror of https://github.com/SerenityOS/serenity synced 2024-07-09 01:47:43 +00:00
Code Issues Projects Releases Wiki Activity

AK: Disallow constness laundering in RefPtr and NonnullRefPtr

Browse Source 
Until now, it was possible to assign a RP<T const> or NNRP<T const>
to RP<T> or NNRP<T>. This meant that the constness of the T was lost.

We had a lot of code that relied on this sloppiness, and by the time
you see this commit, I hopefully found and fixed all of it. :^)
This commit is contained in:
Andreas Kling 2023-02-21 00:25:40 +01:00
parent 33e87d1627
commit 3c7a0ef1ac
2 changed files with 20 additions and 20 deletions
Show Stats 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-2020, Andreas Kling <kling@serenityos.org>
* Copyright (c) 2018-2023, Andreas Kling <kling@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
@ -47,16 +47,16 @@ public:
enum AdoptTag { Adopt };
ALWAYS_INLINE NonnullRefPtr(T const& object)
: m_ptr(const_cast<T*>(&object))
ALWAYS_INLINE NonnullRefPtr(T& object)
: m_ptr(&object)
{
m_ptr->ref();
}
template<typename U>
ALWAYS_INLINE NonnullRefPtr(U const& object)
ALWAYS_INLINE NonnullRefPtr(U& object)
requires(IsConvertible<U*, T*>)
: m_ptr(const_cast<T*>(static_cast<T const*>(&object)))
: m_ptr(static_cast<T*>(&object))
{
m_ptr->ref();
}
@ -79,7 +79,7 @@ public:
}
ALWAYS_INLINE NonnullRefPtr(NonnullRefPtr const& other)
: m_ptr(const_cast<T*>(other.ptr()))
: m_ptr(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(const_cast<T*>(static_cast<T const*>(other.ptr())))
: m_ptr(static_cast<T*>(other.ptr()))
{
m_ptr->ref();
}
@ -145,7 +145,7 @@ public:
return *this;
}
NonnullRefPtr& operator=(T const& object)
NonnullRefPtr& operator=(T& object)
{
NonnullRefPtr tmp { object };
swap(tmp);

24
AK/RefPtr.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
* Copyright (c) 2018-2023, Andreas Kling <kling@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
@ -35,14 +35,14 @@ public:
};
RefPtr() = default;
RefPtr(T const* ptr)
: m_ptr(const_cast<T*>(ptr))
RefPtr(T* ptr)
: m_ptr(ptr)
{
ref_if_not_null(m_ptr);
}
RefPtr(T const& object)
: m_ptr(const_cast<T*>(&object))
RefPtr(T& object)
: m_ptr(&object)
{
m_ptr->ref();
}
@ -58,7 +58,7 @@ public:
}
ALWAYS_INLINE RefPtr(NonnullRefPtr<T> const& other)
: m_ptr(const_cast<T*>(other.ptr()))
: m_ptr(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(const_cast<T*>(static_cast<T const*>(other.ptr())))
: m_ptr(static_cast<T*>(other.ptr()))
{
m_ptr->ref();
}
@ -94,7 +94,7 @@ public:
template<typename U>
RefPtr(RefPtr<U> const& other)
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);
}
@ -181,14 +181,14 @@ public:
return *this;
}
ALWAYS_INLINE RefPtr& operator=(T const* ptr)
ALWAYS_INLINE RefPtr& operator=(T* ptr)
{
RefPtr tmp { ptr };
swap(tmp);
return *this;
}
ALWAYS_INLINE RefPtr& operator=(T const& object)
ALWAYS_INLINE RefPtr& operator=(T& 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 const&>(*ptr));
return NonnullRefPtr<T>(static_cast<T&>(*ptr));
}
template<typename T, typename U>
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, typename U>