Author: Joe Loser Date: 2022-08-12T06:55:59-06:00 New Revision: e8578968f684997840f680ed62bff5cad0accc13
URL: https://github.com/llvm/llvm-project/commit/e8578968f684997840f680ed62bff5cad0accc13 DIFF: https://github.com/llvm/llvm-project/commit/e8578968f684997840f680ed62bff5cad0accc13.diff LOG: [ADT] Replace STLForwardCompat.h's C++17 equivalents 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 use of these equivalents in favor of the ones from the standard library. Differential Revision: https://reviews.llvm.org/D131717 Added: Modified: 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/Support/HashBuilder.h llvm/unittests/ADT/OptionalTest.cpp Removed: ################################################################################ diff --git a/clang/include/clang/Basic/DirectoryEntry.h b/clang/include/clang/Basic/DirectoryEntry.h index f1ec63d975a37..19d52c09dbcce 100644 --- a/clang/include/clang/Basic/DirectoryEntry.h +++ b/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 @@ template <class RefTy> class MapEntryOptionalStorage { 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 @@ class OptionalStorage<clang::DirectoryEntryRef> 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); diff --git a/clang/include/clang/Basic/FileEntry.h b/clang/include/clang/Basic/FileEntry.h index 3ca07cb422b64..d9b92a73a1d82 100644 --- a/clang/include/clang/Basic/FileEntry.h +++ b/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 @@ class OptionalStorage<clang::FileEntryRef> 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); diff --git a/llvm/include/llvm/ADT/Any.h b/llvm/include/llvm/ADT/Any.h index 1c7ba03717816..649a9986c0a41 100644 --- a/llvm/include/llvm/ADT/Any.h +++ b/llvm/include/llvm/ADT/Any.h @@ -68,8 +68,8 @@ class LLVM_EXTERNAL_VISIBILITY Any { // 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 @@ class LLVM_EXTERNAL_VISIBILITY Any { // 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) { diff --git a/llvm/include/llvm/ADT/FunctionExtras.h b/llvm/include/llvm/ADT/FunctionExtras.h index 5a37417ddde5d..8ff0fb787a77d 100644 --- a/llvm/include/llvm/ADT/FunctionExtras.h +++ b/llvm/include/llvm/ADT/FunctionExtras.h @@ -65,7 +65,7 @@ template <typename CallableT, typename ThisT> 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>, diff --git a/llvm/include/llvm/ADT/Optional.h b/llvm/include/llvm/ADT/Optional.h index 09770c4f94a0e..1862a2d703aad 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(std::in_place_t, Args &&...args) : val(std::forward<Args>(args)...), hasVal(true) {} void reset() noexcept { @@ -196,7 +196,7 @@ template <typename T> class OptionalStorage<T, true> { 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 @@ template <typename T> class Optional { 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(T &&y) : Storage(std::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); diff --git a/llvm/include/llvm/ADT/STLExtras.h b/llvm/include/llvm/ADT/STLExtras.h index dd8b2095ba7ee..45641ec144248 100644 --- a/llvm/include/llvm/ADT/STLExtras.h +++ b/llvm/include/llvm/ADT/STLExtras.h @@ -155,12 +155,12 @@ struct function_traits<ReturnType (&)(Args...), false> /// 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 @@ template <> struct rank<0> {}; /// 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 @@ namespace detail { 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 diff --git a/llvm/include/llvm/Support/HashBuilder.h b/llvm/include/llvm/Support/HashBuilder.h index 9d7680d2b6677..51ca97e1597de 100644 --- a/llvm/include/llvm/Support/HashBuilder.h +++ b/llvm/include/llvm/Support/HashBuilder.h @@ -76,7 +76,7 @@ template <typename HasherT> class HashBuilderBase { 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: diff --git a/llvm/unittests/ADT/OptionalTest.cpp b/llvm/unittests/ADT/OptionalTest.cpp index 8d01b0df3fc34..3db84ed4c3306 100644 --- a/llvm/unittests/ADT/OptionalTest.cpp +++ b/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, NullCopyConstructionTest) { 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 @@ static_assert(!std::is_trivially_copyable<Optional<MultiArgConstructor>>::value, 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, Emplace) { 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, InPlaceConstructionMultiArgConstructorTest) { 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, ImmovableEmplace) { 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); _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits