clang-tools-extra/clang-tidy/readability/UseStdMinMaxCheck.cpp

   1 //===--- UseStdMinMaxCheck.cpp - clang-tidy -------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "UseStdMinMaxCheck.h"
  10 #include "../utils/ASTUtils.h"
  11 #include "clang/AST/ASTContext.h"
  12 #include "clang/ASTMatchers/ASTMatchFinder.h"
  13 #include "clang/Lex/Preprocessor.h"
  14
  15 using namespace clang::ast_matchers;
  16
  17 namespace clang::tidy::readability {
  18
  19 namespace {
  20
  21 // Ignore if statements that are inside macros.
  22 AST_MATCHER(IfStmt, isIfInMacro) {
  23   return Node.getIfLoc().isMacroID() || Node.getEndLoc().isMacroID();
  24 }
  25
  26 } // namespace
  27
  28 static const llvm::StringRef AlgorithmHeader("<algorithm>");
  29
  30 static bool minCondition(const BinaryOperator::Opcode Op, const Expr *CondLhs,
  31                          const Expr *CondRhs, const Expr *AssignLhs,
  32                          const Expr *AssignRhs, const ASTContext &Context) {
  33   if ((Op == BO_LT || Op == BO_LE) &&
  34       (tidy::utils::areStatementsIdentical(CondLhs, AssignRhs, Context) &&
  35        tidy::utils::areStatementsIdentical(CondRhs, AssignLhs, Context)))
  36     return true;
  37
  38   if ((Op == BO_GT || Op == BO_GE) &&
  39       (tidy::utils::areStatementsIdentical(CondLhs, AssignLhs, Context) &&
  40        tidy::utils::areStatementsIdentical(CondRhs, AssignRhs, Context)))
  41     return true;
  42
  43   return false;
  44 }
  45
  46 static bool maxCondition(const BinaryOperator::Opcode Op, const Expr *CondLhs,
  47                          const Expr *CondRhs, const Expr *AssignLhs,
  48                          const Expr *AssignRhs, const ASTContext &Context) {
  49   if ((Op == BO_LT || Op == BO_LE) &&
  50       (tidy::utils::areStatementsIdentical(CondLhs, AssignLhs, Context) &&
  51        tidy::utils::areStatementsIdentical(CondRhs, AssignRhs, Context)))
  52     return true;
  53
  54   if ((Op == BO_GT || Op == BO_GE) &&
  55       (tidy::utils::areStatementsIdentical(CondLhs, AssignRhs, Context) &&
  56        tidy::utils::areStatementsIdentical(CondRhs, AssignLhs, Context)))
  57     return true;
  58
  59   return false;
  60 }
  61
  62 QualType getNonTemplateAlias(QualType QT) {
  63   while (true) {
  64     // cast to a TypedefType
  65     if (const TypedefType *TT = dyn_cast<TypedefType>(QT)) {
  66       // check if the typedef is a template and if it is dependent
  67       if (!TT->getDecl()->getDescribedTemplate() &&
  68           !TT->getDecl()->getDeclContext()->isDependentContext())
  69         return QT;
  70       QT = TT->getDecl()->getUnderlyingType();
  71     }
  72     // cast to elaborated type
  73     else if (const ElaboratedType *ET = dyn_cast<ElaboratedType>(QT)) {
  74       QT = ET->getNamedType();
  75     } else {
  76       break;
  77     }
  78   }
  79   return QT;
  80 }
  81
  82 static std::string createReplacement(const Expr *CondLhs, const Expr *CondRhs,
  83                                      const Expr *AssignLhs,
  84                                      const SourceManager &Source,
  85                                      const LangOptions &LO,
  86                                      StringRef FunctionName,
  87                                      const BinaryOperator *BO) {
  88   const llvm::StringRef CondLhsStr = Lexer::getSourceText(
  89       Source.getExpansionRange(CondLhs->getSourceRange()), Source, LO);
  90   const llvm::StringRef CondRhsStr = Lexer::getSourceText(
  91       Source.getExpansionRange(CondRhs->getSourceRange()), Source, LO);
  92   const llvm::StringRef AssignLhsStr = Lexer::getSourceText(
  93       Source.getExpansionRange(AssignLhs->getSourceRange()), Source, LO);
  94
  95   clang::QualType GlobalImplicitCastType;
  96   clang::QualType LhsType = CondLhs->getType()
  97                                 .getCanonicalType()
  98                                 .getNonReferenceType()
  99                                 .getUnqualifiedType();
 100   clang::QualType RhsType = CondRhs->getType()
 101                                 .getCanonicalType()
 102                                 .getNonReferenceType()
 103                                 .getUnqualifiedType();
 104   if (LhsType != RhsType) {
 105     GlobalImplicitCastType = getNonTemplateAlias(BO->getLHS()->getType());
 106   }
 107
 108   return (AssignLhsStr + " = " + FunctionName +
 109           (!GlobalImplicitCastType.isNull()
 110                ? "<" + GlobalImplicitCastType.getAsString() + ">("
 111                : "(") +
 112           CondLhsStr + ", " + CondRhsStr + ");")
 113       .str();
 114 }
 115
 116 UseStdMinMaxCheck::UseStdMinMaxCheck(StringRef Name, ClangTidyContext *Context)
 117     : ClangTidyCheck(Name, Context),
 118       IncludeInserter(Options.getLocalOrGlobal("IncludeStyle",
 119                                                utils::IncludeSorter::IS_LLVM),
 120                       areDiagsSelfContained()) {}
 121
 122 void UseStdMinMaxCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
 123   Options.store(Opts, "IncludeStyle", IncludeInserter.getStyle());
 124 }
 125
 126 void UseStdMinMaxCheck::registerMatchers(MatchFinder *Finder) {
 127   auto AssignOperator =
 128       binaryOperator(hasOperatorName("="),
 129                      hasLHS(expr(unless(isTypeDependent())).bind("AssignLhs")),
 130                      hasRHS(expr(unless(isTypeDependent())).bind("AssignRhs")));
 131   auto BinaryOperator =
 132       binaryOperator(hasAnyOperatorName("<", ">", "<=", ">="),
 133                      hasLHS(expr(unless(isTypeDependent())).bind("CondLhs")),
 134                      hasRHS(expr(unless(isTypeDependent())).bind("CondRhs")))
 135           .bind("binaryOp");
 136   Finder->addMatcher(
 137       ifStmt(stmt().bind("if"), unless(isIfInMacro()),
 138              unless(hasElse(stmt())), // Ensure `if` has no `else`
 139              hasCondition(BinaryOperator),
 140              hasThen(
 141                  anyOf(stmt(AssignOperator),
 142                        compoundStmt(statementCountIs(1), has(AssignOperator)))),
 143              hasParent(stmt(unless(ifStmt(hasElse(
 144                  equalsBoundNode("if"))))))), // Ensure `if` has no `else if`
 145       this);
 146 }
 147
 148 void UseStdMinMaxCheck::registerPPCallbacks(const SourceManager &SM,
 149                                             Preprocessor *PP,
 150                                             Preprocessor *ModuleExpanderPP) {
 151   IncludeInserter.registerPreprocessor(PP);
 152 }
 153
 154 void UseStdMinMaxCheck::check(const MatchFinder::MatchResult &Result) {
 155   const auto *If = Result.Nodes.getNodeAs<IfStmt>("if");
 156   const clang::LangOptions &LO = Result.Context->getLangOpts();
 157   const auto *CondLhs = Result.Nodes.getNodeAs<Expr>("CondLhs");
 158   const auto *CondRhs = Result.Nodes.getNodeAs<Expr>("CondRhs");
 159   const auto *AssignLhs = Result.Nodes.getNodeAs<Expr>("AssignLhs");
 160   const auto *AssignRhs = Result.Nodes.getNodeAs<Expr>("AssignRhs");
 161   const auto *BinaryOp = Result.Nodes.getNodeAs<BinaryOperator>("binaryOp");
 162   const clang::BinaryOperatorKind BinaryOpcode = BinaryOp->getOpcode();
 163   const SourceLocation IfLocation = If->getIfLoc();
 164   const SourceLocation ThenLocation = If->getEndLoc();
 165
 166   auto ReplaceAndDiagnose = [&](const llvm::StringRef FunctionName) {
 167     const SourceManager &Source = *Result.SourceManager;
 168     diag(IfLocation, "use `%0` instead of `%1`")
 169         << FunctionName << BinaryOp->getOpcodeStr()
 170         << FixItHint::CreateReplacement(
 171                SourceRange(IfLocation, Lexer::getLocForEndOfToken(
 172                                            ThenLocation, 0, Source, LO)),
 173                createReplacement(CondLhs, CondRhs, AssignLhs, Source, LO,
 174                                  FunctionName, BinaryOp))
 175         << IncludeInserter.createIncludeInsertion(
 176                Source.getFileID(If->getBeginLoc()), AlgorithmHeader);
 177   };
 178
 179   if (minCondition(BinaryOpcode, CondLhs, CondRhs, AssignLhs, AssignRhs,
 180                    (*Result.Context))) {
 181     ReplaceAndDiagnose("std::min");
 182   } else if (maxCondition(BinaryOpcode, CondLhs, CondRhs, AssignLhs, AssignRhs,
 183                           (*Result.Context))) {
 184     ReplaceAndDiagnose("std::max");
 185   }
 186 }
 187
 188 } // namespace clang::tidy::readability