system/serenity
system/serenity
1
0
Fork 0
mirror of https://github.com/SerenityOS/serenity synced 2024-07-21 18:15:58 +00:00
Code Issues Actions 5 Packages Projects Releases Wiki Activity

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
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-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);

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
*/
@ -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>