Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-08 02:14:43 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1608064 - Replace Is{Rvalue,Lvalue,}Reference with <type_traits> equivalents. r=froydnj

Browse Source 
Differential Revision: https://phabricator.services.mozilla.com/D59309

--HG--
extra : moz-landing-system : lando
This commit is contained in:
Emilio Cobos Álvarez 2020-01-10 10:40:34 +00:00
parent 4b5bcc9de3
commit cde7beaaa4
5 changed files with 15 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
mfbt/TypeTraits.h
View File

@ -235,40 +235,6 @@ struct IsPointerHelper<T*> : TrueType {};
template <typename T>
struct IsPointer : detail::IsPointerHelper<typename RemoveCV<T>::Type> {};
/**
* IsLvalueReference determines whether a type is an lvalue reference.
*
* mozilla::IsLvalueReference<struct S*>::value is false;
* mozilla::IsLvalueReference<int**>::value is false;
* mozilla::IsLvalueReference<void (*)(void)>::value is false;
* mozilla::IsLvalueReference<int>::value is false;
* mozilla::IsLvalueReference<struct S>::value is false;
* mozilla::IsLvalueReference<struct S*&>::value is true;
* mozilla::IsLvalueReference<struct S&&>::value is false.
*/
template <typename T>
struct IsLvalueReference : FalseType {};
template <typename T>
struct IsLvalueReference<T&> : TrueType {};
/**
* IsRvalueReference determines whether a type is an rvalue reference.
*
* mozilla::IsRvalueReference<struct S*>::value is false;
* mozilla::IsRvalueReference<int**>::value is false;
* mozilla::IsRvalueReference<void (*)(void)>::value is false;
* mozilla::IsRvalueReference<int>::value is false;
* mozilla::IsRvalueReference<struct S>::value is false;
* mozilla::IsRvalueReference<struct S*&>::value is false;
* mozilla::IsRvalueReference<struct S&&>::value is true.
*/
template <typename T>
struct IsRvalueReference : FalseType {};
template <typename T>
struct IsRvalueReference<T&&> : TrueType {};
namespace detail {
// __is_enum is a supported extension across all of our supported compilers.
@ -312,24 +278,6 @@ struct IsClass : detail::IsClassHelper<typename RemoveCV<T>::Type> {};
/* 20.9.4.2 Composite type traits [meta.unary.comp] */
/**
* IsReference determines whether a type is an lvalue or rvalue reference.
*
* mozilla::IsReference<struct S*>::value is false;
* mozilla::IsReference<int**>::value is false;
* mozilla::IsReference<int&>::value is true;
* mozilla::IsReference<void (*)(void)>::value is false;
* mozilla::IsReference<const int&>::value is true;
* mozilla::IsReference<int>::value is false;
* mozilla::IsReference<struct S>::value is false;
* mozilla::IsReference<struct S&>::value is true;
* mozilla::IsReference<struct S*&>::value is true;
* mozilla::IsReference<struct S&&>::value is true.
*/
template <typename T>
struct IsReference : IntegralConstant<bool, IsLvalueReference<T>::value ||
IsRvalueReference<T>::value> {};
/**
* IsArithmetic determines whether a type is arithmetic. A type is arithmetic
* iff it is an integral type or a floating point type.

24
mfbt/UniquePtr.h
View File

@ -207,7 +207,7 @@ class UniquePtr {
*/
constexpr UniquePtr() : mTuple(static_cast<Pointer>(nullptr), DeleterType()) {
static_assert(!IsPointer<D>::value, "must provide a deleter instance");
static_assert(!IsReference<D>::value, "must provide a deleter instance");
static_assert(!std::is_reference_v<D>, "must provide a deleter instance");
}
/**
@ -215,11 +215,11 @@ class UniquePtr {
*/
explicit UniquePtr(Pointer aPtr) : mTuple(aPtr, DeleterType()) {
static_assert(!IsPointer<D>::value, "must provide a deleter instance");
static_assert(!IsReference<D>::value, "must provide a deleter instance");
static_assert(!std::is_reference_v<D>, "must provide a deleter instance");
}
UniquePtr(Pointer aPtr,
typename Conditional<IsReference<D>::value, D, const D&>::Type aD1)
typename Conditional<std::is_reference_v<D>, D, const D&>::Type aD1)
: mTuple(aPtr, aD1) {}
// If you encounter an error with MSVC10 about RemoveReference below, along
@ -246,7 +246,7 @@ class UniquePtr {
// behavior really isn't something you should use.
UniquePtr(Pointer aPtr, typename RemoveReference<D>::Type&& aD2)
: mTuple(aPtr, std::move(aD2)) {
static_assert(!IsReference<D>::value,
static_assert(!std::is_reference_v<D>,
"rvalue deleter can't be stored by reference");
}
@ -257,7 +257,7 @@ class UniquePtr {
MOZ_IMPLICIT
UniquePtr(decltype(nullptr)) : mTuple(nullptr, DeleterType()) {
static_assert(!IsPointer<D>::value, "must provide a deleter instance");
static_assert(!IsReference<D>::value, "must provide a deleter instance");
static_assert(!std::is_reference_v<D>, "must provide a deleter instance");
}
template <typename U, class E>
@ -266,8 +266,8 @@ class UniquePtr {
typename EnableIf<
IsConvertible<typename UniquePtr<U, E>::Pointer, Pointer>::value &&
!IsArray<U>::value &&
(IsReference<D>::value ? IsSame<D, E>::value
: IsConvertible<E, D>::value),
(std::is_reference_v<D> ? IsSame<D, E>::value
: IsConvertible<E, D>::value),
int>::Type aDummy = 0)
: mTuple(aOther.release(), std::forward<E>(aOther.get_deleter())) {}
@ -351,7 +351,7 @@ class UniquePtr<T[], D> {
*/
constexpr UniquePtr() : mTuple(static_cast<Pointer>(nullptr), DeleterType()) {
static_assert(!IsPointer<D>::value, "must provide a deleter instance");
static_assert(!IsReference<D>::value, "must provide a deleter instance");
static_assert(!std::is_reference_v<D>, "must provide a deleter instance");
}
/**
@ -359,7 +359,7 @@ class UniquePtr<T[], D> {
*/
explicit UniquePtr(Pointer aPtr) : mTuple(aPtr, DeleterType()) {
static_assert(!IsPointer<D>::value, "must provide a deleter instance");
static_assert(!IsReference<D>::value, "must provide a deleter instance");
static_assert(!std::is_reference_v<D>, "must provide a deleter instance");
}
// delete[] knows how to handle *only* an array of a single class type. For
@ -374,7 +374,7 @@ class UniquePtr<T[], D> {
int>::Type aDummy = 0) = delete;
UniquePtr(Pointer aPtr,
typename Conditional<IsReference<D>::value, D, const D&>::Type aD1)
typename Conditional<std::is_reference_v<D>, D, const D&>::Type aD1)
: mTuple(aPtr, aD1) {}
// If you encounter an error with MSVC10 about RemoveReference below, along
@ -383,7 +383,7 @@ class UniquePtr<T[], D> {
// comment by this constructor in the non-T[] specialization above.
UniquePtr(Pointer aPtr, typename RemoveReference<D>::Type&& aD2)
: mTuple(aPtr, std::move(aD2)) {
static_assert(!IsReference<D>::value,
static_assert(!std::is_reference_v<D>,
"rvalue deleter can't be stored by reference");
}
@ -401,7 +401,7 @@ class UniquePtr<T[], D> {
MOZ_IMPLICIT
UniquePtr(decltype(nullptr)) : mTuple(nullptr, DeleterType()) {
static_assert(!IsPointer<D>::value, "must provide a deleter instance");
static_assert(!IsReference<D>::value, "must provide a deleter instance");
static_assert(!std::is_reference_v<D>, "must provide a deleter instance");
}
~UniquePtr() { reset(nullptr); }

50
mfbt/tests/TestTypeTraits.cpp
View File

@ -23,10 +23,7 @@ using mozilla::IsDefaultConstructible;
using mozilla::IsDestructible;
using mozilla::IsEmpty;
using mozilla::IsFunction;
using mozilla::IsLvalueReference;
using mozilla::IsPointer;
using mozilla::IsReference;
using mozilla::IsRvalueReference;
using mozilla::IsSame;
using mozilla::IsSigned;
using mozilla::IsUnsigned;
@ -63,53 +60,6 @@ static_assert(!IsPointer<bool (IsPointerTest::*)()>::value,
static_assert(!IsPointer<void (IsPointerTest::*)(void)>::value,
"void(IsPointerTest::*)(void) not a pointer");
static_assert(!IsLvalueReference<bool>::value, "bool not an lvalue reference");
static_assert(!IsLvalueReference<bool*>::value,
"bool* not an lvalue reference");
static_assert(IsLvalueReference<bool&>::value, "bool& is an lvalue reference");
static_assert(!IsLvalueReference<bool&&>::value,
"bool&& not an lvalue reference");
static_assert(!IsLvalueReference<void>::value, "void not an lvalue reference");
static_assert(!IsLvalueReference<void*>::value,
"void* not an lvalue reference");
static_assert(!IsLvalueReference<int>::value, "int not an lvalue reference");
static_assert(!IsLvalueReference<int*>::value, "int* not an lvalue reference");
static_assert(IsLvalueReference<int&>::value, "int& is an lvalue reference");
static_assert(!IsLvalueReference<int&&>::value,
"int&& not an lvalue reference");
static_assert(!IsRvalueReference<bool>::value, "bool not an rvalue reference");
static_assert(!IsRvalueReference<bool*>::value,
"bool* not an rvalue reference");
static_assert(!IsRvalueReference<bool&>::value,
"bool& not an rvalue reference");
static_assert(IsRvalueReference<bool&&>::value,
"bool&& is an rvalue reference");
static_assert(!IsRvalueReference<void>::value, "void not an rvalue reference");
static_assert(!IsRvalueReference<void*>::value,
"void* not an rvalue reference");
static_assert(!IsRvalueReference<int>::value, "int not an rvalue reference");
static_assert(!IsRvalueReference<int*>::value, "int* not an rvalue reference");
static_assert(!IsRvalueReference<int&>::value, "int& not an rvalue reference");
static_assert(IsRvalueReference<int&&>::value, "int&& is an rvalue reference");
static_assert(!IsReference<bool>::value, "bool not a reference");
static_assert(!IsReference<bool*>::value, "bool* not a reference");
static_assert(IsReference<bool&>::value, "bool& is a reference");
static_assert(IsReference<bool&&>::value, "bool&& is a reference");
static_assert(!IsReference<void>::value, "void not a reference");
static_assert(!IsReference<void*>::value, "void* not a reference");
static_assert(!IsReference<int>::value, "int not a reference");
static_assert(!IsReference<int*>::value, "int* not a reference");
static_assert(IsReference<int&>::value, "int& is a reference");
static_assert(IsReference<int&&>::value, "int&& is a reference");
namespace CPlusPlus11IsMemberPointer {
using mozilla::IsMemberPointer;

2
xpcom/threads/MozPromise.h
View File

@ -1501,7 +1501,7 @@ static auto InvokeAsync(nsISerialEventTarget* aTarget, const char* aCallerName,
template <typename Function>
static auto InvokeAsync(nsISerialEventTarget* aTarget, const char* aCallerName,
Function&& aFunction) -> decltype(aFunction()) {
static_assert(!IsLvalueReference<Function>::value,
static_assert(!std::is_lvalue_reference_v<Function>,
"Function object must not be passed by lvalue-ref (to avoid "
"unplanned copies); Consider move()ing the object.");
return detail::InvokeAsync(aTarget, aCallerName,

4
xpcom/threads/nsThreadUtils.h
View File

@ -1083,14 +1083,14 @@ struct SmartPointerStorageClass
template <typename T>
struct NonLValueReferenceStorageClass
: mozilla::Conditional<
mozilla::IsRvalueReference<T>::value,
std::is_rvalue_reference_v<T>,
StoreCopyPassByRRef<typename mozilla::RemoveReference<T>::Type>,
typename SmartPointerStorageClass<T>::Type> {};
template <typename T>
struct NonPointerStorageClass
: mozilla::Conditional<
mozilla::IsLvalueReference<T>::value,
std::is_lvalue_reference_v<T>,
typename LValueReferenceStorageClass<
typename mozilla::RemoveReference<T>::Type>::Type,
typename NonLValueReferenceStorageClass<T>::Type> {};