[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

16

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;

28–29

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

28–29

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

16

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.

28–29

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

16

Good point, thanks for the clarification!

28–29

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.

159

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

159

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

159

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

126

Please omit Check.

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

7

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 "llvm/ADT/SmallVector.h"
+#include <vector>
+
+namespace clang::tidy::readability {
+
+/// Check helps enforce consistent token representation for 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:
+  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 {
+
+namespace {
+
+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());
+}
+
+AST_MATCHER_P2(BinaryOperator, hasInvalidRepresentationB, 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, hasInvalidRepresentationU, 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, hasInvalidRepresentationO,
+               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", "and;or;not"))),
+      OverloadedOperators(utils::options::parseStringList(
+          Options.get("OverloadedOperators", "and;or;not"))) {
+  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::registerMatchers(MatchFinder *Finder) {
+
+  if (isAnyOperatorEnabled(BinaryOperators, OperatorsRepresentation)) {
+    Finder->addMatcher(
+        binaryOperator(
+            unless(isExpansionInSystemHeader()),
+            anyOf(
+                hasInvalidRepresentationB(
+                    BO_LAnd, getRepresentation(BinaryOperators, "&&", "and")),
+                hasInvalidRepresentationB(
+                    BO_LOr, getRepresentation(BinaryOperators, "||", "or")),
+                hasInvalidRepresentationB(
+                    BO_NE, getRepresentation(BinaryOperators, "!=", "not_eq")),
+                hasInvalidRepresentationB(
+                    BO_Xor, getRepresentation(BinaryOperators, "^", "xor")),
+                hasInvalidRepresentationB(
+                    BO_And, getRepresentation(BinaryOperators, "&", "bitand")),
+                hasInvalidRepresentationB(
+                    BO_Or, getRepresentation(BinaryOperators, "|", "bitor")),
+                hasInvalidRepresentationB(
+                    BO_AndAssign,
+                    getRepresentation(BinaryOperators, "&=", "and_eq")),
+                hasInvalidRepresentationB(
+                    BO_OrAssign,
+                    getRepresentation(BinaryOperators, "|=", "or_eq")),
+                hasInvalidRepresentationB(
+                    BO_XorAssign,
+                    getRepresentation(BinaryOperators, "^=", "xor_eq"))))
+            .bind("bo"),
+        this);
+  }
+
+  if (isAnyOperatorEnabled(BinaryOperators, UnaryRepresentation)) {
+    Finder->addMatcher(
+        unaryOperator(
+            unless(isExpansionInSystemHeader()),
+            anyOf(
+                hasInvalidRepresentationU(
+                    UO_LNot, getRepresentation(BinaryOperators, "!", "not")),
+                hasInvalidRepresentationU(
+                    UO_Not, getRepresentation(BinaryOperators, "~", "compl"))))
+            .bind("uo"),
+        this);
+  }
+
+  if (!isAnyOperatorEnabled(OverloadedOperators, OperatorsRepresentation) &&
+      isAnyOperatorEnabled(OverloadedOperators, UnaryRepresentation))
+    return;
+
+  Finder->addMatcher(
+      cxxOperatorCallExpr(
+          unless(isExpansionInSystemHeader()),
+          anyOf(
+              hasInvalidRepresentationO(
+                  OO_AmpAmp,
+                  getRepresentation(OverloadedOperators, "&&", "and")),
+              hasInvalidRepresentationO(
+                  OO_PipePipe,
+                  getRepresentation(OverloadedOperators, "||", "or")),
+              hasInvalidRepresentationO(
+                  OO_Exclaim,
+                  getRepresentation(OverloadedOperators, "!", "not")),
+              hasInvalidRepresentationO(
+                  OO_ExclaimEqual,
+                  getRepresentation(OverloadedOperators, "!=", "not_eq")),
+              hasInvalidRepresentationO(
+                  OO_Caret, getRepresentation(OverloadedOperators, "^", "xor")),
+              hasInvalidRepresentationO(
+                  OO_Amp,
+                  getRepresentation(OverloadedOperators, "&", "bitand")),
+              hasInvalidRepresentationO(
+                  OO_Pipe,
+                  getRepresentation(OverloadedOperators, "|", "bitor")),
+              hasInvalidRepresentationO(
+                  OO_AmpEqual,
+                  getRepresentation(OverloadedOperators, "&=", "and_eq")),
+              hasInvalidRepresentationO(
+                  OO_PipeEqual,
+                  getRepresentation(OverloadedOperators, "|=", "or_eq")),
+              hasInvalidRepresentationO(
+                  OO_CaretEqual,
+                  getRepresentation(OverloadedOperators, "^=", "xor_eq")),
+              hasInvalidRepresentationO(
+                  OO_Tilde,
+                  getRepresentation(OverloadedOperators, "~", "compl"))))
+          .bind("oo"),
+      this);
+}
+
+void OperatorsRepresentationCheck::check(
+    const MatchFinder::MatchResult &Result) {
+
+  SourceLocation Loc;
+
+  if (const auto *Op = Result.Nodes.getNodeAs<BinaryOperator>("bo"))
+    Loc = Op->getOperatorLoc();
+  else if (const auto *Op = Result.Nodes.getNodeAs<UnaryOperator>("uo"))
+    Loc = Op->getOperatorLoc();
+  else if (const auto *Op = Result.Nodes.getNodeAs<CXXOperatorCallExpr>("oo"))
+    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-avoid-capture-default-when-capturing-this
   Warns when lambda specify a capture default and capture ``this``.
 
 - 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 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 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.
+
+By using this check, you can ensure that your code uses a consistent
+representation of operators, which can improve readability, maintainability,
+and consistency.
+
+To configure the check to enforce the traditional token representation, you can
+set the `BinaryOperators` and `OverloadedOperators` options to ``&&,||,!``,
+respectively. This will cause the check to warn on any occurrences of ``and``,
+``or``, and ``not`` tokens in the code, and suggest using the traditional tokens
+instead.
+
+Note that the check only warns on operator expressions, and will not warn for
+declarations of overloaded operators, or code inside macros.
+
+Whether you choose to use the traditional or alternative token representation
+is up to you, but before you choose traditional representation please read about
+Alternative Token Representation.
+
+Alternative Token Representation
+--------------------------------
+
+C++ Alternative Token Representation (ATR) is a feature introduced in the C++98
+standard that allows programmers to use alternative tokens to represent some of
+the operators in the C++ language. Specifically, the ATR provides alternative
+spellings for some of the commonly used operators, such as ``and``, ``or``,
+``not``, and others. The ATR was introduced to make C++ more readable and to
+provide an alternative to the traditional operators, which some developers
+found hard to read and understand.
+
+.. table:: Token Representation Mapping Table
+    :widths: auto
+
+    =========== ===========
+    Traditional Alternative
+    =========== ===========
+    ``&&``      ``and``
+    ``&=``      ``and_eq``
+    ``&``       ``bitand``
+    ``|``       ``bitor``
+    ``~``       ``compl``
+    ``!``       ``not``
+    ``!=``      ``not_eq``
+    ``||``      ``or``
+    ``|=``      ``or_eq``
+    ``^``       ``xor``
+    ``^=``      ``xor_eq``
+    =========== ===========
+
+One of the main benefits of using ATR is that it can make the code more
+readable and easier to understand. For example, the token ``!`` is a traditional
+representation of the logical NOT operator, but it is small and can be easily
+overlooked during development or code review. Moreover, the ``!`` token can be
+confusing, especially when used in conjunction with other operators, such as
+the bitwise NOT operator ``~``. In contrast, the alternative token ``not`` is
+much more clear and can make the code more readable.
+
+For example, consider the following code:
+
+.. code-block:: c++
+
+    if (!a||!b)
+    {
+        // do something
+    }
+
+
+While the code is correct, the use of the ``!`` token can make it harder to read
+and understand. After using the ``not`` and ``or`` token, the code becomes:
+
+.. code-block:: c++
+
+    if (not a or not b)
+    {
+        // do something
+    }
+
+The use of the ``not`` and ``or`` token makes the code easier to read and
+understand, especially for new developers. Furthermore, the use of the ``not``
+token can also help in cases where the logical NOT operator is used in
+conjunction with other operators, such as ``&&`` or ``^``.
+
+In addition, this check can improve the consistency of code. By using a
+consistent set of tokens throughout a codebase, it can be easier for developers
+to understand and reason about the code. This can be particularly important in
+larger codebases where many different developers may be working on the same
+code.
+
+Consider the following code:
+
+.. code-block:: c++
+
+    if (a || b)
+    {
+        // do something
+    }
+
+This code uses the ``||`` token to represent the logical OR operation. While
+this may be familiar to experienced developers, it can still require some
+mental effort to convert the symbol into the word `or` when reading the code.
+By using the ``or`` token instead, the code can be more easily read and
+understood:
+
+.. code-block:: c++
+
+    if (a or b)
+    {
+        // do something
+    }
+
+In combination with clear function and variable names, code that uses
+alternative token representation can be read like a well-written book, making
+it easier for developers to understand and modify.
+
+Another benefit of using alternative token representation is that many of the
+alternative tokens are keywords in C++. This means that editors and development
+environments are able to highlight them, making the code even more readable.
+Additionally, alternative tokens are easier to distinguish from other
+identifiers in code, further improving code readability and maintainability.
+
+It is important to note that using alternative token representation has some
+drawbacks as well. One of the main drawbacks is that this functionality is not
+compatible with C. Alternative tokens are defined as macros in ``iso646.h`` in C,
+but they are not supported natively in the C language. Furthermore, some
+developers may be more familiar with the traditional operators, which can make
+the code harder to read and understand if alternative tokens are used.
+Additionally, some developers may find the traditional operators more concise
+and easier to use, especially in cases where code size is a concern.
+
+Despite this limitation, the use of alternative token representation is widely
+accepted and recommended in C++ programming. In fact, the C++ standard
+explicitly allows the use of alternative tokens as an alternative to traditional
+tokens. The standard also recommends the use of alternative tokens when they
+make the code more readable and maintainable.
+
+In conclusion, alternative token representation can be a powerful tool for
+improving the readability and maintainability of C++ code. By using clear and
+consistent tokens, developers can make their code easier to read and understand,
+leading to fewer bugs and faster development times. While there are some
+potential drawbacks, the benefits of alternative token representation make it
+a feature that is well worth considering for any C++ project.
+
+Options
+-------
+
+.. option:: BinaryOperators
+
+    This option allows you to specify a semicolon-separated list of binary
+    operators for which you want to enforce specific token representation.
+    Configuration can be mixed, for example: `and;||;not`.
+    The default value is `and;or;not`.
+
+.. option:: OverloadedOperators
+
+    This option allows you to specify a semicolon-separated list of overloaded
+    operators for which you want to enforce specific token representation.
+    Configuration can be mixed, for example: `and;||;not`.
+    The default value is `and;or;not`.

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]]:14: 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]]:14: 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]]:15: 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]]:15: 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]]:13: 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]]:14: 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]]:13: 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]]:11: 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]]:11: 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]]:15: 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]]:11: 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]]:14: 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]]:14: 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]]:15: 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]]:15: 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]]:13: 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]]:14: 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]]:13: 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]]:11: 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]]:11: 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]]:15: 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]]:11: 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]]:14: 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]]:14: 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]]:15: 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]]:15: 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]]:13: 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]]:14: 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]]:13: 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]]:11: 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]]:11: 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]]:15: 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]]:11: 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]]:15: 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]]:15: 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]]:15: 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]]:15: 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]]:13: 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]]:15: 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]]:13: 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]]:11: 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]]:11: 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]]:15: 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]]:11: 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]]:15: 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]]:15: 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]]:15: 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]]:15: 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]]:13: 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]]:15: 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]]:13: 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]]:11: 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]]:11: 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]]:15: 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]]:11: 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]]:15: 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]]:15: 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]]:15: 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]]:15: 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]]:13: 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]]:15: 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]]:13: 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]]:11: 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]]:11: 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]]:15: 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]]:11: warning: 'xor_eq' is an alternative token spelling, consider using a traditional token '^=' for consistency [readability-operators-representation]
+// CHECK-FIXES: {{^    }}clval ^= a;{{$}}
+}