[llvm] 675a557 - Remove redundant LLVM_HAS_RVALUE_REFERENCE_THIS and LLVM_LVALUE_FUNCTION defines
Simon Pilgrim via llvm-commits
llvm-commits at lists.llvm.org
Wed Feb 2 08:56:36 PST 2022
Author: Simon Pilgrim
Date: 2022-02-02T16:56:26Z
New Revision: 675a557316ef80f57b96c13a77201d63681d81d2
URL: https://github.com/llvm/llvm-project/commit/675a557316ef80f57b96c13a77201d63681d81d2
DIFF: https://github.com/llvm/llvm-project/commit/675a557316ef80f57b96c13a77201d63681d81d2.diff
LOG: Remove redundant LLVM_HAS_RVALUE_REFERENCE_THIS and LLVM_LVALUE_FUNCTION defines
Now that VS2017 support has been dropped (D114639), the LLVM_HAS_RVALUE_REFERENCE_THIS define is always true and the LLVM_LVALUE_FUNCTION define is always enabled for ref-qualifiers.
This patch proposes we remove the defines and use the qualifiers directly.
Differential Revision: https://reviews.llvm.org/D118609
Added:
Modified:
clang/include/clang/ASTMatchers/ASTMatchersInternal.h
clang/include/clang/Basic/DirectoryEntry.h
clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h
llvm/include/llvm/ADT/Optional.h
llvm/include/llvm/ADT/PointerIntPair.h
llvm/include/llvm/Support/Compiler.h
llvm/unittests/ADT/OptionalTest.cpp
Removed:
################################################################################
diff --git a/clang/include/clang/ASTMatchers/ASTMatchersInternal.h b/clang/include/clang/ASTMatchers/ASTMatchersInternal.h
index ab7a445dbcd49..5648c716c539e 100644
--- a/clang/include/clang/ASTMatchers/ASTMatchersInternal.h
+++ b/clang/include/clang/ASTMatchers/ASTMatchersInternal.h
@@ -600,17 +600,15 @@ class Matcher {
/// Convert \c this into a \c Matcher<T> by applying dyn_cast<> to the
/// argument.
/// \c To must be a base class of \c T.
- template <typename To> Matcher<To> dynCastTo() const LLVM_LVALUE_FUNCTION {
+ template <typename To> Matcher<To> dynCastTo() const & {
static_assert(std::is_base_of<To, T>::value, "Invalid dynCast call.");
return Matcher<To>(Implementation);
}
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
template <typename To> Matcher<To> dynCastTo() && {
static_assert(std::is_base_of<To, T>::value, "Invalid dynCast call.");
return Matcher<To>(std::move(Implementation));
}
-#endif
/// Forwards the call to the underlying MatcherInterface<T> pointer.
bool matches(const T &Node,
@@ -628,13 +626,9 @@ class Matcher {
///
/// The returned matcher keeps the same restrictions as \c this and remembers
/// that it is meant to support nodes of type \c T.
- operator DynTypedMatcher() const LLVM_LVALUE_FUNCTION {
- return Implementation;
- }
+ operator DynTypedMatcher() const & { return Implementation; }
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
operator DynTypedMatcher() && { return std::move(Implementation); }
-#endif
/// Allows the conversion of a \c Matcher<Type> to a \c
/// Matcher<QualType>.
@@ -1361,35 +1355,31 @@ template <typename... Ps> class VariadicOperatorMatcher {
VariadicOperatorMatcher(DynTypedMatcher::VariadicOperator Op, Ps &&... Params)
: Op(Op), Params(std::forward<Ps>(Params)...) {}
- template <typename T> operator Matcher<T>() const LLVM_LVALUE_FUNCTION {
+ template <typename T> operator Matcher<T>() const & {
return DynTypedMatcher::constructVariadic(
Op, ASTNodeKind::getFromNodeKind<T>(),
getMatchers<T>(std::index_sequence_for<Ps...>()))
.template unconditionalConvertTo<T>();
}
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
template <typename T> operator Matcher<T>() && {
return DynTypedMatcher::constructVariadic(
Op, ASTNodeKind::getFromNodeKind<T>(),
getMatchers<T>(std::index_sequence_for<Ps...>()))
.template unconditionalConvertTo<T>();
}
-#endif
+
private:
// Helper method to unpack the tuple into a vector.
template <typename T, std::size_t... Is>
- std::vector<DynTypedMatcher>
- getMatchers(std::index_sequence<Is...>) const LLVM_LVALUE_FUNCTION {
+ std::vector<DynTypedMatcher> getMatchers(std::index_sequence<Is...>) const & {
return {Matcher<T>(std::get<Is>(Params))...};
}
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
template <typename T, std::size_t... Is>
std::vector<DynTypedMatcher> getMatchers(std::index_sequence<Is...>) && {
return {Matcher<T>(std::get<Is>(std::move(Params)))...};
}
-#endif
const DynTypedMatcher::VariadicOperator Op;
std::tuple<Ps...> Params;
@@ -1479,15 +1469,13 @@ class ArgumentAdaptingMatcherFuncAdaptor {
using ReturnTypes = ToTypes;
- template <typename To> operator Matcher<To>() const LLVM_LVALUE_FUNCTION {
+ template <typename To> operator Matcher<To>() const & {
return Matcher<To>(new ArgumentAdapterT<To, T>(InnerMatcher));
}
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
template <typename To> operator Matcher<To>() && {
return Matcher<To>(new ArgumentAdapterT<To, T>(std::move(InnerMatcher)));
}
-#endif
private:
Matcher<T> InnerMatcher;
@@ -1558,21 +1546,19 @@ template <typename MatcherType> class TraversalWrapper {
TraversalWrapper(TraversalKind TK, const MatcherType &InnerMatcher)
: TK(TK), InnerMatcher(InnerMatcher) {}
- template <typename T> operator Matcher<T>() const LLVM_LVALUE_FUNCTION {
+ template <typename T> operator Matcher<T>() const & {
return internal::DynTypedMatcher::constructRestrictedWrapper(
new internal::TraversalMatcher<T>(TK, InnerMatcher),
ASTNodeKind::getFromNodeKind<T>())
.template unconditionalConvertTo<T>();
}
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
template <typename T> operator Matcher<T>() && {
return internal::DynTypedMatcher::constructRestrictedWrapper(
new internal::TraversalMatcher<T>(TK, std::move(InnerMatcher)),
ASTNodeKind::getFromNodeKind<T>())
.template unconditionalConvertTo<T>();
}
-#endif
private:
TraversalKind TK;
@@ -1599,20 +1585,18 @@ class PolymorphicMatcher {
using ReturnTypes = typename ExtractFunctionArgMeta<ReturnTypesF>::type;
- template <typename T> operator Matcher<T>() const LLVM_LVALUE_FUNCTION {
+ template <typename T> operator Matcher<T>() const & {
static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value,
"right polymorphic conversion");
return Matcher<T>(new_from_tuple<MatcherT<T, ParamTypes...>>(Params));
}
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
template <typename T> operator Matcher<T>() && {
static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value,
"right polymorphic conversion");
return Matcher<T>(
new_from_tuple<MatcherT<T, ParamTypes...>>(std::move(Params)));
}
-#endif
private:
std::tuple<ParamTypes...> Params;
diff --git a/clang/include/clang/Basic/DirectoryEntry.h b/clang/include/clang/Basic/DirectoryEntry.h
index ac8e790230fcc..21565621b80fc 100644
--- a/clang/include/clang/Basic/DirectoryEntry.h
+++ b/clang/include/clang/Basic/DirectoryEntry.h
@@ -128,20 +128,18 @@ template <class RefTy> class MapEntryOptionalStorage {
bool hasValue() const { return MaybeRef.hasOptionalValue(); }
- RefTy &getValue() LLVM_LVALUE_FUNCTION {
+ RefTy &getValue() & {
assert(hasValue());
return MaybeRef;
}
- RefTy const &getValue() const LLVM_LVALUE_FUNCTION {
+ RefTy const &getValue() const & {
assert(hasValue());
return MaybeRef;
}
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
RefTy &&getValue() && {
assert(hasValue());
return std::move(MaybeRef);
}
-#endif
template <class... Args> void emplace(Args &&...args) {
MaybeRef = RefTy(std::forward<Args>(args)...);
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h
index e87772c04b9be..faabd48574bd2 100644
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h
@@ -161,15 +161,13 @@ class ExplodedNode : public llvm::FoldingSetNode {
return getLocationContext()->getParentMap();
}
- template <typename T>
- T &getAnalysis() const {
+ template <typename T> T &getAnalysis() const {
return *getLocationContext()->getAnalysis<T>();
}
const ProgramStateRef &getState() const { return State; }
- template <typename T>
- Optional<T> getLocationAs() const LLVM_LVALUE_FUNCTION {
+ template <typename T> Optional<T> getLocationAs() const & {
return Location.getAs<T>();
}
diff --git a/llvm/include/llvm/ADT/Optional.h b/llvm/include/llvm/ADT/Optional.h
index e047b0fc6514f..f4608140a974f 100644
--- a/llvm/include/llvm/ADT/Optional.h
+++ b/llvm/include/llvm/ADT/Optional.h
@@ -81,7 +81,7 @@ class OptionalStorage {
}
template <class... Args>
- constexpr explicit OptionalStorage(in_place_t, Args &&... args)
+ constexpr explicit OptionalStorage(in_place_t, Args &&...args)
: value(std::forward<Args>(args)...), hasVal(true) {}
void reset() noexcept {
@@ -93,22 +93,20 @@ class OptionalStorage {
constexpr bool hasValue() const noexcept { return hasVal; }
- T &getValue() LLVM_LVALUE_FUNCTION noexcept {
+ T &getValue() &noexcept {
assert(hasVal);
return value;
}
- constexpr T const &getValue() const LLVM_LVALUE_FUNCTION noexcept {
+ constexpr T const &getValue() const &noexcept {
assert(hasVal);
return value;
}
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
- T &&getValue() && noexcept {
+ T &&getValue() &&noexcept {
assert(hasVal);
return std::move(value);
}
-#endif
- template <class... Args> void emplace(Args &&... args) {
+ template <class... Args> void emplace(Args &&...args) {
reset();
::new ((void *)std::addressof(value)) T(std::forward<Args>(args)...);
hasVal = true;
@@ -193,22 +191,20 @@ template <typename T> class OptionalStorage<T, true> {
constexpr bool hasValue() const noexcept { return hasVal; }
- T &getValue() LLVM_LVALUE_FUNCTION noexcept {
+ T &getValue() &noexcept {
assert(hasVal);
return value;
}
- constexpr T const &getValue() const LLVM_LVALUE_FUNCTION noexcept {
+ constexpr T const &getValue() const &noexcept {
assert(hasVal);
return value;
}
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
- T &&getValue() && noexcept {
+ T &&getValue() &&noexcept {
assert(hasVal);
return std::move(value);
}
-#endif
- template <class... Args> void emplace(Args &&... args) {
+ template <class... Args> void emplace(Args &&...args) {
reset();
::new ((void *)std::addressof(value)) T(std::forward<Args>(args)...);
hasVal = true;
@@ -280,50 +276,43 @@ template <typename T> class Optional {
constexpr const T *getPointer() const { return &Storage.getValue(); }
T *getPointer() { return &Storage.getValue(); }
- constexpr const T &getValue() const LLVM_LVALUE_FUNCTION {
- return Storage.getValue();
- }
- T &getValue() LLVM_LVALUE_FUNCTION { return Storage.getValue(); }
+ constexpr const T &getValue() const & { return Storage.getValue(); }
+ T &getValue() & { return Storage.getValue(); }
constexpr explicit operator bool() const { return hasValue(); }
constexpr bool hasValue() const { return Storage.hasValue(); }
constexpr const T *operator->() const { return getPointer(); }
T *operator->() { return getPointer(); }
- constexpr const T &operator*() const LLVM_LVALUE_FUNCTION {
- return getValue();
- }
- T &operator*() LLVM_LVALUE_FUNCTION { return getValue(); }
+ constexpr const T &operator*() const & { return getValue(); }
+ T &operator*() & { return getValue(); }
- template <typename U>
- constexpr T getValueOr(U &&value) const LLVM_LVALUE_FUNCTION {
+ template <typename U> constexpr T getValueOr(U &&value) const & {
return hasValue() ? getValue() : std::forward<U>(value);
}
/// Apply a function to the value if present; otherwise return None.
template <class Function>
- auto map(const Function &F) const LLVM_LVALUE_FUNCTION
- -> Optional<decltype(F(getValue()))> {
- if (*this) return F(getValue());
+ auto map(const Function &F) const & -> Optional<decltype(F(getValue()))> {
+ if (*this)
+ return F(getValue());
return None;
}
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
T &&getValue() && { return std::move(Storage.getValue()); }
T &&operator*() && { return std::move(Storage.getValue()); }
- template <typename U>
- T getValueOr(U &&value) && {
+ template <typename U> T getValueOr(U &&value) && {
return hasValue() ? std::move(getValue()) : std::forward<U>(value);
}
/// Apply a function to the value if present; otherwise return None.
template <class Function>
- auto map(const Function &F) &&
- -> Optional<decltype(F(std::move(*this).getValue()))> {
- if (*this) return F(std::move(*this).getValue());
+ auto map(const Function &F)
+ && -> Optional<decltype(F(std::move(*this).getValue()))> {
+ if (*this)
+ return F(std::move(*this).getValue());
return None;
}
-#endif
};
template <class T> llvm::hash_code hash_value(const Optional<T> &O) {
diff --git a/llvm/include/llvm/ADT/PointerIntPair.h b/llvm/include/llvm/ADT/PointerIntPair.h
index b7ddf8855605d..7d10b2a6dd149 100644
--- a/llvm/include/llvm/ADT/PointerIntPair.h
+++ b/llvm/include/llvm/ADT/PointerIntPair.h
@@ -61,19 +61,19 @@ class PointerIntPair {
IntType getInt() const { return (IntType)Info::getInt(Value); }
- void setPointer(PointerTy PtrVal) LLVM_LVALUE_FUNCTION {
+ void setPointer(PointerTy PtrVal) & {
Value = Info::updatePointer(Value, PtrVal);
}
- void setInt(IntType IntVal) LLVM_LVALUE_FUNCTION {
+ void setInt(IntType IntVal) & {
Value = Info::updateInt(Value, static_cast<intptr_t>(IntVal));
}
- void initWithPointer(PointerTy PtrVal) LLVM_LVALUE_FUNCTION {
+ void initWithPointer(PointerTy PtrVal) & {
Value = Info::updatePointer(0, PtrVal);
}
- void setPointerAndInt(PointerTy PtrVal, IntType IntVal) LLVM_LVALUE_FUNCTION {
+ void setPointerAndInt(PointerTy PtrVal, IntType IntVal) & {
Value = Info::updateInt(Info::updatePointer(0, PtrVal),
static_cast<intptr_t>(IntVal));
}
@@ -91,7 +91,7 @@ class PointerIntPair {
void *getOpaqueValue() const { return reinterpret_cast<void *>(Value); }
- void setFromOpaqueValue(void *Val) LLVM_LVALUE_FUNCTION {
+ void setFromOpaqueValue(void *Val) & {
Value = reinterpret_cast<intptr_t>(Val);
}
diff --git a/llvm/include/llvm/Support/Compiler.h b/llvm/include/llvm/Support/Compiler.h
index 1f044813bd74a..63f49b3af8ff4 100644
--- a/llvm/include/llvm/Support/Compiler.h
+++ b/llvm/include/llvm/Support/Compiler.h
@@ -102,24 +102,6 @@
#define LLVM_MSC_PREREQ(version) 0
#endif
-/// Does the compiler support ref-qualifiers for *this?
-///
-/// Sadly, this is separate from just rvalue reference support because GCC
-/// and MSVC implemented this later than everything else. This appears to be
-/// corrected in MSVC 2019 but not MSVC 2017.
-/// FIXME: Remove LLVM_HAS_RVALUE_REFERENCE_THIS macro
-#define LLVM_HAS_RVALUE_REFERENCE_THIS 1
-
-/// Expands to '&' if ref-qualifiers for *this are supported.
-///
-/// This can be used to provide lvalue/rvalue overrides of member functions.
-/// The rvalue override should be guarded by LLVM_HAS_RVALUE_REFERENCE_THIS
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
-#define LLVM_LVALUE_FUNCTION &
-#else
-#define LLVM_LVALUE_FUNCTION
-#endif
-
/// LLVM_LIBRARY_VISIBILITY - If a class marked with this attribute is linked
/// into a shared library, then the class should be private to the library and
/// not accessible from outside it. Can also be used to mark variables and
diff --git a/llvm/unittests/ADT/OptionalTest.cpp b/llvm/unittests/ADT/OptionalTest.cpp
index b664792f2dfb9..06283f477e556 100644
--- a/llvm/unittests/ADT/OptionalTest.cpp
+++ b/llvm/unittests/ADT/OptionalTest.cpp
@@ -578,8 +578,6 @@ TEST(OptionalTest, DeletedCopyStringMap) {
Optional<NoCopyStringMap> TestInstantiation;
}
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
-
TEST(OptionalTest, MoveGetValueOr) {
Optional<MoveOnly> A;
@@ -597,8 +595,6 @@ TEST(OptionalTest, MoveGetValueOr) {
EXPECT_EQ(2u, MoveOnly::Destructions);
}
-#endif // LLVM_HAS_RVALUE_REFERENCE_THIS
-
struct EqualTo {
template <typename T, typename U> static bool apply(const T &X, const U &Y) {
return X == Y;
More information about the llvm-commits
mailing list