mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-08 02:14:43 +00:00
Bug 1608064
- Replace Is{Rvalue,Lvalue,}Reference with <type_traits> equivalents. r=froydnj
Differential Revision: https://phabricator.services.mozilla.com/D59309 --HG-- extra : moz-landing-system : lando
This commit is contained in:
parent
4b5bcc9de3
commit
cde7beaaa4
@ -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.
|
||||
|
@ -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,7 +266,7 @@ class UniquePtr {
|
||||
typename EnableIf<
|
||||
IsConvertible<typename UniquePtr<U, E>::Pointer, Pointer>::value &&
|
||||
!IsArray<U>::value &&
|
||||
(IsReference<D>::value ? IsSame<D, E>::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); }
|
||||
|
@ -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;
|
||||
|
@ -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,
|
||||
|
@ -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> {};
|
||||
|
Loading…
Reference in New Issue
Block a user