[ADT] Add llvm::remove_cvref and llvm::remove_cvref_t

[dblaikie]

Change the title (this patch isn't adding any std:: things, it's adding llvm:: things that are equivalent to std:: things) and I think drop the "SHIM" macro (but we'll take that up in the precursor patch that introduces that macro)

Testing - I'm not a huge fan of stamping out tests with macros - makes the tests in some ways harder to read/understand what they're testing. Not sure it's better, but gtest does offer a type based test expansion - maybe you could use that?

[scott.linder]

• Rebase
• Change title, "std::" -> "llvm::"
• Use TYPED_TEST instead of a bespoke macro

[scott.linder]

llvm/unittests/ADT/STLForwardCompatTest.cpp

48–52

The formatting here gets a bit muddy, I considered adding a typedef of std::pair with a longer name, so that the formatting would refer one entry per line. Does that seem like it would be an improvement?

[dblaikie]

llvm/unittests/ADT/STLForwardCompatTest.cpp

48–52

I wouldn't change the type to force a different formatting - I think clang-format has some comment you can use to disable its formatting? Or you can add an empty comment to force a line break.

using STLForwardCompatRemoveCVRefTestTypes = ::testing::Types<
    // clang-format off
    std::pair<int, int>,
    std::pair<int &, int>,  
    std::pair<const int, int>,
    std::pair<volatile int, int>,
    std::pair<const volatile int &, int>,
    std::pair<int *, int *>,
    std::pair<int *const, int *>,
    std::pair<const int *, const int *>,
    std::pair<int *&, int *>
    // clang-format on
    >;

[scott.linder]

llvm/unittests/ADT/STLForwardCompatTest.cpp

48–52

Ah, I wasn't aware that was possible, thank you!

llvm/include/llvm/ADT/Any.h

 };
 
 template <typename T> const char Any::TypeId<T>::Id = 0;
 
 
 template <typename T> bool any_isa(const Any &Value) {
   if (!Value.Storage)
     return false;
-  return Value.Storage->id() ==
-         &Any::TypeId<std::remove_cv_t<std::remove_reference_t<T>>>::Id;
+  return Value.Storage->id() == &Any::TypeId<remove_cvref_t<T>>::Id;
 }
 
 template <class T> T any_cast(const Any &Value) {
-  return static_cast<T>(
-      *any_cast<std::remove_cv_t<std::remove_reference_t<T>>>(&Value));
+  return static_cast<T>(*any_cast<remove_cvref_t<T>>(&Value));
 }
 
 template <class T> T any_cast(Any &Value) {
-  return static_cast<T>(
-      *any_cast<std::remove_cv_t<std::remove_reference_t<T>>>(&Value));
+  return static_cast<T>(*any_cast<remove_cvref_t<T>>(&Value));
 }
 
 template <class T> T any_cast(Any &&Value) {
-  return static_cast<T>(std::move(
-      *any_cast<std::remove_cv_t<std::remove_reference_t<T>>>(&Value)));
+  return static_cast<T>(std::move(*any_cast<remove_cvref_t<T>>(&Value)));
 }
 
 template <class T> const T *any_cast(const Any *Value) {
-  using U = std::remove_cv_t<std::remove_reference_t<T>>;
+  using U = remove_cvref_t<T>;
   assert(Value && any_isa<T>(*Value) && "Bad any cast!");
   if (!Value || !any_isa<U>(*Value))
     return nullptr;
   return &static_cast<Any::StorageImpl<U> &>(*Value->Storage).Value;
 }
 
 template <class T> T *any_cast(Any *Value) {
   using U = std::decay_t<T>;

llvm/include/llvm/ADT/FunctionExtras.h

 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_FUNCTIONEXTRAS_H
 #define LLVM_ADT_FUNCTIONEXTRAS_H
 
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/PointerUnion.h"
+#include "llvm/ADT/STLForwardCompat.h"
 #include "llvm/Support/MemAlloc.h"
 #include "llvm/Support/type_traits.h"
 #include <memory>
 #include <type_traits>
 
 namespace llvm {
 
 /// unique_function is a type-erasing functor similar to std::function.

 
 namespace detail {
 
 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<
-    std::remove_cv_t<std::remove_reference_t<CallableT>>, ThisT>::value>;
+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<std::is_void<Ret>::value ||
                      std::is_convertible<decltype(std::declval<CallableT>()(
                                              std::declval<Params>()...)),
                                          Ret>::value>;
 
 template <typename ReturnT, typename... ParamTs> class UniqueFunctionBase {

llvm/include/llvm/ADT/STLExtras.h

 public:
   function_ref() = default;
   function_ref(std::nullptr_t) {}
 
   template <typename Callable>
   function_ref(
       Callable &&callable,
       // This is not the copy-constructor.
-      std::enable_if_t<
-          !std::is_same<std::remove_cv_t<std::remove_reference_t<Callable>>,
+      std::enable_if_t<!std::is_same<remove_cvref_t<Callable>,
                                      function_ref>::value> * = nullptr,
       // Functor must be callable and return a suitable type.
       std::enable_if_t<std::is_void<Ret>::value ||
                        std::is_convertible<decltype(std::declval<Callable>()(
                                                std::declval<Params>()...)),
                                            Ret>::value> * = nullptr)
       : callback(callback_fn<typename std::remove_reference<Callable>::type>),
         callable(reinterpret_cast<intptr_t>(&callable)) {}
 

llvm/include/llvm/ADT/STLForwardCompat.h

 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 {};
 
+//===----------------------------------------------------------------------===//
+//     Features from C++20
+//===----------------------------------------------------------------------===//
+
+template <typename T>
+struct remove_cvref // NOLINT(readability-identifier-naming)
+{
+  using type = std::remove_cv_t<std::remove_reference_t<T>>;
+};
+
+template <typename T>
+using remove_cvref_t // NOLINT(readability-identifier-naming)
+    = typename llvm::remove_cvref<T>::type;
+
 } // namespace llvm
 
 #endif // LLVM_ADT_STLFORWARDCOMPAT_H

llvm/unittests/ADT/STLForwardCompatTest.cpp

TEST(STLForwardCompatTest, DisjunctionTest) {
   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 {};
+
+using STLForwardCompatRemoveCVRefTestTypes = ::testing::Types<
+    // clang-format off
+    std::pair<int, int>,
+    std::pair<int &, int>,
+    std::pair<const int, int>,
+    std::pair<volatile int, int>,
+    std::pair<const volatile int &, int>,
+    std::pair<int *, int *>,
+    std::pair<int *const, int *>,
+    std::pair<const int *, const int *>,
+    std::pair<int *&, int *>
+    // clang-format on
+    >;
+
+TYPED_TEST_CASE(STLForwardCompatRemoveCVRefTest,
+                STLForwardCompatRemoveCVRefTestTypes);
+
+TYPED_TEST(STLForwardCompatRemoveCVRefTest, RemoveCVRef) {
+  using From = typename TypeParam::first_type;
+  using To = typename TypeParam::second_type;
+  EXPECT_TRUE(
+      (std::is_same<typename llvm::remove_cvref<From>::type, To>::value));
+}
+
+TYPED_TEST(STLForwardCompatRemoveCVRefTest, RemoveCVRefT) {
+  using From = typename TypeParam::first_type;
+  EXPECT_TRUE((std::is_same<typename llvm::remove_cvref<From>::type,
+                            llvm::remove_cvref_t<From>>::value));
+}
+
 } // namespace