[clang-tidy] Implement modernize-use-constraints

[ccotter]

Summary

Add new check to replace enable_if with C++20 constraints

[ccotter]

For the sake of demonstration, https://github.com/llvm/llvm-project/commit/9c556ce59edf5a4293d4497d5815544afc0eb878 is the result of running this tool on all headers under clang/include/clang and llvm/include/llvm.

[ccotter]

Overall, we could eventually upgrade code in three stages, each a separate reusable check.

1. enable_if -> requires clauses
2. replace the non _v templates to the _v variants is_same -> is_same_v or the equivalent concept same_as
3. replace requires clause on declarations to be template type constraint (replace template <typename T> void foo() requires std::same_as<T, int> void foo() {} to template <std::same_as<int> T> void foo() {}

[njames93]

In D141892#4057722, @ccotter wrote:

2. replace the non _v templates to the _v variants is_same -> is_same_v or the equivalent concept same_as

See D137302

[ccotter]

In D141892#4058273, @njames93 wrote:

In D141892#4057722, @ccotter wrote:

2. replace the non _v templates to the _v variants is_same -> is_same_v or the equivalent concept same_as

See D137302

Awesome!

[ccotter]

• Add fno-delayed-template-parsing

[ccotter]

• Use nested namespaces

[ccotter]

Rebase + Simplify match logic

[ccotter]

This is more or less ready for review (not planning on making any further changes; there are more features to be added, but I was thinking of handling those in follow up changesets). I know it's a relatively large review, but let me know if anyone can take a first pass. Thanks!

[ccotter]

rebase

[ccotter]

rebase

[ccotter]

rebase

[ccotter]

• format

[njames93]

Would you consider supporting enable_if via parameters

template<typename T>
void doStuff(T&, std::enable_if_t<T::some_value, void*> = nullptr) {}

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

72

nit: Don't need to explicitly call make_optional here, the implicit conversion will handle that for you, same goes for everywhere else.

90

dyn_cast is brought into clangs namespace so the llvm:: qualifier is unnecessary here

110–113

Nit

126–129

Ditto as above

130–131

Don't use else after a return.
Same goes for anywhere else that this pattern occurs

134

Prefer pair over tuple when only 2 elements

158–161

Prefer braced initialization rather than the factory make_tuple(or make_pair). Same goes below.

216

This can return a std::optional<StringRef> if you remove the call the .str() and assignment to std::string below.

267

Isn't there a copy of this function in clang::tidy::utils?

297–300

336

No need to call .str() here if the lambda expects a StringRef, also removed std::make_optional.

460–462

463–467

Though a different approach of passing the DiagnosticBuilder to the handleReturnType function and just appending the fixits in place would be a nicer solution.
Maybe change the function name to addReturnTypeFixes(DiagnosticBuilder&, const FunctionDecl *, const TypeLoc &, const EnableIfData &, ASTContext &);

Same transformation can be made below.

472–475

[ccotter]

feedback+rebase

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

158–161

I've seen this feedback twice now - is this (or others, like preferring tuple over pair) written down somewhere? I didn't see anything on https://llvm.org/docs/CodingStandards.htm (or it wasn't obvious to me). Thanks!

267

Ah, this version that I copied takes the Location by modifiable reference so it can be updated. I will update the original version

463–467

Updated to apply your first suggestion.

For the addReturnTypeFixes suggestion, I find that handleReturnType returning the vector of FixItHints simpler since it has less responsibility or knowledge about how the FixItHints are to be applied - it's main purpose is to compute them, so why have the function also know how to apply them? Practically speaking, maybe this is not really useful since this function is not say, exposed as a library function to other code (it's just used as an implementation detail of this check).

Can you clarify what makes the application in place a nicer solution?

[ccotter]

> Would you consider supporting enable_if via parameters

I was planning to support those too, but in a subsequent commit / review since this review is rather large. Is that OK?

[ccotter]

refactor

[ccotter]

rebase

[ccotter]

arc diff properly

[njames93]

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

64–66

This string manipulation is unfortunate, check https://github.com/llvm/llvm-project/blob/main/clang-tools-extra/clang-tidy/modernize/TypeTraitsCheck.cpp#L208 for a way to do it without that.
Could extract it out to its own function to use it below as well

223

No need for move here.

236–238

This seems dangerous, CXXCtorInitializer also contains in class initializers

struct Foo : Base { // < The first implicit constructor initializer - SourceOrder: -1
  Foo() : 
    Bat(0),  // <- The fourth constructor initializer - SourceOrder: -0
    Baz(0){} // <- The third constructor initializer - SourceOrder: 1
  int Bar = 5; // <- The second (implicit) constructor initializer - SourceOrder: -1
  int Baz = 6;
  int Bat;
};

Off the top of my head I can remember if the implicit initializers have a valid source location.
I think tbh the safest way to approach this would actually be to loop through the initializers and check their GetSourceOrder for the first item that returns 0. In the example I have tried to demonstrate the possibilities.

248–249

Super contrived, but looking for the = delete like this could be problematic

template<typename T>
std::enable_if_t<std::is_const_v<T>> Foo() noexcept(requires (T a) { a = 4; }) = delete;

Here I'd imagine it would return the = in the noexcept requires clause.
I'd imagine the safest bet would be to work from the function end loc looking for the delete, then the equals.

[ccotter]

Fix bug, other cleanups, rebase

[ccotter]

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

248–249

Good catch. Added a test case for this. Looks like getSourceRange() returns the location after the parameter list and noexcept (if any), but before the = delete, so I went with that.

[ccotter]

• Better handling for ctor inits

[ccotter]

Addressed all comments except for the handleReturnType one which I responded to - let me know your thoughts, thanks!

[ccotter]

bump - @njames93 let me know if you have any further feedback. thanks!

[ccotter]

rebase

[ccotter]

• Fix ReleaseNotes again

[PiotrZSL]

clang-tools-extra/docs/clang-tidy/checks/modernize/use-constraints.rst

5

[ccotter]

• Fix docs

[PiotrZSL]

Overall this check is complicated, simply because it's doing complicated stuff.

1. Add description to all functions (what is their purpose, what is expected outcome, maybe put some "example")
2. Extend documentation, add "supported" constructions, (pre C++20, C++20).
3. What about boost enable_if ? Support it, or restrict check to std only.
4. What about enable_if used as an function argument ? Support it, or add some info to documentation that such construction is not supported.

I don't think that this check will ever be "perfect", so LGTM.
We got entire release to "stabilize it".

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

55

what if we do not have Identifier here ?

206–209

353

You not checking anywhere if this optional is initialized.

clang-tools-extra/docs/clang-tidy/checks/modernize/use-constraints.rst

11

move this link to new line, 80 characters limit

21–25

Put into documentation also example how this code should look in C++20.

[ccotter]

• Improve docs, check for null/empty

[ccotter]

3. What about boost enable_if ? Support it, or restrict check to std only.
4. What about enable_if used as an function argument ? Support it, or add some info to documentation that such construction is not supported.

I added some notes to the documentation on supported constructions and unsupported ones. The unsupported ones can be added; I intentionally did not support them in this initial version of the tool to keep the review simpler, although I'd like to add them soon after it lands.

If there are no other comments, @PiotrZSL would you mind landing this for me? Thanks!

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

353

Indeed - bugprone-unchecked-optional-access finds this!

[PiotrZSL]

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

43

Would be good to exclude here implicit code. For example with IgnoreUnlessSpelledInSource, maybe in next patch.

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

add_clang_library(clangTidyModernizeModule
   ReplaceDisallowCopyAndAssignMacroCheck.cpp
   ReplaceRandomShuffleCheck.cpp
   ReturnBracedInitListCheck.cpp
   ShrinkToFitCheck.cpp
   TypeTraitsCheck.cpp
   UnaryStaticAssertCheck.cpp
   UseAutoCheck.cpp
   UseBoolLiteralsCheck.cpp
+  UseConstraintsCheck.cpp
   UseDefaultMemberInitCheck.cpp
   UseEmplaceCheck.cpp
   UseEqualsDefaultCheck.cpp
   UseEqualsDeleteCheck.cpp
   UseNodiscardCheck.cpp
   UseNoexceptCheck.cpp
   UseNullptrCheck.cpp
   UseOverrideCheck.cpp

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

 #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 "UseConstraintsCheck.h"
 #include "UseDefaultMemberInitCheck.h"
 #include "UseEmplaceCheck.h"
 #include "UseEqualsDefaultCheck.h"
 #include "UseEqualsDeleteCheck.h"
 #include "UseNodiscardCheck.h"
 #include "UseNoexceptCheck.h"
 #include "UseNullptrCheck.h"
 #include "UseOverrideCheck.h"
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<UseConstraintsCheck>(
+        "modernize-use-constraints");
     CheckFactories.registerCheck<UseDefaultMemberInitCheck>(
         "modernize-use-default-member-init");
     CheckFactories.registerCheck<UseEmplaceCheck>("modernize-use-emplace");
     CheckFactories.registerCheck<UseEqualsDefaultCheck>("modernize-use-equals-default");
     CheckFactories.registerCheck<UseEqualsDeleteCheck>(
         "modernize-use-equals-delete");
     CheckFactories.registerCheck<UseNodiscardCheck>(
         "modernize-use-nodiscard");

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

+//===--- UseConstraintsCheck.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_USECONSTRAINTSCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USECONSTRAINTSCHECK_H
+
+#include "../ClangTidyCheck.h"
+
+namespace clang::tidy::modernize {
+
+/// Replace enable_if with C++20 requires clauses.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/modernize/use-constraints.html
+class UseConstraintsCheck : public ClangTidyCheck {
+public:
+  UseConstraintsCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, 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.CPlusPlus20;
+  }
+};
+
+} // namespace clang::tidy::modernize
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USECONSTRAINTSCHECK_H

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

+//===--- UseConstraintsCheck.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 "UseConstraintsCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Lex/Lexer.h"
+
+#include "../utils/LexerUtils.h"
+
+#include <optional>
+#include <utility>
+
+using namespace clang::ast_matchers;
+
+namespace clang::tidy::modernize {
+
+struct EnableIfData {
+  TemplateSpecializationTypeLoc Loc;
+  TypeLoc Outer;
+};
+
+namespace {
+AST_MATCHER(FunctionDecl, hasOtherDeclarations) {
+  auto It = Node.redecls_begin();
+  auto EndIt = Node.redecls_end();
+
+  if (It == EndIt)
+    return false;
+
+  ++It;
+  return It != EndIt;
+}
+} // namespace
+
+void UseConstraintsCheck::registerMatchers(MatchFinder *Finder) {
+  Finder->addMatcher(
+      functionTemplateDecl(
+          has(functionDecl(unless(hasOtherDeclarations()), isDefinition(),
+                           hasReturnTypeLoc(typeLoc().bind("return")))
+                  .bind("function")))
+          .bind("functionTemplate"),
+      this);
+}
+
+static std::optional<TemplateSpecializationTypeLoc>
+matchEnableIfSpecializationImplTypename(TypeLoc TheType) {
+  if (const auto Dep = TheType.getAs<DependentNameTypeLoc>()) {
+    const IdentifierInfo *Identifier = Dep.getTypePtr()->getIdentifier();
+    if (!Identifier || Identifier->getName() != "type" ||
+        Dep.getTypePtr()->getKeyword() != ETK_Typename) {
+      return std::nullopt;
+    }
+    TheType = Dep.getQualifierLoc().getTypeLoc();
+  }
+
+  if (const auto SpecializationLoc =
+          TheType.getAs<TemplateSpecializationTypeLoc>()) {
+
+    const auto *Specialization =
+        dyn_cast<TemplateSpecializationType>(SpecializationLoc.getTypePtr());
+    if (!Specialization)
+      return std::nullopt;
+
+    const TemplateDecl *TD =
+        Specialization->getTemplateName().getAsTemplateDecl();
+    if (!TD || TD->getName() != "enable_if")
+      return std::nullopt;
+
+    int NumArgs = SpecializationLoc.getNumArgs();
+    if (NumArgs != 1 && NumArgs != 2)
+      return std::nullopt;
+
+    return SpecializationLoc;
+  }
+  return std::nullopt;
+}
+
+static std::optional<TemplateSpecializationTypeLoc>
+matchEnableIfSpecializationImplTrait(TypeLoc TheType) {
+  if (const auto Elaborated = TheType.getAs<ElaboratedTypeLoc>())
+    TheType = Elaborated.getNamedTypeLoc();
+
+  if (const auto SpecializationLoc =
+          TheType.getAs<TemplateSpecializationTypeLoc>()) {
+
+    const auto *Specialization =
+        dyn_cast<TemplateSpecializationType>(SpecializationLoc.getTypePtr());
+    if (!Specialization)
+      return std::nullopt;
+
+    const TemplateDecl *TD =
+        Specialization->getTemplateName().getAsTemplateDecl();
+    if (!TD || TD->getName() != "enable_if_t")
+      return std::nullopt;
+
+    if (!Specialization->isTypeAlias())
+      return std::nullopt;
+
+    if (const auto *AliasedType =
+            dyn_cast<DependentNameType>(Specialization->getAliasedType())) {
+      if (AliasedType->getIdentifier()->getName() != "type" ||
+          AliasedType->getKeyword() != ETK_Typename) {
+        return std::nullopt;
+      }
+    } else {
+      return std::nullopt;
+    }
+    int NumArgs = SpecializationLoc.getNumArgs();
+    if (NumArgs != 1 && NumArgs != 2)
+      return std::nullopt;
+
+    return SpecializationLoc;
+  }
+  return std::nullopt;
+}
+
+static std::optional<TemplateSpecializationTypeLoc>
+matchEnableIfSpecializationImpl(TypeLoc TheType) {
+  if (auto EnableIf = matchEnableIfSpecializationImplTypename(TheType))
+    return EnableIf;
+  return matchEnableIfSpecializationImplTrait(TheType);
+}
+
+static std::optional<EnableIfData>
+matchEnableIfSpecialization(TypeLoc TheType) {
+  if (const auto Pointer = TheType.getAs<PointerTypeLoc>())
+    TheType = Pointer.getPointeeLoc();
+  else if (const auto Reference = TheType.getAs<ReferenceTypeLoc>())
+    TheType = Reference.getPointeeLoc();
+  if (const auto Qualified = TheType.getAs<QualifiedTypeLoc>())
+    TheType = Qualified.getUnqualifiedLoc();
+
+  if (auto EnableIf = matchEnableIfSpecializationImpl(TheType))
+    return EnableIfData{std::move(*EnableIf), TheType};
+  return std::nullopt;
+}
+
+static std::pair<std::optional<EnableIfData>, const Decl *>
+matchTrailingTemplateParam(const FunctionTemplateDecl *FunctionTemplate) {
+  // For non-type trailing param, match very specifically
+  // 'template <..., enable_if_type<Condition, Type> = Default>' where
+  // enable_if_type is 'enable_if' or 'enable_if_t'. E.g., 'template <typename
+  // T, enable_if_t<is_same_v<T, bool>, int*> = nullptr>
+  //
+  // Otherwise, match a trailing default type arg.
+  // E.g., 'template <typename T, typename = enable_if_t<is_same_v<T, bool>>>'
+
+  const TemplateParameterList *TemplateParams =
+      FunctionTemplate->getTemplateParameters();
+  if (TemplateParams->size() == 0)
+    return {};
+
+  const NamedDecl *LastParam =
+      TemplateParams->getParam(TemplateParams->size() - 1);
+  if (const auto *LastTemplateParam =
+          dyn_cast<NonTypeTemplateParmDecl>(LastParam)) {
+
+    if (!LastTemplateParam->hasDefaultArgument() ||
+        !LastTemplateParam->getName().empty())
+      return {};
+
+    return {matchEnableIfSpecialization(
+                LastTemplateParam->getTypeSourceInfo()->getTypeLoc()),
+            LastTemplateParam};
+  } else if (const auto *LastTemplateParam =
+                 dyn_cast<TemplateTypeParmDecl>(LastParam)) {
+    if (LastTemplateParam->hasDefaultArgument() &&
+        LastTemplateParam->getIdentifier() == nullptr) {
+      return {matchEnableIfSpecialization(
+                  LastTemplateParam->getDefaultArgumentInfo()->getTypeLoc()),
+              LastTemplateParam};
+    }
+  }
+  return {};
+}
+
+template <typename T>
+static SourceLocation getRAngleFileLoc(const SourceManager &SM,
+                                       const T &Element) {
+  // getFileLoc handles the case where the RAngle loc is part of a synthesized
+  // '>>', which ends up allocating a 'scratch space' buffer in the source
+  // manager.
+  return SM.getFileLoc(Element.getRAngleLoc());
+}
+
+static SourceRange
+getConditionRange(ASTContext &Context,
+                  const TemplateSpecializationTypeLoc &EnableIf) {
+  // TemplateArgumentLoc's SourceRange End is the location of the last token
+  // (per UnqualifiedId docs). E.g., in `enable_if<AAA && BBB>`, the End
+  // location will be the first 'B' in 'BBB'.
+  const LangOptions &LangOpts = Context.getLangOpts();
+  const SourceManager &SM = Context.getSourceManager();
+  if (EnableIf.getNumArgs() > 1) {
+    TemplateArgumentLoc NextArg = EnableIf.getArgLoc(1);
+    return SourceRange(
+        EnableIf.getLAngleLoc().getLocWithOffset(1),
+        utils::lexer::findPreviousTokenKind(NextArg.getSourceRange().getBegin(),
+                                            SM, LangOpts, tok::comma));
+  }
+
+  return SourceRange(EnableIf.getLAngleLoc().getLocWithOffset(1),
+                     getRAngleFileLoc(SM, EnableIf));
+}
+
+static SourceRange getTypeRange(ASTContext &Context,
+                                const TemplateSpecializationTypeLoc &EnableIf) {
+  TemplateArgumentLoc Arg = EnableIf.getArgLoc(1);
+  const LangOptions &LangOpts = Context.getLangOpts();
+  const SourceManager &SM = Context.getSourceManager();
+  return SourceRange(
+      utils::lexer::findPreviousTokenKind(Arg.getSourceRange().getBegin(), SM,
+                                          LangOpts, tok::comma)
+          .getLocWithOffset(1),
+      getRAngleFileLoc(SM, EnableIf));
+}
+
+// Returns the original source text of the second argument of a call to
+// enable_if_t. E.g., in enable_if_t<Condition, TheType>, this function
+// returns 'TheType'.
+static std::optional<StringRef>
+getTypeText(ASTContext &Context,
+            const TemplateSpecializationTypeLoc &EnableIf) {
+  if (EnableIf.getNumArgs() > 1) {
+    const LangOptions &LangOpts = Context.getLangOpts();
+    const SourceManager &SM = Context.getSourceManager();
+    bool Invalid = false;
+    StringRef Text = Lexer::getSourceText(CharSourceRange::getCharRange(
+                                              getTypeRange(Context, EnableIf)),
+                                          SM, LangOpts, &Invalid)
+                         .trim();
+    if (Invalid)
+      return std::nullopt;
+
+    return Text;
+  }
+
+  return "void";
+}
+
+static std::optional<SourceLocation>
+findInsertionForConstraint(const FunctionDecl *Function, ASTContext &Context) {
+  SourceManager &SM = Context.getSourceManager();
+  const LangOptions &LangOpts = Context.getLangOpts();
+
+  if (const auto *Constructor = dyn_cast<CXXConstructorDecl>(Function)) {
+    for (const CXXCtorInitializer *Init : Constructor->inits()) {
+      if (Init->getSourceOrder() == 0)
+        return utils::lexer::findPreviousTokenKind(Init->getSourceLocation(),
+                                                   SM, LangOpts, tok::colon);
+    }
+    if (Constructor->init_begin() != Constructor->init_end())
+      return std::nullopt;
+  }
+  if (Function->isDeleted()) {
+    SourceLocation FunctionEnd = Function->getSourceRange().getEnd();
+    return utils::lexer::findNextAnyTokenKind(FunctionEnd, SM, LangOpts,
+                                              tok::equal, tok::equal);
+  }
+  const Stmt *Body = Function->getBody();
+  if (!Body)
+    return std::nullopt;
+
+  return Body->getBeginLoc();
+}
+
+bool isPrimaryExpression(const Expr *Expression) {
+  // This function is an incomplete approximation of checking whether
+  // an Expr is a primary expression. In particular, if this function
+  // returns true, the expression is a primary expression. The converse
+  // is not necessarily true.
+
+  if (const auto *Cast = dyn_cast<ImplicitCastExpr>(Expression))
+    Expression = Cast->getSubExprAsWritten();
+  if (isa<ParenExpr, DependentScopeDeclRefExpr>(Expression))
+    return true;
+
+  return false;
+}
+
+// Return the original source text of an enable_if_t condition, i.e., the
+// first template argument). For example, in
+// 'enable_if_t<FirstCondition || SecondCondition, AType>', the text
+// the text 'FirstCondition || SecondCondition' is returned.
+static std::optional<std::string> getConditionText(const Expr *ConditionExpr,
+                                                   SourceRange ConditionRange,
+                                                   ASTContext &Context) {
+  SourceManager &SM = Context.getSourceManager();
+  const LangOptions &LangOpts = Context.getLangOpts();
+
+  SourceLocation PrevTokenLoc = ConditionRange.getEnd();
+  if (PrevTokenLoc.isInvalid())
+    return std::nullopt;
+
+  const bool SkipComments = false;
+  Token PrevToken;
+  std::tie(PrevToken, PrevTokenLoc) = utils::lexer::getPreviousTokenAndStart(
+      PrevTokenLoc, SM, LangOpts, SkipComments);
+  bool EndsWithDoubleSlash =
+      PrevToken.is(tok::comment) &&
+      Lexer::getSourceText(CharSourceRange::getCharRange(
+                               PrevTokenLoc, PrevTokenLoc.getLocWithOffset(2)),
+                           SM, LangOpts) == "//";
+
+  bool Invalid = false;
+  llvm::StringRef ConditionText = Lexer::getSourceText(
+      CharSourceRange::getCharRange(ConditionRange), SM, LangOpts, &Invalid);
+  if (Invalid)
+    return std::nullopt;
+
+  auto AddParens = [&](llvm::StringRef Text) -> std::string {
+    if (isPrimaryExpression(ConditionExpr))
+      return Text.str();
+    return "(" + Text.str() + ")";
+  };
+
+  if (EndsWithDoubleSlash)
+    return AddParens(ConditionText);
+  return AddParens(ConditionText.trim());
+}
+
+// Handle functions that return enable_if_t, e.g.,
+//   template <...>
+//   enable_if_t<Condition, ReturnType> function();
+//
+// Return a vector of FixItHints if the code can be replaced with
+// a C++20 requires clause. In the example above, returns FixItHints
+// to result in
+//   template <...>
+//   ReturnType function() requires Condition {}
+static std::vector<FixItHint> handleReturnType(const FunctionDecl *Function,
+                                               const TypeLoc &ReturnType,
+                                               const EnableIfData &EnableIf,
+                                               ASTContext &Context) {
+  TemplateArgumentLoc EnableCondition = EnableIf.Loc.getArgLoc(0);
+
+  SourceRange ConditionRange = getConditionRange(Context, EnableIf.Loc);
+
+  std::optional<std::string> ConditionText = getConditionText(
+      EnableCondition.getSourceExpression(), ConditionRange, Context);
+  if (!ConditionText)
+    return {};
+
+  std::optional<StringRef> TypeText = getTypeText(Context, EnableIf.Loc);
+  if (!TypeText)
+    return {};
+
+  SmallVector<const Expr *, 3> ExistingConstraints;
+  Function->getAssociatedConstraints(ExistingConstraints);
+  if (ExistingConstraints.size() > 0) {
+    // FIXME - Support adding new constraints to existing ones. Do we need to
+    // consider subsumption?
+    return {};
+  }
+
+  std::optional<SourceLocation> ConstraintInsertionLoc =
+      findInsertionForConstraint(Function, Context);
+  if (!ConstraintInsertionLoc)
+    return {};
+
+  std::vector<FixItHint> FixIts;
+  FixIts.push_back(FixItHint::CreateReplacement(
+      CharSourceRange::getTokenRange(EnableIf.Outer.getSourceRange()),
+      *TypeText));
+  FixIts.push_back(FixItHint::CreateInsertion(
+      *ConstraintInsertionLoc, "requires " + *ConditionText + " "));
+  return FixIts;
+}
+
+// Handle enable_if_t in a trailing template parameter, e.g.,
+//   template <..., enable_if_t<Condition, Type> = Type{}>
+//   ReturnType function();
+//
+// Return a vector of FixItHints if the code can be replaced with
+// a C++20 requires clause. In the example above, returns FixItHints
+// to result in
+//   template <...>
+//   ReturnType function() requires Condition {}
+static std::vector<FixItHint>
+handleTrailingTemplateType(const FunctionTemplateDecl *FunctionTemplate,
+                           const FunctionDecl *Function,
+                           const Decl *LastTemplateParam,
+                           const EnableIfData &EnableIf, ASTContext &Context) {
+  SourceManager &SM = Context.getSourceManager();
+  const LangOptions &LangOpts = Context.getLangOpts();
+
+  TemplateArgumentLoc EnableCondition = EnableIf.Loc.getArgLoc(0);
+
+  SourceRange ConditionRange = getConditionRange(Context, EnableIf.Loc);
+
+  std::optional<std::string> ConditionText = getConditionText(
+      EnableCondition.getSourceExpression(), ConditionRange, Context);
+  if (!ConditionText)
+    return {};
+
+  SmallVector<const Expr *, 3> ExistingConstraints;
+  Function->getAssociatedConstraints(ExistingConstraints);
+  if (ExistingConstraints.size() > 0) {
+    // FIXME - Support adding new constraints to existing ones. Do we need to
+    // consider subsumption?
+    return {};
+  }
+
+  SourceRange RemovalRange;
+  const TemplateParameterList *TemplateParams =
+      FunctionTemplate->getTemplateParameters();
+  if (!TemplateParams || TemplateParams->size() == 0)
+    return {};
+
+  if (TemplateParams->size() == 1) {
+    RemovalRange =
+        SourceRange(TemplateParams->getTemplateLoc(),
+                    getRAngleFileLoc(SM, *TemplateParams).getLocWithOffset(1));
+  } else {
+    RemovalRange =
+        SourceRange(utils::lexer::findPreviousTokenKind(
+                        LastTemplateParam->getSourceRange().getBegin(), SM,
+                        LangOpts, tok::comma),
+                    getRAngleFileLoc(SM, *TemplateParams));
+  }
+
+  std::optional<SourceLocation> ConstraintInsertionLoc =
+      findInsertionForConstraint(Function, Context);
+  if (!ConstraintInsertionLoc)
+    return {};
+
+  std::vector<FixItHint> FixIts;
+  FixIts.push_back(
+      FixItHint::CreateRemoval(CharSourceRange::getCharRange(RemovalRange)));
+  FixIts.push_back(FixItHint::CreateInsertion(
+      *ConstraintInsertionLoc, "requires " + *ConditionText + " "));
+  return FixIts;
+}
+
+void UseConstraintsCheck::check(const MatchFinder::MatchResult &Result) {
+  const auto *FunctionTemplate =
+      Result.Nodes.getNodeAs<FunctionTemplateDecl>("functionTemplate");
+  const auto *Function = Result.Nodes.getNodeAs<FunctionDecl>("function");
+  const auto *ReturnType = Result.Nodes.getNodeAs<TypeLoc>("return");
+  if (!FunctionTemplate || !Function || !ReturnType)
+    return;
+
+  // Check for
+  //
+  //   Case 1. Return type of function
+  //
+  //     template <...>
+  //     enable_if_t<Condition, ReturnType>::type function() {}
+  //
+  //   Case 2. Trailing template parameter
+  //
+  //     template <..., enable_if_t<Condition, Type> = Type{}>
+  //     ReturnType function() {}
+  //
+  //     or
+  //
+  //     template <..., typename = enable_if_t<Condition, void>>
+  //     ReturnType function() {}
+  //
+
+  // Case 1. Return type of function
+  if (auto EnableIf = matchEnableIfSpecialization(*ReturnType)) {
+    diag(ReturnType->getBeginLoc(),
+         "use C++20 requires constraints instead of enable_if")
+        << handleReturnType(Function, *ReturnType, *EnableIf, *Result.Context);
+    return;
+  }
+
+  // Case 2. Trailing template parameter
+  if (auto [EnableIf, LastTemplateParam] =
+          matchTrailingTemplateParam(FunctionTemplate);
+      EnableIf && LastTemplateParam) {
+    diag(LastTemplateParam->getSourceRange().getBegin(),
+         "use C++20 requires constraints instead of enable_if")
+        << handleTrailingTemplateType(FunctionTemplate, Function,
+                                      LastTemplateParam, *EnableIf,
+                                      *Result.Context);
+    return;
+  }
+}
+
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/utils/LexerUtils.h

 //===--- LexerUtils.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_UTILS_LEXER_UTILS_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_LEXER_UTILS_H
 
 #include "clang/AST/ASTContext.h"
 #include "clang/Basic/TokenKinds.h"
 #include "clang/Lex/Lexer.h"
 #include <optional>
+#include <utility>
 
 namespace clang {
 
 class Stmt;
 
 namespace tidy::utils::lexer {
 
 /// Returns previous token or ``tok::unknown`` if not found.
 Token getPreviousToken(SourceLocation Location, const SourceManager &SM,
                        const LangOptions &LangOpts, bool SkipComments = true);
+std::pair<Token, SourceLocation>
+getPreviousTokenAndStart(SourceLocation Location, const SourceManager &SM,
+                         const LangOptions &LangOpts, bool SkipComments = true);
 
 SourceLocation findPreviousTokenStart(SourceLocation Start,
                                       const SourceManager &SM,
                                       const LangOptions &LangOpts);
 
 SourceLocation findPreviousTokenKind(SourceLocation Start,
                                      const SourceManager &SM,
                                      const LangOptions &LangOpts,

clang-tools-extra/clang-tidy/utils/LexerUtils.cpp

 //===--- LexerUtils.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 "LexerUtils.h"
 #include "clang/AST/AST.h"
 #include "clang/Basic/SourceManager.h"
 #include <optional>
+#include <utility>
 
 namespace clang::tidy::utils::lexer {
 
-Token getPreviousToken(SourceLocation Location, const SourceManager &SM,
+std::pair<Token, SourceLocation>
+getPreviousTokenAndStart(SourceLocation Location, const SourceManager &SM,
                          const LangOptions &LangOpts, bool SkipComments) {
   Token Token;
   Token.setKind(tok::unknown);
 
   Location = Location.getLocWithOffset(-1);
   if (Location.isInvalid())
-    return Token;
+    return {Token, Location};
 
   auto StartOfFile = SM.getLocForStartOfFile(SM.getFileID(Location));
   while (Location != StartOfFile) {
     Location = Lexer::GetBeginningOfToken(Location, SM, LangOpts);
     if (!Lexer::getRawToken(Location, Token, SM, LangOpts) &&
         (!SkipComments || !Token.is(tok::comment))) {
       break;
     }
     Location = Location.getLocWithOffset(-1);
   }
+  return {Token, Location};
+}
+
+Token getPreviousToken(SourceLocation Location, const SourceManager &SM,
+                       const LangOptions &LangOpts, bool SkipComments) {
+  auto [Token, Start] =
+      getPreviousTokenAndStart(Location, SM, LangOpts, SkipComments);
   return Token;
 }
 
 SourceLocation findPreviousTokenStart(SourceLocation Start,
                                       const SourceManager &SM,
                                       const LangOptions &LangOpts) {
   if (Start.isInvalid() || Start.isMacroID())
     return SourceLocation();

clang-tools-extra/docs/ReleaseNotes.rst

- New :doc:`bugprone-inc-dec-in-conditions
   the variable's value.
 
 - New :doc:`bugprone-multi-level-implicit-pointer-conversion
   <clang-tidy/checks/bugprone/multi-level-implicit-pointer-conversion>` check.
 
   Detects implicit conversions between pointers of different levels of
   indirection.
 
+- New :doc:`modernize-use-constraints
+  <clang-tidy/checks/modernize/use-constraints>` check.
+
+  Replace ``enable_if`` with C++20 requires clauses.
+
 - New :doc:`performance-enum-size
   <clang-tidy/checks/performance/enum-size>` check.
 
   Recommends the smallest possible underlying type for an ``enum`` or ``enum``
   class based on the range of its enumerators.
 
 - New :doc:`readability-reference-to-constructed-temporary
   <clang-tidy/checks/readability/reference-to-constructed-temporary>` check.

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

.. csv-table::
    `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-constraints <modernize/use-constraints.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"
    `modernize-use-noexcept <modernize/use-noexcept.html>`_, "Yes"
    `modernize-use-nullptr <modernize/use-nullptr.html>`_, "Yes"
    `modernize-use-override <modernize/use-override.html>`_, "Yes"

clang-tools-extra/docs/clang-tidy/checks/modernize/use-constraints.rst

+.. title:: clang-tidy - modernize-use-constraints
+
+modernize-use-constraints
+=========================
+
+Replace ``std::enable_if`` with C++20 requires clauses.
+
+``std::enable_if`` is a SFINAE mechanism for selecting the desired function or
+class template based on type traits or other requirements. ``enable_if`` changes
+the meta-arity of the template, and has other
+`adverse side effects
+<https://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0225r0.html>`_
+in the code. C++20 introduces concepts and constraints as a cleaner language
+provided solution to achieve the same outcome.
+
+This check finds some common ``std::enable_if`` patterns that can be replaced
+by C++20 requires clauses. The tool can replace some of these patterns
+automatically, otherwise, the tool will emit a diagnostic without a
+replacement. The tool can detect the following ``std::enable_if`` patterns
+
+1. ``std::enable_if`` in the return type of a function
+2. ``std::enable_if`` as the trailing template parameter for function templates
+
+Other uses, for example, in class templates for function parameters, are not
+currently supported by this tool. Other variants such as ``boost::enable_if``
+are not currently supported by this tool.
+
+Below are some examples of code using ``std::enable_if``.
+
+.. code-block:: c++
+
+  // enable_if in function return type
+  template <typename T>
+  std::enable_if_t<T::some_trait, int> only_if_t_has_the_trait() { ... }
+
+  // enable_if in the trailing template parameter
+  template <typename T, std::enable_if_t<T::some_trait, int> = 0>
+  void another_version() { ... }
+
+  template <typename T>
+  typename std::enable_if<T::some_value, Obj>::type existing_constraint() requires (T::another_value) {
+    return Obj{};
+  }
+
+  template <typename T, std::enable_if_t<T::some_trait, int> = 0>
+  struct my_class {};
+
+The tool will replace the above code with,
+
+.. code-block:: c++
+
+  // warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+  template <typename T>
+  int only_if_t_has_the_trait() requires T::some_trait { ... }
+
+  // warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+  template <typename T>
+  void another_version() requires T::some_trait { ... }
+
+  // The tool will emit a diagnostic for the following, but will
+  // not attempt to replace the code.
+  // warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+  template <typename T>
+  typename std::enable_if<T::some_value, Obj>::type existing_constraint() requires (T::another_value) {
+    return Obj{};
+  }
+
+  // The tool will not emit a diagnostic or attempt to replace the code.
+  template <typename T, std::enable_if_t<T::some_trait, int> = 0>
+  struct my_class {};

clang-tools-extra/test/clang-tidy/checkers/modernize/use-constraints-first-greatergreater.cpp

+// RUN: %check_clang_tidy -std=c++20 %s modernize-use-constraints %t -- -- -fno-delayed-template-parsing
+
+// NOLINTBEGIN
+namespace std {
+template <bool B, class T = void> struct enable_if { };
+
+template <class T> struct enable_if<true, T> { typedef T type; };
+
+template <bool B, class T = void>
+using enable_if_t = typename enable_if<B, T>::type;
+
+} // namespace std
+// NOLINTEND
+
+// Separate test file for the case where the first '>>' token part of
+// an enable_if expression correctly handles the synthesized token.
+
+template <typename T, typename = std::enable_if_t<T::some_value>>
+void first_greatergreater_is_enable_if() {
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:23: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}void first_greatergreater_is_enable_if() requires T::some_value {{{$}}

clang-tools-extra/test/clang-tidy/checkers/modernize/use-constraints.cpp

+// RUN: %check_clang_tidy -std=c++20 %s modernize-use-constraints %t -- -- -fno-delayed-template-parsing
+
+// NOLINTBEGIN
+namespace std {
+template <bool B, class T = void> struct enable_if { };
+
+template <class T> struct enable_if<true, T> { typedef T type; };
+
+template <bool B, class T = void>
+using enable_if_t = typename enable_if<B, T>::type;
+
+} // namespace std
+// NOLINTEND
+
+template <typename...>
+struct ConsumeVariadic;
+
+struct Obj {
+};
+
+namespace enable_if_in_return_type {
+
+////////////////////////////////
+// Section 1: enable_if in return type of function
+////////////////////////////////
+
+////////////////////////////////
+// General tests
+////////////////////////////////
+
+template <typename T>
+typename std::enable_if<T::some_value, Obj>::type basic() {
+  return Obj{};
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}Obj basic() requires T::some_value {{{$}}
+
+template <typename T>
+std::enable_if_t<T::some_value, Obj> basic_t() {
+  return Obj{};
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}Obj basic_t() requires T::some_value {{{$}}
+
+template <typename T>
+auto basic_trailing() -> typename std::enable_if<T::some_value, Obj>::type {
+  return Obj{};
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:26: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}auto basic_trailing() -> Obj requires T::some_value {{{$}}
+
+template <typename T>
+typename std::enable_if<T::some_value, Obj>::type existing_constraint() requires (T::another_value) {
+  return Obj{};
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}typename std::enable_if<T::some_value, Obj>::type existing_constraint() requires (T::another_value) {{{$}}
+
+template <typename U>
+typename std::enable_if<U::some_value, Obj>::type decl_without_def();
+
+template <typename U>
+typename std::enable_if<U::some_value, Obj>::type decl_with_separate_def();
+
+template <typename U>
+typename std::enable_if<U::some_value, Obj>::type decl_with_separate_def() {
+  return Obj{};
+}
+// FIXME - Support definitions with separate decls
+
+template <typename U>
+std::enable_if_t<true, Obj> no_dependent_type(U) {
+  return Obj{};
+}
+// FIXME - Support non-dependent enable_ifs. Low priority though...
+
+template <typename T>
+typename std::enable_if<T::some_value, int>::type* pointer_of_enable_if() {
+  return nullptr;
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}template <typename T>{{$}}
+// CHECK-FIXES-NEXT: {{^}}int* pointer_of_enable_if() requires T::some_value {{{$}}
+
+template <typename T>
+std::enable_if_t<T::some_value, int>* pointer_of_enable_if_t() {
+  return nullptr;
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}template <typename T>{{$}}
+// CHECK-FIXES-NEXT: {{^}}int* pointer_of_enable_if_t() requires T::some_value {{{$}}
+
+template <typename T>
+const std::enable_if_t<T::some_value, int>* const_pointer_of_enable_if_t() {
+  return nullptr;
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:7: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}template <typename T>{{$}}
+// CHECK-FIXES-NEXT: {{^}}const int* const_pointer_of_enable_if_t() requires T::some_value {{{$}}
+
+template <typename T>
+std::enable_if_t<T::some_value, int> const * const_pointer_of_enable_if_t2() {
+  return nullptr;
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}template <typename T>{{$}}
+// CHECK-FIXES-NEXT: {{^}}int const * const_pointer_of_enable_if_t2() requires T::some_value {{{$}}
+
+
+template <typename T>
+std::enable_if_t<T::some_value, int>& reference_of_enable_if_t() {
+  static int x; return x;
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}template <typename T>{{$}}
+// CHECK-FIXES-NEXT: {{^}}int& reference_of_enable_if_t() requires T::some_value {{{$}}
+
+template <typename T>
+const std::enable_if_t<T::some_value, int>& const_reference_of_enable_if_t() {
+  static int x; return x;
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:7: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}template <typename T>{{$}}
+// CHECK-FIXES-NEXT: {{^}}const int& const_reference_of_enable_if_t() requires T::some_value {{{$}}
+
+template <typename T>
+typename std::enable_if<T::some_value>::type enable_if_default_void() {
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}void enable_if_default_void() requires T::some_value {{{$}}
+
+template <typename T>
+std::enable_if_t<T::some_value> enable_if_t_default_void() {
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}void enable_if_t_default_void() requires T::some_value {{{$}}
+
+template <typename T>
+std::enable_if_t<T::some_value>* enable_if_t_default_void_pointer() {
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}void* enable_if_t_default_void_pointer() requires T::some_value {{{$}}
+
+namespace using_namespace_std {
+
+using namespace std;
+
+template <typename T>
+typename enable_if<T::some_value>::type with_typename() {
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}void with_typename() requires T::some_value {{{$}}
+
+template <typename T>
+enable_if_t<T::some_value> with_t() {
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}void with_t() requires T::some_value {{{$}}
+
+template <typename T>
+typename enable_if<T::some_value, int>::type with_typename_and_type() {
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}int with_typename_and_type() requires T::some_value {{{$}}
+
+template <typename T>
+enable_if_t<T::some_value, int> with_t_and_type() {
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}int with_t_and_type() requires T::some_value {{{$}}
+
+} // namespace using_namespace_std
+
+
+////////////////////////////////
+// Negative tests - incorrect uses of enable_if
+////////////////////////////////
+template <typename U>
+std::enable_if<U::some_value, Obj> not_enable_if() {
+  return {};
+}
+template <typename U>
+typename std::enable_if<U::some_value, Obj>::type123 not_enable_if_wrong_type() {
+  return {};
+}
+template <typename U>
+typename std::enable_if_t<U::some_value, Obj>::type not_enable_if_t() {
+  return {};
+}
+template <typename U>
+typename std::enable_if_t<U::some_value, Obj>::type123 not_enable_if_t_again() {
+  return {};
+}
+template <typename U>
+std::enable_if<U::some_value, int>* not_pointer_of_enable_if() {
+  return nullptr;
+}
+template <typename U>
+typename std::enable_if<U::some_value, int>::type123 * not_pointer_of_enable_if_t() {
+  return nullptr;
+}
+
+
+namespace primary_expression_tests {
+
+////////////////////////////////
+// Primary/non-primary expression tests
+////////////////////////////////
+
+template <typename T> struct Traits;
+
+template <typename T>
+std::enable_if_t<Traits<T>::value> type_trait_value() {
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}void type_trait_value() requires Traits<T>::value {{{$}}
+
+template <typename T>
+std::enable_if_t<Traits<T>::member()> type_trait_member_call() {
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}void type_trait_member_call() requires (Traits<T>::member()) {{{$}}
+
+template <typename T>
+std::enable_if_t<!Traits<T>::value> negate() {
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}void negate() requires (!Traits<T>::value) {{{$}}
+
+template <typename T>
+std::enable_if_t<Traits<T>::value1 && Traits<T>::value2> conjunction() {
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}void conjunction() requires (Traits<T>::value1 && Traits<T>::value2) {{{$}}
+
+template <typename T>
+std::enable_if_t<Traits<T>::value1 || Traits<T>::value2> disjunction() {
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}void disjunction() requires (Traits<T>::value1 || Traits<T>::value2) {{{$}}
+
+template <typename T>
+std::enable_if_t<Traits<T>::value1 && !Traits<T>::value2> conjunction_with_negate() {
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}void conjunction_with_negate() requires (Traits<T>::value1 && !Traits<T>::value2) {{{$}}
+
+template <typename T>
+std::enable_if_t<Traits<T>::value1 == (Traits<T>::value2 + 5)> complex_operators() {
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}void complex_operators() requires (Traits<T>::value1 == (Traits<T>::value2 + 5)) {{{$}}
+
+} // namespace primary_expression_tests
+
+
+////////////////////////////////
+// Functions with specifier
+////////////////////////////////
+
+template <typename T>
+constexpr typename std::enable_if<T::some_value, int>::type constexpr_decl() {
+  return 10;
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:11: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}constexpr int constexpr_decl() requires T::some_value {{{$}}
+
+template <typename T>
+static inline constexpr typename std::enable_if<T::some_value, int>::type static_inline_constexpr_decl() {
+  return 10;
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:25: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}static inline constexpr int static_inline_constexpr_decl() requires T::some_value {{{$}}
+
+template <typename T>
+static
+typename std::enable_if<T::some_value, int>::type
+static_decl() {
+  return 10;
+}
+// CHECK-MESSAGES: :[[@LINE-4]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}static{{$}}
+// CHECK-FIXES-NEXT: {{^}}int{{$}}
+// CHECK-FIXES-NEXT: {{^}}static_decl() requires T::some_value {{{$}}
+
+template <typename T>
+constexpr /* comment */ typename std::enable_if<T::some_value, int>::type constexpr_comment_decl() {
+  return 10;
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:25: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}constexpr /* comment */ int constexpr_comment_decl() requires T::some_value {{{$}}
+
+
+////////////////////////////////
+// Class definition tests
+////////////////////////////////
+
+struct AClass {
+
+  template <typename T>
+  static typename std::enable_if<T::some_value, Obj>::type static_method() {
+    return Obj{};
+  }
+  // CHECK-MESSAGES: :[[@LINE-3]]:10: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+  // CHECK-FIXES: {{^}}  static Obj static_method() requires T::some_value {{{$}}
+
+  template <typename T>
+  typename std::enable_if<T::some_value, Obj>::type member() {
+    return Obj{};
+  }
+  // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+  // CHECK-FIXES: {{^}}  Obj member() requires T::some_value {{{$}}
+
+  template <typename T>
+  typename std::enable_if<T::some_value, Obj>::type const_qualifier() const {
+    return Obj{};
+  }
+  // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+  // CHECK-FIXES: {{^}}  Obj const_qualifier() const requires T::some_value {{{$}}
+
+  template <typename T>
+  typename std::enable_if<T::some_value, Obj>::type rvalue_ref_qualifier() && {
+    return Obj{};
+  }
+  // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+  // CHECK-FIXES: {{^}}  Obj rvalue_ref_qualifier() && requires T::some_value {{{$}}
+
+  template <typename T>
+  typename std::enable_if<T::some_value, Obj>::type rvalue_ref_qualifier_comment() /* c1 */ && /* c2 */ {
+    return Obj{};
+  }
+  // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+  // CHECK-FIXES: {{^}}  Obj rvalue_ref_qualifier_comment() /* c1 */ && /* c2 */ requires T::some_value {{{$}}
+
+  template <typename T>
+  std::enable_if_t<T::some_value, AClass&> operator=(T&&) = delete;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+  // CHECK-FIXES: {{^}}  AClass& operator=(T&&) requires T::some_value = delete;
+
+  template<typename T>
+  std::enable_if_t<T::some_value, AClass&> operator=(ConsumeVariadic<T>) noexcept(requires (T t) { t = 4; }) = delete;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+  // CHECK-FIXES: {{^}}  AClass& operator=(ConsumeVariadic<T>) noexcept(requires (T t) { t = 4; }) requires T::some_value = delete;
+
+};
+
+
+////////////////////////////////
+// Comments and whitespace tests
+////////////////////////////////
+
+template <typename T>
+typename std::enable_if</* check1 */ T::some_value, Obj>::type leading_comment() {
+  return Obj{};
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}Obj leading_comment() requires /* check1 */ T::some_value {{{$}}
+
+template <typename T>
+typename std::enable_if<T::some_value, Obj>::type body_on_next_line()
+{
+  return Obj{};
+}
+// CHECK-MESSAGES: :[[@LINE-4]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}Obj body_on_next_line(){{$}}
+// CHECK-FIXES-NEXT: {{^}}requires T::some_value {{{$}}
+
+template <typename T>
+typename std::enable_if<  /* check1 */ T::some_value, Obj>::type leading_comment_whitespace() {
+  return Obj{};
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}Obj leading_comment_whitespace() requires /* check1 */ T::some_value {{{$}}
+
+template <typename T>
+typename std::enable_if</* check1 */ T::some_value /* check2 */, Obj>::type leading_and_trailing_comment() {
+  return Obj{};
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}Obj leading_and_trailing_comment() requires /* check1 */ T::some_value /* check2 */ {{{$}}
+
+template <typename T, typename U>
+typename std::enable_if<T::some_value &&
+                        U::another_value, Obj>::type condition_on_two_lines() {
+  return Obj{};
+}
+// CHECK-MESSAGES: :[[@LINE-4]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}Obj condition_on_two_lines() requires (T::some_value &&{{$}}
+// CHECK-FIXES-NEXT: U::another_value) {{{$}}
+
+template <typename T>
+typename std::enable_if<T::some_value, int> :: type* pointer_of_enable_if_t_with_spaces() {
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}template <typename T>{{$}}
+// CHECK-FIXES-NEXT: {{^}}int* pointer_of_enable_if_t_with_spaces() requires T::some_value {{{$}}
+
+template <typename T>
+typename std::enable_if<T::some_value, int> :: /*c*/ type* pointer_of_enable_if_t_with_comment() {
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}template <typename T>{{$}}
+// CHECK-FIXES-NEXT: {{^}}int* pointer_of_enable_if_t_with_comment() requires T::some_value {{{$}}
+
+template <typename T>
+std::enable_if_t<T::some_value // comment
+              > trailing_slash_slash_comment() {
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}template <typename T>{{$}}
+// CHECK-FIXES-NEXT: {{^}}void trailing_slash_slash_comment() requires T::some_value // comment{{$}}
+// CHECK-FIXES-NEXT: {{^}}               {{{$}}
+
+} // namespace enable_if_in_return_type
+
+
+namespace enable_if_trailing_non_type_parameter {
+
+////////////////////////////////
+// Section 2: enable_if as final template non-type parameter
+////////////////////////////////
+
+template <typename T, typename std::enable_if<T::some_value, int>::type = 0>
+void basic() {
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:23: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}template <typename T>{{$}}
+// CHECK-FIXES-NEXT: {{^}}void basic() requires T::some_value {{{$}}
+
+template <typename T, std::enable_if_t<T::some_value, int> = 0>
+void basic_t() {
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:23: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}template <typename T>{{$}}
+// CHECK-FIXES-NEXT: {{^}}void basic_t() requires T::some_value {{{$}}
+
+template <typename T, template <typename> class U, class V, std::enable_if_t<T::some_value, int> = 0>
+void basic_many_template_params() {
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:61: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}template <typename T, template <typename> class U, class V>{{$}}
+// CHECK-FIXES-NEXT: {{^}}void basic_many_template_params() requires T::some_value {{{$}}
+
+template <std::enable_if_t<true, int> = 0>
+void no_dependent_type() {
+}
+// FIXME - Support non-dependent enable_ifs. Low priority though...
+
+struct ABaseClass {
+  ABaseClass();
+  ABaseClass(int);
+};
+
+template <typename T>
+struct AClass : ABaseClass {
+  template <std::enable_if_t<T::some_value, int> = 0>
+  void no_other_template_params() {
+  }
+  // CHECK-MESSAGES: :[[@LINE-3]]:13: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+  // CHECK-FIXES: {{^}}  {{$}}
+  // CHECK-FIXES-NEXT: {{^}}  void no_other_template_params() requires T::some_value {{{$}}
+
+  template <typename U, std::enable_if_t<U::some_value, int> = 0>
+  AClass() {}
+  // CHECK-MESSAGES: :[[@LINE-2]]:25: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+  // CHECK-FIXES: {{^}}  template <typename U>{{$}}
+  // CHECK-FIXES-NEXT: {{^}}  AClass() requires U::some_value {}{{$}}
+
+  template <typename U, std::enable_if_t<U::some_value, int> = 0>
+  AClass(int) : data(0) {}
+  // CHECK-MESSAGES: :[[@LINE-2]]:25: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+  // CHECK-FIXES: {{^}}  template <typename U>{{$}}
+  // CHECK-FIXES-NEXT: {{^}}  AClass(int) requires U::some_value : data(0) {}{{$}}
+
+  template <typename U, std::enable_if_t<U::some_value, int> = 0>
+  AClass(int, int) : AClass(0) {}
+  // CHECK-MESSAGES: :[[@LINE-2]]:25: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+  // CHECK-FIXES: {{^}}  template <typename U>{{$}}
+  // CHECK-FIXES-NEXT: {{^}}  AClass(int, int) requires U::some_value : AClass(0) {}{{$}}
+
+  template <typename U, std::enable_if_t<U::some_value, int> = 0>
+  AClass(int, int, int) : ABaseClass(0) {}
+  // CHECK-MESSAGES: :[[@LINE-2]]:25: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+  // CHECK-FIXES: {{^}}  template <typename U>{{$}}
+  // CHECK-FIXES-NEXT: {{^}}  AClass(int, int, int) requires U::some_value : ABaseClass(0) {}{{$}}
+
+  template <typename U, std::enable_if_t<U::some_value, int> = 0>
+  AClass(int, int, int, int) : data2(), data() {}
+  // CHECK-MESSAGES: :[[@LINE-2]]:25: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+  // CHECK-FIXES: {{^}}  template <typename U>{{$}}
+  // CHECK-FIXES-NEXT: {{^}}  AClass(int, int, int, int) requires U::some_value : data2(), data() {}{{$}}
+
+  int data;
+  int data2;
+};
+
+template <typename T>
+struct AClass2 : ABaseClass {
+
+  template <typename U, std::enable_if_t<U::some_value, int> = 0>
+  AClass2() {}
+  // CHECK-MESSAGES: :[[@LINE-2]]:25: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+  // CHECK-FIXES: {{^}}  template <typename U>{{$}}
+  // CHECK-FIXES-NEXT: {{^}}  AClass2() requires U::some_value {}{{$}}
+
+  template <typename U, std::enable_if_t<U::some_value, int> = 0>
+  AClass2(int) : data2(0) {}
+  // CHECK-MESSAGES: :[[@LINE-2]]:25: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+  // CHECK-FIXES: {{^}}  template <typename U>{{$}}
+  // CHECK-FIXES-NEXT: {{^}}  AClass2(int) requires U::some_value : data2(0) {}{{$}}
+
+  int data = 10;
+  int data2;
+  int data3;
+};
+
+template <typename T, std::enable_if_t<T::some_value, T>* = 0>
+void pointer_type() {
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:23: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}template <typename T>{{$}}
+// CHECK-FIXES-NEXT: {{^}}void pointer_type() requires T::some_value {{{$}}
+
+template <typename T,
+          std::enable_if_t<T::some_value, T>* = nullptr>
+void param_on_newline() {
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:11: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}template <typename T>{{$}}
+// CHECK-FIXES-NEXT: {{^}}void param_on_newline() requires T::some_value {{{$}}
+
+template <typename T,
+          typename U,
+          std::enable_if_t<
+            ConsumeVariadic<T,
+                            U>::value, T>* = nullptr>
+void param_split_on_two_lines() {
+}
+// CHECK-MESSAGES: :[[@LINE-5]]:11: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}template <typename T,{{$}}
+// CHECK-FIXES-NEXT: {{^}}          typename U>{{$}}
+// CHECK-FIXES-NEXT: {{^}}void param_split_on_two_lines() requires ConsumeVariadic<T,{{$}}
+// CHECK-FIXES-NEXT: {{^}}                            U>::value {{{$}}
+
+template <typename T, std::enable_if_t<T::some_value // comment
+         >* = nullptr>
+void trailing_slash_slash_comment() {
+}
+// CHECK-MESSAGES: :[[@LINE-4]]:23: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}template <typename T>{{$}}
+// CHECK-FIXES-NEXT: {{^}}void trailing_slash_slash_comment() requires T::some_value // comment{{$}}
+// CHECK-FIXES-NEXT: {{^}}          {{{$}}
+
+template <typename T, std::enable_if_t<T::some_value>* = nullptr, std::enable_if_t<T::another_value>* = nullptr>
+void two_enable_ifs() {
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:67: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}template <typename T, std::enable_if_t<T::some_value>* = nullptr>{{$}}
+// CHECK-FIXES-NEXT: {{^}}void two_enable_ifs() requires T::another_value {{{$}}
+
+////////////////////////////////
+// Negative tests
+////////////////////////////////
+
+template <typename U, std::enable_if_t<U::some_value, int> V = 0>
+void non_type_param_has_name() {
+}
+template <typename U, std::enable_if_t<U::some_value, int>>
+void non_type_param_has_no_default() {
+}
+template <typename U, std::enable_if_t<U::some_value, int> V>
+void non_type_param_has_name_and_no_default() {
+}
+template <typename U, std::enable_if_t<U::some_value, int>...>
+void non_type_variadic() {
+}
+template <typename U, std::enable_if_t<U::some_value, int> = 0, int = 0>
+void non_type_not_last() {
+}
+
+#define TEMPLATE_REQUIRES(U, IF) template <typename U, std::enable_if_t<IF, int> = 0>
+TEMPLATE_REQUIRES(U, U::some_value)
+void macro_entire_enable_if() {
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-MESSAGES: :[[@LINE-5]]:56: note: expanded from macro 'TEMPLATE_REQUIRES'
+// CHECK-FIXES: {{^}}TEMPLATE_REQUIRES(U, U::some_value)
+// CHECK-FIXES-NEXT: {{^}}void macro_entire_enable_if() {{{$}}
+
+#define CONDITION U::some_value
+template <typename U, std::enable_if_t<CONDITION, int> = 0>
+void macro_condition() {
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:23: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}template <typename U>{{$}}
+// CHECK-FIXES-NEXT: {{^}}void macro_condition() requires CONDITION {{{$}}
+
+#undef CONDITION
+#define CONDITION !U::some_value
+template <typename U, std::enable_if_t<CONDITION, int> = 0>
+void macro_condition_not_primary() {
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:23: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}template <typename U>{{$}}
+// CHECK-FIXES-NEXT: {{^}}void macro_condition_not_primary() requires (CONDITION) {{{$}}
+
+} // namespace enable_if_trailing_non_type_parameter
+
+
+namespace enable_if_trailing_type_parameter {
+
+////////////////////////////////
+// Section 3: enable_if as final template nameless defaulted type parameter
+////////////////////////////////
+
+template <typename T, typename = std::enable_if<T::some_value>::type>
+void basic() {
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:23: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}template <typename T>{{$}}
+// CHECK-FIXES-NEXT: {{^}}void basic() requires T::some_value {{{$}}
+
+template <typename T, typename = std::enable_if_t<T::some_value>>
+void basic_t() {
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:23: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}template <typename T>{{$}}
+// CHECK-FIXES-NEXT: {{^}}void basic_t() requires T::some_value {{{$}}
+
+template <typename T, template <typename> class U, class V, typename = std::enable_if_t<T::some_value>>
+void basic_many_template_params() {
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:61: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}template <typename T, template <typename> class U, class V>{{$}}
+// CHECK-FIXES-NEXT: {{^}}void basic_many_template_params() requires T::some_value {{{$}}
+
+struct ABaseClass {
+  ABaseClass();
+  ABaseClass(int);
+};
+
+template <typename T>
+struct AClass : ABaseClass {
+  template <typename = std::enable_if_t<T::some_value>>
+  void no_other_template_params() {
+  }
+  // CHECK-MESSAGES: :[[@LINE-3]]:13: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+  // CHECK-FIXES: {{^}}  {{$}}
+  // CHECK-FIXES-NEXT: {{^}}  void no_other_template_params() requires T::some_value {{{$}}
+
+  template <typename U, typename = std::enable_if_t<U::some_value>>
+  AClass() {}
+  // CHECK-MESSAGES: :[[@LINE-2]]:25: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+  // CHECK-FIXES: {{^}}  template <typename U>{{$}}
+  // CHECK-FIXES-NEXT: {{^}}  AClass() requires U::some_value {}{{$}}
+
+  template <typename U, typename = std::enable_if_t<U::some_value>>
+  AClass(int) : data(0) {}
+  // CHECK-MESSAGES: :[[@LINE-2]]:25: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+  // CHECK-FIXES: {{^}}  template <typename U>{{$}}
+  // CHECK-FIXES-NEXT: {{^}}  AClass(int) requires U::some_value : data(0) {}{{$}}
+
+  template <typename U, typename = std::enable_if_t<U::some_value>>
+  AClass(int, int) : AClass(0) {}
+  // CHECK-MESSAGES: :[[@LINE-2]]:25: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+  // CHECK-FIXES: {{^}}  template <typename U>{{$}}
+  // CHECK-FIXES-NEXT: {{^}}  AClass(int, int) requires U::some_value : AClass(0) {}{{$}}
+
+  template <typename U, typename = std::enable_if_t<U::some_value>>
+  AClass(int, int, int) : ABaseClass(0) {}
+  // CHECK-MESSAGES: :[[@LINE-2]]:25: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+  // CHECK-FIXES: {{^}}  template <typename U>{{$}}
+  // CHECK-FIXES-NEXT: {{^}}  AClass(int, int, int) requires U::some_value : ABaseClass(0) {}{{$}}
+
+  int data;
+};
+
+template <typename T, typename = std::enable_if_t<T::some_value>*>
+void pointer_type() {
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:23: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}template <typename T>{{$}}
+// CHECK-FIXES-NEXT: {{^}}void pointer_type() requires T::some_value {{{$}}
+
+template <typename T, typename = std::enable_if_t<T::some_value>&>
+void reference_type() {
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:23: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}template <typename T>{{$}}
+// CHECK-FIXES-NEXT: {{^}}void reference_type() requires T::some_value {{{$}}
+
+template <typename T,
+          typename = std::enable_if_t<T::some_value>*>
+void param_on_newline() {
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:11: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}template <typename T>{{$}}
+// CHECK-FIXES-NEXT: {{^}}void param_on_newline() requires T::some_value {{{$}}
+
+template <typename T,
+          typename U,
+          typename = std::enable_if_t<
+            ConsumeVariadic<T,
+                            U>::value>>
+void param_split_on_two_lines() {
+}
+// CHECK-MESSAGES: :[[@LINE-5]]:11: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints]
+// CHECK-FIXES: {{^}}template <typename T,{{$}}
+// CHECK-FIXES-NEXT: {{^}}          typename U>{{$}}
+// CHECK-FIXES-NEXT: {{^}}void param_split_on_two_lines() requires ConsumeVariadic<T,{{$}}
+// CHECK-FIXES-NEXT: {{^}}                            U>::value {{{$}}
+
+
+////////////////////////////////
+// Negative tests
+////////////////////////////////
+
+template <typename U, typename Named = std::enable_if_t<U::some_value>>
+void param_has_name() {
+}
+
+template <typename U, typename = std::enable_if_t<U::some_value>, typename = int>
+void not_last_param() {
+}
+
+} // namespace enable_if_trailing_type_parameter