Use std::foo_t rather than std::foo in clang.

[jlebar]

Summary

No functional change.

[bkramer]

lg

clang/include/clang/AST/ASTTypeTraits.h

private:
   /// pointers and thus need to be stored by value.
   llvm::AlignedCharArrayUnion<const void *, TemplateArgument,
                               NestedNameSpecifierLoc, QualType,
                               TypeLoc> Storage;
 };
 
 template <typename T>
 struct DynTypedNode::BaseConverter<
-    T, typename std::enable_if<std::is_base_of<Decl, T>::value>::type>
+    T, std::enable_if_t<std::is_base_of<Decl, T>::value>>
     : public DynCastPtrConverter<T, Decl> {};
 
 template <typename T>
 struct DynTypedNode::BaseConverter<
-    T, typename std::enable_if<std::is_base_of<Stmt, T>::value>::type>
+    T, std::enable_if_t<std::is_base_of<Stmt, T>::value>>
     : public DynCastPtrConverter<T, Stmt> {};
 
 template <typename T>
 struct DynTypedNode::BaseConverter<
-    T, typename std::enable_if<std::is_base_of<Type, T>::value>::type>
+    T, std::enable_if_t<std::is_base_of<Type, T>::value>>
     : public DynCastPtrConverter<T, Type> {};
 
 template <typename T>
 struct DynTypedNode::BaseConverter<
-    T, typename std::enable_if<std::is_base_of<OMPClause, T>::value>::type>
+    T, std::enable_if_t<std::is_base_of<OMPClause, T>::value>>
     : public DynCastPtrConverter<T, OMPClause> {};
 
 template <>
 struct DynTypedNode::BaseConverter<
     NestedNameSpecifier, void> : public PtrConverter<NestedNameSpecifier> {};
 
 template <>
 struct DynTypedNode::BaseConverter<

clang/include/clang/AST/CanonicalType.h

 public:
   /// Constructs a NULL canonical type.
   CanQual() = default;
 
   /// Converting constructor that permits implicit upcasting of
   /// canonical type pointers.
   template <typename U>
   CanQual(const CanQual<U> &Other,
-          typename std::enable_if<std::is_base_of<T, U>::value, int>::type = 0);
+          std::enable_if_t<std::is_base_of<T, U>::value, int> = 0);
 
   /// Retrieve the underlying type pointer, which refers to a
   /// canonical type.
   ///
   /// The underlying pointer must not be nullptr.
   const T *getTypePtr() const { return cast<T>(Stored.getTypePtr()); }
 
   /// Retrieve the underlying type pointer, which refers to a

clang/include/clang/AST/DataCollection.h

void addDataToConsumer(T &DataConsumer, llvm::StringRef Str) {
   DataConsumer.update(Str);
 }
 
 template <class T> void addDataToConsumer(T &DataConsumer, const QualType &QT) {
   addDataToConsumer(DataConsumer, QT.getAsString());
 }
 
 template <class T, class Type>
-typename std::enable_if<
-    std::is_integral<Type>::value || std::is_enum<Type>::value ||
+std::enable_if_t<std::is_integral<Type>::value || std::is_enum<Type>::value ||
                  std::is_convertible<Type, size_t>::value // for llvm::hash_code
-    >::type
+                 >
 addDataToConsumer(T &DataConsumer, Type Data) {
   DataConsumer.update(StringRef(reinterpret_cast<char *>(&Data), sizeof(Data)));
 }
 
 } // end namespace data_collection
 } // end namespace clang
 
 #endif // LLVM_CLANG_AST_DATACOLLECTION_H

clang/include/clang/AST/Expr.h

class GenericSelectionExpr final
 
   template <bool Const> class AssociationIteratorTy;
   /// Bundle together an association expression and its TypeSourceInfo.
   /// The Const template parameter is for the const and non-const versions
   /// of AssociationTy.
   template <bool Const> class AssociationTy {
     friend class GenericSelectionExpr;
     template <bool OtherConst> friend class AssociationIteratorTy;
-    using ExprPtrTy =
-        typename std::conditional<Const, const Expr *, Expr *>::type;
-    using TSIPtrTy = typename std::conditional<Const, const TypeSourceInfo *,
-                                               TypeSourceInfo *>::type;
+    using ExprPtrTy = std::conditional_t<Const, const Expr *, Expr *>;
+    using TSIPtrTy =
+        std::conditional_t<Const, const TypeSourceInfo *, TypeSourceInfo *>;
     ExprPtrTy E;
     TSIPtrTy TSI;
     bool Selected;
     AssociationTy(ExprPtrTy E, TSIPtrTy TSI, bool Selected)
         : E(E), TSI(TSI), Selected(Selected) {}
 
   public:
     ExprPtrTy getAssociationExpr() const { return E; }
class AssociationIteratorTy
     // An alternative design approach was discussed during review;
     // store an Association object inside the iterator, and return a reference
     // to it when dereferenced. This idea was discarded beacuse of nasty
     // lifetime issues:
     //    AssociationIterator It = ...;
     //    const Association &Assoc = *It++; // Oops, Assoc is dangling.
     using BaseTy = typename AssociationIteratorTy::iterator_facade_base;
     using StmtPtrPtrTy =
-        typename std::conditional<Const, const Stmt *const *, Stmt **>::type;
-    using TSIPtrPtrTy =
-        typename std::conditional<Const, const TypeSourceInfo *const *,
-                                  TypeSourceInfo **>::type;
+        std::conditional_t<Const, const Stmt *const *, Stmt **>;
+    using TSIPtrPtrTy = std::conditional_t<Const, const TypeSourceInfo *const *,
+                                           TypeSourceInfo **>;
     StmtPtrPtrTy E; // = nullptr; FIXME: Once support for gcc 4.8 is dropped.
     TSIPtrPtrTy TSI; // Kept in sync with E.
     unsigned Offset = 0, SelectedOffset = 0;
     AssociationIteratorTy(StmtPtrPtrTy E, TSIPtrPtrTy TSI, unsigned Offset,
                           unsigned SelectedOffset)
         : E(E), TSI(TSI), Offset(Offset), SelectedOffset(SelectedOffset) {}
 
   public:

clang/include/clang/AST/OpenMPClause.h

public:
   }
 };
 
 /// This class implements a simple visitor for OMPClause
 /// subclasses.
 template<class ImplClass, template <typename> class Ptr, typename RetTy>
 class OMPClauseVisitorBase {
 public:
-#define PTR(CLASS) typename Ptr<CLASS>::type
+#define PTR(CLASS) Ptr<CLASS>
 #define DISPATCH(CLASS) \
   return static_cast<ImplClass*>(this)->Visit##CLASS(static_cast<PTR(CLASS)>(S))
 
 #define OPENMP_CLAUSE(Name, Class)                              \
   RetTy Visit ## Class (PTR(Class) S) { DISPATCH(Class); }
 #include "clang/Basic/OpenMPKinds.def"
 
   RetTy Visit(PTR(OMPClause) S) {
     // Top switch clause: visit each OMPClause.
     switch (S->getClauseKind()) {
     default: llvm_unreachable("Unknown clause kind!");
 #define OPENMP_CLAUSE(Name, Class)                              \
     case OMPC_ ## Name : return Visit ## Class(static_cast<PTR(Class)>(S));
 #include "clang/Basic/OpenMPKinds.def"
     }
   }
   // Base case, ignore it. :)
   RetTy VisitOMPClause(PTR(OMPClause) Node) { return RetTy(); }
 #undef PTR
 #undef DISPATCH
 };
 
-template <typename T>
-using const_ptr = typename std::add_pointer<typename std::add_const<T>::type>;
+template <typename T> using const_ptr = std::add_pointer_t<std::add_const_t<T>>;
 
-template<class ImplClass, typename RetTy = void>
-class OMPClauseVisitor :
-      public OMPClauseVisitorBase <ImplClass, std::add_pointer, RetTy> {};
+template <class ImplClass, typename RetTy = void>
+class OMPClauseVisitor
+    : public OMPClauseVisitorBase<ImplClass, std::add_pointer_t, RetTy> {};
 template<class ImplClass, typename RetTy = void>
 class ConstOMPClauseVisitor :
       public OMPClauseVisitorBase <ImplClass, const_ptr, RetTy> {};
 
 class OMPClausePrinter final : public OMPClauseVisitor<OMPClausePrinter> {
   raw_ostream &OS;
   const PrintingPolicy &Policy;
 

clang/include/clang/AST/RecursiveASTVisitor.h

private:
   // data recursion queue, pass it on; otherwise, discard it. Note that the
   // first branch of this conditional must compile whether or not the derived
   // class can take a queue, so if we're taking the second arm, make the first
   // arm call our function rather than the derived class version.
 #define TRAVERSE_STMT_BASE(NAME, CLASS, VAR, QUEUE)                            \
   (has_same_member_pointer_type<decltype(                                      \
                                     &RecursiveASTVisitor::Traverse##NAME),     \
                                 decltype(&Derived::Traverse##NAME)>::value     \
-       ? static_cast<typename std::conditional<                                \
+       ? static_cast<std::conditional_t<                                       \
              has_same_member_pointer_type<                                     \
                  decltype(&RecursiveASTVisitor::Traverse##NAME),               \
                  decltype(&Derived::Traverse##NAME)>::value,                   \
-             Derived &, RecursiveASTVisitor &>::type>(*this)                   \
+             Derived &, RecursiveASTVisitor &>>(*this)                         \
              .Traverse##NAME(static_cast<CLASS *>(VAR), QUEUE)                 \
        : getDerived().Traverse##NAME(static_cast<CLASS *>(VAR)))
 
 // Try to traverse the given statement, or enqueue it if we're performing data
 // recursion in the middle of traversing another statement. Can only be called
 // from within a DEF_TRAVERSE_STMT body or similar context.
 #define TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S)                                     \
   do {                                                                         \

clang/include/clang/ASTMatchers/ASTMatchersInternal.h

public:
   explicit Matcher(MatcherInterface<T> *Implementation)
       : Implementation(Implementation) {}
 
   /// Implicitly converts \c Other to a Matcher<T>.
   ///
   /// Requires \c T to be derived from \c From.
   template <typename From>
   Matcher(const Matcher<From> &Other,
-          typename std::enable_if<std::is_base_of<From, T>::value &&
-                               !std::is_same<From, T>::value>::type * = nullptr)
+          std::enable_if_t<std::is_base_of<From, T>::value &&
+                           !std::is_same<From, T>::value> * = nullptr)
       : Implementation(restrictMatcher(Other.Implementation)) {
     assert(Implementation.getSupportedKind().isSame(
         ast_type_traits::ASTNodeKind::getFromNodeKind<T>()));
   }
 
   /// Implicitly converts \c Matcher<Type> to \c Matcher<QualType>.
   ///
   /// The resulting matcher is not strict, i.e. ignores qualifiers.
   template <typename TypeT>
   Matcher(const Matcher<TypeT> &Other,
-          typename std::enable_if<
-            std::is_same<T, QualType>::value &&
-            std::is_same<TypeT, Type>::value>::type* = nullptr)
+          std::enable_if_t<std::is_same<T, QualType>::value &&
+                           std::is_same<TypeT, Type>::value> * = nullptr)
       : Implementation(new TypeToQualType<TypeT>(Other)) {}
 
   /// Convert \c this into a \c Matcher<T> by applying dyn_cast<> to the
   /// argument.
   /// \c To must be a base class of \c T.
   template <typename To>
   Matcher<To> dynCastTo() const {
     static_assert(std::is_base_of<To, T>::value, "Invalid dynCast call.");

clang/include/clang/Analysis/CFG.h

class CFGBlock {
   /// A convenience class for comparing CFGElements, since methods of CFGBlock
   /// like operator[] return CFGElements by value. This is practically a wrapper
   /// around a (CFGBlock, Index) pair.
   template <bool IsConst> class ElementRefImpl {
 
     template <bool IsOtherConst> friend class ElementRefImpl;
 
     using CFGBlockPtr =
-        typename std::conditional<IsConst, const CFGBlock *, CFGBlock *>::type;
+        std::conditional_t<IsConst, const CFGBlock *, CFGBlock *>;
 
-    using CFGElementPtr = typename std::conditional<IsConst, const CFGElement *,
-                                                    CFGElement *>::type;
+    using CFGElementPtr =
+        std::conditional_t<IsConst, const CFGElement *, CFGElement *>;
 
   protected:
     CFGBlockPtr Parent;
     size_t Index;
 
   public:
     ElementRefImpl(CFGBlockPtr Parent, size_t Index)
         : Parent(Parent), Index(Index) {}
class CFGBlock {
   };
 
   template <bool IsReverse, bool IsConst> class ElementRefIterator {
 
     template <bool IsOtherReverse, bool IsOtherConst>
     friend class ElementRefIterator;
 
     using CFGBlockRef =
-        typename std::conditional<IsConst, const CFGBlock *, CFGBlock *>::type;
+        std::conditional_t<IsConst, const CFGBlock *, CFGBlock *>;
 
-    using UnderlayingIteratorTy = typename std::conditional<
+    using UnderlayingIteratorTy = std::conditional_t<
         IsConst,
-        typename std::conditional<IsReverse,
-                                  ElementList::const_reverse_iterator,
-                                  ElementList::const_iterator>::type,
-        typename std::conditional<IsReverse, ElementList::reverse_iterator,
-                                  ElementList::iterator>::type>::type;
+        std::conditional_t<IsReverse, ElementList::const_reverse_iterator,
+                           ElementList::const_iterator>,
+        std::conditional_t<IsReverse, ElementList::reverse_iterator,
+                           ElementList::iterator>>;
 
     using IteratorTraits = typename std::iterator_traits<UnderlayingIteratorTy>;
     using ElementRef = typename CFGBlock::ElementRefImpl<IsConst>;
 
   public:
     using difference_type = typename IteratorTraits::difference_type;
     using value_type = ElementRef;
     using pointer = ElementRef *;

clang/include/clang/Basic/Diagnostic.h

 inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB, int I) {
   DB.AddTaggedVal(I, DiagnosticsEngine::ak_sint);
   return DB;
 }
 
 // We use enable_if here to prevent that this overload is selected for
 // pointers or other arguments that are implicitly convertible to bool.
 template <typename T>
-inline
-typename std::enable_if<std::is_same<T, bool>::value,
-                        const DiagnosticBuilder &>::type
+inline std::enable_if_t<std::is_same<T, bool>::value, const DiagnosticBuilder &>
 operator<<(const DiagnosticBuilder &DB, T I) {
   DB.AddTaggedVal(I, DiagnosticsEngine::ak_sint);
   return DB;
 }
 
 inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
                                            unsigned I) {
   DB.AddTaggedVal(I, DiagnosticsEngine::ak_uint);
inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
   return DB;
 }
 
 // Adds a DeclContext to the diagnostic. The enable_if template magic is here
 // so that we only match those arguments that are (statically) DeclContexts;
 // other arguments that derive from DeclContext (e.g., RecordDecls) will not
 // match.
 template <typename T>
-inline typename std::enable_if<
-    std::is_same<typename std::remove_const<T>::type, DeclContext>::value,
-    const DiagnosticBuilder &>::type
+inline std::enable_if_t<
+    std::is_same<std::remove_const_t<T>, DeclContext>::value,
+    const DiagnosticBuilder &>
 operator<<(const DiagnosticBuilder &DB, T *DC) {
   DB.AddTaggedVal(reinterpret_cast<intptr_t>(DC),
                   DiagnosticsEngine::ak_declcontext);
   return DB;
 }
 
 inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
                                            SourceRange R) {

clang/include/clang/Basic/PartialDiagnostic.h

PD.AddTaggedVal(reinterpret_cast<intptr_t>(II),
                     DiagnosticsEngine::ak_identifierinfo);
     return PD;
   }
 
   // Adds a DeclContext to the diagnostic. The enable_if template magic is here
   // so that we only match those arguments that are (statically) DeclContexts;
   // other arguments that derive from DeclContext (e.g., RecordDecls) will not
   // match.
-  template<typename T>
-  friend inline
-  typename std::enable_if<std::is_same<T, DeclContext>::value,
-                          const PartialDiagnostic &>::type
+  template <typename T>
+  friend inline std::enable_if_t<std::is_same<T, DeclContext>::value,
+                                 const PartialDiagnostic &>
   operator<<(const PartialDiagnostic &PD, T *DC) {
     PD.AddTaggedVal(reinterpret_cast<intptr_t>(DC),
                     DiagnosticsEngine::ak_declcontext);
     return PD;
   }
 
   friend inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
                                                     SourceRange R) {

clang/include/clang/Tooling/Refactoring/RefactoringOptions.h

 #include "clang/Tooling/Refactoring/RefactoringOptionVisitor.h"
 #include "llvm/Support/Error.h"
 #include <type_traits>
 
 namespace clang {
 namespace tooling {
 
 /// A refactoring option that stores a value of type \c T.
-template <typename T, typename = typename std::enable_if<
-                          traits::IsValidOptionType<T>::value>::type>
+template <typename T,
+          typename = std::enable_if_t<traits::IsValidOptionType<T>::value>>
 class OptionalRefactoringOption : public RefactoringOption {
 public:
   void passToVisitor(RefactoringOptionVisitor &Visitor) final override {
     Visitor.visit(*this, Value);
   }
 
   bool isRequired() const override { return false; }
 
   using ValueType = Optional<T>;
 
   const ValueType &getValue() const { return Value; }
 
 protected:
   Optional<T> Value;
 };
 
 /// A required refactoring option that stores a value of type \c T.
-template <typename T, typename = typename std::enable_if<
-                          traits::IsValidOptionType<T>::value>::type>
+template <typename T,
+          typename = std::enable_if_t<traits::IsValidOptionType<T>::value>>
 class RequiredRefactoringOption : public OptionalRefactoringOption<T> {
 public:
   using ValueType = T;
 
   const ValueType &getValue() const {
     return *OptionalRefactoringOption<T>::Value;
   }
   bool isRequired() const final override { return true; }
 };
 
 } // end namespace tooling
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLING_REFACTOR_REFACTORING_OPTIONS_H

clang/lib/AST/ASTImporter.cpp

public:
     ExpectedStmt VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E);
     ExpectedStmt VisitCXXNamedCastExpr(CXXNamedCastExpr *E);
     ExpectedStmt VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E);
     ExpectedStmt VisitTypeTraitExpr(TypeTraitExpr *E);
     ExpectedStmt VisitCXXTypeidExpr(CXXTypeidExpr *E);
 
     template<typename IIter, typename OIter>
     Error ImportArrayChecked(IIter Ibegin, IIter Iend, OIter Obegin) {
-      using ItemT = typename std::remove_reference<decltype(*Obegin)>::type;
+      using ItemT = std::remove_reference_t<decltype(*Obegin)>;
       for (; Ibegin != Iend; ++Ibegin, ++Obegin) {
         Expected<ItemT> ToOrErr = import(*Ibegin);
         if (!ToOrErr)
           return ToOrErr.takeError();
         *Obegin = *ToOrErr;
       }
       return Error::success();
     }

clang/lib/AST/Interp/Boolean.h

public:
   Boolean truncate(unsigned TruncBits) const { return *this; }
 
   void print(llvm::raw_ostream &OS) const { OS << (V ? "true" : "false"); }
 
   static Boolean min(unsigned NumBits) { return Boolean(false); }
   static Boolean max(unsigned NumBits) { return Boolean(true); }
 
   template <typename T>
-  static typename std::enable_if<std::is_integral<T>::value, Boolean>::type
-  from(T Value) {
+  static std::enable_if_t<std::is_integral<T>::value, Boolean> from(T Value) {
     return Boolean(Value != 0);
   }
 
   template <unsigned SrcBits, bool SrcSign>
-  static typename std::enable_if<SrcBits != 0, Boolean>::type from(
-      Integral<SrcBits, SrcSign> Value) {
+  static std::enable_if_t<SrcBits != 0, Boolean>
+  from(Integral<SrcBits, SrcSign> Value) {
     return Boolean(!Value.isZero());
   }
 
   template <bool SrcSign>
   static Boolean from(Integral<0, SrcSign> Value) {
     return Boolean(!Value.isZero());
   }
 

clang/lib/AST/Interp/Integral.h

public:
   static Integral min(unsigned NumBits) {
     return Integral(Min);
   }
   static Integral max(unsigned NumBits) {
     return Integral(Max);
   }
 
   template <typename T>
-  static typename std::enable_if<std::is_integral<T>::value, Integral>::type
-  from(T Value) {
+  static std::enable_if_t<std::is_integral<T>::value, Integral> from(T Value) {
     return Integral(Value);
   }
 
   template <unsigned SrcBits, bool SrcSign>
-  static typename std::enable_if<SrcBits != 0, Integral>::type
+  static std::enable_if_t<SrcBits != 0, Integral>
   from(Integral<SrcBits, SrcSign> Value) {
     return Integral(Value.V);
   }
 
   template <bool SrcSign> static Integral from(Integral<0, SrcSign> Value) {
     if (SrcSign)
       return Integral(Value.V.getSExtValue());
     else
public:
   }
 
   static bool mul(Integral A, Integral B, unsigned OpBits, Integral *R) {
     return CheckMulUB(A.V, B.V, R->V);
   }
 
 private:
   template <typename T>
-  static typename std::enable_if<std::is_signed<T>::value, bool>::type
-  CheckAddUB(T A, T B, T &R) {
+  static std::enable_if_t<std::is_signed<T>::value, bool> CheckAddUB(T A, T B,
+                                                                     T &R) {
     return llvm::AddOverflow<T>(A, B, R);
   }
 
   template <typename T>
-  static typename std::enable_if<std::is_unsigned<T>::value, bool>::type
-  CheckAddUB(T A, T B, T &R) {
+  static std::enable_if_t<std::is_unsigned<T>::value, bool> CheckAddUB(T A, T B,
+                                                                       T &R) {
     R = A + B;
     return false;
   }
 
   template <typename T>
-  static typename std::enable_if<std::is_signed<T>::value, bool>::type
-  CheckSubUB(T A, T B, T &R) {
+  static std::enable_if_t<std::is_signed<T>::value, bool> CheckSubUB(T A, T B,
+                                                                     T &R) {
     return llvm::SubOverflow<T>(A, B, R);
   }
 
   template <typename T>
-  static typename std::enable_if<std::is_unsigned<T>::value, bool>::type
-  CheckSubUB(T A, T B, T &R) {
+  static std::enable_if_t<std::is_unsigned<T>::value, bool> CheckSubUB(T A, T B,
+                                                                       T &R) {
     R = A - B;
     return false;
   }
 
   template <typename T>
-  static typename std::enable_if<std::is_signed<T>::value, bool>::type
-  CheckMulUB(T A, T B, T &R) {
+  static std::enable_if_t<std::is_signed<T>::value, bool> CheckMulUB(T A, T B,
+                                                                     T &R) {
     return llvm::MulOverflow<T>(A, B, R);
   }
 
   template <typename T>
-  static typename std::enable_if<std::is_unsigned<T>::value, bool>::type
-  CheckMulUB(T A, T B, T &R) {
+  static std::enable_if_t<std::is_unsigned<T>::value, bool> CheckMulUB(T A, T B,
+                                                                       T &R) {
     R = A * B;
     return false;
   }
 
   template <typename T, T Min, T Max>
-  static typename std::enable_if<std::is_signed<T>::value, bool>::type
+  static std::enable_if_t<std::is_signed<T>::value, bool>
   CheckRange(int64_t V) {
     return Min <= V && V <= Max;
   }
 
   template <typename T, T Min, T Max>
-  static typename std::enable_if<std::is_unsigned<T>::value, bool>::type
+  static std::enable_if_t<std::is_unsigned<T>::value, bool>
   CheckRange(int64_t V) {
     return V >= 0 && static_cast<uint64_t>(V) <= Max;
   }
 };
 
 template <unsigned Bits, bool Signed>
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, Integral<Bits, Signed> I) {
   I.print(OS);
   return OS;
 }
 
 } // namespace interp
 } // namespace clang
 
 #endif

clang/lib/AST/Interp/Source.h

public:
   }
 
 private:
   /// Constructor used by Function to generate pointers.
   CodePtr(const char *Ptr) : Ptr(Ptr) {}
 
   /// Helper to decode a value or a pointer.
   template <typename T>
-  static typename std::enable_if<!std::is_pointer<T>::value, T>::type
+  static std::enable_if_t<!std::is_pointer<T>::value, T>
   ReadHelper(const char *Ptr) {
     using namespace llvm::support;
     return endian::read<T, endianness::native, 1>(Ptr);
   }
 
   template <typename T>
-  static typename std::enable_if<std::is_pointer<T>::value, T>::type
+  static std::enable_if_t<std::is_pointer<T>::value, T>
   ReadHelper(const char *Ptr) {
     using namespace llvm::support;
     auto Punned = endian::read<uintptr_t, endianness::native, 1>(Ptr);
     return reinterpret_cast<T>(Punned);
   }
 
 private:
   friend class Function;

clang/lib/Analysis/ThreadSafety.cpp

 static StringRef ClassifyDiagnostic(const ValueDecl *VD) {
   assert(VD && "No ValueDecl passed");
 
   // The ValueDecl is the declaration of a mutex or role (hopefully).
   return ClassifyDiagnostic(VD->getType());
 }
 
 template <typename AttrTy>
-static typename std::enable_if<!has_arg_iterator_range<AttrTy>::value,
-                               StringRef>::type
+static std::enable_if_t<!has_arg_iterator_range<AttrTy>::value, StringRef>
 ClassifyDiagnostic(const AttrTy *A) {
   if (const ValueDecl *VD = getValueDecl(A->getArg()))
     return ClassifyDiagnostic(VD);
   return "mutex";
 }
 
 template <typename AttrTy>
-static typename std::enable_if<has_arg_iterator_range<AttrTy>::value,
-                               StringRef>::type
+static std::enable_if_t<has_arg_iterator_range<AttrTy>::value, StringRef>
 ClassifyDiagnostic(const AttrTy *A) {
   for (const auto *Arg : A->args()) {
     if (const ValueDecl *VD = getValueDecl(Arg))
       return ClassifyDiagnostic(VD);
   }
   return "mutex";
 }
 

clang/lib/CodeGen/CGOpenMPRuntime.h

static void CallbackFn(intptr_t CodeGen, CodeGenFunction &CGF,
                          PrePostActionTy &Action) {
     return (*reinterpret_cast<Callable *>(CodeGen))(CGF, Action);
   }
 
 public:
   template <typename Callable>
   RegionCodeGenTy(
       Callable &&CodeGen,
-      typename std::enable_if<
-          !std::is_same<typename std::remove_reference<Callable>::type,
-                        RegionCodeGenTy>::value>::type * = nullptr)
+      std::enable_if_t<!std::is_same<std::remove_reference_t<Callable>,
+                                     RegionCodeGenTy>::value> * = nullptr)
       : CodeGen(reinterpret_cast<intptr_t>(&CodeGen)),
-        Callback(CallbackFn<typename std::remove_reference<Callable>::type>),
+        Callback(CallbackFn<std::remove_reference_t<Callable>>),
         PrePostAction(nullptr) {}
   void setAction(PrePostActionTy &Action) const { PrePostAction = &Action; }
   void operator()(CodeGenFunction &CGF) const;
 };
 
 struct OMPTaskDataTy final {
   SmallVector<const Expr *, 4> PrivateVars;
   SmallVector<const Expr *, 4> PrivateCopies;

clang/lib/Sema/SemaDeclAttr.cpp

static bool checkAttributeAtMostNumArgs(Sema &S, const ParsedAttr &AL,
   return checkAttributeNumArgsImpl(S, AL, Num,
                                    diag::err_attribute_too_many_arguments,
                                    std::greater<unsigned>());
 }
 
 /// A helper function to provide Attribute Location for the Attr types
 /// AND the ParsedAttr.
 template <typename AttrInfo>
-static typename std::enable_if<std::is_base_of<Attr, AttrInfo>::value,
-                               SourceLocation>::type
+static std::enable_if_t<std::is_base_of<Attr, AttrInfo>::value, SourceLocation>
 getAttrLoc(const AttrInfo &AL) {
   return AL.getLocation();
 }
 static SourceLocation getAttrLoc(const ParsedAttr &AL) { return AL.getLoc(); }
 
 /// If Expr is a valid integer constant, get the value of the integer
 /// expression and return success or failure. May output an error.
 ///

clang/lib/Sema/SemaTemplateDeduction.cpp

if (S.CheckConstraintSatisfaction(Template, AssociatedConstraints,
     Info.reset(TemplateArgumentList::CreateCopy(S.Context, DeducedArgs));
     return Sema::TDK_ConstraintsNotSatisfied;
   }
   return Sema::TDK_Success;
 }
 
 /// Complete template argument deduction for a partial specialization.
 template <typename T>
-static typename std::enable_if<IsPartialSpecialization<T>::value,
-                               Sema::TemplateDeductionResult>::type
+static std::enable_if_t<IsPartialSpecialization<T>::value,
+                        Sema::TemplateDeductionResult>
 FinishTemplateArgumentDeduction(
     Sema &S, T *Partial, bool IsPartialOrdering,
     const TemplateArgumentList &TemplateArgs,
     SmallVectorImpl<DeducedTemplateArgument> &Deduced,
     TemplateDeductionInfo &Info) {
   // Unevaluated SFINAE context.
   EnterExpressionEvaluationContext Unevaluated(
       S, Sema::ExpressionEvaluationContext::Unevaluated);

clang/lib/StaticAnalyzer/Frontend/CheckerRegistry.cpp

template <class T> struct FullNameLT {
   }
 };
 
 using PackageNameLT = FullNameLT<CheckerRegistry::PackageInfo>;
 using CheckerNameLT = FullNameLT<CheckerRegistry::CheckerInfo>;
 } // end of anonymous namespace
 
 template <class CheckerOrPackageInfoList>
-static
-    typename std::conditional<std::is_const<CheckerOrPackageInfoList>::value,
-                              typename CheckerOrPackageInfoList::const_iterator,
-                              typename CheckerOrPackageInfoList::iterator>::type
-    binaryFind(CheckerOrPackageInfoList &Collection, StringRef FullName) {
+static std::conditional_t<std::is_const<CheckerOrPackageInfoList>::value,
+                          typename CheckerOrPackageInfoList::iterator>
 
   using CheckerOrPackage = typename CheckerOrPackageInfoList::value_type;
   using CheckerOrPackageFullNameLT = FullNameLT<CheckerOrPackage>;
 
   assert(std::is_sorted(Collection.begin(), Collection.end(),
                         CheckerOrPackageFullNameLT{}) &&
          "In order to efficiently gather checkers/packages, this function "
          "expects them to be already sorted!");

clang/lib/Tooling/ASTDiff/ASTDiff.cpp

 class SyntaxTree::Impl {
 public:
   Impl(SyntaxTree *Parent, ASTContext &AST);
   /// Constructs a tree from an AST node.
   Impl(SyntaxTree *Parent, Decl *N, ASTContext &AST);
   Impl(SyntaxTree *Parent, Stmt *N, ASTContext &AST);
   template <class T>
   Impl(SyntaxTree *Parent,
-       typename std::enable_if<std::is_base_of<Stmt, T>::value, T>::type *Node,
+       std::enable_if_t<std::is_base_of<Stmt, T>::value, T> *Node,
        ASTContext &AST)
       : Impl(Parent, dyn_cast<Stmt>(Node), AST) {}
   template <class T>
   Impl(SyntaxTree *Parent,
-       typename std::enable_if<std::is_base_of<Decl, T>::value, T>::type *Node,
+       std::enable_if_t<std::is_base_of<Decl, T>::value, T> *Node,
        ASTContext &AST)
       : Impl(Parent, dyn_cast<Decl>(Node), AST) {}
 
   SyntaxTree *Parent;
   ASTContext &AST;
   PrintingPolicy TypePP;
   /// Nodes in preorder.
   std::vector<Node> Nodes;

clang/unittests/Tooling/ASTSelectionTest.cpp

 
 void checkDeclName(const SelectedASTNode &Node, StringRef Name) {
   const auto *ND = Node.Node.get<NamedDecl>();
   EXPECT_TRUE(!!ND);
   ASSERT_EQ(ND->getName(), Name);
 }
 
 template <typename T>
-const SelectedASTNode &
-checkNode(const SelectedASTNode &StmtNode, SourceSelectionKind SelectionKind,
-          unsigned NumChildren = 0,
-          typename std::enable_if<std::is_base_of<Stmt, T>::value, T>::type
-              *StmtOverloadChecker = nullptr) {
+const SelectedASTNode &checkNode(
+    const SelectedASTNode &StmtNode, SourceSelectionKind SelectionKind,
+    std::enable_if_t<std::is_base_of<Stmt, T>::value, T> *StmtOverloadChecker =
+        nullptr) {
   checkNodeImpl(isa<T>(StmtNode.Node.get<Stmt>()), StmtNode, SelectionKind,
                 NumChildren);
   return StmtNode;
 }
 
 template <typename T>
-const SelectedASTNode &
-checkNode(const SelectedASTNode &DeclNode, SourceSelectionKind SelectionKind,
-          unsigned NumChildren = 0, StringRef Name = "",
-          typename std::enable_if<std::is_base_of<Decl, T>::value, T>::type
-              *DeclOverloadChecker = nullptr) {
+const SelectedASTNode &checkNode(
+    const SelectedASTNode &DeclNode, SourceSelectionKind SelectionKind,
+    std::enable_if_t<std::is_base_of<Decl, T>::value, T> *DeclOverloadChecker =
+        nullptr) {
   checkNodeImpl(isa<T>(DeclNode.Node.get<Decl>()), DeclNode, SelectionKind,
                 NumChildren);
   if (!Name.empty())
     checkDeclName(DeclNode, Name);
   return DeclNode;
 }
 
 struct ForAllChildrenOf {