[clang-tidy] Add readability-operators-representation check

[PiotrZSL]

Summary

Check helps enforce consistent token representation for binary, unary and
overloaded operators in C++ code. The check supports both traditional and
alternative representations of operators.

[PiotrZSL]

TODO: Tests still need to be extended to cover conversion of all operators in both direction.

[PiotrZSL]

list.rst correction

[Eugene.Zelenko]

Actually https://github.com/llvm/llvm-project/issues/25569 is exactly about this :-)

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

17

cstring, please.

30

Please don't use auto unless type is spelled explicidly in same statement or iterator.

clang-tools-extra/docs/clang-tidy/checks/readability/operators-representation.rst

155

Clang-tidy.

160

Excessive newline.

[PiotrZSL]

Update tests + change config

[PiotrZSL]

This check replaces D31308 and D107294.

[PiotrZSL]

Style fixes

[PiotrZSL]

Ready for review

[PiotrZSL]

Ping, Rebase

[carlosgalvezp]

clang-tools-extra/docs/clang-tidy/checks/readability/operators-representation.rst

17

Is there any reason why this distinction is needed? The usage of the operator happens in client code - it's unlikely one would want different style depending on whether the operator is overloaded or not?

bool x = some_bool and some_other_bool;
bool y = some_object && some_other_object;

29–30

Personally I find this to be a matter of style, and arguments could be found for either style. As such I don't think this check should promote the style preference of the author of the check.

It's like having a written discussion in the clang-format option ColumnLimit explaining why N characters is a better choice than M characters. In the end this is a decision each project should take, and the check should not have a bias towards a preferred choice.

[carlosgalvezp]

clang-tools-extra/docs/clang-tidy/checks/readability/operators-representation.rst

29–30

FYI @njames93 , do you have an opinion on the matter as Code Owner?

[PiotrZSL]

clang-tools-extra/docs/clang-tidy/checks/readability/operators-representation.rst

17

Consider code like this:

template<typename T>
void archive(T&& a, std::optional<int>& v)
{
    a & v;
}

and

bool test(unsigned value, unsigned mask)
{
    return value & mask;
}

Those are 2 different use-cases, probably you don't want to use bit_and, but you could use bit_and for value & mask.

29–30

Following this way of thinking none of value is correct. Always will be group that is for it or against it. Initially this check had to be only to enforce alternative tokens but then made it configurable and change name of check. This check is for "readability" and alternative tokens are more readable. If someone don't like them, their choose, they can change config to their needs.

[carlosgalvezp]

clang-tools-extra/docs/clang-tidy/checks/readability/operators-representation.rst

17

Good point, thanks for the clarification!

29–30

alternative tokens are more readable

I don't believe this is an objective, universal truth - I think it's very subjective, and you will find people who disagrees.

Take for example the "readability-identifier-naming" check. There's many different conventions supported there, there's no "correct" one and "incorrect" one. Imagine if the author wrote a 100+ lines dissertation about why Hungarian notation is better than the others, and encourage people to choose that.

if someone don't like them, their choose, they can change config to their needs.

Yes, this is exactly what I would expect from this check. My point is that this lengthy discussion here encouraging choosing one style over the other is out of place, cluttering the documentation with content that is not relevant to understand what the check does and how to use it. The check documentation should be neutral and just present the available options. This is consistent with all other checks.

The purpose of this check is not to transform code into ATR style, but rather to ensure consistency in a project, whichever style is wanted.

160

It's unclear what the default value is for the other operators. From the code I see that ATR is the default - in that case I think the documentation should either a) provide the full list of defaults here, or b) simply mention "ATR style is the default". As a user I would prefer the former, so I know what keywords I am allowed to type in here, without having to go and consult cppreference.

Actually, now that I think about it, wouldn't it be better to implement this as an enum, similar to the readability-identifier-naming checks? Is there a use case for having and;||;not, i.e. a mix of style within the same category (e.g. BinaryOperators)?

In that case, it could look something like:

readability-operators-representation.BinaryOperatorsStyle = Traditional
readability-operators-representation.BinaryOperatorsStyle = Alternative

This would be easier to use from a user perspective, and IMHO would lead to a more consistent codebase, where one style or the other is chosen for all operators in each category.

[PiotrZSL]

Update documentation, and config examples, add "Traditional Tokens Representation" section.

clang-tools-extra/docs/clang-tidy/checks/readability/operators-representation.rst

160

I choose this style just because with single option you can define whatever you like.
You can easily be less or more strict, enforce for example alternative tokens for some, and enforce traditional for other.

Entire section "Alternative Token Representation" is here so you wouldn't need to go to cppreference, there is an mapping.

And note that default config don't enforce alternative tokens for all, just for 3 most common.
Not everyone know about alternative token existence. And cppreference don't describe why they exist. This is why this description with examples were added, about pros and some cons. Not only engineers read checks documentations , quality/product managers do that also.
And most of checks descriptions basically don't provide any information that would answer a question: "Why I should enable this check, what I will gain".

I agree, that some additional paragraph about example configurations (less, more strict) and maybe some clarification about options could be added. And some clarification why options are split into two with example, I will think about this.

As for "Alternative Token Representation" if you wan't I can extract from it also "Traditional Token Representation" and put there pros and cons. And move mapping table in front of both of them.

[PiotrZSL]

Update documentation, changed default check configuration.

[carlosgalvezp]

Looks really good, thank you! I have only very minor comments, mostly style nits and suggestions for improved readability.

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

26

As per LLVM guidelines this should be static, outside the anonymous namespace.

177

Nit: would be good to add a one-line comment before each of the code blocks to describe at high-level what they do, to get a better birds-eye view of the code structure in this large function. At first sight it took me a while to spot the difference and understand why it's not exactly duplicated code.

Alternatively creating a function for each of the 3 addMatcher lines could be self-documenting and make the "registerMatches" smaller.

203

Nit: could get a bit more descriptive name, like "binary_op"

221

Is this condition intended to be negated too? Also, would it make sense to move this early return to the beginning of the function?

228

Nit: would be good to spell this out for better readability.

clang-tools-extra/clang-tidy/readability/OperatorsRepresentationCheck.h

14

I believe this include is not in use in this header?

clang-tools-extra/docs/clang-tidy/checks/readability/operators-representation.rst

160

Really appreciate the changes to the documentation, as a user it's much more clear how the check behaves and how to configure it, in a self-contained way!

clang-tools-extra/test/clang-tidy/checkers/readability/operators-representation-to-traditional.cpp

7

Nit: keep indentation to 2 spaces as is standard in the rest of the repo (including tests).

10

Nit: indent comments 2 spaces so they align with the code

[PiotrZSL]

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

221

Good catch.

[PiotrZSL]

Rebase + Fix comments

[Eugene.Zelenko]

clang-tools-extra/docs/ReleaseNotes.rst

139

Please omit Check.

clang-tools-extra/docs/clang-tidy/checks/readability/operators-representation.rst

6

Ditto.

[PiotrZSL]

Fixes in documentation & clang-format

[carlosgalvezp]

LGTM, thanks for the check! Please fix the missing space comment before landing.

clang-tools-extra/clang-tidy/readability/OperatorsRepresentationCheck.h

18

Missing space

[PiotrZSL]

@carlosgalvezp
Thank you, by any chance would you be able to look into other reviews ?

[cjdb]

Thanks so much for seeing this through; I'm unusually looking forward to rebuilding LLVM this weekend!

clang-tools-extra/docs/clang-tidy/checks/readability/operators-representation.rst

83

This is a great solution for ranges pipelines, which I've struggled to work out a good automated policy on for years.

[carlosgalvezp]

In D144522#4236636, @PiotrZSL wrote:

@carlosgalvezp
Thank you, by any chance would you be able to look into other reviews ?

Doing my best to catch up, I have a long list of patches to review! Unfortunately very limited availability at the moment, mostly only weekends. I tend to prioritize smaller patches that fix things since they are easier/faster to review, but I'll definitely come back to your other larger patches when I find some time :)

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

add_clang_library(clangTidyReadabilityModule
   IsolateDeclarationCheck.cpp
   MagicNumbersCheck.cpp
   MakeMemberFunctionConstCheck.cpp
   MisleadingIndentationCheck.cpp
   MisplacedArrayIndexCheck.cpp
   NamedParameterCheck.cpp
   NamespaceCommentCheck.cpp
   NonConstParameterCheck.cpp
+  OperatorsRepresentationCheck.cpp
   QualifiedAutoCheck.cpp
   ReadabilityTidyModule.cpp
   RedundantAccessSpecifiersCheck.cpp
   RedundantControlFlowCheck.cpp
   RedundantDeclarationCheck.cpp
   RedundantFunctionPtrDereferenceCheck.cpp
   RedundantMemberInitCheck.cpp
   RedundantPreprocessorCheck.cpp

clang-tools-extra/clang-tidy/readability/OperatorsRepresentationCheck.h

+//===--- OperatorsRepresentationCheck.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_READABILITY_OPERATORSREPRESENTATIONCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_OPERATORSREPRESENTATIONCHECK_H
+
+#include "../ClangTidyCheck.h"
+#include <vector>
+
+namespace clang::tidy::readability {
+
+/// Check helps enforce consistent token representation for invoked binary,
+/// unary and overloaded operators in C++ code.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/readability/operators-representation.html
+class OperatorsRepresentationCheck : public ClangTidyCheck {
+public:
+  OperatorsRepresentationCheck(StringRef Name, ClangTidyContext *Context);
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+  bool isLanguageVersionSupported(const LangOptions &LangOpts) const override;
+  std::optional<TraversalKind> getCheckTraversalKind() const override;
+
+private:
+  void registerBinaryOperatorMatcher(ast_matchers::MatchFinder *Finder);
+  void registerUnaryOperatorMatcher(ast_matchers::MatchFinder *Finder);
+  void registerOverloadedOperatorMatcher(ast_matchers::MatchFinder *Finder);
+
+  std::vector<llvm::StringRef> BinaryOperators;
+  std::vector<llvm::StringRef> OverloadedOperators;
+};
+
+} // namespace clang::tidy::readability
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_OPERATORSREPRESENTATIONCHECK_H

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

+//===--- OperatorsRepresentationCheck.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 "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 {};
+
+  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, llvm::StringRef, ExpectedRepresentation) {
+  if (Node.getOpcode() != Kind || ExpectedRepresentation.empty())
+    return false;
+
+  StringRef Spelling =
+      getOperatorSpelling(Node.getOperatorLoc(), Finder->getASTContext());
+  return !Spelling.empty() && Spelling != ExpectedRepresentation;
+}
+
+AST_MATCHER_P2(UnaryOperator, hasInvalidUnaryOperatorRepresentation, UnaryOperatorKind,
+               Kind, llvm::StringRef, ExpectedRepresentation) {
+  if (Node.getOpcode() != Kind || ExpectedRepresentation.empty())
+    return false;
+
+  StringRef Spelling =
+      getOperatorSpelling(Node.getOperatorLoc(), Finder->getASTContext());
+  return !Spelling.empty() && Spelling != ExpectedRepresentation;
+}
+
+AST_MATCHER_P2(CXXOperatorCallExpr, hasInvalidOverloadedOperatorRepresentation,
+               OverloadedOperatorKind, Kind, llvm::StringRef,
+               ExpectedRepresentation) {
+  if (Node.getOperator() != Kind || ExpectedRepresentation.empty())
+    return false;
+
+  StringRef Spelling =
+      getOperatorSpelling(Node.getOperatorLoc(), Finder->getASTContext());
+  return !Spelling.empty() && Spelling != ExpectedRepresentation;
+}
+
+} // namespace
+
+constexpr std::array<std::pair<llvm::StringRef, llvm::StringRef>, 2U>
+    UnaryRepresentation{{{"!", "not"}, {"~", "compl"}}};
+
+constexpr std::array<std::pair<llvm::StringRef, llvm::StringRef>, 9U>
+    OperatorsRepresentation{{{"&&", "and"},
+                             {"||", "or"},
+                             {"^", "xor"},
+                             {"&", "bitand"},
+                             {"|", "bitor"},
+                             {"&=", "and_eq"},
+                             {"|=", "or_eq"},
+                             {"!=", "not_eq"},
+                             {"^=", "xor_eq"}}};
+
+static llvm::StringRef translate(llvm::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(llvm::StringRef Value) {
+  return translate(Value).empty();
+}
+
+static bool isSeparator(char C) noexcept {
+  constexpr llvm::StringRef Separators(" \t\r\n\0()<>{};,");
+  return llvm::is_contained(Separators, C);
+}
+
+static bool needEscaping(llvm::StringRef Operator) {
+  switch (Operator[0]) {
+  case '&':
+  case '|':
+  case '!':
+  case '^':
+  case '~':
+    return false;
+  default:
+    return true;
+  }
+}
+
+static llvm::StringRef
+getRepresentation(const std::vector<llvm::StringRef> &Config,
+                  llvm::StringRef Traditional, llvm::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<llvm::StringRef> &Config,
+                                 T &&Operators) {
+  for (const auto &[traditional, alternative] : Operators) {
+    if (!getRepresentation(Config, traditional, alternative).empty())
+      return true;
+  }
+  return false;
+}
+
+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(
+            unless(isExpansionInSystemHeader()),
+            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(
+            unless(isExpansionInSystemHeader()),
+            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(
+          unless(isExpansionInSystemHeader()),
+          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;
+
+  StringRef Spelling = Lexer::getSourceText(TokenRange, *Result.SourceManager,
+                                            Result.Context->getLangOpts());
+  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";
+
+    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

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

 #include "InconsistentDeclarationParameterNameCheck.h"
 #include "IsolateDeclarationCheck.h"
 #include "MagicNumbersCheck.h"
 #include "MakeMemberFunctionConstCheck.h"
 #include "MisleadingIndentationCheck.h"
 #include "MisplacedArrayIndexCheck.h"
 #include "NamedParameterCheck.h"
 #include "NonConstParameterCheck.h"
+#include "OperatorsRepresentationCheck.h"
 #include "QualifiedAutoCheck.h"
 #include "RedundantAccessSpecifiersCheck.h"
 #include "RedundantControlFlowCheck.h"
 #include "RedundantDeclarationCheck.h"
 #include "RedundantFunctionPtrDereferenceCheck.h"
 #include "RedundantMemberInitCheck.h"
 #include "RedundantPreprocessorCheck.h"
 #include "RedundantSmartptrGetCheck.h"
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<MagicNumbersCheck>(
         "readability-magic-numbers");
     CheckFactories.registerCheck<MakeMemberFunctionConstCheck>(
         "readability-make-member-function-const");
     CheckFactories.registerCheck<MisleadingIndentationCheck>(
         "readability-misleading-indentation");
     CheckFactories.registerCheck<MisplacedArrayIndexCheck>(
         "readability-misplaced-array-index");
+    CheckFactories.registerCheck<OperatorsRepresentationCheck>(
+        "readability-operators-representation");
     CheckFactories.registerCheck<QualifiedAutoCheck>(
         "readability-qualified-auto");
     CheckFactories.registerCheck<RedundantAccessSpecifiersCheck>(
         "readability-redundant-access-specifiers");
     CheckFactories.registerCheck<RedundantFunctionPtrDereferenceCheck>(
         "readability-redundant-function-ptr-dereference");
     CheckFactories.registerCheck<RedundantMemberInitCheck>(
         "readability-redundant-member-init");

clang-tools-extra/docs/ReleaseNotes.rst

- New :doc:`cppcoreguidelines-rvalue-reference-param-not-moved
   the function body.
 
 - New :doc:`llvmlibc-inline-function-decl
   <clang-tidy/checks/llvmlibc/inline-function-decl>` check.
 
   Checks that all implicit and explicit inline functions in header files are
   tagged with the ``LIBC_INLINE`` macro.
 
+- New :doc:`readability-operators-representation
+  <clang-tidy/checks/readability/operators-representation>` check.
+
+  Check helps enforce consistent token representation for invoked binary,
+  unary and overloaded operators in C++ code.
+
 New check aliases
 ^^^^^^^^^^^^^^^^^
 
 - New alias :doc:`cert-msc24-c
   <clang-tidy/checks/cert/msc24-c>` to :doc:`bugprone-unsafe-functions
   <clang-tidy/checks/bugprone/unsafe-functions>` was added.
 
 - New alias :doc:`cert-msc33-c

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

.. csv-table::
    `readability-inconsistent-declaration-parameter-name <readability/inconsistent-declaration-parameter-name.html>`_, "Yes"
    `readability-isolate-declaration <readability/isolate-declaration.html>`_, "Yes"
    `readability-magic-numbers <readability/magic-numbers.html>`_,
    `readability-make-member-function-const <readability/make-member-function-const.html>`_, "Yes"
    `readability-misleading-indentation <readability/misleading-indentation.html>`_,
    `readability-misplaced-array-index <readability/misplaced-array-index.html>`_, "Yes"
    `readability-named-parameter <readability/named-parameter.html>`_, "Yes"
    `readability-non-const-parameter <readability/non-const-parameter.html>`_, "Yes"
+   `readability-operators-representation <readability/operators-representation.html>`_, "Yes"
    `readability-qualified-auto <readability/qualified-auto.html>`_, "Yes"
    `readability-redundant-access-specifiers <readability/redundant-access-specifiers.html>`_, "Yes"
    `readability-redundant-control-flow <readability/redundant-control-flow.html>`_, "Yes"
    `readability-redundant-declaration <readability/redundant-declaration.html>`_, "Yes"
    `readability-redundant-function-ptr-dereference <readability/redundant-function-ptr-dereference.html>`_, "Yes"
    `readability-redundant-member-init <readability/redundant-member-init.html>`_, "Yes"
    `readability-redundant-preprocessor <readability/redundant-preprocessor.html>`_,
    `readability-redundant-smartptr-get <readability/redundant-smartptr-get.html>`_, "Yes"

clang-tools-extra/docs/clang-tidy/checks/readability/operators-representation.rst

+.. title:: clang-tidy - readability-operators-representation
+
+readability-operators-representation
+====================================
+
+Check helps enforce consistent token representation for invoked binary, unary
+and overloaded operators in C++ code. The check supports both traditional and
+alternative representations of operators, such as ``&&`` and ``and``, ``||``
+and ``or``, and so on.
+
+In the realm of C++ programming, developers have the option to choose between
+two distinct representations for operators: traditional token representation
+and alternative token representation. Traditional tokens utilize symbols,
+such as ``&&``, ``||``, and ``!``, while alternative tokens employ more
+descriptive words like ``and``, ``or``, and ``not``.
+
+In the following mapping table, a comprehensive list of traditional and
+alternative tokens, along with their corresponding representations,
+is presented:
+
+.. table:: Token Representation Mapping Table
+    :widths: auto
+
+    =========== ===========
+    Traditional Alternative
+    =========== ===========
+    ``&&``      ``and``
+    ``&=``      ``and_eq``
+    ``&``       ``bitand``
+    ``|``       ``bitor``
+    ``~``       ``compl``
+    ``!``       ``not``
+    ``!=``      ``not_eq``
+    ``||``      ``or``
+    ``|=``      ``or_eq``
+    ``^``       ``xor``
+    ``^=``      ``xor_eq``
+    =========== ===========
+
+Example
+-------
+
+.. code-block:: c++
+
+    // Traditional Token Representation:
+
+    if (!a||!b)
+    {
+        // do something
+    }
+
+    // Alternative Token Representation:
+
+    if (not a or not b)
+    {
+        // do something
+    }
+
+Options
+-------
+
+Due to the distinct benefits and drawbacks of each representation, the default
+configuration doesn't enforce either. Explicit configuration is needed.
+
+To configure check to enforce Traditional Token Representation for all
+operators set options to `&&;&=;&;|;~;!;!=;||;|=;^;^=`.
+
+To configure check to enforce Alternative Token Representation for all
+operators set options to
+`and;and_eq;bitand;bitor;compl;not;not_eq;or;or_eq;xor;xor_eq`.
+
+Developers do not need to enforce all operators, and can mix the representations
+as desired by specifying a semicolon-separated list of both traditional and
+alternative tokens in the configuration, such as `and;||;not`.
+
+.. option:: BinaryOperators
+
+    This option allows you to specify a semicolon-separated list of binary
+    operators for which you want to enforce specific token representation.
+    The default value is empty string.
+
+.. option:: OverloadedOperators
+
+    This option allows you to specify a semicolon-separated list of overloaded
+    operators for which you want to enforce specific token representation.
+    The default value is empty string.

clang-tools-extra/test/clang-tidy/checkers/readability/operators-representation-to-alternative.cpp

+// RUN: %check_clang_tidy %s readability-operators-representation %t -- -config="{CheckOptions: [\
+// RUN: {key: readability-operators-representation.BinaryOperators, value: 'and;and_eq;bitand;bitor;compl;not;not_eq;or;or_eq;xor;xor_eq'}, \
+// RUN: {key: readability-operators-representation.OverloadedOperators, value: 'and;and_eq;bitand;bitor;compl;not;not_eq;or;or_eq;xor;xor_eq'}]}" --
+
+void testAllTokensToAlternative(int a, int b) {
+  int value = 0;
+
+  value = a||b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: '||' is a traditional token spelling, consider using an alternative token 'or' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = a or b;{{$}}
+
+  value = a&&b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: '&&' is a traditional token spelling, consider using an alternative token 'and' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = a and b;{{$}}
+
+  value = a | b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: '|' is a traditional token spelling, consider using an alternative token 'bitor' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = a bitor b;{{$}}
+
+  value = a & b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: '&' is a traditional token spelling, consider using an alternative token 'bitand' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = a bitand b;{{$}}
+
+  value = !a;
+  // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: '!' is a traditional token spelling, consider using an alternative token 'not' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = not a;{{$}}
+
+  value = a^b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: '^' is a traditional token spelling, consider using an alternative token 'xor' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = a xor b;{{$}}
+
+  value = ~b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: '~' is a traditional token spelling, consider using an alternative token 'compl' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = compl b;{{$}}
+
+  value &= b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: '&=' is a traditional token spelling, consider using an alternative token 'and_eq' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value and_eq b;{{$}}
+
+  value |= b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: '|=' is a traditional token spelling, consider using an alternative token 'or_eq' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value or_eq b;{{$}}
+
+  value = a != b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: '!=' is a traditional token spelling, consider using an alternative token 'not_eq' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = a not_eq b;{{$}}
+
+  value ^= a;
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: '^=' is a traditional token spelling, consider using an alternative token 'xor_eq' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value xor_eq a;{{$}}
+}
+
+struct Class {
+  bool operator!() const;
+  Class operator~() const;
+  bool operator&&(const Class&) const;
+  Class operator&(const Class&) const;
+  bool operator||(const Class&) const;
+  Class operator|(const Class&) const;
+  Class operator^(const Class&) const;
+  Class& operator&=(const Class&) const;
+  Class& operator|=(const Class&) const;
+  Class& operator^=(const Class&) const;
+  bool operator!=(const Class&) const;
+};
+
+void testAllTokensToAlternative(Class a, Class b) {
+  int value = 0;
+  Class clval;
+
+  value = a||b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: '||' is a traditional token spelling, consider using an alternative token 'or' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = a or b;{{$}}
+
+  value = a&&b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: '&&' is a traditional token spelling, consider using an alternative token 'and' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = a and b;{{$}}
+
+  clval = a | b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: '|' is a traditional token spelling, consider using an alternative token 'bitor' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}clval = a bitor b;{{$}}
+
+  clval = a & b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: '&' is a traditional token spelling, consider using an alternative token 'bitand' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}clval = a bitand b;{{$}}
+
+  value = !a;
+  // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: '!' is a traditional token spelling, consider using an alternative token 'not' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = not a;{{$}}
+
+  clval = a^b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: '^' is a traditional token spelling, consider using an alternative token 'xor' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}clval = a xor b;{{$}}
+
+  clval = ~b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: '~' is a traditional token spelling, consider using an alternative token 'compl' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}clval = compl b;{{$}}
+
+  clval &= b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: '&=' is a traditional token spelling, consider using an alternative token 'and_eq' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}clval and_eq b;{{$}}
+
+  clval |= b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: '|=' is a traditional token spelling, consider using an alternative token 'or_eq' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}clval or_eq b;{{$}}
+
+  value = a != b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: '!=' is a traditional token spelling, consider using an alternative token 'not_eq' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = a not_eq b;{{$}}
+
+  clval ^= a;
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: '^=' is a traditional token spelling, consider using an alternative token 'xor_eq' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}clval xor_eq a;{{$}}
+}
+
+struct ClassO {};
+
+ClassO& operator&=(ClassO&, const ClassO&);
+ClassO& operator|=(ClassO&, const ClassO&);
+ClassO& operator^=(ClassO&, const ClassO&);
+bool operator!=(const ClassO&, const ClassO&);
+bool operator&&(const ClassO&, const ClassO&);
+bool operator||(const ClassO&, const ClassO&);
+bool operator!(const ClassO&);
+ClassO operator&(const ClassO&, const ClassO&);
+ClassO operator|(const ClassO&, const ClassO&);
+ClassO operator^(const ClassO&, const ClassO&);
+ClassO operator~(const ClassO&);
+
+void testAllTokensToAlternative(ClassO a, ClassO b) {
+  int value = 0;
+  ClassO clval;
+
+  value = a||b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: '||' is a traditional token spelling, consider using an alternative token 'or' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = a or b;{{$}}
+
+  value = a&&b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: '&&' is a traditional token spelling, consider using an alternative token 'and' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = a and b;{{$}}
+
+  clval = a | b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: '|' is a traditional token spelling, consider using an alternative token 'bitor' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}clval = a bitor b;{{$}}
+
+  clval = a & b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: '&' is a traditional token spelling, consider using an alternative token 'bitand' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}clval = a bitand b;{{$}}
+
+  value = !a;
+  // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: '!' is a traditional token spelling, consider using an alternative token 'not' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = not a;{{$}}
+
+  clval = a^b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: '^' is a traditional token spelling, consider using an alternative token 'xor' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}clval = a xor b;{{$}}
+
+  clval = ~b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: '~' is a traditional token spelling, consider using an alternative token 'compl' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}clval = compl b;{{$}}
+
+  clval &= b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: '&=' is a traditional token spelling, consider using an alternative token 'and_eq' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}clval and_eq b;{{$}}
+
+  clval |= b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: '|=' is a traditional token spelling, consider using an alternative token 'or_eq' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}clval or_eq b;{{$}}
+
+  value = a != b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: '!=' is a traditional token spelling, consider using an alternative token 'not_eq' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = a not_eq b;{{$}}
+
+  clval ^= a;
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: '^=' is a traditional token spelling, consider using an alternative token 'xor_eq' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}clval xor_eq a;{{$}}
+}

clang-tools-extra/test/clang-tidy/checkers/readability/operators-representation-to-traditional.cpp

+// RUN: %check_clang_tidy %s readability-operators-representation %t -- -config="{CheckOptions: [\
+// RUN: {key: readability-operators-representation.BinaryOperators, value: '&&;&=;&;|;~;!;!=;||;|=;^;^='}, \
+// RUN: {key: readability-operators-representation.OverloadedOperators, value: '&&;&=;&;|;~;!;!=;||;|=;^;^='}]}" --
+
+void testAllTokensToAlternative(int a, int b) {
+  int value = 0;
+
+  value = a or b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'or' is an alternative token spelling, consider using a traditional token '||' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = a || b;{{$}}
+
+  value = a and b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'and' is an alternative token spelling, consider using a traditional token '&&' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = a && b;{{$}}
+
+  value = a bitor b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'bitor' is an alternative token spelling, consider using a traditional token '|' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = a | b;{{$}}
+
+  value = a bitand b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'bitand' is an alternative token spelling, consider using a traditional token '&' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = a & b;{{$}}
+
+  value = not a;
+  // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: 'not' is an alternative token spelling, consider using a traditional token '!' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = ! a;{{$}}
+
+  value = a xor b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'xor' is an alternative token spelling, consider using a traditional token '^' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = a ^ b;{{$}}
+
+  value = compl b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: 'compl' is an alternative token spelling, consider using a traditional token '~' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = ~ b;{{$}}
+
+  value and_eq b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: 'and_eq' is an alternative token spelling, consider using a traditional token '&=' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value &= b;{{$}}
+
+  value or_eq b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: 'or_eq' is an alternative token spelling, consider using a traditional token '|=' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value |= b;{{$}}
+
+  value = a not_eq b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'not_eq' is an alternative token spelling, consider using a traditional token '!=' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = a != b;{{$}}
+
+  value xor_eq a;
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: 'xor_eq' is an alternative token spelling, consider using a traditional token '^=' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value ^= a;{{$}}
+}
+
+struct Class {
+  bool operator!() const;
+  Class operator~() const;
+  bool operator&&(const Class&) const;
+  Class operator&(const Class&) const;
+  bool operator||(const Class&) const;
+  Class operator|(const Class&) const;
+  Class operator^(const Class&) const;
+  Class& operator&=(const Class&) const;
+  Class& operator|=(const Class&) const;
+  Class& operator^=(const Class&) const;
+  bool operator!=(const Class&) const;
+};
+
+void testAllTokensToAlternative(Class a, Class b) {
+  int value = 0;
+  Class clval;
+
+  value = a or b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'or' is an alternative token spelling, consider using a traditional token '||' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = a || b;{{$}}
+
+  value = a and b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'and' is an alternative token spelling, consider using a traditional token '&&' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = a && b;{{$}}
+
+  clval = a bitor b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'bitor' is an alternative token spelling, consider using a traditional token '|' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}clval = a | b;{{$}}
+
+  clval = a bitand b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'bitand' is an alternative token spelling, consider using a traditional token '&' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}clval = a & b;{{$}}
+
+  value = not a;
+  // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: 'not' is an alternative token spelling, consider using a traditional token '!' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = ! a;{{$}}
+
+  clval = a xor b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'xor' is an alternative token spelling, consider using a traditional token '^' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}clval = a ^ b;{{$}}
+
+  clval = compl b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: 'compl' is an alternative token spelling, consider using a traditional token '~' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}clval = ~ b;{{$}}
+
+  clval and_eq b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: 'and_eq' is an alternative token spelling, consider using a traditional token '&=' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}clval &= b;{{$}}
+
+  clval or_eq b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: 'or_eq' is an alternative token spelling, consider using a traditional token '|=' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}clval |= b;{{$}}
+
+  value = a not_eq b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'not_eq' is an alternative token spelling, consider using a traditional token '!=' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = a != b;{{$}}
+
+  clval xor_eq a;
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: 'xor_eq' is an alternative token spelling, consider using a traditional token '^=' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}clval ^= a;{{$}}
+}
+
+struct ClassO {};
+
+ClassO& operator&=(ClassO&, const ClassO&);
+ClassO& operator|=(ClassO&, const ClassO&);
+ClassO& operator^=(ClassO&, const ClassO&);
+bool operator!=(const ClassO&, const ClassO&);
+bool operator&&(const ClassO&, const ClassO&);
+bool operator||(const ClassO&, const ClassO&);
+bool operator!(const ClassO&);
+ClassO operator&(const ClassO&, const ClassO&);
+ClassO operator|(const ClassO&, const ClassO&);
+ClassO operator^(const ClassO&, const ClassO&);
+ClassO operator~(const ClassO&);
+
+void testAllTokensToAlternative(ClassO a, ClassO b) {
+  int value = 0;
+  ClassO clval;
+
+  value = a or b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'or' is an alternative token spelling, consider using a traditional token '||' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = a || b;{{$}}
+
+  value = a and b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'and' is an alternative token spelling, consider using a traditional token '&&' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = a && b;{{$}}
+
+  clval = a bitor b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'bitor' is an alternative token spelling, consider using a traditional token '|' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}clval = a | b;{{$}}
+
+  clval = a bitand b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'bitand' is an alternative token spelling, consider using a traditional token '&' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}clval = a & b;{{$}}
+
+  value = not a;
+  // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: 'not' is an alternative token spelling, consider using a traditional token '!' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = ! a;{{$}}
+
+  clval = a xor b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'xor' is an alternative token spelling, consider using a traditional token '^' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}clval = a ^ b;{{$}}
+
+  clval = compl b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: 'compl' is an alternative token spelling, consider using a traditional token '~' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}clval = ~ b;{{$}}
+
+  clval and_eq b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: 'and_eq' is an alternative token spelling, consider using a traditional token '&=' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}clval &= b;{{$}}
+
+  clval or_eq b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: 'or_eq' is an alternative token spelling, consider using a traditional token '|=' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}clval |= b;{{$}}
+
+  value = a not_eq b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'not_eq' is an alternative token spelling, consider using a traditional token '!=' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}value = a != b;{{$}}
+
+  clval xor_eq a;
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: 'xor_eq' is an alternative token spelling, consider using a traditional token '^=' for consistency [readability-operators-representation]
+  // CHECK-FIXES: {{^  }}clval ^= a;{{$}}
+}