OperatorsRepresentationCheck.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 "OperatorsRepresentationCheck.h"
#include "../utils/OptionsUtils.h"
#include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h"
#include "llvm/ADT/STLExtras.h"
#include <array>
#include <utility>
 
using namespace clang::ast_matchers;
 
namespace clang::tidy::readability {
 
static StringRef getOperatorSpelling(SourceLocation Loc, ASTContext &Context) {
  if (Loc.isInvalid())
    return {};
 
  const SourceManager &SM = Context.getSourceManager();
 
  Loc = SM.getSpellingLoc(Loc);
  if (Loc.isInvalid())
    return {};
 
  const CharSourceRange TokenRange = CharSourceRange::getTokenRange(Loc);
  return Lexer::getSourceText(TokenRange, SM, Context.getLangOpts());
}
 
namespace {
 
AST_MATCHER_P2(BinaryOperator, hasInvalidBinaryOperatorRepresentation,
               BinaryOperatorKind, Kind, StringRef, ExpectedRepresentation) {
  if (Node.getOpcode() != Kind || ExpectedRepresentation.empty())
    return false;
 
  const StringRef Spelling =
      getOperatorSpelling(Node.getOperatorLoc(), Finder->getASTContext());
  return !Spelling.empty() && Spelling != ExpectedRepresentation;
}
 
AST_MATCHER_P2(UnaryOperator, hasInvalidUnaryOperatorRepresentation,
               UnaryOperatorKind, Kind, StringRef, ExpectedRepresentation) {
  if (Node.getOpcode() != Kind || ExpectedRepresentation.empty())
    return false;
 
  const StringRef Spelling =
      getOperatorSpelling(Node.getOperatorLoc(), Finder->getASTContext());
  return !Spelling.empty() && Spelling != ExpectedRepresentation;
}
 
AST_MATCHER_P2(CXXOperatorCallExpr, hasInvalidOverloadedOperatorRepresentation,
               OverloadedOperatorKind, Kind, StringRef,
               ExpectedRepresentation) {
  if (Node.getOperator() != Kind || ExpectedRepresentation.empty())
    return false;
 
  const StringRef Spelling =
      getOperatorSpelling(Node.getOperatorLoc(), Finder->getASTContext());
  return !Spelling.empty() && Spelling != ExpectedRepresentation;
}
 
} // namespace
 
constexpr std::array<std::pair<StringRef, StringRef>, 2U> UnaryRepresentation{
    {{"!", "not"}, {"~", "compl"}}};
 
constexpr std::array<std::pair<StringRef, StringRef>, 9U>
    OperatorsRepresentation{{{"&&", "and"},
                             {"||", "or"},
                             {"^", "xor"},
                             {"&", "bitand"},
                             {"|", "bitor"},
                             {"&=", "and_eq"},
                             {"|=", "or_eq"},
                             {"!=", "not_eq"},
                             {"^=", "xor_eq"}}};
 
static StringRef translate(StringRef Value) {
  for (const auto &[Traditional, Alternative] : UnaryRepresentation) {
    if (Value == Traditional)
      return Alternative;
    if (Value == Alternative)
      return Traditional;
  }
 
  for (const auto &[Traditional, Alternative] : OperatorsRepresentation) {
    if (Value == Traditional)
      return Alternative;
    if (Value == Alternative)
      return Traditional;
  }
  return {};
}
 
static bool isNotOperatorStr(StringRef Value) {
  return translate(Value).empty();
}
 
static bool isSeparator(char C) noexcept {
  constexpr StringRef Separators(" \t\r\n\0()<>{};,");
  return Separators.contains(C);
}
 
static bool needEscaping(StringRef Operator) {
  switch (Operator[0]) {
  case '&':
  case '|':
  case '!':
  case '^':
  case '~':
    return false;
  default:
    return true;
  }
}
 
static StringRef getRepresentation(const std::vector<StringRef> &Config,
                                   StringRef Traditional,
                                   StringRef Alternative) {
  if (llvm::is_contained(Config, Traditional))
    return Traditional;
  if (llvm::is_contained(Config, Alternative))
    return Alternative;
  return {};
}
 
template <typename T>
static bool isAnyOperatorEnabled(const std::vector<StringRef> &Config,
                                 const T &Operators) {
  return llvm::any_of(Operators, [&](const auto &Op) {
    return !getRepresentation(Config, Op.first, Op.second).empty();
  });
}
 
OperatorsRepresentationCheck::OperatorsRepresentationCheck(
    StringRef Name, ClangTidyContext *Context)
    : ClangTidyCheck(Name, Context),
      BinaryOperators(
          utils::options::parseStringList(Options.get("BinaryOperators", ""))),
      OverloadedOperators(utils::options::parseStringList(
          Options.get("OverloadedOperators", ""))) {
  llvm::erase_if(BinaryOperators, isNotOperatorStr);
  llvm::erase_if(OverloadedOperators, isNotOperatorStr);
}
 
void OperatorsRepresentationCheck::storeOptions(
    ClangTidyOptions::OptionMap &Opts) {
  Options.store(Opts, "BinaryOperators",
                utils::options::serializeStringList(BinaryOperators));
  Options.store(Opts, "OverloadedOperators",
                utils::options::serializeStringList(OverloadedOperators));
}
 
std::optional<TraversalKind>
OperatorsRepresentationCheck::getCheckTraversalKind() const {
  return TK_IgnoreUnlessSpelledInSource;
}
 
bool OperatorsRepresentationCheck::isLanguageVersionSupported(
    const LangOptions &LangOpts) const {
  return LangOpts.CPlusPlus;
}
 
void OperatorsRepresentationCheck::registerBinaryOperatorMatcher(
    MatchFinder *Finder) {
  if (!isAnyOperatorEnabled(BinaryOperators, OperatorsRepresentation))
    return;
 
  Finder->addMatcher(
      binaryOperator(
          anyOf(hasInvalidBinaryOperatorRepresentation(
                    BO_LAnd, getRepresentation(BinaryOperators, "&&", "and")),
                hasInvalidBinaryOperatorRepresentation(
                    BO_LOr, getRepresentation(BinaryOperators, "||", "or")),
                hasInvalidBinaryOperatorRepresentation(
                    BO_NE, getRepresentation(BinaryOperators, "!=", "not_eq")),
                hasInvalidBinaryOperatorRepresentation(
                    BO_Xor, getRepresentation(BinaryOperators, "^", "xor")),
                hasInvalidBinaryOperatorRepresentation(
                    BO_And, getRepresentation(BinaryOperators, "&", "bitand")),
                hasInvalidBinaryOperatorRepresentation(
                    BO_Or, getRepresentation(BinaryOperators, "|", "bitor")),
                hasInvalidBinaryOperatorRepresentation(
                    BO_AndAssign,
                    getRepresentation(BinaryOperators, "&=", "and_eq")),
                hasInvalidBinaryOperatorRepresentation(
                    BO_OrAssign,
                    getRepresentation(BinaryOperators, "|=", "or_eq")),
                hasInvalidBinaryOperatorRepresentation(
                    BO_XorAssign,
                    getRepresentation(BinaryOperators, "^=", "xor_eq"))))
          .bind("binary_op"),
      this);
}
 
void OperatorsRepresentationCheck::registerUnaryOperatorMatcher(
    MatchFinder *Finder) {
  if (!isAnyOperatorEnabled(BinaryOperators, UnaryRepresentation))
    return;
 
  Finder->addMatcher(
      unaryOperator(
          anyOf(hasInvalidUnaryOperatorRepresentation(
                    UO_LNot, getRepresentation(BinaryOperators, "!", "not")),
                hasInvalidUnaryOperatorRepresentation(
                    UO_Not, getRepresentation(BinaryOperators, "~", "compl"))))
          .bind("unary_op"),
      this);
}
 
void OperatorsRepresentationCheck::registerOverloadedOperatorMatcher(
    MatchFinder *Finder) {
  if (!isAnyOperatorEnabled(OverloadedOperators, OperatorsRepresentation) &&
      !isAnyOperatorEnabled(OverloadedOperators, UnaryRepresentation))
    return;
 
  Finder->addMatcher(
      cxxOperatorCallExpr(
          anyOf(
              hasInvalidOverloadedOperatorRepresentation(
                  OO_AmpAmp,
                  getRepresentation(OverloadedOperators, "&&", "and")),
              hasInvalidOverloadedOperatorRepresentation(
                  OO_PipePipe,
                  getRepresentation(OverloadedOperators, "||", "or")),
              hasInvalidOverloadedOperatorRepresentation(
                  OO_Exclaim,
                  getRepresentation(OverloadedOperators, "!", "not")),
              hasInvalidOverloadedOperatorRepresentation(
                  OO_ExclaimEqual,
                  getRepresentation(OverloadedOperators, "!=", "not_eq")),
              hasInvalidOverloadedOperatorRepresentation(
                  OO_Caret, getRepresentation(OverloadedOperators, "^", "xor")),
              hasInvalidOverloadedOperatorRepresentation(
                  OO_Amp,
                  getRepresentation(OverloadedOperators, "&", "bitand")),
              hasInvalidOverloadedOperatorRepresentation(
                  OO_Pipe,
                  getRepresentation(OverloadedOperators, "|", "bitor")),
              hasInvalidOverloadedOperatorRepresentation(
                  OO_AmpEqual,
                  getRepresentation(OverloadedOperators, "&=", "and_eq")),
              hasInvalidOverloadedOperatorRepresentation(
                  OO_PipeEqual,
                  getRepresentation(OverloadedOperators, "|=", "or_eq")),
              hasInvalidOverloadedOperatorRepresentation(
                  OO_CaretEqual,
                  getRepresentation(OverloadedOperators, "^=", "xor_eq")),
              hasInvalidOverloadedOperatorRepresentation(
                  OO_Tilde,
                  getRepresentation(OverloadedOperators, "~", "compl"))))
          .bind("overloaded_op"),
      this);
}
 
void OperatorsRepresentationCheck::registerMatchers(MatchFinder *Finder) {
  registerBinaryOperatorMatcher(Finder);
  registerUnaryOperatorMatcher(Finder);
  registerOverloadedOperatorMatcher(Finder);
}
 
void OperatorsRepresentationCheck::check(
    const MatchFinder::MatchResult &Result) {
  SourceLocation Loc;
 
  if (const auto *Op = Result.Nodes.getNodeAs<BinaryOperator>("binary_op"))
    Loc = Op->getOperatorLoc();
  else if (const auto *Op = Result.Nodes.getNodeAs<UnaryOperator>("unary_op"))
    Loc = Op->getOperatorLoc();
  else if (const auto *Op =
               Result.Nodes.getNodeAs<CXXOperatorCallExpr>("overloaded_op"))
    Loc = Op->getOperatorLoc();
 
  if (Loc.isInvalid())
    return;
 
  Loc = Result.SourceManager->getSpellingLoc(Loc);
  if (Loc.isInvalid() || Loc.isMacroID())
    return;
 
  const CharSourceRange TokenRange = CharSourceRange::getTokenRange(Loc);
  if (TokenRange.isInvalid())
    return;
 
  const StringRef Spelling = Lexer::getSourceText(
      TokenRange, *Result.SourceManager, Result.Context->getLangOpts());
  const StringRef TranslatedSpelling = translate(Spelling);
 
  if (TranslatedSpelling.empty())
    return;
 
  std::string FixSpelling = TranslatedSpelling.str();
 
  StringRef SourceRepresentation = "an alternative";
  StringRef TargetRepresentation = "a traditional";
  if (needEscaping(TranslatedSpelling)) {
    SourceRepresentation = "a traditional";
    TargetRepresentation = "an alternative";
 
    const StringRef SpellingEx = Lexer::getSourceText(
        CharSourceRange::getCharRange(
            TokenRange.getBegin().getLocWithOffset(-1),
            TokenRange.getBegin().getLocWithOffset(Spelling.size() + 1U)),
        *Result.SourceManager, Result.Context->getLangOpts());
    if (SpellingEx.empty() || !isSeparator(SpellingEx.front()))
      FixSpelling.insert(FixSpelling.begin(), ' ');
    if (SpellingEx.empty() || !isSeparator(SpellingEx.back()))
      FixSpelling.push_back(' ');
  }
 
  diag(
      Loc,
      "'%0' is %1 token spelling, consider using %2 token '%3' for consistency")
      << Spelling << SourceRepresentation << TargetRepresentation
      << TranslatedSpelling
      << FixItHint::CreateReplacement(TokenRange, FixSpelling);
}
 
} // namespace clang::tidy::readability