[ADT] Replace STLForwardCompat.h's C++17 equivalents

[jloser]

Summary

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.

[MaskRay]

The llvm/include/llvm/ADT/STLForwardCompat.h and llvm/unittests/ADT/STLForwardCompatTest.cpp removal can be in a separate patch.

[jloser]

Revert removal of these utilities and type traits from STLForwardCompat.h and their corresponding unit tests. The removal of these will be done in a separate patch.

[jloser]

In D131717#3717363, @MaskRay wrote:

The llvm/include/llvm/ADT/STLForwardCompat.h and llvm/unittests/ADT/STLForwardCompatTest.cpp removal can be in a separate patch.

Sure. I just split them out of this patch and I'll do the removal in a follow-up patch.

[scott.linder]

LGTM, thank you!

I have some pending changes which would add C++20 "compat" types, but removing it until those land sounds fine to me.

[jloser]

Fix unqualified use of in_place so the delegating constructor in Optional calls the one taking the std::in_place_t tag.

clang/include/clang/Basic/DirectoryEntry.h

 #include "clang/Basic/LLVM.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/ErrorOr.h"
 
+#include <utility>
+
 namespace clang {
 namespace FileMgr {
 
 template <class RefTy> class MapEntryOptionalStorage;
 
 } // end namespace FileMgr
 
 /// Cached information about one directory (either on disk or in

 template <class RefTy> class MapEntryOptionalStorage {
   using optional_none_tag = typename RefTy::optional_none_tag;
   RefTy MaybeRef;
 
 public:
   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(); }
 
   bool has_value() const { return MaybeRef.hasOptionalValue(); }
   LLVM_DEPRECATED("Use has_value instead.", "has_value") bool hasValue() const {
     return MaybeRef.hasOptionalValue();
   }
class OptionalStorage<clang::DirectoryEntryRef>
     : public clang::FileMgr::MapEntryOptionalStorage<clang::DirectoryEntryRef> {
   using StorageImpl =
       clang::FileMgr::MapEntryOptionalStorage<clang::DirectoryEntryRef>;
 
 public:
   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);
     return *this;
   }
 };
 
 static_assert(sizeof(Optional<clang::DirectoryEntryRef>) ==

clang/include/clang/Basic/FileEntry.h

 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileSystem/UniqueID.h"
 
+#include <utility>
+
 namespace llvm {
 
 class MemoryBuffer;
 
 namespace vfs {
 
 class File;
 
class OptionalStorage<clang::FileEntryRef>
     : public clang::FileMgr::MapEntryOptionalStorage<clang::FileEntryRef> {
   using StorageImpl =
       clang::FileMgr::MapEntryOptionalStorage<clang::FileEntryRef>;
 
 public:
   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);
     return *this;
   }
 };
 
 static_assert(sizeof(Optional<clang::FileEntryRef>) ==

llvm/include/llvm/ADT/Any.h

public:
   Any(const Any &Other)
       : Storage(Other.Storage ? Other.Storage->clone() : nullptr) {}
 
   // When T is Any or T is not copy-constructible we need to explicitly disable
   // the forwarding constructor so that the copy constructor gets selected
   // 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
                     // overload resolution for determining copy
                     // constructibility, and then when we try to determine copy
                     // constructibility below we may infinitely recurse. This is
                     // being evaluated by the standards committee as a potential
                     // 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) {
     Storage =
         std::make_unique<StorageImpl<std::decay_t<T>>>(std::forward<T>(Value));
   }
 
   Any(Any &&Other) : Storage(std::move(Other.Storage)) {}

llvm/include/llvm/ADT/FunctionExtras.h

 template <typename T>
 using EnableIfTrivial =
     std::enable_if_t<llvm::is_trivially_move_constructible<T>::value &&
                      std::is_trivially_destructible<T>::value>;
 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>,
     std::is_same<const decltype(std::declval<CallableT>()(
                      std::declval<Params>()...)),
                  Ret>,
     std::is_convertible<decltype(std::declval<CallableT>()(
                             std::declval<Params>()...)),

llvm/include/llvm/ADT/Optional.h

public:
   }
   constexpr OptionalStorage(OptionalStorage &&other) : OptionalStorage() {
     if (other.has_value()) {
       emplace(std::move(other.val));
     }
   }
 
   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 {
     if (hasVal) {
       val.~T();
       hasVal = false;
     }
   }
public:
 
   constexpr OptionalStorage(OptionalStorage const &other) = default;
   constexpr OptionalStorage(OptionalStorage &&other) = default;
 
   OptionalStorage &operator=(OptionalStorage const &other) = default;
   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 {
     if (hasVal) {
       val.~T();
       hasVal = false;
     }
   }
template <typename T> class Optional {
   optional_detail::OptionalStorage<T> Storage;
 
 public:
   using value_type = T;
 
   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);
     return *this;
   }
   Optional &operator=(Optional &&O) = default;
 
   /// Create a new object by constructing it in place with the given arguments.

llvm/include/llvm/ADT/STLExtras.h

 /// Overload for non-class function type references.
 template <typename ReturnType, typename... Args>
 struct function_traits<ReturnType (&)(Args...), false>
     : public function_traits<ReturnType (*)(Args...)> {};
 
 /// 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;
 template <typename T, typename... Us>
 struct TypesAreDistinct
     : std::integral_constant<bool, !is_one_of<T, Us...>::value &&
                                        TypesAreDistinct<Us...>::value> {};
 template <typename T> struct TypesAreDistinct<T> : std::true_type {};

 /// Utility type to build an inheritance chain that makes it easy to rank
 /// overload candidates.
 template <int N> struct rank : rank<N - 1> {};
 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;
 
 template <typename HeadT, typename... TailTs>
 struct Visitor<HeadT, TailTs...> : remove_cvref_t<HeadT>, Visitor<TailTs...> {
   explicit constexpr Visitor(HeadT &&Head, TailTs &&...Tail)
       : remove_cvref_t<HeadT>(std::forward<HeadT>(Head)),
#endif
   qsort(&*Start, NElts, sizeof(*Start),
         reinterpret_cast<int (*)(const void *, const void *)>(Compare));
 }
 
 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
 
 // Provide wrappers to std::sort which shuffle the elements before sorting
 // to help uncover non-deterministic behavior (PR35135).
 template <typename IteratorTy,
           std::enable_if_t<!detail::sort_trivially_copyable<IteratorTy>::value,

llvm/include/llvm/Support/HashBuilder.h

template <typename HasherT_ = HasherT> HashResultTy<HasherT_> result() {
     return this->getHasher().result();
   }
 
 protected:
   explicit HashBuilderBase(HasherT &Hasher) : Hasher(Hasher) {}
 
   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:
   Optional<HasherT> OptionalHasher;
   HasherT &Hasher;
 };
 
 /// Implementation of the `HashBuilder` interface.

llvm/unittests/ADT/OptionalTest.cpp

 //===- llvm/unittest/ADT/OptionalTest.cpp - Optional unit tests -----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/raw_ostream.h"
 #include "gtest/gtest-spi.h"
 #include "gtest/gtest.h"
 
 #include <array>
-
+#include <utility>
 
 using namespace llvm;
 
 static_assert(std::is_trivially_copyable<Optional<int>>::value,
               "trivially copyable");
 
 static_assert(std::is_trivially_copyable<Optional<std::array<int, 3>>>::value,
               "trivially copyable");
TEST(OptionalTest, NullCopyConstructionTest) {
   }
   EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
   EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
   EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
 }
 
 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);
 }
 
 TEST(OptionalTest, GetValueOr) {
   Optional<int> A;
   EXPECT_EQ(42, A.value_or(42));

 unsigned MultiArgConstructor::Destructions = 0;
 
 static_assert(!std::is_trivially_copyable<Optional<MultiArgConstructor>>::value,
               "not trivially copyable");
 
 TEST(OptionalTest, Emplace) {
   MultiArgConstructor::ResetCounts();
   Optional<MultiArgConstructor> A;
-  
   A.emplace(1, 2);
   EXPECT_TRUE(A.has_value());
   EXPECT_TRUE(A.has_value());
   EXPECT_EQ(1, A->x);
   EXPECT_EQ(2, A->y);
   EXPECT_EQ(0u, MultiArgConstructor::Destructions);
 
   A.emplace(5, false);
   EXPECT_TRUE(A.has_value());
   EXPECT_TRUE(A.has_value());
   EXPECT_EQ(5, A->x);
   EXPECT_EQ(-5, A->y);
   EXPECT_EQ(1u, MultiArgConstructor::Destructions);
 }
 
 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);
     EXPECT_EQ(-5, B->y);
     EXPECT_EQ(0u, MultiArgConstructor::Destructions);
   }
   EXPECT_EQ(2u, MultiArgConstructor::Destructions);
 }
 
 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);
     ASSERT_EQ(A, B);
   }
   EXPECT_EQ(2u, MultiArgConstructor::Destructions);
 }
 
TEST(OptionalTest, ImmovableEmplace) {
   EXPECT_TRUE((bool)A);
   EXPECT_EQ(4, A->val);
   EXPECT_EQ(1u, Immovable::Constructions);
   EXPECT_EQ(0u, Immovable::Destructions);
 }
 
 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);
   EXPECT_EQ(0u, Immovable::Destructions);
 }
 
 // Craft a class which is_trivially_copyable, but not
 // is_trivially_copy_constructible.