[clang-tidy] Add modernize-type-traits check

[njames93]

Summary

This check will look for usages of standard library type traits of the form traits<...>::type and traits<...>::value and convert them into traits_t<...> and traits_v<...> respectively.
This expands on the work in D135404 by supporting dependent traits with no instantiations as well as types.

[Eugene.Zelenko]

clang-tools-extra/docs/ReleaseNotes.rst

127

Please use double back-ticks for language constructs.

clang-tools-extra/docs/clang-tidy/checks/modernize/type-traits.rst

7

Ditto.

27

Excessive newline.

[njames93]

Address documentation comments

[njames93]

Fix various crashes on real world code

[tschuett]

clang-tools-extra/clang-tidy/modernize/TypeTraitsCheck.h

18

Why do you refuse to use nested namespaces in modernize ?

[njames93]

Fix crash when running over llvm

[njames93]

clang-tools-extra/clang-tidy/modernize/TypeTraitsCheck.h

18

Because the add_new_check script hasn't been updated since we went to c++17

[Eugene.Zelenko]

clang-tools-extra/clang-tidy/modernize/TypeTraitsCheck.h

18

I think this is done for legacy reasons. This should be done for all checks and add_new_check.py.

[royjacobson]

This seems to be stuck with no reviewers, is there any way to help here?

[carlosgalvezp]

clang-tools-extra/clang-tidy/modernize/TypeTraitsCheck.cpp

141

I don't see a reason why the naming convention can't be followed here?

143

Why is an internal namespace needed, when you are already have the anonymous namespace?

144

Internal functions and variables should be declared "static", outside the anonymous namespace, as per the LLVM Coding Standards. AST matchers can be put in the anonymous namespace.

182

I think clang-format should remove these braces since it's only 1 statement in the "if" condition.

clang-tools-extra/clang-tidy/modernize/TypeTraitsCheck.h

31

Nit: typically this is implemented inline in the header.

32

There's an ongoing effort to deprecate llvm::Optional in favor of std::optional, perhaps start using it right away in this check?

clang-tools-extra/test/clang-tidy/checkers/modernize/type-traits.cpp

24

Typo. Shouldn't the test have failed?

[njames93]

clang-tools-extra/clang-tidy/modernize/TypeTraitsCheck.cpp

141

Following the naming convention of the AST matchers, which all use camelBack

143

I think it was because the matchers use an internal namespace, probably not need and can be removed. Let me check.

182

As its more than 1 lines, keeping it in braces is cleaner.
Also clang-format passed on the pre-merge so it thinks this code is correct according to the style guide

clang-tools-extra/clang-tidy/modernize/TypeTraitsCheck.h

32

This patch was last update before the switch, when the virtual function still returned an llvm::Optional, when I rebase it will need changing.

clang-tools-extra/test/clang-tidy/checkers/modernize/type-traits.cpp

24

Good catch, it won't fail the test as filecheck will just ignore it.

[njames93]

Address comments.

[carlosgalvezp]

clang-tools-extra/clang-tidy/modernize/TypeTraitsCheck.cpp

18

I'm guessing this list was obtained in some automatic way - could we document the process for generating it, so a future maintainer knows how to do it?

105

Ditto

106–109

Please keep alphabetical order.

135–140

Why do we need these matchers at global scope, if they are only used in the registerMatchers function?

Unless they are POD types, putting objects at global scope is bugprone since they are initialized before main in an unspecified order.

clang-tools-extra/clang-tidy/modernize/TypeTraitsCheck.h

18

Is the goal to update all existing checks to C++17 format?

clang-tools-extra/test/clang-tidy/checkers/modernize/type-traits.cpp

39

There should be a space in here, right? Same for the rest.

53

As a user I find it a bit confusing that there is a warning, but no fix. Should we just disable the warning on macros entirely?

Furthermore, the warning shows up at the call site, so if it's not possible to fix it will be very noisy for people to suppress it everywhere where the macro is used. Maybe add an option IgnoreMacros similar to how it's done for other checks? Alternatively, as a user I would like to be able to suppress the warning in line 54 once only instead of at the call site.

[njames93]

clang-tools-extra/clang-tidy/modernize/TypeTraitsCheck.cpp

18

They weren't, just copied from cppreference, I'm sure there is a way to automate it, but honestly there's not much point

106–109

This is the order they appear on cppreference, so I think it makes sense to keep it like that, will make for an easier time maintaining this

135–140

These are stateless matchers which require no construction, so there will be no initialisation order issues.

They could be moved into the function that uses them without any issue though.

clang-tools-extra/clang-tidy/modernize/TypeTraitsCheck.h

18

It should be done separately as an NFC change

clang-tools-extra/test/clang-tidy/checkers/modernize/type-traits.cpp

39

I'm assuming you mean between <b> and inTemplate.
If so, because we disable clang-format in the tests, the code isn't being reformatted and the replacement logic happens to get rid of the space too. As missing the space doesn't break the code and clang-format would reformat the code for us in typical use cases, its not worth worrying about.

53

I think IgnoreMacros is probably the best approach here, Getting warnings about marcos can be helpful if they are able to be fixed, but it would be nice to also silence those in cases when they can't.

[njames93]

Add IgnoreMacros options.
Address comments.

[carlosgalvezp]

clang-tools-extra/clang-tidy/modernize/TypeTraitsCheck.cpp

173

static not needed here, remove. I don't think LLVM guidelines enforce strict const correctness either so the const could be removed as well if wanted.

clang-tools-extra/clang-tidy/modernize/TypeTraitsCheck.h

18

Sounds good, just want to make sure it's something we see value in fixing (as opposed to just being "churn"). I'm happy to put up an NFC patch for that!

clang-tools-extra/test/clang-tidy/checkers/modernize/type-traits.cpp

39

I disagree, just because the code "compiles" it doesn't mean it's good. The only time I've seen code like this is in obfuscated code competitions :)

We should not force the user to run clang-format to fix this - clang-tidy should preserve the existing space. This is not a matter of style either, it's a de-facto way of writting C++ (and many other languages): variable types and variable names in a declaration are separated by a space.

[njames93]

clang-tools-extra/clang-tidy/modernize/TypeTraitsCheck.cpp

173

const correctness isn't enforced, but it doesn't harm

clang-tools-extra/test/clang-tidy/checkers/modernize/type-traits.cpp

39

One of the original design decisions of clang-tidy was that check authors should not worry about formatting. This is partly because not everyone can agree on a style, but the main driving factor is that clang-tidy runs clang-format on the fixes that it generates unless you explicitly tell clang-tidy not to reformat your fixes.
Given that the set of real world projects that have a clang-tidy configuration file is nearly a perfect subset of the projects that have a clang-format configuration file, it's safe to assume that fixes would always be reformatted when running clang-tidy

[njames93]

Remove unneeded static keyword
Improved fix-it logic if there is a space between the template name and the < token

[njames93]

Extend test cases to check inline namespace, extension namespaces and alias namespaces

[carlosgalvezp]

LGTM, really useful check! Would be nice to get some more eyes on the implementation, it's fairly advanced for my basic AST knowledge.

[ccotter]

Looks good to me - looking forward to this check!

clang-tools-extra/clang-tidy/modernize/TypeTraitsCheck.cpp

170

NIT: should the bound node have some meaningful non-empty name?

197

For a future release, could we add an option to allow replacing "standard type traits" defined in separate namespaces, as the BSL library does? This would be useful in my case at least.

[njames93]

Rebased and sorted release notes

[njames93]

clang-tools-extra/clang-tidy/modernize/TypeTraitsCheck.cpp

170

Not strictly required as we only ever bind one node.

197

This could definitely be extended in the future to support extended traits.

clang-tools-extra/clang-tidy/modernize/CMakeLists.txt

add_clang_library(clangTidyModernizeModule
   PassByValueCheck.cpp
   RawStringLiteralCheck.cpp
   RedundantVoidArgCheck.cpp
   ReplaceAutoPtrCheck.cpp
   ReplaceDisallowCopyAndAssignMacroCheck.cpp
   ReplaceRandomShuffleCheck.cpp
   ReturnBracedInitListCheck.cpp
   ShrinkToFitCheck.cpp
+  TypeTraitsCheck.cpp
   UnaryStaticAssertCheck.cpp
   UseAutoCheck.cpp
   UseBoolLiteralsCheck.cpp
   UseDefaultMemberInitCheck.cpp
   UseEmplaceCheck.cpp
   UseEqualsDefaultCheck.cpp
   UseEqualsDeleteCheck.cpp
   UseNodiscardCheck.cpp

clang-tools-extra/clang-tidy/modernize/ModernizeTidyModule.cpp

 #include "PassByValueCheck.h"
 #include "RawStringLiteralCheck.h"
 #include "RedundantVoidArgCheck.h"
 #include "ReplaceAutoPtrCheck.h"
 #include "ReplaceDisallowCopyAndAssignMacroCheck.h"
 #include "ReplaceRandomShuffleCheck.h"
 #include "ReturnBracedInitListCheck.h"
 #include "ShrinkToFitCheck.h"
+#include "TypeTraitsCheck.h"
 #include "UnaryStaticAssertCheck.h"
 #include "UseAutoCheck.h"
 #include "UseBoolLiteralsCheck.h"
 #include "UseDefaultMemberInitCheck.h"
 #include "UseEmplaceCheck.h"
 #include "UseEqualsDefaultCheck.h"
 #include "UseEqualsDeleteCheck.h"
 #include "UseNodiscardCheck.h"
CheckFactories.registerCheck<ReplaceAutoPtrCheck>(
         "modernize-replace-auto-ptr");
     CheckFactories.registerCheck<ReplaceDisallowCopyAndAssignMacroCheck>(
         "modernize-replace-disallow-copy-and-assign-macro");
     CheckFactories.registerCheck<ReplaceRandomShuffleCheck>(
         "modernize-replace-random-shuffle");
     CheckFactories.registerCheck<ReturnBracedInitListCheck>(
         "modernize-return-braced-init-list");
     CheckFactories.registerCheck<ShrinkToFitCheck>("modernize-shrink-to-fit");
+    CheckFactories.registerCheck<TypeTraitsCheck>("modernize-type-traits");
     CheckFactories.registerCheck<UnaryStaticAssertCheck>(
         "modernize-unary-static-assert");
     CheckFactories.registerCheck<UseAutoCheck>("modernize-use-auto");
     CheckFactories.registerCheck<UseBoolLiteralsCheck>(
         "modernize-use-bool-literals");
     CheckFactories.registerCheck<UseDefaultMemberInitCheck>(
         "modernize-use-default-member-init");
     CheckFactories.registerCheck<UseEmplaceCheck>("modernize-use-emplace");

clang-tools-extra/clang-tidy/modernize/TypeTraitsCheck.h

+//===--- TypeTraitsCheck.h - clang-tidy -------------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_TYPETRAITSCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_TYPETRAITSCHECK_H
+
+#include "../ClangTidyCheck.h"
+
+namespace clang::tidy::modernize {
+
+/// Converts standard library type traits of the form `traits<...>::type` and
+/// `traits<...>::value` into `traits_t<...>` and `traits_v<...>` respectively.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/modernize/type-traits.html
+class TypeTraitsCheck : public ClangTidyCheck {
+public:
+  TypeTraitsCheck(StringRef Name, ClangTidyContext *Context);
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
+    return LangOpts.CPlusPlus14;
+  }
+  std::optional<TraversalKind> getCheckTraversalKind() const override {
+    return TK_IgnoreUnlessSpelledInSource;
+  }
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+
+private:
+  const bool IgnoreMacros;
+};
+
+} // namespace clang::tidy::modernize
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_TYPETRAITSCHECK_H

clang-tools-extra/clang-tidy/modernize/TypeTraitsCheck.cpp

+//===--- TypeTraitsCheck.cpp - clang-tidy ---------------------------------===//
+//
+// 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 "TypeTraitsCheck.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/Lex/Lexer.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang::tidy::modernize {
+
+static const llvm::StringSet<> ValueTraits = {
+    "alignment_of",
+    "conjunction",
+    "disjunction",
+    "extent",
+    "has_unique_object_representations",
+    "has_virtual_destructor",
+    "is_abstract",
+    "is_aggregate",
+    "is_arithmetic",
+    "is_array",
+    "is_assignable",
+    "is_base_of",
+    "is_bounded_array",
+    "is_class",
+    "is_compound",
+    "is_const",
+    "is_constructible",
+    "is_convertible",
+    "is_copy_assignable",
+    "is_copy_constructible",
+    "is_default_constructible",
+    "is_destructible",
+    "is_empty",
+    "is_enum",
+    "is_final",
+    "is_floating_point",
+    "is_function",
+    "is_fundamental",
+    "is_integral",
+    "is_invocable",
+    "is_invocable_r",
+    "is_layout_compatible",
+    "is_lvalue_reference",
+    "is_member_function_pointer",
+    "is_member_object_pointer",
+    "is_member_pointer",
+    "is_move_assignable",
+    "is_move_constructible",
+    "is_nothrow_assignable",
+    "is_nothrow_constructible",
+    "is_nothrow_convertible",
+    "is_nothrow_copy_assignable",
+    "is_nothrow_copy_constructible",
+    "is_nothrow_default_constructible",
+    "is_nothrow_destructible",
+    "is_nothrow_invocable",
+    "is_nothrow_invocable_r",
+    "is_nothrow_move_assignable",
+    "is_nothrow_move_constructible",
+    "is_nothrow_swappable",
+    "is_nothrow_swappable_with",
+    "is_null_pointer",
+    "is_object",
+    "is_pointer",
+    "is_pointer_interconvertible_base_of",
+    "is_polymorphic",
+    "is_reference",
+    "is_rvalue_reference",
+    "is_same",
+    "is_scalar",
+    "is_scoped_enum",
+    "is_signed",
+    "is_standard_layout",
+    "is_swappable",
+    "is_swappable_with",
+    "is_trivial",
+    "is_trivially_assignable",
+    "is_trivially_constructible",
+    "is_trivially_copy_assignable",
+    "is_trivially_copy_constructible",
+    "is_trivially_copyable",
+    "is_trivially_default_constructible",
+    "is_trivially_destructible",
+    "is_trivially_move_assignable",
+    "is_trivially_move_constructible",
+    "is_unbounded_array",
+    "is_union",
+    "is_unsigned",
+    "is_void",
+    "is_volatile",
+    "negation",
+    "rank",
+    "reference_constructs_from_temporary",
+    "reference_converts_from_temporary",
+};
+
+static const llvm::StringSet<> TypeTraits = {
+    "remove_cv",
+    "remove_const",
+    "remove_volatile",
+    "add_cv",
+    "add_const",
+    "add_volatile",
+    "remove_reference",
+    "add_lvalue_reference",
+    "add_rvalue_reference",
+    "remove_pointer",
+    "add_pointer",
+    "make_signed",
+    "make_unsigned",
+    "remove_extent",
+    "remove_all_extents",
+    "aligned_storage",
+    "aligned_union",
+    "decay",
+    "remove_cvref",
+    "enable_if",
+    "conditional",
+    "common_type",
+    "common_reference",
+    "underlying_type",
+    "result_of",
+    "invoke_result",
+    "type_identity",
+};
+
+static DeclarationName getName(const DependentScopeDeclRefExpr &D) {
+  return D.getDeclName();
+}
+
+static DeclarationName getName(const DeclRefExpr &D) {
+  return D.getDecl()->getDeclName();
+}
+
+static bool isNamedType(const ElaboratedTypeLoc &ETL) {
+  if (const auto *TFT =
+          ETL.getNamedTypeLoc().getTypePtr()->getAs<TypedefType>()) {
+    const TypedefNameDecl *Decl = TFT->getDecl();
+    return Decl->getDeclName().isIdentifier() && Decl->getName() == "type";
+  }
+  return false;
+}
+
+static bool isNamedType(const DependentNameTypeLoc &DTL) {
+  return DTL.getTypePtr()->getIdentifier()->getName() == "type";
+}
+
+namespace {
+AST_POLYMORPHIC_MATCHER(isValue, AST_POLYMORPHIC_SUPPORTED_TYPES(
+                                     DeclRefExpr, DependentScopeDeclRefExpr)) {
+  const IdentifierInfo *Ident = getName(Node).getAsIdentifierInfo();
+  return Ident && Ident->isStr("value");
+}
+
+AST_POLYMORPHIC_MATCHER(isType,
+                        AST_POLYMORPHIC_SUPPORTED_TYPES(ElaboratedTypeLoc,
+                                                        DependentNameTypeLoc)) {
+  return Node.getBeginLoc().isValid() && isNamedType(Node);
+}
+} // namespace
+
+static constexpr char Bind[] = "";
+
+void TypeTraitsCheck::registerMatchers(MatchFinder *Finder) {
+  const ast_matchers::internal::VariadicDynCastAllOfMatcher<
+      Stmt,
+      DependentScopeDeclRefExpr>
+      dependentScopeDeclRefExpr; // NOLINT(readability-identifier-naming)
+  const ast_matchers::internal::VariadicDynCastAllOfMatcher<
+      TypeLoc,
+      DependentNameTypeLoc>
+      dependentNameTypeLoc; // NOLINT(readability-identifier-naming)
+
+  // Only register matchers for trait<...>::value in c++17 mode.
+  if (getLangOpts().CPlusPlus17) {
+    Finder->addMatcher(mapAnyOf(declRefExpr, dependentScopeDeclRefExpr)
+                           .with(isValue())
+                           .bind(Bind),
+                       this);
+  }
+  Finder->addMatcher(mapAnyOf(elaboratedTypeLoc, dependentNameTypeLoc)
+                         .with(isType())
+                         .bind(Bind),
+                     this);
+}
+
+static bool isNamedDeclInStdTraitsSet(const NamedDecl *ND,
+                                      const llvm::StringSet<> &Set) {
+  return ND->isInStdNamespace() && ND->getDeclName().isIdentifier() &&
+         Set.contains(ND->getName());
+}
+
+static bool checkTemplatedDecl(const NestedNameSpecifier *NNS,
+                               const llvm::StringSet<> &Set) {
+  if (!NNS)
+    return false;
+  const Type *NNST = NNS->getAsType();
+  if (!NNST)
+    return false;
+  const auto *TST = NNST->getAs<TemplateSpecializationType>();
+  if (!TST)
+    return false;
+  if (const TemplateDecl *TD = TST->getTemplateName().getAsTemplateDecl()) {
+    return isNamedDeclInStdTraitsSet(TD, Set);
+  }
+  return false;
+}
+
+TypeTraitsCheck::TypeTraitsCheck(StringRef Name, ClangTidyContext *Context)
+    : ClangTidyCheck(Name, Context),
+      IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", false)) {}
+
+void TypeTraitsCheck::check(const MatchFinder::MatchResult &Result) {
+  auto EmitValueWarning = [this, &Result](const NestedNameSpecifierLoc &QualLoc,
+                                          SourceLocation EndLoc) {
+    SourceLocation TemplateNameEndLoc;
+    if (auto TSTL = QualLoc.getTypeLoc().getAs<TemplateSpecializationTypeLoc>();
+        !TSTL.isNull())
+      TemplateNameEndLoc = Lexer::getLocForEndOfToken(
+          TSTL.getTemplateNameLoc(), 0, *Result.SourceManager,
+          Result.Context->getLangOpts());
+    else
+      return;
+
+    if (EndLoc.isMacroID() || QualLoc.getEndLoc().isMacroID() ||
+        TemplateNameEndLoc.isMacroID()) {
+      if (IgnoreMacros)
+        return;
+      diag(QualLoc.getBeginLoc(), "use c++17 style variable templates");
+      return;
+    }
+    diag(QualLoc.getBeginLoc(), "use c++17 style variable templates")
+        << FixItHint::CreateInsertion(TemplateNameEndLoc, "_v")
+        << FixItHint::CreateRemoval({QualLoc.getEndLoc(), EndLoc});
+  };
+
+  auto EmitTypeWarning = [this, &Result](const NestedNameSpecifierLoc &QualLoc,
+                                         SourceLocation EndLoc,
+                                         SourceLocation TypenameLoc) {
+    SourceLocation TemplateNameEndLoc;
+    if (auto TSTL = QualLoc.getTypeLoc().getAs<TemplateSpecializationTypeLoc>();
+        !TSTL.isNull())
+      TemplateNameEndLoc = Lexer::getLocForEndOfToken(
+          TSTL.getTemplateNameLoc(), 0, *Result.SourceManager,
+          Result.Context->getLangOpts());
+    else
+      return;
+
+    if (EndLoc.isMacroID() || QualLoc.getEndLoc().isMacroID() ||
+        TemplateNameEndLoc.isMacroID() || TypenameLoc.isMacroID()) {
+      if (IgnoreMacros)
+        return;
+      diag(QualLoc.getBeginLoc(), "use c++14 style type templates");
+      return;
+    }
+    auto Diag = diag(QualLoc.getBeginLoc(), "use c++14 style type templates");
+
+    if (TypenameLoc.isValid())
+      Diag << FixItHint::CreateRemoval(TypenameLoc);
+    Diag << FixItHint::CreateInsertion(TemplateNameEndLoc, "_t")
+         << FixItHint::CreateRemoval({QualLoc.getEndLoc(), EndLoc});
+  };
+
+  if (const auto *DRE = Result.Nodes.getNodeAs<DeclRefExpr>(Bind)) {
+    if (!DRE->hasQualifier())
+      return;
+    if (const auto *CTSD = dyn_cast_if_present<ClassTemplateSpecializationDecl>(
+            DRE->getQualifier()->getAsRecordDecl())) {
+      if (isNamedDeclInStdTraitsSet(CTSD, ValueTraits))
+        EmitValueWarning(DRE->getQualifierLoc(), DRE->getEndLoc());
+    }
+    return;
+  }
+
+  if (const auto *ETL = Result.Nodes.getNodeAs<ElaboratedTypeLoc>(Bind)) {
+    const NestedNameSpecifierLoc QualLoc = ETL->getQualifierLoc();
+    const auto *NNS = QualLoc.getNestedNameSpecifier();
+    if (!NNS)
+      return;
+    if (const auto *CTSD = dyn_cast_if_present<ClassTemplateSpecializationDecl>(
+            NNS->getAsRecordDecl())) {
+      if (isNamedDeclInStdTraitsSet(CTSD, TypeTraits))
+        EmitTypeWarning(ETL->getQualifierLoc(), ETL->getEndLoc(),
+                        ETL->getElaboratedKeywordLoc());
+    }
+    return;
+  }
+
+  if (const auto *DSDRE =
+          Result.Nodes.getNodeAs<DependentScopeDeclRefExpr>(Bind)) {
+    if (checkTemplatedDecl(DSDRE->getQualifier(), ValueTraits))
+      EmitValueWarning(DSDRE->getQualifierLoc(), DSDRE->getEndLoc());
+    return;
+  }
+
+  if (const auto *DNTL = Result.Nodes.getNodeAs<DependentNameTypeLoc>(Bind)) {
+    NestedNameSpecifierLoc QualLoc = DNTL->getQualifierLoc();
+    if (checkTemplatedDecl(QualLoc.getNestedNameSpecifier(), TypeTraits))
+      EmitTypeWarning(QualLoc, DNTL->getEndLoc(),
+                      DNTL->getElaboratedKeywordLoc());
+    return;
+  }
+}
+
+void TypeTraitsCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "IgnoreMacros", IgnoreMacros);
+}
+} // namespace clang::tidy::modernize

clang-tools-extra/docs/ReleaseNotes.rst

 - New :doc:`cppcoreguidelines-avoid-do-while
   <clang-tidy/checks/cppcoreguidelines/avoid-do-while>` check.
 
   Warns when using ``do-while`` loops.
 
 - New :doc:`cppcoreguidelines-avoid-reference-coroutine-parameters
   <clang-tidy/checks/cppcoreguidelines/avoid-reference-coroutine-parameters>` check.
 
   Warns on coroutines that accept reference parameters.
 
 - New :doc:`misc-use-anonymous-namespace
   <clang-tidy/checks/misc/use-anonymous-namespace>` check.
 
   Warns when using ``static`` function or variables at global scope, and suggests
   moving them into an anonymous namespace.
 
 - New :doc:`bugprone-standalone-empty <clang-tidy/checks/bugprone/standalone-empty>` check.
 
   Warns when `empty()` is used on a range and the result is ignored. Suggests `clear()`
   if it is an existing member function.
 
+- New :doc:`modernize-type-traits
+  <clang-tidy/checks/modernize/type-traits>` check.
+
+  Converts standard library type traits of the form ``traits<...>::type`` and
+  ``traits<...>::value`` into ``traits_t<...>`` and ``traits_v<...>`` respectively.
+
 New check aliases
 ^^^^^^^^^^^^^^^^^
 
 - New alias :doc:`cert-msc54-cpp
   <clang-tidy/checks/cert/msc54-cpp>` to
   :doc:`bugprone-signal-handler
   <clang-tidy/checks/bugprone/signal-handler>` was added.
 

clang-tools-extra/docs/clang-tidy/checks/list.rst

.. csv-table::
    `modernize-pass-by-value <modernize/pass-by-value.html>`_, "Yes"
    `modernize-raw-string-literal <modernize/raw-string-literal.html>`_, "Yes"
    `modernize-redundant-void-arg <modernize/redundant-void-arg.html>`_, "Yes"
    `modernize-replace-auto-ptr <modernize/replace-auto-ptr.html>`_, "Yes"
    `modernize-replace-disallow-copy-and-assign-macro <modernize/replace-disallow-copy-and-assign-macro.html>`_, "Yes"
    `modernize-replace-random-shuffle <modernize/replace-random-shuffle.html>`_, "Yes"
    `modernize-return-braced-init-list <modernize/return-braced-init-list.html>`_, "Yes"
    `modernize-shrink-to-fit <modernize/shrink-to-fit.html>`_, "Yes"
+   `modernize-type-traits <modernize/type-traits.html>`_, "Yes"
    `modernize-unary-static-assert <modernize/unary-static-assert.html>`_, "Yes"
    `modernize-use-auto <modernize/use-auto.html>`_, "Yes"
    `modernize-use-bool-literals <modernize/use-bool-literals.html>`_, "Yes"
    `modernize-use-default-member-init <modernize/use-default-member-init.html>`_, "Yes"
    `modernize-use-emplace <modernize/use-emplace.html>`_, "Yes"
    `modernize-use-equals-default <modernize/use-equals-default.html>`_, "Yes"
    `modernize-use-equals-delete <modernize/use-equals-delete.html>`_, "Yes"
    `modernize-use-nodiscard <modernize/use-nodiscard.html>`_, "Yes"

clang-tools-extra/docs/clang-tidy/checks/modernize/type-traits.rst

+.. title:: clang-tidy - modernize-type-traits
+
+modernize-type-traits
+=====================
+
+Converts standard library type traits of the form ``traits<...>::type`` and
+``traits<...>::value`` into ``traits_t<...>`` and ``traits_v<...>`` respectively.
+
+For example:
+
+.. code-block:: c++
+
+  std::is_integral<T>::value
+  std::is_same<int, float>::value
+  typename std::add_const<T>::type
+  std::make_signed<unsigned>::type
+
+Would be converted into:
+
+.. code-block:: c++
+
+  std::is_integral_v<T>
+  std::is_same_v<int, float>
+  std::add_const_t<T>
+  std::make_signed_t<unsigned>
+
+Options
+-------
+
+.. option:: IgnoreMacros
+
+  If `true` don't diagnose traits defined in macros.
+
+  Note: Fixes will never be emitted for code inside of macros.
+
+  .. code-block:: c++
+
+    #define IS_SIGNED(T) std::is_signed<T>::value
+
+  Defaults to `false`. 

clang-tools-extra/test/clang-tidy/checkers/modernize/type-traits.cpp

+// RUN: %check_clang_tidy -std=c++14 %s modernize-type-traits %t -check-suffixes=',MACRO'
+// RUN: %check_clang_tidy -std=c++14 %s modernize-type-traits %t -- \
+// RUN:   -config='{CheckOptions: {modernize-type-traits.IgnoreMacros: true}}'
+// RUN: %check_clang_tidy -std=c++17 %s modernize-type-traits %t -check-suffixes=',CXX17,MACRO,CXX17MACRO'
+
+namespace std {
+  template <typename>
+  struct is_const {
+    static constexpr bool value = true;
+  };
+
+  template <typename, typename>
+  struct is_same {
+    static constexpr bool value = true;
+  };
+
+  template<bool, typename T = void>
+  struct enable_if {
+    using type = T;
+  };
+
+inline namespace __std_lib_version1 {
+  template<typename T>
+  struct add_const {
+    using type = T;
+  };
+} // namespace __std_lib_version1
+
+namespace ext {
+  template<typename T>
+  struct add_const {
+    using type = T;
+  };
+} // namespace ext
+
+} // namespace std
+
+bool NoTemplate = std::is_const<bool>::value;
+// CHECK-MESSAGES-CXX17: :[[@LINE-1]]:19: warning: use c++17 style variable templates
+// CHECK-FIXES-CXX17: bool NoTemplate = std::is_const_v<bool>
+
+template<typename T>
+constexpr bool InTemplate = std::is_const<T>::value;
+// CHECK-MESSAGES-CXX17: :[[@LINE-1]]:29: warning: use c++17 style variable templates
+// CHECK-FIXES-CXX17: constexpr bool InTemplate = std::is_const_v<T>;
+
+template<typename U, typename V>
+constexpr bool Template2Params = std::is_same<U,V>::value;
+// CHECK-MESSAGES-CXX17: :[[@LINE-1]]:34: warning: use c++17 style variable templates
+// CHECK-FIXES-CXX17: constexpr bool Template2Params = std::is_same_v<U,V>;
+
+template<bool b>
+typename std::enable_if<b>::type inTemplate();
+// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use c++14 style type templates
+// CHECK-FIXES: std::enable_if_t<b>inTemplate();
+
+typename std::enable_if<true>::type noTemplate();
+// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use c++14 style type templates
+// CHECK-FIXES: std::enable_if_t<true>noTemplate();
+
+std::enable_if<true>::type noTemplateOrTypename();
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: use c++14 style type templates
+// CHECK-FIXES: std::enable_if_t<true>noTemplateOrTypename();
+
+using UsingNoTypename = std::enable_if<true>::type;
+// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: use c++14 style type templates
+// CHECK-FIXES: using UsingNoTypename = std::enable_if_t<true>;
+
+using UsingSpace = std::enable_if <true>::type;
+// CHECK-MESSAGES: :[[@LINE-1]]:20: warning: use c++14 style type templates
+// CHECK-FIXES: using UsingSpace = std::enable_if_t <true>;
+
+template<bool b>
+using UsingSpaceTemplate = typename std::enable_if <b>::type;
+// CHECK-MESSAGES: :[[@LINE-1]]:37: warning: use c++14 style type templates
+// CHECK-FIXES: using UsingSpaceTemplate = std::enable_if_t <b>;
+
+bool NoTemplateSpace = std::is_const <bool> ::value;
+// CHECK-MESSAGES-CXX17: :[[@LINE-1]]:24: warning: use c++17 style variable templates
+// CHECK-FIXES-CXX17: bool NoTemplateSpace = std::is_const_v <bool> ;
+
+template<typename T>
+constexpr bool InTemplateSpace = std::is_const  <T> ::value;
+// CHECK-MESSAGES-CXX17: :[[@LINE-1]]:34: warning: use c++17 style variable templates
+// CHECK-FIXES-CXX17: constexpr bool InTemplateSpace = std::is_const_v  <T> ;
+
+// For macros, no diagnostics if IgnoreMacros is set,
+// No fixes emitted even if IgnoreMacros is unset.
+
+#define VALUE_MACRO std::is_same<int, int>::value
+bool MacroValue = VALUE_MACRO;
+// CHECK-MESSAGES-CXX17MACRO: :[[@LINE-1]]:19: warning: use c++17 style variable templates
+// CHECK-FIXES-CXX17MACRO: #define VALUE_MACRO std::is_same<int, int>::value
+
+#define TYPE_MACRO typename std::enable_if<true>::type
+using MacroType = TYPE_MACRO;
+// CHECK-MESSAGES-MACRO: :[[@LINE-1]]:19: warning: use c++14 style type templates
+// CHECK-FIXES-MACRO: #define TYPE_MACRO typename std::enable_if<true>::type
+
+
+// Names defined and accessed inside an inline namespace should be converted.
+// Whether or not the inline namespace is specified
+
+using InlineUnspecified = std::add_const<bool>::type;
+// CHECK-MESSAGES: :[[@LINE-1]]:27: warning: use c++14 style type templates
+// CHECK-FIXES: using InlineUnspecified = std::add_const_t<bool>;
+
+using Inline = std::__std_lib_version1::add_const<bool>::type;
+// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: use c++14 style type templates
+// CHECK-FIXES: using Inline = std::__std_lib_version1::add_const_t<bool>;
+
+// Don't try to offer any fix if the name is an extension to the standard library
+using Ext = std::ext::add_const<bool>::type;
+
+namespace my_std = std;
+
+using Alias = my_std::add_const<bool>::type;
+// CHECK-MESSAGES: :[[@LINE-1]]:15: warning: use c++14 style type templates
+// CHECK-FIXES: using Alias = my_std::add_const_t<bool>;