Replace std::foo with std::foo_t in LLVM.

[jlebar]

Summary

This patch is replacements missed in my last change doing this across LLVM.

No functional change, although I think there was a missing typename
in struct conjunction that is now fixed.

[bkramer]

looks good

[jlebar]

Thank you for the reviews!

[jlebar]

Submitted as a4384c756bd8a8190510. I'm working from my wife's machine and accidentally submitted with her name instead of mine. Oops. :)

llvm/include/llvm/ADT/DenseMap.h

 class DenseMapIterator : DebugEpochBase::HandleBase {
   friend class DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, true>;
   friend class DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, false>;
 
   using ConstIterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, true>;
 
 public:
   using difference_type = ptrdiff_t;
-  using value_type =
-      typename std::conditional<IsConst, const Bucket, Bucket>::type;
+  using value_type = std::conditional_t<IsConst, const Bucket, Bucket>;
   using pointer = value_type *;
   using reference = value_type &;
   using iterator_category = std::forward_iterator_tag;
 
 private:
   pointer Ptr = nullptr;
   pointer End = nullptr;
 

llvm/include/llvm/ADT/FunctionExtras.h

class unique_function<ReturnT(ParamTs...)> {
   // and all other types to l-value reference types. We use this to compute the
   // types used in our erased call utility to minimize copies and moves unless
   // doing so would force things unnecessarily into memory.
   //
   // The heuristic used is related to common ABI register passing conventions.
   // It doesn't have to be exact though, and in one way it is more strict
   // because we want to still be able to observe either moves *or* copies.
   template <typename T>
-  using AdjustedParamT = typename std::conditional<
-      !std::is_reference<T>::value &&
+  using AdjustedParamT =
+      std::conditional_t<!std::is_reference<T>::value &&
                              llvm::is_trivially_copy_constructible<T>::value &&
                              llvm::is_trivially_move_constructible<T>::value &&
                              IsSizeLessThanThresholdT<T>::value,
-      T, T &>::type;
+                         T, T &>;
 
   // The type of the erased function pointer we use as a callback to dispatch to
   // the stored callable when it is trivial to move and destroy.
   using CallPtrT = ReturnT (*)(void *CallableAddr,
                                AdjustedParamT<ParamTs>... Params);
   using MovePtrT = void (*)(void *LHSCallableAddr, void *RHSCallableAddr);
   using DestroyPtrT = void (*)(void *CallableAddr);
 
struct OutOfLineStorageT {
       size_t Alignment;
     } OutOfLineStorage;
     static_assert(
         sizeof(OutOfLineStorageT) <= InlineStorageSize,
         "Should always use all of the out-of-line storage for inline storage!");
 
     // For in-line storage, we just provide an aligned character buffer. We
     // provide three pointers worth of storage here.
-    typename std::aligned_storage<InlineStorageSize, alignof(void *)>::type
-        InlineStorage;
+    std::aligned_storage_t<InlineStorageSize, alignof(void *)> InlineStorage;
   } StorageUnion;
 
   // A compressed pointer to either our dispatching callback or our table of
   // dispatching callbacks and the flag for whether the callable itself is
   // stored inline or not.
   PointerIntPair<CallbackPointerUnionT, 1, bool> CallbackAndInlineFlag;
 
   bool isInlineStorage() const { return CallbackAndInlineFlag.getInt(); }

llvm/include/llvm/ADT/ImmutableList.h

public:
   public:
     iterator() = default;
     iterator(ImmutableList l) : L(l.getInternalPointer()) {}
 
     iterator& operator++() { L = L->getTail(); return *this; }
     bool operator==(const iterator& I) const { return L == I.L; }
     bool operator!=(const iterator& I) const { return L != I.L; }
     const value_type& operator*() const { return L->getHead(); }
-    const typename std::remove_reference<value_type>::type* operator->() const {
+    const std::remove_reference_t<value_type> *operator->() const {
       return &L->getHead();
     }
 
     ImmutableList getList() const { return L; }
   };
 
   /// begin - Returns an iterator referring to the head of the list, or
   ///  an iterator denoting the end of the list if the list is empty.

llvm/include/llvm/ADT/STLExtras.h

 
 template <typename T>
 struct negation : std::integral_constant<bool, !bool(T::value)> {};
 
 template <typename...> struct conjunction : 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 {};
+    : std::conditional_t<bool(B1::value), conjunction<Bn...>, B1> {};
 
 template <typename T> struct make_const_ptr {
-  using type =
-      typename std::add_pointer<typename std::add_const<T>::type>::type;
+  using type = std::add_pointer_t<std::add_const_t<T>>;
 };
 
 template <typename T> struct make_const_ref {
-  using type = typename std::add_lvalue_reference<
-      typename std::add_const<T>::type>::type;
+  using type = std::add_lvalue_reference_t<std::add_const_t<T>>;
 };
 
 //===----------------------------------------------------------------------===//
 //     Extra additions to <functional>
 //===----------------------------------------------------------------------===//
 
 template <class Ty> struct identity {
   using argument_type = Ty;

 public:
   function_ref() = default;
   function_ref(std::nullptr_t) {}
 
   template <typename Callable>
   function_ref(Callable &&callable,
                std::enable_if_t<!std::is_same<std::remove_reference_t<Callable>,
                                               function_ref>::value> * = nullptr)
-      : callback(callback_fn<typename std::remove_reference<Callable>::type>),
+      : callback(callback_fn<std::remove_reference_t<Callable>>),
         callable(reinterpret_cast<intptr_t>(&callable)) {}
 
   Ret operator()(Params ...params) const {
     return callback(callable, std::forward<Params>(params)...);
   }
 
   operator bool() const { return callback; }
 };
return make_range(std::next(adl_begin(RangeOrContainer), N),
                     adl_end(RangeOrContainer));
 }
 
 // mapped_iterator - This is a simple iterator adapter that causes a function to
 // be applied whenever operator* is invoked on the iterator.
 
 template <typename ItTy, typename FuncTy,
           typename FuncReturnTy =
               decltype(std::declval<FuncTy>()(*std::declval<ItTy>()))>
 class mapped_iterator
     : public iterator_adaptor_base<
-             mapped_iterator<ItTy, FuncTy>, ItTy,
-             typename std::iterator_traits<ItTy>::iterator_category,
-             typename std::remove_reference<FuncReturnTy>::type> {
+          std::remove_reference_t<FuncReturnTy>> {
 public:
   mapped_iterator(ItTy U, FuncTy F)
     : mapped_iterator::iterator_adaptor_base(std::move(U)), F(std::move(F)) {}
 
   ItTy getCurrent() { return this->I; }
 
   FuncReturnTy operator*() { return F(*this->I); }
 
template <typename Ty> class has_rbegin_impl {
   static no& test(...);
 
 public:
   static const bool value = sizeof(test<Ty>(nullptr)) == sizeof(yes);
 };
 
 /// Metafunction to determine if T& or T has a member called rbegin().
 template <typename Ty>
-struct has_rbegin : has_rbegin_impl<typename std::remove_reference<Ty>::type> {
-};
+struct has_rbegin : has_rbegin_impl<std::remove_reference_t<Ty>> {};
 
 // Returns an iterator_range over the given container which iterates in reverse.
 // Note that the container must have rbegin()/rend() methods for this to work.
 template <typename ContainerTy>
 auto reverse(ContainerTy &&C,
              std::enable_if_t<has_rbegin<ContainerTy>::value> * = nullptr) {
   return make_range(C.rbegin(), C.rend());
 }

 /// Note: filter_iterator_base implements support for forward iteration.
 /// filter_iterator_impl exists to provide support for bidirectional iteration,
 /// conditional on whether the wrapped iterator supports it.
 template <typename WrappedIteratorT, typename PredicateT, typename IterTag>
 class filter_iterator_base
     : public iterator_adaptor_base<
           filter_iterator_base<WrappedIteratorT, PredicateT, IterTag>,
           WrappedIteratorT,
-          typename std::common_type<
-              IterTag, typename std::iterator_traits<
-                           WrappedIteratorT>::iterator_category>::type> {
+          std::common_type_t<IterTag,
+                             typename std::iterator_traits<
+                                 WrappedIteratorT>::iterator_category>> {
   using BaseT = iterator_adaptor_base<
       filter_iterator_base<WrappedIteratorT, PredicateT, IterTag>,
       WrappedIteratorT,
-      typename std::common_type<
-          IterTag, typename std::iterator_traits<
-                       WrappedIteratorT>::iterator_category>::type>;
+      std::common_type_t<IterTag, typename std::iterator_traits<
+                                      WrappedIteratorT>::iterator_category>>;
 
 protected:
   WrappedIteratorT End;
   PredicateT Pred;
 
   void findNextValid() {
     while (this->I != End && !Pred(*this->I))
       BaseT::operator++();

 // We have to alias this since inlining the actual type at the usage site
 // in the parameter list of iterator_facade_base<> below ICEs MSVC 2017.
 template<typename... Iters> struct ZipTupleType {
   using type = std::tuple<decltype(*declval<Iters>())...>;
 };
 
 template <typename ZipType, typename... Iters>
 using zip_traits = iterator_facade_base<
-    ZipType, typename std::common_type<std::bidirectional_iterator_tag,
-                                       typename std::iterator_traits<
-                                           Iters>::iterator_category...>::type,
+    ZipType,
+    std::common_type_t<
+        std::bidirectional_iterator_tag,
+        typename std::iterator_traits<Iters>::iterator_category...>,
     // ^ TODO: Implement random access methods.
     typename ZipTupleType<Iters...>::type,
     typename std::iterator_traits<typename std::tuple_element<
         0, std::tuple<Iters...>>::type>::difference_type,
     // ^ FIXME: This follows boost::make_zip_iterator's assumption that all
     // inner iterators have the same difference_type. It would fail if, for
     // instance, the second field's difference_type were non-numeric while the
     // first is.

 static auto deref_or_none(const Iter &I, const Iter &End) -> llvm::Optional<
     std::remove_const_t<std::remove_reference_t<decltype(*I)>>> {
   if (I == End)
     return None;
   return *I;
 }
 
 template <typename Iter> struct ZipLongestItemType {
-  using type =
-      llvm::Optional<typename std::remove_const<typename std::remove_reference<
-          decltype(*std::declval<Iter>())>::type>::type>;
+  using type = llvm::Optional<std::remove_const_t<
+      std::remove_reference_t<decltype(*std::declval<Iter>())>>>;
 };
 
 template <typename... Iters> struct ZipLongestTupleType {
   using type = std::tuple<typename ZipLongestItemType<Iters>::type...>;
 };
 
 template <typename... Iters>
 class zip_longest_iterator
     : public iterator_facade_base<
           zip_longest_iterator<Iters...>,
-          typename std::common_type<
+          std::common_type_t<
               std::forward_iterator_tag,
-              typename std::iterator_traits<Iters>::iterator_category...>::type,
+              typename std::iterator_traits<Iters>::iterator_category...>,
           typename ZipLongestTupleType<Iters...>::type,
-          typename std::iterator_traits<typename std::tuple_element<
-              0, std::tuple<Iters...>>::type>::difference_type,
+          typename std::iterator_traits<
+              std::tuple_element_t<0, std::tuple<Iters...>>>::difference_type,
           typename ZipLongestTupleType<Iters...>::type *,
           typename ZipLongestTupleType<Iters...>::type> {
 public:
   using value_type = typename ZipLongestTupleType<Iters...>::type;
 
 private:
   std::tuple<Iters...> iterators;
   std::tuple<Iters...> end_iterators;

 
 } // end namespace detail
 
 /// Given an input tuple (a1, a2, ..., an), pass the arguments of the
 /// tuple variadically to f as if by calling f(a1, a2, ..., an) and
 /// return the result.
 template <typename F, typename Tuple>
 decltype(auto) apply_tuple(F &&f, Tuple &&t) {
-  using Indices = std::make_index_sequence<
-      std::tuple_size<typename std::decay<Tuple>::type>::value>;
+  using Indices =
+      std::make_index_sequence<std::tuple_size<std::decay_t<Tuple>>::value>;
 
   return detail::apply_tuple_impl(std::forward<F>(f), std::forward<Tuple>(t),
                                   Indices{});
 }
 
 /// Return true if the sequence [Begin, End) has exactly N items. Runs in O(N)
 /// time. Not meant for use with random-access iterators.
 template <typename IterTy>

llvm/include/llvm/ADT/ScopeExit.h

 } // end namespace detail
 
 // Keeps the callable object that is passed in, and execute it at the
 // destruction of the returned object (usually at the scope exit where the
 // returned object is kept).
 //
 // Interface is specified by p0052r2.
 template <typename Callable>
-LLVM_NODISCARD detail::scope_exit<typename std::decay<Callable>::type>
+LLVM_NODISCARD detail::scope_exit<std::decay_t<Callable>>
 make_scope_exit(Callable &&F) {
-  return detail::scope_exit<typename std::decay<Callable>::type>(
-      std::forward<Callable>(F));
+  return detail::scope_exit<std::decay_t<Callable>>(std::forward<Callable>(F));
 }
 
 } // end namespace llvm
 
 #endif

llvm/include/llvm/ADT/SmallVector.h

static void uninitialized_copy(It1 I, It1 E, It2 Dest) {
     std::uninitialized_copy(I, E, Dest);
   }
 
   /// Copy the range [I, E) onto the uninitialized memory
   /// starting with "Dest", constructing elements into it as needed.
   template <typename T1, typename T2>
   static void uninitialized_copy(
       T1 *I, T1 *E, T2 *Dest,
-      std::enable_if_t<std::is_same<typename std::remove_const<T1>::type,
-                                    T2>::value> * = nullptr) {
+      std::enable_if_t<std::is_same<std::remove_const_t<T1>, T2>::value> * =
+          nullptr) {
     // Use memcpy for PODs iterated by pointers (which includes SmallVector
     // iterators): std::uninitialized_copy optimizes to memmove, but we can
     // use memcpy here. Note that I and E are iterators and thus might be
     // invalid for memcpy if they are equal.
     if (I != E)
       memcpy(reinterpret_cast<void *>(Dest), I, (E - I) * sizeof(T));
   }
 

 inline size_t capacity_in_bytes(const SmallVector<T, N> &X) {
   return X.capacity_in_bytes();
 }
 
 /// Given a range of type R, iterate the entire range and return a
 /// SmallVector with elements of the vector.  This is useful, for example,
 /// when you want to iterate a range and then sort the results.
 template <unsigned Size, typename R>
-SmallVector<typename std::remove_const<typename std::remove_reference<
-                decltype(*std::begin(std::declval<R &>()))>::type>::type,
+SmallVector<std::remove_const_t<std::remove_reference_t<
+                decltype(*std::begin(std::declval<R &>()))>>,
             Size>
 to_vector(R &&Range) {
   return {std::begin(Range), std::end(Range)};
 }
 
 } // end namespace llvm
 
 namespace std {