UseStdBitCheck.cpp

Go to the documentation of this file.

//===----------------------------------------------------------------------===//
//
// 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 "UseStdBitCheck.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
 
using namespace clang::ast_matchers;
 
namespace clang::tidy::modernize {
 
UseStdBitCheck::UseStdBitCheck(StringRef Name, ClangTidyContext *Context)
    : ClangTidyCheck(Name, Context),
      IncludeInserter(Options.getLocalOrGlobal("IncludeStyle",
                                               utils::IncludeSorter::IS_LLVM),
                      areDiagsSelfContained()) {}
 
void UseStdBitCheck::registerMatchers(MatchFinder *Finder) {
  const auto MakeBinaryOperatorMatcher = [](auto Op) {
    return [=](const auto &LHS, const auto &RHS) {
      return binaryOperator(hasOperatorName(Op),
                            hasLHS(ignoringParenImpCasts(LHS)),
                            hasRHS(ignoringParenImpCasts(RHS)));
    };
  };
  const auto MakeCommutativeBinaryOperatorMatcher = [](auto Op) {
    return [=](const auto &LHS, const auto &RHS) {
      return binaryOperator(
          hasOperatorName(Op),
          hasOperands(ignoringParenImpCasts(LHS), ignoringParenImpCasts(RHS)));
    };
  };
 
  const auto LogicalAnd = MakeCommutativeBinaryOperatorMatcher("&&");
  const auto Sub = MakeBinaryOperatorMatcher("-");
  const auto BitwiseAnd = MakeCommutativeBinaryOperatorMatcher("&");
  const auto CmpNot = MakeCommutativeBinaryOperatorMatcher("!=");
  const auto CmpGt = MakeBinaryOperatorMatcher(">");
  const auto CmpGte = MakeBinaryOperatorMatcher(">=");
  const auto CmpLt = MakeBinaryOperatorMatcher("<");
  const auto CmpLte = MakeBinaryOperatorMatcher("<=");
 
  const auto Literal0 = integerLiteral(equals(0));
  const auto Literal1 = integerLiteral(equals(1));
 
  const auto LogicalNot = [](const auto &Expr) {
    return unaryOperator(hasOperatorName("!"),
                         hasUnaryOperand(ignoringParenImpCasts(Expr)));
  };
 
  const auto IsNonNull = [=](const auto &Expr) {
    return anyOf(Expr, CmpNot(Expr, Literal0), CmpGt(Expr, Literal0),
                 CmpGte(Expr, Literal1), CmpLt(Literal0, Expr),
                 CmpLte(Literal1, Expr));
  };
  const auto BindDeclRef = [](StringRef Name) {
    return declRefExpr(
        to(varDecl(hasType(isUnsignedInteger())).bind(Name.str())));
  };
  const auto BoundDeclRef = [](StringRef Name) {
    return declRefExpr(to(varDecl(equalsBoundNode(Name.str()))));
  };
 
  // Determining if an integer is a power of 2 with following pattern:
  // has_one_bit(v) = v && !(v & (v - 1));
  Finder->addMatcher(
      LogicalAnd(IsNonNull(BindDeclRef("v")),
                 LogicalNot(BitwiseAnd(
                     BoundDeclRef("v"),
                     Sub(BoundDeclRef("v"), integerLiteral(equals(1))))))
          .bind("has_one_bit_expr"),
      this);
 
  // Computing popcount with following pattern:
  // std::bitset<N>(val).count()
  Finder->addMatcher(
      cxxMemberCallExpr(
          argumentCountIs(0),
          callee(cxxMethodDecl(
              hasName("count"),
              ofClass(cxxRecordDecl(hasName("bitset"), isInStdNamespace())))),
          on(cxxConstructExpr(
              hasArgument(0, expr(hasType(isUnsignedInteger())).bind("v")))))
          .bind("popcount_expr"),
      this);
}
 
void UseStdBitCheck::registerPPCallbacks(const SourceManager &SM,
                                         Preprocessor *PP,
                                         Preprocessor *ModuleExpanderPP) {
  IncludeInserter.registerPreprocessor(PP);
}
 
void UseStdBitCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
  Options.store(Opts, "IncludeStyle", IncludeInserter.getStyle());
}
 
void UseStdBitCheck::check(const MatchFinder::MatchResult &Result) {
  const ASTContext &Context = *Result.Context;
  const SourceManager &Source = Context.getSourceManager();
 
  if (const auto *MatchedExpr =
          Result.Nodes.getNodeAs<BinaryOperator>("has_one_bit_expr")) {
    const auto *MatchedVarDecl = Result.Nodes.getNodeAs<VarDecl>("v");
 
    auto Diag =
        diag(MatchedExpr->getBeginLoc(), "use 'std::has_one_bit' instead");
    if (auto R = MatchedExpr->getSourceRange();
        !R.getBegin().isMacroID() && !R.getEnd().isMacroID()) {
      Diag << FixItHint::CreateReplacement(
                  MatchedExpr->getSourceRange(),
                  ("std::has_one_bit(" + MatchedVarDecl->getName() + ")").str())
           << IncludeInserter.createIncludeInsertion(
                  Source.getFileID(MatchedExpr->getBeginLoc()), "<bit>");
    }
  } else if (const auto *MatchedExpr =
                 Result.Nodes.getNodeAs<CXXMemberCallExpr>("popcount_expr")) {
    const auto *BitsetInstantiatedDecl =
        cast<ClassTemplateSpecializationDecl>(MatchedExpr->getRecordDecl());
    const llvm::APSInt BitsetSize =
        BitsetInstantiatedDecl->getTemplateArgs()[0].getAsIntegral();
    const auto *MatchedArg = Result.Nodes.getNodeAs<Expr>("v");
    const uint64_t MatchedVarSize = Context.getTypeSize(MatchedArg->getType());
    if (BitsetSize < MatchedVarSize)
      return;
    auto Diag = diag(MatchedExpr->getBeginLoc(), "use 'std::popcount' instead");
    if (auto R = MatchedExpr->getSourceRange();
        !R.getBegin().isMacroID() && !R.getEnd().isMacroID()) {
      Diag << FixItHint::CreateRemoval(CharSourceRange::getTokenRange(
                  MatchedArg->getEndLoc().getLocWithOffset(1),
                  MatchedExpr->getRParenLoc().getLocWithOffset(-1)))
           << FixItHint::CreateReplacement(
                  CharSourceRange::getTokenRange(
                      MatchedExpr->getBeginLoc(),
                      MatchedArg->getBeginLoc().getLocWithOffset(-1)),
                  "std::popcount(")
           << IncludeInserter.createIncludeInsertion(
                  Source.getFileID(MatchedExpr->getBeginLoc()), "<bit>");
    }
  } else {
    llvm_unreachable("unexpected match");
  }
}
 
} // namespace clang::tidy::modernize