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

   1 //===--- UseStdNumbersCheck.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 "UseStdNumbersCheck.h"
  10 #include "../ClangTidyDiagnosticConsumer.h"
  11 #include "clang/AST/ASTContext.h"
  12 #include "clang/AST/Decl.h"
  13 #include "clang/AST/Expr.h"
  14 #include "clang/AST/Stmt.h"
  15 #include "clang/AST/Type.h"
  16 #include "clang/ASTMatchers/ASTMatchFinder.h"
  17 #include "clang/ASTMatchers/ASTMatchers.h"
  18 #include "clang/ASTMatchers/ASTMatchersInternal.h"
  19 #include "clang/ASTMatchers/ASTMatchersMacros.h"
  20 #include "clang/Basic/Diagnostic.h"
  21 #include "clang/Basic/LLVM.h"
  22 #include "clang/Basic/LangOptions.h"
  23 #include "clang/Basic/SourceLocation.h"
  24 #include "clang/Basic/SourceManager.h"
  25 #include "clang/Lex/Lexer.h"
  26 #include "llvm/ADT/STLExtras.h"
  27 #include "llvm/ADT/SmallVector.h"
  28 #include "llvm/ADT/StringRef.h"
  29 #include "llvm/Support/FormatVariadic.h"
  30 #include "llvm/Support/MathExtras.h"
  31 #include <array>
  32 #include <cmath>
  33 #include <cstdint>
  34 #include <cstdlib>
  35 #include <initializer_list>
  36 #include <string>
  37 #include <tuple>
  38 #include <utility>
  39
  40 namespace {
  41 using namespace clang::ast_matchers;
  42 using clang::ast_matchers::internal::Matcher;
  43 using llvm::StringRef;
  44
  45 AST_MATCHER_P2(clang::FloatingLiteral, near, double, Value, double,
  46                DiffThreshold) {
  47   return std::abs(Node.getValueAsApproximateDouble() - Value) < DiffThreshold;
  48 }
  49
  50 AST_MATCHER_P(clang::QualType, hasCanonicalTypeUnqualified,
  51               Matcher<clang::QualType>, InnerMatcher) {
  52   return !Node.isNull() &&
  53          InnerMatcher.matches(Node->getCanonicalTypeUnqualified(), Finder,
  54                               Builder);
  55 }
  56
  57 AST_MATCHER(clang::QualType, isArithmetic) {
  58   return !Node.isNull() && Node->isArithmeticType();
  59 }
  60 AST_MATCHER(clang::QualType, isFloating) {
  61   return !Node.isNull() && Node->isFloatingType();
  62 }
  63
  64 AST_MATCHER_P(clang::Expr, anyOfExhaustive, std::vector<Matcher<clang::Stmt>>,
  65               Exprs) {
  66   bool FoundMatch = false;
  67   for (const auto &InnerMatcher : Exprs) {
  68     clang::ast_matchers::internal::BoundNodesTreeBuilder Result = *Builder;
  69     if (InnerMatcher.matches(Node, Finder, &Result)) {
  70       *Builder = std::move(Result);
  71       FoundMatch = true;
  72     }
  73   }
  74   return FoundMatch;
  75 }
  76
  77 // Using this struct to store the 'DiffThreshold' config value to create the
  78 // matchers without the need to pass 'DiffThreshold' into every matcher.
  79 // 'DiffThreshold' is needed in the 'near' matcher, which is used for matching
  80 // the literal of every constant and for formulas' subexpressions that look at
  81 // literals.
  82 struct MatchBuilder {
  83   auto
  84   ignoreParenAndArithmeticCasting(const Matcher<clang::Expr> Matcher) const {
  85     return expr(hasType(qualType(isArithmetic())), ignoringParenCasts(Matcher));
  86   }
  87
  88   auto ignoreParenAndFloatingCasting(const Matcher<clang::Expr> Matcher) const {
  89     return expr(hasType(qualType(isFloating())), ignoringParenCasts(Matcher));
  90   }
  91
  92   auto matchMathCall(const StringRef FunctionName,
  93                      const Matcher<clang::Expr> ArgumentMatcher) const {
  94     return expr(ignoreParenAndFloatingCasting(
  95         callExpr(callee(functionDecl(hasName(FunctionName),
  96                                      hasParameter(0, hasType(isArithmetic())))),
  97                  hasArgument(0, ArgumentMatcher))));
  98   }
  99
 100   auto matchSqrt(const Matcher<clang::Expr> ArgumentMatcher) const {
 101     return matchMathCall("sqrt", ArgumentMatcher);
 102   }
 103
 104   // Used for top-level matchers (i.e. the match that replaces Val with its
 105   // constant).
 106   //
 107   // E.g. The matcher of `std::numbers::pi` uses this matcher to look for
 108   // floatLiterals that have the value of pi.
 109   //
 110   // If the match is for a top-level match, we only care about the literal.
 111   auto matchFloatLiteralNear(const StringRef Constant, const double Val) const {
 112     return expr(ignoreParenAndFloatingCasting(
 113         floatLiteral(near(Val, DiffThreshold)).bind(Constant)));
 114   }
 115
 116   // Used for non-top-level matchers (i.e. matchers that are used as inner
 117   // matchers for top-level matchers).
 118   //
 119   // E.g.: The matcher of `std::numbers::log2e` uses this matcher to check if
 120   // `e` of `log2(e)` is declared constant and initialized with the value for
 121   // eulers number.
 122   //
 123   // Here, we do care about literals and about DeclRefExprs to variable
 124   // declarations that are constant and initialized with `Val`. This allows
 125   // top-level matchers to see through declared constants for their inner
 126   // matches like the `std::numbers::log2e` matcher.
 127   auto matchFloatValueNear(const double Val) const {
 128     const auto Float = floatLiteral(near(Val, DiffThreshold));
 129
 130     const auto Dref = declRefExpr(
 131         to(varDecl(hasType(qualType(isConstQualified(), isFloating())),
 132                    hasInitializer(ignoreParenAndFloatingCasting(Float)))));
 133     return expr(ignoreParenAndFloatingCasting(anyOf(Float, Dref)));
 134   }
 135
 136   auto matchValue(const int64_t ValInt) const {
 137     const auto Int =
 138         expr(ignoreParenAndArithmeticCasting(integerLiteral(equals(ValInt))));
 139     const auto Float = expr(ignoreParenAndFloatingCasting(
 140         matchFloatValueNear(static_cast<double>(ValInt))));
 141     const auto Dref = declRefExpr(to(varDecl(
 142         hasType(qualType(isConstQualified(), isArithmetic())),
 143         hasInitializer(expr(anyOf(ignoringImplicit(Int),
 144                                   ignoreParenAndFloatingCasting(Float)))))));
 145     return expr(anyOf(Int, Float, Dref));
 146   }
 147
 148   auto match1Div(const Matcher<clang::Expr> Match) const {
 149     return binaryOperator(hasOperatorName("/"), hasLHS(matchValue(1)),
 150                           hasRHS(Match));
 151   }
 152
 153   auto matchEuler() const {
 154     return expr(anyOf(matchFloatValueNear(llvm::numbers::e),
 155                       matchMathCall("exp", matchValue(1))));
 156   }
 157   auto matchEulerTopLevel() const {
 158     return expr(anyOf(matchFloatLiteralNear("e_literal", llvm::numbers::e),
 159                       matchMathCall("exp", matchValue(1)).bind("e_pattern")))
 160         .bind("e");
 161   }
 162
 163   auto matchLog2Euler() const {
 164     return expr(
 165                anyOf(
 166                    matchFloatLiteralNear("log2e_literal", llvm::numbers::log2e),
 167                    matchMathCall("log2", matchEuler()).bind("log2e_pattern")))
 168         .bind("log2e");
 169   }
 170
 171   auto matchLog10Euler() const {
 172     return expr(
 173                anyOf(
 174                    matchFloatLiteralNear("log10e_literal",
 175                                          llvm::numbers::log10e),
 176                    matchMathCall("log10", matchEuler()).bind("log10e_pattern")))
 177         .bind("log10e");
 178   }
 179
 180   auto matchPi() const { return matchFloatValueNear(llvm::numbers::pi); }
 181   auto matchPiTopLevel() const {
 182     return matchFloatLiteralNear("pi_literal", llvm::numbers::pi).bind("pi");
 183   }
 184
 185   auto matchEgamma() const {
 186     return matchFloatLiteralNear("egamma_literal", llvm::numbers::egamma)
 187         .bind("egamma");
 188   }
 189
 190   auto matchInvPi() const {
 191     return expr(anyOf(matchFloatLiteralNear("inv_pi_literal",
 192                                             llvm::numbers::inv_pi),
 193                       match1Div(matchPi()).bind("inv_pi_pattern")))
 194         .bind("inv_pi");
 195   }
 196
 197   auto matchInvSqrtPi() const {
 198     return expr(anyOf(
 199                     matchFloatLiteralNear("inv_sqrtpi_literal",
 200                                           llvm::numbers::inv_sqrtpi),
 201                     match1Div(matchSqrt(matchPi())).bind("inv_sqrtpi_pattern")))
 202         .bind("inv_sqrtpi");
 203   }
 204
 205   auto matchLn2() const {
 206     return expr(anyOf(matchFloatLiteralNear("ln2_literal", llvm::numbers::ln2),
 207                       matchMathCall("log", matchValue(2)).bind("ln2_pattern")))
 208         .bind("ln2");
 209   }
 210
 211   auto machterLn10() const {
 212     return expr(
 213                anyOf(matchFloatLiteralNear("ln10_literal", llvm::numbers::ln10),
 214                      matchMathCall("log", matchValue(10)).bind("ln10_pattern")))
 215         .bind("ln10");
 216   }
 217
 218   auto matchSqrt2() const {
 219     return expr(anyOf(matchFloatLiteralNear("sqrt2_literal",
 220                                             llvm::numbers::sqrt2),
 221                       matchSqrt(matchValue(2)).bind("sqrt2_pattern")))
 222         .bind("sqrt2");
 223   }
 224
 225   auto matchSqrt3() const {
 226     return expr(anyOf(matchFloatLiteralNear("sqrt3_literal",
 227                                             llvm::numbers::sqrt3),
 228                       matchSqrt(matchValue(3)).bind("sqrt3_pattern")))
 229         .bind("sqrt3");
 230   }
 231
 232   auto matchInvSqrt3() const {
 233     return expr(anyOf(matchFloatLiteralNear("inv_sqrt3_literal",
 234                                             llvm::numbers::inv_sqrt3),
 235                       match1Div(matchSqrt(matchValue(3)))
 236                           .bind("inv_sqrt3_pattern")))
 237         .bind("inv_sqrt3");
 238   }
 239
 240   auto matchPhi() const {
 241     const auto PhiFormula = binaryOperator(
 242         hasOperatorName("/"),
 243         hasLHS(binaryOperator(
 244             hasOperatorName("+"), hasEitherOperand(matchValue(1)),
 245             hasEitherOperand(matchMathCall("sqrt", matchValue(5))))),
 246         hasRHS(matchValue(2)));
 247     return expr(anyOf(PhiFormula.bind("phi_pattern"),
 248                       matchFloatLiteralNear("phi_literal", llvm::numbers::phi)))
 249         .bind("phi");
 250   }
 251
 252   double DiffThreshold;
 253 };
 254
 255 std::string getCode(const StringRef Constant, const bool IsFloat,
 256                     const bool IsLongDouble) {
 257   if (IsFloat) {
 258     return ("std::numbers::" + Constant + "_v<float>").str();
 259   }
 260   if (IsLongDouble) {
 261     return ("std::numbers::" + Constant + "_v<long double>").str();
 262   }
 263   return ("std::numbers::" + Constant).str();
 264 }
 265
 266 bool isRangeOfCompleteMacro(const clang::SourceRange &Range,
 267                             const clang::SourceManager &SM,
 268                             const clang::LangOptions &LO) {
 269   if (!Range.getBegin().isMacroID()) {
 270     return false;
 271   }
 272   if (!clang::Lexer::isAtStartOfMacroExpansion(Range.getBegin(), SM, LO)) {
 273     return false;
 274   }
 275
 276   if (!Range.getEnd().isMacroID()) {
 277     return false;
 278   }
 279
 280   if (!clang::Lexer::isAtEndOfMacroExpansion(Range.getEnd(), SM, LO)) {
 281     return false;
 282   }
 283
 284   return true;
 285 }
 286
 287 } // namespace
 288
 289 namespace clang::tidy::modernize {
 290 UseStdNumbersCheck::UseStdNumbersCheck(const StringRef Name,
 291                                        ClangTidyContext *const Context)
 292     : ClangTidyCheck(Name, Context),
 293       IncludeInserter(Options.getLocalOrGlobal("IncludeStyle",
 294                                                utils::IncludeSorter::IS_LLVM),
 295                       areDiagsSelfContained()),
 296       DiffThresholdString{Options.get("DiffThreshold", "0.001")} {
 297   if (DiffThresholdString.getAsDouble(DiffThreshold)) {
 298     configurationDiag(
 299         "Invalid DiffThreshold config value: '%0', expected a double")
 300         << DiffThresholdString;
 301     DiffThreshold = 0.001;
 302   }
 303 }
 304
 305 void UseStdNumbersCheck::registerMatchers(MatchFinder *const Finder) {
 306   const auto Matches = MatchBuilder{DiffThreshold};
 307   std::vector<Matcher<clang::Stmt>> ConstantMatchers = {
 308       Matches.matchLog2Euler(),     Matches.matchLog10Euler(),
 309       Matches.matchEulerTopLevel(), Matches.matchEgamma(),
 310       Matches.matchInvSqrtPi(),     Matches.matchInvPi(),
 311       Matches.matchPiTopLevel(),    Matches.matchLn2(),
 312       Matches.machterLn10(),        Matches.matchSqrt2(),
 313       Matches.matchInvSqrt3(),      Matches.matchSqrt3(),
 314       Matches.matchPhi(),
 315   };
 316
 317   Finder->addMatcher(
 318       expr(
 319           anyOfExhaustive(std::move(ConstantMatchers)),
 320           unless(hasParent(explicitCastExpr(hasDestinationType(isFloating())))),
 321           hasType(qualType(hasCanonicalTypeUnqualified(
 322               anyOf(qualType(asString("float")).bind("float"),
 323                     qualType(asString("double")),
 324                     qualType(asString("long double")).bind("long double")))))),
 325       this);
 326 }
 327
 328 void UseStdNumbersCheck::check(const MatchFinder::MatchResult &Result) {
 329   /*
 330     List of all math constants in the `<numbers>` header
 331     + e
 332     + log2e
 333     + log10e
 334     + pi
 335     + inv_pi
 336     + inv_sqrtpi
 337     + ln2
 338     + ln10
 339     + sqrt2
 340     + sqrt3
 341     + inv_sqrt3
 342     + egamma
 343     + phi
 344   */
 345
 346   // The ordering determines what constants are looked at first.
 347   // E.g. look at 'inv_sqrt3' before 'sqrt3' to be able to replace the larger
 348   // expression
 349   constexpr auto Constants = std::array<std::pair<StringRef, double>, 13>{
 350       std::pair{StringRef{"log2e"}, llvm::numbers::log2e},
 351       std::pair{StringRef{"log10e"}, llvm::numbers::log10e},
 352       std::pair{StringRef{"e"}, llvm::numbers::e},
 353       std::pair{StringRef{"egamma"}, llvm::numbers::egamma},
 354       std::pair{StringRef{"inv_sqrtpi"}, llvm::numbers::inv_sqrtpi},
 355       std::pair{StringRef{"inv_pi"}, llvm::numbers::inv_pi},
 356       std::pair{StringRef{"pi"}, llvm::numbers::pi},
 357       std::pair{StringRef{"ln2"}, llvm::numbers::ln2},
 358       std::pair{StringRef{"ln10"}, llvm::numbers::ln10},
 359       std::pair{StringRef{"sqrt2"}, llvm::numbers::sqrt2},
 360       std::pair{StringRef{"inv_sqrt3"}, llvm::numbers::inv_sqrt3},
 361       std::pair{StringRef{"sqrt3"}, llvm::numbers::sqrt3},
 362       std::pair{StringRef{"phi"}, llvm::numbers::phi},
 363   };
 364
 365   auto MatchedLiterals =
 366       llvm::SmallVector<std::tuple<std::string, double, const Expr *>>{};
 367
 368   const auto &SM = *Result.SourceManager;
 369   const auto &LO = Result.Context->getLangOpts();
 370
 371   const auto IsFloat = Result.Nodes.getNodeAs<QualType>("float") != nullptr;
 372   const auto IsLongDouble =
 373       Result.Nodes.getNodeAs<QualType>("long double") != nullptr;
 374
 375   for (const auto &[ConstantName, ConstantValue] : Constants) {
 376     const auto *const Match = Result.Nodes.getNodeAs<Expr>(ConstantName);
 377     if (Match == nullptr) {
 378       continue;
 379     }
 380
 381     const auto Range = Match->getSourceRange();
 382
 383     const auto IsMacro = Range.getBegin().isMacroID();
 384
 385     // We do not want to emit a diagnostic when we are matching a macro, but the
 386     // match inside of the macro does not cover the whole macro.
 387     if (IsMacro && !isRangeOfCompleteMacro(Range, SM, LO)) {
 388       continue;
 389     }
 390
 391     if (const auto PatternBindString = (ConstantName + "_pattern").str();
 392         Result.Nodes.getNodeAs<Expr>(PatternBindString) != nullptr) {
 393       const auto Code = getCode(ConstantName, IsFloat, IsLongDouble);
 394       diag(Range.getBegin(), "prefer '%0' to this %select{formula|macro}1")
 395           << Code << IsMacro << FixItHint::CreateReplacement(Range, Code);
 396       return;
 397     }
 398
 399     const auto LiteralBindString = (ConstantName + "_literal").str();
 400     if (const auto *const Literal =
 401             Result.Nodes.getNodeAs<FloatingLiteral>(LiteralBindString)) {
 402       MatchedLiterals.emplace_back(
 403           ConstantName,
 404           std::abs(Literal->getValueAsApproximateDouble() - ConstantValue),
 405           Match);
 406     }
 407   }
 408
 409   // We may have had no matches with literals, but a match with a pattern that
 410   // was a part of a macro which was therefore skipped.
 411   if (MatchedLiterals.empty()) {
 412     return;
 413   }
 414
 415   llvm::sort(MatchedLiterals, [](const auto &LHS, const auto &RHS) {
 416     return std::get<1>(LHS) < std::get<1>(RHS);
 417   });
 418
 419   const auto &[Constant, Diff, Node] = MatchedLiterals.front();
 420
 421   const auto Range = Node->getSourceRange();
 422   const auto IsMacro = Range.getBegin().isMacroID();
 423
 424   // We do not want to emit a diagnostic when we are matching a macro, but the
 425   // match inside of the macro does not cover the whole macro.
 426   if (IsMacro && !isRangeOfCompleteMacro(Range, SM, LO)) {
 427     return;
 428   }
 429
 430   const auto Code = getCode(Constant, IsFloat, IsLongDouble);
 431   diag(Range.getBegin(),
 432        "prefer '%0' to this %select{literal|macro}1, differs by '%2'")
 433       << Code << IsMacro << llvm::formatv("{0:e2}", Diff).str()
 434       << FixItHint::CreateReplacement(Range, Code)
 435       << IncludeInserter.createIncludeInsertion(
 436              Result.SourceManager->getFileID(Range.getBegin()), "<numbers>");
 437 }
 438
 439 void UseStdNumbersCheck::registerPPCallbacks(
 440     const SourceManager &SM, Preprocessor *const PP,
 441     Preprocessor *const ModuleExpanderPP) {
 442   IncludeInserter.registerPreprocessor(PP);
 443 }
 444
 445 void UseStdNumbersCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
 446   Options.store(Opts, "IncludeStyle", IncludeInserter.getStyle());
 447   Options.store(Opts, "DiffThreshold", DiffThresholdString);
 448 }
 449 } // namespace clang::tidy::modernize