jloser created this revision.
jloser added reviewers: scott.linder, MaskRay, bkramer, zero9178, dblaikie.
Herald added a subscriber: StephenFan.
Herald added a project: All.
jloser requested review of this revision.
Herald added projects: clang, LLVM.
Herald added subscribers: llvm-commits, cfe-commits.
STLForwardCompat.h defines several utilities and type traits to mimic that of
the ones in the C++17 standard library. Now that LLVM is built with the C++17
standards mode, remove these equivalents in favor of the ones from the
standard library.
Repository:
rG LLVM Github Monorepo
https://reviews.llvm.org/D131717
Files:
clang/include/clang/Basic/DirectoryEntry.h
clang/include/clang/Basic/FileEntry.h
llvm/include/llvm/ADT/Any.h
llvm/include/llvm/ADT/FunctionExtras.h
llvm/include/llvm/ADT/Optional.h
llvm/include/llvm/ADT/STLExtras.h
llvm/include/llvm/ADT/STLForwardCompat.h
llvm/include/llvm/Support/HashBuilder.h
llvm/unittests/ADT/OptionalTest.cpp
llvm/unittests/ADT/STLForwardCompatTest.cpp
Index: llvm/unittests/ADT/STLForwardCompatTest.cpp
===================================================================
--- llvm/unittests/ADT/STLForwardCompatTest.cpp
+++ llvm/unittests/ADT/STLForwardCompatTest.cpp
@@ -11,37 +11,6 @@
namespace {
-TEST(STLForwardCompatTest, NegationTest) {
- EXPECT_TRUE((llvm::negation<std::false_type>::value));
- EXPECT_FALSE((llvm::negation<std::true_type>::value));
-}
-
-struct incomplete_type;
-
-TEST(STLForwardCompatTest, ConjunctionTest) {
- EXPECT_TRUE((llvm::conjunction<>::value));
- EXPECT_FALSE((llvm::conjunction<std::false_type>::value));
- EXPECT_TRUE((llvm::conjunction<std::true_type>::value));
- EXPECT_FALSE((llvm::conjunction<std::false_type, incomplete_type>::value));
- EXPECT_FALSE((llvm::conjunction<std::false_type, std::true_type>::value));
- EXPECT_FALSE((llvm::conjunction<std::true_type, std::false_type>::value));
- EXPECT_TRUE((llvm::conjunction<std::true_type, std::true_type>::value));
- EXPECT_TRUE((llvm::conjunction<std::true_type, std::true_type,
- std::true_type>::value));
-}
-
-TEST(STLForwardCompatTest, DisjunctionTest) {
- EXPECT_FALSE((llvm::disjunction<>::value));
- EXPECT_FALSE((llvm::disjunction<std::false_type>::value));
- EXPECT_TRUE((llvm::disjunction<std::true_type>::value));
- EXPECT_TRUE((llvm::disjunction<std::true_type, incomplete_type>::value));
- EXPECT_TRUE((llvm::disjunction<std::false_type, std::true_type>::value));
- EXPECT_TRUE((llvm::disjunction<std::true_type, std::false_type>::value));
- EXPECT_TRUE((llvm::disjunction<std::true_type, std::true_type>::value));
- EXPECT_TRUE((llvm::disjunction<std::true_type, std::true_type,
- std::true_type>::value));
-}
-
template <typename T>
class STLForwardCompatRemoveCVRefTest : public ::testing::Test {};
Index: llvm/unittests/ADT/OptionalTest.cpp
===================================================================
--- llvm/unittests/ADT/OptionalTest.cpp
+++ llvm/unittests/ADT/OptionalTest.cpp
@@ -14,7 +14,7 @@
#include "gtest/gtest.h"
#include <array>
-
+#include <utility>
using namespace llvm;
@@ -201,7 +201,7 @@
TEST(OptionalTest, InPlaceConstructionNonDefaultConstructibleTest) {
NonDefaultConstructible::ResetCounts();
- { Optional<NonDefaultConstructible> A{in_place, 1}; }
+ { Optional<NonDefaultConstructible> A{std::in_place, 1}; }
EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
@@ -247,7 +247,7 @@
TEST(OptionalTest, Emplace) {
MultiArgConstructor::ResetCounts();
Optional<MultiArgConstructor> A;
-
+
A.emplace(1, 2);
EXPECT_TRUE(A.has_value());
EXPECT_TRUE(A.has_value());
@@ -266,12 +266,12 @@
TEST(OptionalTest, InPlaceConstructionMultiArgConstructorTest) {
MultiArgConstructor::ResetCounts();
{
- Optional<MultiArgConstructor> A{in_place, 1, 2};
+ Optional<MultiArgConstructor> A{std::in_place, 1, 2};
EXPECT_TRUE(A.has_value());
EXPECT_TRUE(A.has_value());
EXPECT_EQ(1, A->x);
EXPECT_EQ(2, A->y);
- Optional<MultiArgConstructor> B{in_place, 5, false};
+ Optional<MultiArgConstructor> B{std::in_place, 5, false};
EXPECT_TRUE(B.has_value());
EXPECT_TRUE(B.has_value());
EXPECT_EQ(5, B->x);
@@ -284,7 +284,7 @@
TEST(OptionalTest, InPlaceConstructionAndEmplaceEquivalentTest) {
MultiArgConstructor::ResetCounts();
{
- Optional<MultiArgConstructor> A{in_place, 1, 2};
+ Optional<MultiArgConstructor> A{std::in_place, 1, 2};
Optional<MultiArgConstructor> B;
B.emplace(1, 2);
EXPECT_EQ(0u, MultiArgConstructor::Destructions);
@@ -442,7 +442,7 @@
TEST(OptionalTest, ImmovableInPlaceConstruction) {
Immovable::ResetCounts();
- Optional<Immovable> A{in_place, 4};
+ Optional<Immovable> A{std::in_place, 4};
EXPECT_TRUE((bool)A);
EXPECT_EQ(4, A->val);
EXPECT_EQ(1u, Immovable::Constructions);
Index: llvm/include/llvm/Support/HashBuilder.h
===================================================================
--- llvm/include/llvm/Support/HashBuilder.h
+++ llvm/include/llvm/Support/HashBuilder.h
@@ -76,7 +76,7 @@
template <typename... ArgTypes>
explicit HashBuilderBase(ArgTypes &&...Args)
- : OptionalHasher(in_place, std::forward<ArgTypes>(Args)...),
+ : OptionalHasher(std::in_place, std::forward<ArgTypes>(Args)...),
Hasher(*OptionalHasher) {}
private:
Index: llvm/include/llvm/ADT/STLForwardCompat.h
===================================================================
--- llvm/include/llvm/ADT/STLForwardCompat.h
+++ llvm/include/llvm/ADT/STLForwardCompat.h
@@ -21,49 +21,6 @@
namespace llvm {
-//===----------------------------------------------------------------------===//
-// Features from C++17
-//===----------------------------------------------------------------------===//
-
-template <typename T>
-struct negation // NOLINT(readability-identifier-naming)
- : std::integral_constant<bool, !bool(T::value)> {};
-
-template <typename...>
-struct conjunction // NOLINT(readability-identifier-naming)
- : std::true_type {};
-template <typename B1> struct conjunction<B1> : B1 {};
-template <typename B1, typename... Bn>
-struct conjunction<B1, Bn...>
- : std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
-
-template <typename...>
-struct disjunction // NOLINT(readability-identifier-naming)
- : std::false_type {};
-template <typename B1> struct disjunction<B1> : B1 {};
-template <typename B1, typename... Bn>
-struct disjunction<B1, Bn...>
- : std::conditional<bool(B1::value), B1, disjunction<Bn...>>::type {};
-
-struct in_place_t // NOLINT(readability-identifier-naming)
-{
- explicit in_place_t() = default;
-};
-/// \warning This must not be odr-used, as it cannot be made \c inline in C++14.
-constexpr in_place_t in_place; // NOLINT(readability-identifier-naming)
-
-template <typename T>
-struct in_place_type_t // NOLINT(readability-identifier-naming)
-{
- explicit in_place_type_t() = default;
-};
-
-template <std::size_t I>
-struct in_place_index_t // NOLINT(readability-identifier-naming)
-{
- explicit in_place_index_t() = default;
-};
-
//===----------------------------------------------------------------------===//
// Features from C++20
//===----------------------------------------------------------------------===//
Index: llvm/include/llvm/ADT/STLExtras.h
===================================================================
--- llvm/include/llvm/ADT/STLExtras.h
+++ llvm/include/llvm/ADT/STLExtras.h
@@ -155,12 +155,12 @@
/// traits class for checking whether type T is one of any of the given
/// types in the variadic list.
template <typename T, typename... Ts>
-using is_one_of = disjunction<std::is_same<T, Ts>...>;
+using is_one_of = std::disjunction<std::is_same<T, Ts>...>;
/// traits class for checking whether type T is a base class for all
/// the given types in the variadic list.
template <typename T, typename... Ts>
-using are_base_of = conjunction<std::is_base_of<T, Ts>...>;
+using are_base_of = std::conjunction<std::is_base_of<T, Ts>...>;
namespace detail {
template <typename T, typename... Us> struct TypesAreDistinct;
@@ -1386,12 +1386,12 @@
/// traits class for checking whether type T is one of any of the given
/// types in the variadic list.
template <typename T, typename... Ts>
-using is_one_of = disjunction<std::is_same<T, Ts>...>;
+using is_one_of = std::disjunction<std::is_same<T, Ts>...>;
/// traits class for checking whether type T is a base class for all
/// the given types in the variadic list.
template <typename T, typename... Ts>
-using are_base_of = conjunction<std::is_base_of<T, Ts>...>;
+using are_base_of = std::conjunction<std::is_base_of<T, Ts>...>;
namespace detail {
template <typename... Ts> struct Visitor;
@@ -1550,7 +1550,7 @@
template <typename T>
// We can use qsort if the iterator type is a pointer and the underlying value
// is trivially copyable.
-using sort_trivially_copyable = conjunction<
+using sort_trivially_copyable = std::conjunction<
std::is_pointer<T>,
std::is_trivially_copyable<typename std::iterator_traits<T>::value_type>>;
} // namespace detail
Index: llvm/include/llvm/ADT/Optional.h
===================================================================
--- llvm/include/llvm/ADT/Optional.h
+++ llvm/include/llvm/ADT/Optional.h
@@ -81,7 +81,7 @@
}
template <class... Args>
- constexpr explicit OptionalStorage(in_place_t, Args &&...args)
+ constexpr explicit OptionalStorage(std::in_place_t, Args &&...args)
: val(std::forward<Args>(args)...), hasVal(true) {}
void reset() noexcept {
@@ -196,7 +196,7 @@
OptionalStorage &operator=(OptionalStorage &&other) = default;
template <class... Args>
- constexpr explicit OptionalStorage(in_place_t, Args &&...args)
+ constexpr explicit OptionalStorage(std::in_place_t, Args &&...args)
: val(std::forward<Args>(args)...), hasVal(true) {}
void reset() noexcept {
@@ -275,15 +275,15 @@
constexpr Optional() = default;
constexpr Optional(NoneType) {}
- constexpr Optional(const T &y) : Storage(in_place, y) {}
+ constexpr Optional(const T &y) : Storage(std::in_place, y) {}
constexpr Optional(const Optional &O) = default;
constexpr Optional(T &&y) : Storage(in_place, std::move(y)) {}
constexpr Optional(Optional &&O) = default;
template <typename... ArgTypes>
- constexpr Optional(in_place_t, ArgTypes &&...Args)
- : Storage(in_place, std::forward<ArgTypes>(Args)...) {}
+ constexpr Optional(std::in_place_t, ArgTypes &&...Args)
+ : Storage(std::in_place, std::forward<ArgTypes>(Args)...) {}
Optional &operator=(T &&y) {
Storage = std::move(y);
Index: llvm/include/llvm/ADT/FunctionExtras.h
===================================================================
--- llvm/include/llvm/ADT/FunctionExtras.h
+++ llvm/include/llvm/ADT/FunctionExtras.h
@@ -65,7 +65,7 @@
using EnableUnlessSameType =
std::enable_if_t<!std::is_same<remove_cvref_t<CallableT>, ThisT>::value>;
template <typename CallableT, typename Ret, typename... Params>
-using EnableIfCallable = std::enable_if_t<llvm::disjunction<
+using EnableIfCallable = std::enable_if_t<std::disjunction<
std::is_void<Ret>,
std::is_same<decltype(std::declval<CallableT>()(std::declval<Params>()...)),
Ret>,
Index: llvm/include/llvm/ADT/Any.h
===================================================================
--- llvm/include/llvm/ADT/Any.h
+++ llvm/include/llvm/ADT/Any.h
@@ -68,8 +68,8 @@
// instead.
template <typename T,
std::enable_if_t<
- llvm::conjunction<
- llvm::negation<std::is_same<std::decay_t<T>, Any>>,
+ std::conjunction<
+ std::negation<std::is_same<std::decay_t<T>, Any>>,
// We also disable this overload when an `Any` object can be
// converted to the parameter type because in that case,
// this constructor may combine with that conversion during
@@ -80,7 +80,7 @@
// DR in `std::any` as well, but we're going ahead and
// adopting it to work-around usage of `Any` with types that
// need to be implicitly convertible from an `Any`.
- llvm::negation<std::is_convertible<Any, std::decay_t<T>>>,
+ std::negation<std::is_convertible<Any, std::decay_t<T>>>,
std::is_copy_constructible<std::decay_t<T>>>::value,
int> = 0>
Any(T &&Value) {
Index: clang/include/clang/Basic/FileEntry.h
===================================================================
--- clang/include/clang/Basic/FileEntry.h
+++ clang/include/clang/Basic/FileEntry.h
@@ -24,6 +24,8 @@
#include "llvm/Support/ErrorOr.h"
#include "llvm/Support/FileSystem/UniqueID.h"
+#include <utility>
+
namespace llvm {
class MemoryBuffer;
@@ -222,8 +224,8 @@
OptionalStorage() = default;
template <class... ArgTypes>
- explicit OptionalStorage(in_place_t, ArgTypes &&...Args)
- : StorageImpl(in_place_t{}, std::forward<ArgTypes>(Args)...) {}
+ explicit OptionalStorage(std::in_place_t, ArgTypes &&...Args)
+ : StorageImpl(std::in_place_t{}, std::forward<ArgTypes>(Args)...) {}
OptionalStorage &operator=(clang::FileEntryRef Ref) {
StorageImpl::operator=(Ref);
Index: clang/include/clang/Basic/DirectoryEntry.h
===================================================================
--- clang/include/clang/Basic/DirectoryEntry.h
+++ clang/include/clang/Basic/DirectoryEntry.h
@@ -22,6 +22,8 @@
#include "llvm/ADT/STLExtras.h"
#include "llvm/Support/ErrorOr.h"
+#include <utility>
+
namespace clang {
namespace FileMgr {
@@ -125,7 +127,7 @@
MapEntryOptionalStorage() : MaybeRef(optional_none_tag()) {}
template <class... ArgTypes>
- explicit MapEntryOptionalStorage(llvm::in_place_t, ArgTypes &&...Args)
+ explicit MapEntryOptionalStorage(std::in_place_t, ArgTypes &&...Args)
: MaybeRef(std::forward<ArgTypes>(Args)...) {}
void reset() { MaybeRef = optional_none_tag(); }
@@ -189,8 +191,8 @@
OptionalStorage() = default;
template <class... ArgTypes>
- explicit OptionalStorage(in_place_t, ArgTypes &&...Args)
- : StorageImpl(in_place_t{}, std::forward<ArgTypes>(Args)...) {}
+ explicit OptionalStorage(std::in_place_t, ArgTypes &&...Args)
+ : StorageImpl(std::in_place_t{}, std::forward<ArgTypes>(Args)...) {}
OptionalStorage &operator=(clang::DirectoryEntryRef Ref) {
StorageImpl::operator=(Ref);
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
