RKSimon created this revision.
RKSimon added reviewers: rnk, aaron.ballman, zturner, jhenderson.
Herald added a subscriber: dexonsmith.
RKSimon requested review of this revision.
Herald added projects: clang, LLVM.
Herald added a subscriber: cfe-commits.
Now that VS2017 support has been dropped (D114639
<https://reviews.llvm.org/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.
NOTE: I'm not intending to push this before the 14.x branch.
Repository:
rG LLVM Github Monorepo
https://reviews.llvm.org/D118609
Files:
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
Index: llvm/unittests/ADT/OptionalTest.cpp
===================================================================
--- llvm/unittests/ADT/OptionalTest.cpp
+++ llvm/unittests/ADT/OptionalTest.cpp
@@ -578,8 +578,6 @@
Optional<NoCopyStringMap> TestInstantiation;
}
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
-
TEST(OptionalTest, MoveGetValueOr) {
Optional<MoveOnly> A;
@@ -597,8 +595,6 @@
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;
Index: llvm/include/llvm/Support/Compiler.h
===================================================================
--- llvm/include/llvm/Support/Compiler.h
+++ llvm/include/llvm/Support/Compiler.h
@@ -98,24 +98,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
Index: llvm/include/llvm/ADT/PointerIntPair.h
===================================================================
--- llvm/include/llvm/ADT/PointerIntPair.h
+++ llvm/include/llvm/ADT/PointerIntPair.h
@@ -61,19 +61,19 @@
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 @@
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);
}
Index: llvm/include/llvm/ADT/Optional.h
===================================================================
--- llvm/include/llvm/ADT/Optional.h
+++ llvm/include/llvm/ADT/Optional.h
@@ -93,20 +93,18 @@
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 {
assert(hasVal);
return std::move(value);
}
-#endif
template <class... Args> void emplace(Args &&... args) {
reset();
@@ -193,20 +191,18 @@
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 {
assert(hasVal);
return std::move(value);
}
-#endif
template <class... Args> void emplace(Args &&... args) {
reset();
@@ -280,34 +276,32 @@
constexpr const T *getPointer() const { return &Storage.getValue(); }
T *getPointer() { return &Storage.getValue(); }
- constexpr const T &getValue() const LLVM_LVALUE_FUNCTION {
+ constexpr const T &getValue() const & {
return Storage.getValue();
}
- T &getValue() LLVM_LVALUE_FUNCTION { 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 {
+ constexpr const T &operator*() const & {
return getValue();
}
- T &operator*() LLVM_LVALUE_FUNCTION { 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()); }
@@ -323,7 +317,6 @@
if (*this) return F(std::move(*this).getValue());
return None;
}
-#endif
};
template <class T> llvm::hash_code hash_value(const Optional<T> &O) {
Index: clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h
===================================================================
--- clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h
+++ clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h
@@ -169,7 +169,7 @@
const ProgramStateRef &getState() const { return State; }
template <typename T>
- Optional<T> getLocationAs() const LLVM_LVALUE_FUNCTION {
+ Optional<T> getLocationAs() const & {
return Location.getAs<T>();
}
Index: clang/include/clang/Basic/DirectoryEntry.h
===================================================================
--- clang/include/clang/Basic/DirectoryEntry.h
+++ clang/include/clang/Basic/DirectoryEntry.h
@@ -128,20 +128,18 @@
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)...);
Index: clang/include/clang/ASTMatchers/ASTMatchersInternal.h
===================================================================
--- clang/include/clang/ASTMatchers/ASTMatchersInternal.h
+++ clang/include/clang/ASTMatchers/ASTMatchersInternal.h
@@ -600,17 +600,15 @@
/// 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,11 @@
///
/// 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 {
+ 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 +1357,31 @@
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 +1471,13 @@
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 +1548,19 @@
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 +1587,18 @@
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;
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
