[clang][NFC] Use c++17 style variable type traits

[njames93]

Summary

This was done as a test for D137302 and it makes sense to push these changes

[shafik]

LGTM

clang/lib/AST/ASTContext.cpp

if (DX == Y)
       return X;
     // If we reach the first decl, then Y is older.
     if (DX->isFirstDecl())
       return Y;
   }
   llvm_unreachable("Corrupt redecls chain");
 }
 
-template <class T,
-          std::enable_if_t<std::is_base_of<Decl, T>::value, bool> = true>
+template <class T, std::enable_if_t<std::is_base_of_v<Decl, T>, bool> = true>
 T *getCommonDecl(T *X, T *Y) {
   return cast_or_null<T>(
       getCommonDecl(const_cast<Decl *>(cast_or_null<Decl>(X)),
                     const_cast<Decl *>(cast_or_null<Decl>(Y))));
 }
 
-template <class T,
-          std::enable_if_t<std::is_base_of<Decl, T>::value, bool> = true>
+template <class T, std::enable_if_t<std::is_base_of_v<Decl, T>, bool> = true>
 T *getCommonDeclChecked(T *X, T *Y) {
   return cast<T>(getCommonDecl(const_cast<Decl *>(cast<Decl>(X)),
                                const_cast<Decl *>(cast<Decl>(Y))));
 }
 
 static TemplateName getCommonTemplateName(ASTContext &Ctx, TemplateName X,
                                           TemplateName Y) {
   if (X.getAsVoidPointer() == Y.getAsVoidPointer())

clang/lib/AST/ASTImporter.cpp

[[nodiscard]] Error importInto(ImportT *&To, ImportT *From) {
         To = cast_or_null<ImportT>(*ToOrErr);
       return ToOrErr.takeError();
     }
 
     // Call the import function of ASTImporter for a baseclass of type `T` and
     // cast the return value to `T`.
     template <typename T>
     auto import(T *From)
-        -> std::conditional_t<std::is_base_of<Type, T>::value,
-                              Expected<const T *>, Expected<T *>> {
+        -> std::conditional_t<std::is_base_of_v<Type, T>, Expected<const T *>,
+                              Expected<T *>> {
       auto ToOrErr = Importer.Import(From);
       if (!ToOrErr)
         return ToOrErr.takeError();
       return cast_or_null<T>(*ToOrErr);
     }
 
     template <typename T>
     auto import(const T *From) {

clang/lib/AST/Comment.cpp

 #define COMMENT(CLASS, PARENT)                                                 \
   static_assert(std::is_trivially_destructible<CLASS>::value,                  \
                 #CLASS " should be trivially destructible!");
 #include "clang/AST/CommentNodes.inc"
 #undef COMMENT
 #undef ABSTRACT_COMMENT
 
 // DeclInfo is also allocated with a BumpPtrAllocator.
-static_assert(std::is_trivially_destructible<DeclInfo>::value,
+static_assert(std::is_trivially_destructible_v<DeclInfo>,
               "DeclInfo should be trivially destructible!");
 
 const char *Comment::getCommentKindName() const {
   switch (getCommentKind()) {
   case NoCommentKind: return "NoCommentKind";
 #define ABSTRACT_COMMENT(COMMENT)
 #define COMMENT(CLASS, PARENT) \
   case CLASS##Kind: \

clang/lib/AST/Decl.cpp

static bool usesTypeVisibility(const NamedDecl *D) {
   return isa<TypeDecl>(D) ||
          isa<ClassTemplateDecl>(D) ||
          isa<ObjCInterfaceDecl>(D);
 }
 
 /// Does the given declaration have member specialization information,
 /// and if so, is it an explicit specialization?
 template <class T>
-static std::enable_if_t<!std::is_base_of<RedeclarableTemplateDecl, T>::value,
-                        bool>
+static std::enable_if_t<!std::is_base_of_v<RedeclarableTemplateDecl, T>, bool>
 isExplicitMemberSpecialization(const T *D) {
   if (const MemberSpecializationInfo *member =
         D->getMemberSpecializationInfo()) {
     return member->isExplicitSpecialization();
   }
   return false;
 }
 

clang/lib/AST/Interp/Disasm.cpp

 #include "clang/AST/DeclCXX.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Format.h"
 
 using namespace clang;
 using namespace clang::interp;
 
 template <typename T> inline T ReadArg(Program &P, CodePtr &OpPC) {
-  if constexpr (std::is_pointer<T>::value) {
+  if constexpr (std::is_pointer_v<T>) {
     uint32_t ID = OpPC.read<uint32_t>();
     return reinterpret_cast<T>(P.getNativePointer(ID));
   } else {
     return OpPC.read<T>();
   }
 }
 
 LLVM_DUMP_METHOD void Function::dump() const { dump(llvm::errs()); }

clang/lib/Analysis/CFG.cpp

private:
   void findConstructionContexts(const ConstructionContextLayer *Layer,
                                 Stmt *Child);
 
   // Scan all arguments of a call expression for a construction context.
   // These sorts of call expressions don't have a common superclass,
   // hence strict duck-typing.
   template <typename CallLikeExpr,
             typename = std::enable_if_t<
-                std::is_base_of<CallExpr, CallLikeExpr>::value ||
-                std::is_base_of<CXXConstructExpr, CallLikeExpr>::value ||
-                std::is_base_of<ObjCMessageExpr, CallLikeExpr>::value>>
+                std::is_base_of_v<CallExpr, CallLikeExpr> ||
+                std::is_base_of_v<CXXConstructExpr, CallLikeExpr> ||
+                std::is_base_of_v<ObjCMessageExpr, CallLikeExpr>>>
   void findConstructionContextsForArguments(CallLikeExpr *E) {
     for (unsigned i = 0, e = E->getNumArgs(); i != e; ++i) {
       Expr *Arg = E->getArg(i);
       if (Arg->getType()->getAsCXXRecordDecl() && !Arg->isGLValue())
         findConstructionContexts(
             ConstructionContextLayer::create(cfg->getBumpVectorContext(),
                                              ConstructionContextItem(E, i)),
             Arg);

clang/lib/Analysis/RetainSummaryManager.cpp

 constexpr static bool isOneOf() {
   return false;
 }
 
 /// Helper function to check whether the class is one of the
 /// rest of varargs.
 template <class T, class P, class... ToCompare>
 constexpr static bool isOneOf() {
-  return std::is_same<T, P>::value || isOneOf<T, ToCompare...>();
+  return std::is_same_v<T, P> || isOneOf<T, ToCompare...>();
 }
 
 namespace {
 
 /// Fake attribute class for RC* attributes.
 struct GeneralizedReturnsRetainedAttr {
   static bool classof(const Attr *A) {
     if (auto AA = dyn_cast<AnnotateAttr>(A))

clang/lib/Basic/SourceLocation.cpp

void PrettyStackTraceLoc::print(raw_ostream &OS) const {
   }
   OS << Message << '\n';
 }
 
 //===----------------------------------------------------------------------===//
 // SourceLocation
 //===----------------------------------------------------------------------===//
 
-static_assert(std::is_trivially_destructible<SourceLocation>::value,
+static_assert(std::is_trivially_destructible_v<SourceLocation>,
               "SourceLocation must be trivially destructible because it is "
               "used in unions");
 
-static_assert(std::is_trivially_destructible<SourceRange>::value,
+static_assert(std::is_trivially_destructible_v<SourceRange>,
               "SourceRange must be trivially destructible because it is "
               "used in unions");
 
 unsigned SourceLocation::getHashValue() const {
   return llvm::DenseMapInfo<UIntTy>::getHashValue(ID);
 }
 
 void llvm::FoldingSetTrait<SourceLocation>::Profile(

clang/lib/Frontend/CompilerInvocation.cpp

 static void denormalizeSimpleFlag(SmallVectorImpl<const char *> &Args,
                                   const char *Spelling,
                                   CompilerInvocation::StringAllocator,
                                   Option::OptionClass, unsigned, /*T*/...) {
   Args.push_back(Spelling);
 }
 
 template <typename T> static constexpr bool is_uint64_t_convertible() {
-  return !std::is_same<T, uint64_t>::value &&
-         llvm::is_integral_or_enum<T>::value;
+  return !std::is_same_v<T, uint64_t> && llvm::is_integral_or_enum<T>::value;
 }
 
 template <typename T,
           std::enable_if_t<!is_uint64_t_convertible<T>(), bool> = false>
 static auto makeFlagToValueNormalizer(T Value) {
   return [Value](OptSpecifier Opt, unsigned, const ArgList &Args,
                  DiagnosticsEngine &) -> Optional<T> {
     if (Args.hasArg(Opt))

clang/lib/Lex/MacroArgs.cpp

if (!ResultEnt) {
     *ResultEnt = Result->ArgCache;
     Result->NumUnexpArgTokens = UnexpArgTokens.size();
     Result->VarargsElided = VarargsElided;
     Result->NumMacroArgs = MI->getNumParams();
   }
 
   // Copy the actual unexpanded tokens to immediately after the result ptr.
   if (!UnexpArgTokens.empty()) {
-    static_assert(std::is_trivial<Token>::value,
+    static_assert(std::is_trivial_v<Token>,
                   "assume trivial copyability if copying into the "
                   "uninitialized array (as opposed to reusing a cached "
                   "MacroArgs)");
     std::copy(UnexpArgTokens.begin(), UnexpArgTokens.end(),
               Result->getTrailingObjects<Token>());
   }
 
   return Result;

 /// deallocate - This should only be called by the Preprocessor when managing
 /// its freelist.
 MacroArgs *MacroArgs::deallocate() {
   MacroArgs *Next = ArgCache;
 
   // Run the dtor to deallocate the vectors.
   this->~MacroArgs();
   // Release the memory for the object.
-  static_assert(std::is_trivially_destructible<Token>::value,
+  static_assert(std::is_trivially_destructible_v<Token>,
                 "assume trivially destructible and forego destructors");
   free(this);
 
   return Next;
 }
 
 
 /// getArgLength - Given a pointer to an expanded or unexpanded argument,

clang/lib/Sema/SemaDeclAttr.cpp

 static unsigned getNumAttributeArgs(const ParsedAttr &AL) {
   // FIXME: Include the type in the argument list.
   return AL.getNumArgs() + AL.hasParsedType();
 }
 
 /// A helper function to provide Attribute Location for the Attr types
 /// AND the ParsedAttr.
 template <typename AttrInfo>
-static std::enable_if_t<std::is_base_of<Attr, AttrInfo>::value, SourceLocation>
+static std::enable_if_t<std::is_base_of_v<Attr, AttrInfo>, 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

static bool isAtLeastAsSpecializedAs(Sema &S, QualType T1, QualType T2,
   return AtLeastAsSpecialized;
 }
 
 namespace {
 // A dummy class to return nullptr instead of P2 when performing "more
 // specialized than primary" check.
 struct GetP2 {
   template <typename T1, typename T2,
-            std::enable_if_t<std::is_same<T1, T2>::value, bool> = true>
+            std::enable_if_t<std::is_same_v<T1, T2>, bool> = true>
   T2 *operator()(T1 *, T2 *P2) {
     return P2;
   }
   template <typename T1, typename T2,
-            std::enable_if_t<!std::is_same<T1, T2>::value, bool> = true>
+            std::enable_if_t<!std::is_same_v<T1, T2>, bool> = true>
   T1 *operator()(T1 *, T2 *) {
     return nullptr;
   }
 };
 
 // The assumption is that two template argument lists have the same size.
 struct TemplateArgumentListAreEqual {
   ASTContext &Ctx;
   TemplateArgumentListAreEqual(ASTContext &Ctx) : Ctx(Ctx) {}
 
   template <typename T1, typename T2,
-            std::enable_if_t<std::is_same<T1, T2>::value, bool> = true>
+            std::enable_if_t<std::is_same_v<T1, T2>, bool> = true>
   bool operator()(T1 *PS1, T2 *PS2) {
     ArrayRef<TemplateArgument> Args1 = PS1->getTemplateArgs().asArray(),
                                Args2 = PS2->getTemplateArgs().asArray();
 
     for (unsigned I = 0, E = Args1.size(); I < E; ++I) {
       // We use profile, instead of structural comparison of the arguments,
       // because canonicalization can't do the right thing for dependent
       // expressions.
       llvm::FoldingSetNodeID IDA, IDB;
       Args1[I].Profile(IDA, Ctx);
       Args2[I].Profile(IDB, Ctx);
       if (IDA != IDB)
         return false;
     }
     return true;
   }
 
   template <typename T1, typename T2,
-            std::enable_if_t<!std::is_same<T1, T2>::value, bool> = true>
+            std::enable_if_t<!std::is_same_v<T1, T2>, bool> = true>
   bool operator()(T1 *Spec, T2 *Primary) {
     ArrayRef<TemplateArgument> Args1 = Spec->getTemplateArgs().asArray(),
                                Args2 = Primary->getInjectedTemplateArgs();
 
     for (unsigned I = 0, E = Args1.size(); I < E; ++I) {
       // We use profile, instead of structural comparison of the arguments,
       // because canonicalization can't do the right thing for dependent
       // expressions.

 ///          - otherwise, returns the more specialized template partial
 ///            specialization. If neither partial specialization is more
 ///            specialized, returns NULL.
 template <typename TemplateLikeDecl, typename PrimaryDel>
 static TemplateLikeDecl *
 getMoreSpecialized(Sema &S, QualType T1, QualType T2, TemplateLikeDecl *P1,
                    PrimaryDel *P2, TemplateDeductionInfo &Info) {
   constexpr bool IsMoreSpecialThanPrimaryCheck =
-      !std::is_same<TemplateLikeDecl, PrimaryDel>::value;
+      !std::is_same_v<TemplateLikeDecl, PrimaryDel>;
 
   bool Better1 = isAtLeastAsSpecializedAs(S, T1, T2, P2, Info);
   if (IsMoreSpecialThanPrimaryCheck && !Better1)
     return nullptr;
 
   bool Better2 = isAtLeastAsSpecializedAs(S, T2, T1, P1, Info);
   if (IsMoreSpecialThanPrimaryCheck && !Better2)
     return P1;

clang/lib/StaticAnalyzer/Core/ExprEngine.cpp

static void printStateTraitWithLocationContextJson(
     const char *jsonPropertyName, Printer printer, Args &&...args) {
 
   using RequiredType =
       void (*)(raw_ostream &, ProgramStateRef, const char *,
                const LocationContext *, unsigned int, bool, Args &&...);
 
   // Try to do as much compile time checking as possible.
   // FIXME: check for invocable instead of function?
-  static_assert(std::is_function<std::remove_pointer_t<Printer>>::value,
+  static_assert(std::is_function_v<std::remove_pointer_t<Printer>>,
                 "Printer is not a function!");
-  static_assert(std::is_convertible<Printer, RequiredType>::value,
+  static_assert(std::is_convertible_v<Printer, RequiredType>,
                 "Printer doesn't have the required type!");
 
   if (LCtx && !State->get<Trait>().isEmpty()) {
     Indent(Out, Space, IsDot) << '\"' << jsonPropertyName << "\": ";
     ++Space;
     Out << '[' << NL;
     LCtx->printJson(Out, NL, Space, IsDot, [&](const LocationContext *LC) {
       printer(Out, State, NL, LC, Space, IsDot, std::forward<Args>(args)...);

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,
-       std::enable_if_t<std::is_base_of<Stmt, T>::value, T> *Node,
-       ASTContext &AST)
+       std::enable_if_t<std::is_base_of_v<Stmt, T>, T> *Node, ASTContext &AST)
       : Impl(Parent, dyn_cast<Stmt>(Node), AST) {}
   template <class T>
   Impl(SyntaxTree *Parent,
-       std::enable_if_t<std::is_base_of<Decl, T>::value, T> *Node,
-       ASTContext &AST)
+       std::enable_if_t<std::is_base_of_v<Decl, T>, T> *Node, ASTContext &AST)
       : Impl(Parent, dyn_cast<Decl>(Node), AST) {}
 
   SyntaxTree *Parent;
   ASTContext &AST;
   PrintingPolicy TypePP;
   /// Nodes in preorder.
   std::vector<Node> Nodes;
   std::vector<NodeId> Leaves;

clang/unittests/Lex/HeaderMapTest.cpp

 template <class FileTy, class PaddingTy> struct PaddedFile {
   FileTy File;
   PaddingTy Padding;
 };
 
 TEST(HeaderMapTest, lookupFilenameTruncatedSuffix) {
   typedef HMapFileMock<2, 64 - sizeof(HMapHeader) - 2 * sizeof(HMapBucket)>
       FileTy;
-  static_assert(std::is_standard_layout<FileTy>::value,
-                "Expected standard layout");
+  static_assert(std::is_standard_layout_v<FileTy>, "Expected standard layout");
   static_assert(sizeof(FileTy) == 64, "check the math");
   PaddedFile<FileTy, uint64_t> P;
   auto &File = P.File;
   auto &Padding = P.Padding;
   File.init();
 
   HMapFileMockMaker<FileTy> Maker(File);
   auto a = Maker.addString("a");
TEST(HeaderMapTest, lookupFilenameTruncatedSuffix) {
   // ("cxxxx...") is detected as truncated, and an empty string is returned.
   SmallString<24> DestPath;
   ASSERT_EQ("", Map.lookupFilename("a", DestPath));
 }
 
 TEST(HeaderMapTest, lookupFilenameTruncatedPrefix) {
   typedef HMapFileMock<2, 64 - sizeof(HMapHeader) - 2 * sizeof(HMapBucket)>
       FileTy;
-  static_assert(std::is_standard_layout<FileTy>::value,
-                "Expected standard layout");
+  static_assert(std::is_standard_layout_v<FileTy>, "Expected standard layout");
   static_assert(sizeof(FileTy) == 64, "check the math");
   PaddedFile<FileTy, uint64_t> P;
   auto &File = P.File;
   auto &Padding = P.Padding;
   File.init();
 
   HMapFileMockMaker<FileTy> Maker(File);
   auto a = Maker.addString("a");

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,
+const SelectedASTNode &
+checkNode(const SelectedASTNode &StmtNode, SourceSelectionKind SelectionKind,
           unsigned NumChildren = 0,
-    std::enable_if_t<std::is_base_of<Stmt, T>::value, T> *StmtOverloadChecker =
+          std::enable_if_t<std::is_base_of_v<Stmt, T>, 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,
+const SelectedASTNode &
+checkNode(const SelectedASTNode &DeclNode, SourceSelectionKind SelectionKind,
           unsigned NumChildren = 0, StringRef Name = "",
-    std::enable_if_t<std::is_base_of<Decl, T>::value, T> *DeclOverloadChecker =
+          std::enable_if_t<std::is_base_of_v<Decl, T>, T> *DeclOverloadChecker =
               nullptr) {
   checkNodeImpl(isa<T>(DeclNode.Node.get<Decl>()), DeclNode, SelectionKind,
                 NumChildren);
   if (!Name.empty())
     checkDeclName(DeclNode, Name);
   return DeclNode;
 }
 
 struct ForAllChildrenOf {

clang/unittests/Tooling/Syntax/TreeTest.cpp

TEST_F(TreeTest, Iterators) {
   auto ConstRange = ConstTree->getChildren();
   EXPECT_THAT(ConstRange, ElementsAre(role(NodeRole::LeftHandSide),
                                       role(NodeRole::OperatorToken),
                                       role(NodeRole::RightHandSide)));
 
   // FIXME: mutate and observe no invalidation. Mutations are private for now...
   auto It = Range.begin();
   auto CIt = ConstRange.begin();
-  static_assert(std::is_same<decltype(*It), syntax::Node &>::value,
-                "mutable range");
-  static_assert(std::is_same<decltype(*CIt), const syntax::Node &>::value,
+  static_assert(std::is_same_v<decltype(*It), syntax::Node &>, "mutable range");
+  static_assert(std::is_same_v<decltype(*CIt), const syntax::Node &>,
                 "const range");
 
   for (unsigned I = 0; I < 3; ++I) {
     EXPECT_EQ(It, CIt);
     EXPECT_TRUE(It);
     EXPECT_TRUE(CIt);
     EXPECT_EQ(It.asPointer(), Children[I]);
     EXPECT_EQ(CIt.asPointer(), Children[I]);