[clang-tidy] add cppcoreguidelines-symmetric-binary-operator

[5chmidti]

Summary

Adds a check for C++ Core Guidelines "C.161: Use non-member functions for symmetric operators"
Produces a warning on member operators that are symmetric binary operators
and generates fixes for symmetric defaulted comparison operators to be changed
to friend operator functions.

[5chmidti]

rm unused function

[5chmidti]

rm wrong op from isComparisonOperator

[Eugene.Zelenko]

Please note that documentation and test locations were changed recently. Please rebase from main and make necessary changes.

clang-tools-extra/clang-tidy/cppcoreguidelines/SymmetricBinaryOperatorCheck.h

28

Please add isLanguageVersionSupported.

clang-tools-extra/docs/ReleaseNotes.rst

139

Please keep alphabetic order of entries.

142

One sentence should be enough.

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines-symmetric-binary-operator.rst

6 ↗

(On Diff #441186)

Please make first sentence same as in Release Notes.

10 ↗

(On Diff #441186)

This should be at end of documentation.

[5chmidti]

Addressed comments

[5chmidti]

Fixup addressing comments, missed changing the links for docs

[5chmidti]

Fixup for the same reason

[Eugene.Zelenko]

clang-tools-extra/clang-tidy/cppcoreguidelines/SymmetricBinaryOperatorCheck.h

29

This method is usually inlined.

[5chmidti]

Address inlining isLanguageVersionSupported

[5chmidti]

Question: Should this check be extended to also include C.86: "Flag an operator==() for which the argument types differ; same for other comparison operators: !=, <, <=, >, and >=."? With a warning along the lines of: "comparison operators should be symmetric with respect to the parameters types" or "parameters of comparison operators should be of the same type" (or some other warning). Or should that be a new check? I think it fits.

[5chmidti]

Ping

[5chmidti]

Gentle Ping

[5chmidti]

Ping

[njames93]

clang-tools-extra/clang-tidy/cppcoreguidelines/SymmetricBinaryOperatorCheck.cpp

25–35

Just bring the whole namespace into scope.

57

Could these not be represented as a bitset?

85

Should there ever be a case where this returns an error. If not can this assert instead and just return a DynTypedNode?

118–123

Looks like this is begging to be a while loop.

130–134

If its unreachable, use unreachable to indicate that.

135

This semi-colon looks suspicious

136–137

Is this error reachable? Again if not use unreachable.
If it is reachable, is it possible to show a test case where this error is expected and detected in the test?

[5chmidti]

I've got everything done locally, but I'm waiting on the decision on the bitset to update the diff, including some minor additional updates I will list then.

clang-tools-extra/clang-tidy/cppcoreguidelines/SymmetricBinaryOperatorCheck.cpp

57

Yes. I changed this to use a bitset. While changing it I thought about the performance and came to these two solutions:
A) is straight forward but suffers from bad-ish code gen when doing -O0 (58 instructions), on -O1 and up it's just 4 instructions.

bool isComparisonOperator(OverloadedOperatorKind Kind) {
  std::bitset<NUM_OVERLOADED_OPERATORS> BitSetCompOps{};
  BitSetCompOps.set(OO_Less);
  BitSetCompOps.set(OO_Greater);
  BitSetCompOps.set(OO_EqualEqual);
  BitSetCompOps.set(OO_ExclaimEqual);
  BitSetCompOps.set(OO_LessEqual);
  BitSetCompOps.set(OO_GreaterEqual);
  BitSetCompOps.set(OO_Spaceship);
  BitSetCompOps.set(OO_AmpAmp);
  BitSetCompOps.set(OO_PipePipe);
  return BitSetCompOps[Kind];
}

B) the same, but this emits much less code during -O0 (14 instructions) and for -O1 and up it's the same as A)

template <OverloadedOperatorKind... ComparisonKinds>
constexpr size_t isComparisonOperatorGenerateBitset() {
  return ((static_cast<size_t>(1U) << ComparisonKinds) | ...);
}

bool isComparisonOperator(OverloadedOperatorKind Kind) {
  constexpr static auto BitsetCompOps = isComparisonOperatorGenerateBitset<
      OO_Less, OO_Greater, OO_EqualEqual, OO_ExclaimEqual, OO_LessEqual,
      OO_GreaterEqual, OO_Spaceship, OO_AmpAmp, OO_PipePipe>();
  return BitsetCompOps & (static_cast<size_t>(1U) << Kind);
}

See also https://godbolt.org/z/E9aeW67xb for both examples.
I think B) would be better, but I thought I'd ask before going with a parameter pack instead of the std::bitset.

85

I got this bit from the Transformer lib implementation, but you're right, there are no paths in this check that call getNode with an unbound ID.

136–137

Yes it's unreachable, constSpec get's only called on bound node "op" which is a CXXMethodDecl. Changed it to llvm_unreachable like the other unreachable.

[njames93]

clang-tools-extra/clang-tidy/cppcoreguidelines/SymmetricBinaryOperatorCheck.cpp

57

If the optimiser is able to see through the original set up then there's no issue and the initial code should be fine.

85

In which case make the below an assert and return by DynTypedNode.

[5chmidti]

• address all comments
• minor renames of variables/functions
• add missing & when accessing OptTokens value
• rebase onto current HEAD
• fix llvm::Optional member deprecation warnings
• add support to match when the parameter type explicitly instantiaties itself (i.e. const A<T>& instead of const A& for template <typename T> struct A {...};)

[5chmidti]

lower c++ version requirement by making the fixes conditional on c++20 instead of the whole check

[5chmidti]

Ping

[5chmidti]

Ping

[5chmidti]

Ping

[5chmidti]

Because there was no activity on this patch, I am closing it. I should've pinged a bit more :)
With the move to GitHub pull requests soon, pushing this patch further in phabricator does not make sense to me. Instead, I could reopen this patch as a pull request. There are some problems I have encountered anyway that need fixing.
Is there general interest in this check?
The cppcoreguidelines prefix could be changed to something else (e.g. modernize), if that is a hindrance.

[PiotrZSL]

For me check is fine and bring some value. But for me auto-fixes in this check aren't needed, this simply complicate a check that could be very simple.

[5chmidti]

In D128861#4604193, @PiotrZSL wrote:

But for me auto-fixes in this check aren't needed, this simply complicate a check that could be very simple.

You might be right. I will fix the issues I have found and will propose this check without the fixes. For completeness, I will mention that I have the implementation for them available, and raise your concern about the complexity of introducing these fixes.

[PiotrZSL]

clang-tools-extra/clang-tidy/cppcoreguidelines/SymmetricBinaryOperatorCheck.cpp

30

again, I would probably try to generate simple switch with those macros., and this function should be static.

49

For me this function is overkill, I would use simple switch and let compiler optimize it. except that should be static.

63–69

put matchers into anonymous namespace....

165

Consider writing this check as an normal simple one without using TransformerClangTidyCheck as base. After that half of this code won't be needed, and it will be very easy to maintain/fix/extend it.

[5chmidti]

Thanks for your review comments :) . I'll incorporate them and reference your comments when I post the patch.

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

add_clang_library(clangTidyCppCoreGuidelinesModule
   ProTypeCstyleCastCheck.cpp
   ProTypeMemberInitCheck.cpp
   ProTypeReinterpretCastCheck.cpp
   ProTypeStaticCastDowncastCheck.cpp
   ProTypeUnionAccessCheck.cpp
   ProTypeVarargCheck.cpp
   SlicingCheck.cpp
   SpecialMemberFunctionsCheck.cpp
+  SymmetricBinaryOperatorCheck.cpp
   VirtualClassDestructorCheck.cpp
 
   LINK_LIBS
   clangTidy
   clangTidyMiscModule
   clangTidyModernizeModule
   clangTidyReadabilityModule
   clangTidyUtils

clang-tools-extra/clang-tidy/cppcoreguidelines/CppCoreGuidelinesTidyModule.cpp

 #include "ProTypeCstyleCastCheck.h"
 #include "ProTypeMemberInitCheck.h"
 #include "ProTypeReinterpretCastCheck.h"
 #include "ProTypeStaticCastDowncastCheck.h"
 #include "ProTypeUnionAccessCheck.h"
 #include "ProTypeVarargCheck.h"
 #include "SlicingCheck.h"
 #include "SpecialMemberFunctionsCheck.h"
+#include "SymmetricBinaryOperatorCheck.h"
 #include "VirtualClassDestructorCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace cppcoreguidelines {
 
 /// A module containing checks of the C++ Core Guidelines
 class CppCoreGuidelinesModule : public ClangTidyModule {
CheckFactories.registerCheck<ProTypeUnionAccessCheck>(
         "cppcoreguidelines-pro-type-union-access");
     CheckFactories.registerCheck<ProTypeVarargCheck>(
         "cppcoreguidelines-pro-type-vararg");
     CheckFactories.registerCheck<SpecialMemberFunctionsCheck>(
         "cppcoreguidelines-special-member-functions");
     CheckFactories.registerCheck<SlicingCheck>("cppcoreguidelines-slicing");
     CheckFactories.registerCheck<misc::UnconventionalAssignOperatorCheck>(
         "cppcoreguidelines-c-copy-assignment-signature");
+    CheckFactories.registerCheck<SymmetricBinaryOperatorCheck>(
+        "cppcoreguidelines-symmetric-binary-operator");
     CheckFactories.registerCheck<VirtualClassDestructorCheck>(
         "cppcoreguidelines-virtual-class-destructor");
   }
 
   ClangTidyOptions getModuleOptions() override {
     ClangTidyOptions Options;
     ClangTidyOptions::OptionMap &Opts = Options.CheckOptions;
 

clang-tools-extra/clang-tidy/cppcoreguidelines/SymmetricBinaryOperatorCheck.h

+//===--- SymmetricBinaryOperatorCheck.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_CPPCOREGUIDELINES_SYMMETRICBINARYOPERATORCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_SYMMETRICBINARYOPERATORCHECK_H
+
+#include "../utils/TransformerClangTidyCheck.h"
+
+namespace clang {
+namespace tidy {
+namespace cppcoreguidelines {
+
+/// Finds operators that are symmetric with respect to the type of their
+/// parameters. Warns that such operators should be friend functions or free
+/// functions. Generates fixes to change defaulted comparison operators to
+/// defaulted friend operators. See also C.161.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-symmetric-binary-operator.html
+class SymmetricBinaryOperatorCheck : public utils::TransformerClangTidyCheck {
+public:
+  SymmetricBinaryOperatorCheck(StringRef Name, ClangTidyContext *Context);
+
+  bool isLanguageVersionSupported(const LangOptions &LangOpts) const override;
+};
+
+} // namespace cppcoreguidelines
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_SYMMETRICBINARYOPERATORCHECK_H

clang-tools-extra/clang-tidy/cppcoreguidelines/SymmetricBinaryOperatorCheck.cpp

+//===--- SymmetricBinaryOperatorCheck.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 "SymmetricBinaryOperatorCheck.h"
+#include "../utils/LexerUtils.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/Basic/SourceLocation.h"
+#include "clang/Tooling/Transformer/RangeSelector.h"
+#include "clang/Tooling/Transformer/RewriteRule.h"
+#include "clang/Tooling/Transformer/Stencil.h"
+#include "llvm/ADT/StringRef.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace cppcoreguidelines {
+using transformer::applyFirst;
+using transformer::cat;
+using transformer::changeTo;
+using transformer::insertBefore;
+using transformer::makeRule;
+using transformer::name;
+using transformer::node;
+using transformer::noopEdit;
+using transformer::RangeSelector;
+using transformer::remove;
+using transformer::RewriteRule;
+
+bool isPotentialBinaryOperator(OverloadedOperatorKind Kind) {
+  return llvm::is_contained(
+      std::initializer_list<OverloadedOperatorKind>{
+#define OVERLOADED_OPERATOR_true(Name) OO_##Name,
+#define OVERLOADED_OPERATOR_false(Name)
+
+#define OVERLOADED_OPERATOR_IS_ASSIGNMENT_true(Name, Binary)
+#define OVERLOADED_OPERATOR_IS_ASSIGNMENT_false(Name, Binary)                  \
+  OVERLOADED_OPERATOR_##Binary(Name)
+
+#define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly)  \
+  OVERLOADED_OPERATOR_IS_ASSIGNMENT_##MemberOnly(Name, Binary)
+#define OVERLOADED_OPERATOR_MULTI(Name, Spelling, Unary, Binary, MemberOnly)
+
+#include "clang/Basic/OperatorKinds.def"
+      },
+      Kind);
+}
+
+bool isComparisonOperator(OverloadedOperatorKind Kind) {
+  return llvm::is_contained(
+      std::initializer_list<OverloadedOperatorKind>{
+          OO_Less,
+          OO_Greater,
+          OO_EqualEqual,
+          OO_ExclaimEqual,
+          OO_LessEqual,
+          OO_GreaterEqual,
+          OO_Spaceship,
+          OO_AmpAmp,
+          OO_PipePipe,
+      },
+      Kind);
+}
+
+AST_MATCHER(CXXMethodDecl, isPotentialBinaryOperator) {
+  return isPotentialBinaryOperator(Node.getOverloadedOperator());
+}
+
+AST_MATCHER(CXXMethodDecl, isComparisonOperator) {
+  return isComparisonOperator(Node.getOverloadedOperator());
+}
+
+static llvm::Error invalidArgumentError(Twine Message) {
+  return llvm::make_error<llvm::StringError>(llvm::errc::invalid_argument,
+                                             Message);
+}
+
+static Expected<DynTypedNode> getNode(const BoundNodes &Nodes, StringRef ID) {
+  auto &NodesMap = Nodes.getMap();
+  auto It = NodesMap.find(ID);
+  if (It == NodesMap.end())
+    return invalidArgumentError("ID not bound: " + ID);
+  return It->second;
+}
+
+static RangeSelector constSpec(std::string ID) {
+  return [ID](const MatchFinder::MatchResult &Result)
+             -> Expected<CharSourceRange> {
+    Expected<DynTypedNode> Node = getNode(Result.Nodes, ID);
+
+    if (!Node)
+      return Node.takeError();
+
+    if (const auto *Method = Node->get<CXXMethodDecl>()) {
+      const SourceLocation ParensEndLoc =
+          Method->getFunctionTypeLoc().getParensRange().getEnd();
+
+      const auto GetNextToken = [&](const SourceLocation Loc) {
+        return utils::lexer::findNextTokenSkippingComments(
+            Loc, *Result.SourceManager, Result.Context->getLangOpts());
+      };
+
+      llvm::Optional<Token> OptToken{GetNextToken(ParensEndLoc)};
+
+      const auto IsConstToken = [](Token &Tok) {
+        return Tok.is(tok::TokenKind::kw_const) ||
+               (Tok.is(tok::TokenKind::raw_identifier) &&
+                Tok.getRawIdentifier().equals("const"));
+      };
+
+      for (; OptToken.hasValue() && !IsConstToken(OptToken.getValue()) &&
+             !OptToken.getValue().isOneOf(tok::TokenKind::l_brace,
+                                          tok::TokenKind::kw_default,
+                                          tok::TokenKind::semi);
+           OptToken = GetNextToken(OptToken.getValue().getLocation())) {
+      }
+
+      if (OptToken.hasValue() && IsConstToken(OptToken.getValue())) {
+        const auto Token = OptToken.getValue();
+        return CharSourceRange::getCharRange(Token.getLocation(),
+                                             Token.getEndLoc());
+      }
+      // This error is unreachable within this check. constSpec is only called
+      // on defaulted symmetric binary operators, which are required to be const
+      // specified.
+      return invalidArgumentError(
+          "constSpec invalid argument: member function is not const qualified");
+    };
+    return invalidArgumentError(
+        "constSpec invalid argument: not a CXXMethodDecl");
+  };
+}
+
+static transformer::RewriteRuleWith<std::string> makeRewriteRule() {
+  const auto Parameter =
+      parmVarDecl(hasType(qualType(references(cxxRecordDecl().bind("record")))))
+          .bind("param");
+
+  const auto IsBinaryOperator =
+      cxxMethodDecl(isPotentialBinaryOperator(), hasParameter(0, Parameter));
+
+  // Using hasParent instead of ofClass because we want to match declarations
+  // within the CXXRecord and not an outside definition
+  const auto BaseMatch =
+      cxxMethodDecl(IsBinaryOperator, unless(hasAncestor(functionDecl())),
+                    hasParent(cxxRecordDecl(equalsBoundNode("record"))))
+          .bind("op");
+  const auto MatchDefaultedComparisonOperator =
+      cxxMethodDecl(BaseMatch, isDefaulted(), isComparisonOperator());
+
+  const auto AddFriendToFunctionDecl = insertBefore(node("op"), cat("friend "));
+  const auto RemoveConst = remove(constSpec("op"));
+  const auto AddSecondParameterToDeclaration =
+      changeTo(node("param"),
+               cat("const ", name("record"), "&, const ", name("record"), "&"));
+
+  const auto WarningMessage = cat(
+      "symmetric binary operator should be a friend or free operator function");
+
+  return applyFirst(
+      {makeRule(MatchDefaultedComparisonOperator,
+                {AddFriendToFunctionDecl, RemoveConst,
+                 AddSecondParameterToDeclaration},
+                WarningMessage),
+       makeRule(BaseMatch, noopEdit(node("op")), WarningMessage)});
+}
+
+SymmetricBinaryOperatorCheck::SymmetricBinaryOperatorCheck(
+    StringRef Name, ClangTidyContext *Context)
+    : TransformerClangTidyCheck(makeRewriteRule(), Name, Context) {}
+
+bool SymmetricBinaryOperatorCheck::isLanguageVersionSupported(
+    const LangOptions &LangOpts) const {
+  return LangOpts.CPlusPlus20;
+}
+} // namespace cppcoreguidelines
+} // namespace tidy
+} // namespace clang

clang-tools-extra/docs/ReleaseNotes.rst

- New :doc:`bugprone-shared-ptr-array-mismatch <clang-tidy/checks/bugprone/shared-ptr-array-mismatch>` check.
   Finds initializations of C++ shared pointers to non-array type that are initialized with an array.
 
 - New :doc:`bugprone-unchecked-optional-access
   <clang-tidy/checks/bugprone/unchecked-optional-access>` check.
 
   Warns when the code is unwrapping a `std::optional<T>`, `absl::optional<T>`,
   or `base::Optional<T>` object without assuring that it contains a value.
 
+- New :doc:`cppcoreguidelines-symmetric-binary-operator <clang-tidy/checks/cppcoreguidelines/symmetric-binary-operator>` check.
+
+  Warns that symmetric binary operators should be friend or free functions.
+
 - New :doc:`misc-confusable-identifiers <clang-tidy/checks/misc/confusable-identifiers>` check.
 
   Detects confusable Unicode identifiers.
 
 - New :doc:`modernize-macro-to-enum
   <clang-tidy/checks/modernize/macro-to-enum>` check.
 
   Replaces groups of adjacent macros with an unscoped anonymous enum.
 
 - New :doc:`portability-std-allocator-const <clang-tidy/checks/portability/std-allocator-const>` check.
 
   Report use of ``std::vector<const T>`` (and similar containers of const
   elements). These are not allowed in standard C++ due to undefined
   ``std::allocator<const T>``. They do not compile with libstdc++ or MSVC.
   Future libc++ will remove the extension (`D120996
   <https://reviews.llvm.org/D120996>`).

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines/symmetric-binary-operator.rst

+.. title:: clang-tidy - cppcoreguidelines-symmetric-binary-operator
+
+cppcoreguidelines-symmetric-binary-operator
+===========================================
+
+Warns that symmetric binary operators should be friend or free functions.
+
+Operators are considered symmetric if the type of lhs and rhs are the same as the record they are declared in.
+
+Given a simple struct with member operators
+(incomplete set of operators, for demonstration purposes only)
+
+.. code-block:: c++
+
+   struct A {
+        int X;
+        // Member-operator that is symmetric, defaulted and a comparison operator
+        bool operator==(const A &) const = default; // Warn + fix
+        A operator+(const A &rhs) const { return A{X + rhs.X}; } // Warn
+    };
+
+the check matches both member operators ``operator==`` and ``operator+`` and
+warns on both occasions that it is a symmetric binary operator that should be a friend or free function.
+Additionally, a fix is created for symmetric comparison operators, ``operator==`` in the example,
+that rewrites the operator to a friend operator function
+
+.. code-block:: c++
+
+   struct A {
+        int X;
+        friend bool operator==(const A &, const A &) = default;  // Rewritten operator
+        A operator+(const A &rhs) const { return A{X + rhs.X}; }
+    };
+
+The check is based on `C++ Core Guidelines C.161 <https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#c161-use-non-member-functions-for-symmetric-operators>`

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

.. csv-table::
    `cppcoreguidelines-pro-type-cstyle-cast <cppcoreguidelines/pro-type-cstyle-cast.html>`_, "Yes"
    `cppcoreguidelines-pro-type-member-init <cppcoreguidelines/pro-type-member-init.html>`_, "Yes"
    `cppcoreguidelines-pro-type-reinterpret-cast <cppcoreguidelines/pro-type-reinterpret-cast.html>`_,
    `cppcoreguidelines-pro-type-static-cast-downcast <cppcoreguidelines/pro-type-static-cast-downcast.html>`_, "Yes"
    `cppcoreguidelines-pro-type-union-access <cppcoreguidelines/pro-type-union-access.html>`_,
    `cppcoreguidelines-pro-type-vararg <cppcoreguidelines/pro-type-vararg.html>`_,
    `cppcoreguidelines-slicing <cppcoreguidelines/slicing.html>`_,
    `cppcoreguidelines-special-member-functions <cppcoreguidelines/special-member-functions.html>`_,
+   `cppcoreguidelines-symmetric-binary-operator <cppcoreguidelines/symmetric-binary-operator.html>`_, "Yes"
    `cppcoreguidelines-virtual-class-destructor <cppcoreguidelines/virtual-class-destructor.html>`_, "Yes"
    `darwin-avoid-spinlock <darwin/avoid-spinlock.html>`_,
    `darwin-dispatch-once-nonstatic <darwin/dispatch-once-nonstatic.html>`_, "Yes"
    `fuchsia-default-arguments-calls <fuchsia/default-arguments-calls.html>`_,
    `fuchsia-default-arguments-declarations <fuchsia/default-arguments-declarations.html>`_, "Yes"
    `fuchsia-multiple-inheritance <fuchsia/multiple-inheritance.html>`_,
    `fuchsia-overloaded-operator <fuchsia/overloaded-operator.html>`_,
    `fuchsia-statically-constructed-objects <fuchsia/statically-constructed-objects.html>`_,

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/symmetric-binary-operator.cpp

+// RUN: %check_clang_tidy -std=c++20 %s cppcoreguidelines-symmetric-binary-operator %t
+
+namespace std {
+class string {
+public:
+  friend bool operator!=(const string &, const string &) { return true; }
+  friend bool operator<(const string &, const string &) { return true; }
+};
+template <typename T>
+class vector {
+public:
+  int size() const;
+  const T &operator[](int) const;
+  friend bool operator==(const vector &, const vector &) = default;
+};
+} // namespace std
+
+using size_t = unsigned long long;
+
+namespace test_base {
+struct A {
+  int X;
+  bool operator==(const A &) const = default;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+  // CHECK-FIXES: friend bool operator==(const A&, const A&) = default;
+};
+
+struct A2 {
+  int X;
+  bool operator==(const A2 &rhs) const = default;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+  // CHECK-FIXES: friend bool operator==(const A2&, const A2&) = default;
+};
+
+struct B {
+  int X;
+  friend bool operator==(const B &, const B &) = default;
+};
+
+template <typename T>
+struct C {
+  int X;
+  bool operator==(const C &) const = default;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+  // CHECK-FIXES: friend bool operator==(const C&, const C&) = default;
+};
+
+template <typename T>
+struct D {
+  int X;
+  friend bool operator==(const D &, const D &) = default;
+};
+
+struct E {
+  int X;
+  bool operator==(const E &) const = default;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+  // CHECK-FIXES: friend bool operator==(const E&, const E&) = default;
+};
+
+struct F {
+  int X;
+  friend bool operator==(const F &, const F &) = default;
+};
+
+template <typename T>
+struct G {
+  int X;
+  bool operator==(const G &) const = default;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+  // CHECK-FIXES: friend bool operator==(const G&, const G&) = default;
+};
+
+template <typename T>
+struct H {
+  int X;
+  friend bool operator==(const H &, const H &) = default;
+};
+} // namespace test_base
+
+namespace test_constexpr {
+struct A {
+  int X;
+  constexpr bool operator==(const A &) const = default;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+  // CHECK-FIXES: friend constexpr bool operator==(const A&, const A&) = default;
+};
+
+struct B {
+  int X;
+  friend constexpr bool operator==(const B &, const B &) = default;
+};
+
+template <typename T>
+struct C {
+  int X;
+  constexpr bool operator==(const C &) const = default;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+  // CHECK-FIXES: friend constexpr bool operator==(const C&, const C&) = default;
+};
+
+template <typename T>
+struct D {
+  int X;
+  friend constexpr bool operator==(const D &, const D &) = default;
+};
+
+struct E {
+  int X;
+  constexpr bool operator==(const E &) const = default;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+  // CHECK-FIXES: friend constexpr bool operator==(const E&, const E&) = default;
+};
+
+struct F {
+  int X;
+  friend constexpr bool operator==(const F &, const F &) = default;
+};
+
+template <typename T>
+struct G {
+  int X;
+  constexpr bool operator==(const G &) const = default;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+  // CHECK-FIXES: friend constexpr bool operator==(const G&, const G&) = default;
+};
+
+template <typename T>
+struct H {
+  int X;
+  friend constexpr bool operator==(const H &, const H &) = default;
+};
+} // namespace test_constexpr
+
+namespace test_trailing_return_type {
+struct A {
+  int X;
+  auto operator==(const A &) const -> bool = default;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+  // CHECK-FIXES: friend auto operator==(const A&, const A&) -> bool = default;
+};
+
+struct B {
+  int X;
+  friend auto operator==(const B &, const B &) -> bool = default;
+};
+
+template <typename T>
+struct C {
+  int X;
+  auto operator==(const C &) const -> bool = default;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+  // CHECK-FIXES: friend auto operator==(const C&, const C&) -> bool = default;
+};
+
+template <typename T>
+struct D {
+  int X;
+  friend auto operator==(const D &, const D &) -> bool = default;
+};
+
+struct E {
+  int X;
+  auto operator==(const E &) const -> bool = default;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+  // CHECK-FIXES: friend auto operator==(const E&, const E&) -> bool = default;
+};
+
+struct F {
+  int X;
+  friend auto operator==(const F &, const F &) -> bool = default;
+};
+
+template <typename T>
+struct G {
+  int X;
+  auto operator==(const G &) const -> bool = default;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+  // CHECK-FIXES: friend auto operator==(const G&, const G&) -> bool = default;
+};
+
+template <typename T>
+struct H {
+  int X;
+  friend auto operator==(const H &, const H &) -> bool = default;
+};
+} // namespace test_trailing_return_type
+
+namespace non_default {
+struct A {
+  int X;
+  bool operator==(const A &rhs) const {
+    return X == rhs.X;
+  }
+  // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+};
+
+template <typename T>
+struct C {
+  int X;
+  bool operator==(const C &rhs) const {
+    return X == rhs.X;
+  }
+  // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+};
+} // namespace non_default
+
+namespace non_const {
+struct A {
+  int X;
+  bool operator==(const A &rhs) {
+    return X == rhs.X;
+  }
+  // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+};
+
+template <typename T>
+struct C {
+  int X;
+  bool operator==(const C &rhs) {
+    return X == rhs.X;
+  }
+  // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+};
+} // namespace non_const
+
+namespace out_of_class_definition {
+struct A {
+  int X;
+  bool operator==(const A &rhs) const;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+};
+
+bool A::operator==(const A &rhs) const {
+  return X == rhs.X;
+}
+
+struct B {
+  int X;
+  bool operator==(const B &rhs) const;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+};
+
+template <typename T>
+struct C {
+  int X;
+  bool operator==(const C &rhs) const;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+};
+
+template <typename T>
+bool C<T>::operator==(const C<T> &rhs) const {
+  return X == rhs.X;
+}
+} // namespace out_of_class_definition
+
+bool out_of_class_definition::B::operator==(const B &rhs) const {
+  return X == rhs.X;
+}
+
+namespace templates_no_match {
+template <typename T>
+struct A {
+  bool operator==(const T &);
+};
+
+struct B {
+  template <typename T>
+  bool operator==(const T &);
+};
+
+template <typename T>
+struct C {
+  template <typename W>
+  bool operator==(const C<W> &);
+  bool operator!=(const C<int> &);
+};
+
+} // namespace templates_no_match
+
+namespace test_base_definition_not_visible {
+struct A {
+  int X;
+  bool operator==(const A &) const;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+};
+
+struct A2 {
+  int X;
+  bool operator==(const A2 &rhs) const;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+};
+
+struct B {
+  int X;
+  friend bool operator==(const B &, const B &);
+};
+
+template <typename T>
+struct C {
+  int X;
+  bool operator==(const C &) const;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+};
+
+template <typename T>
+struct D {
+  int X;
+  friend bool operator==(const D &, const D &);
+};
+
+struct E {
+  int X;
+  bool operator==(const E &) const;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+};
+
+struct F {
+  int X;
+  friend bool operator==(const F &, const F &);
+};
+
+template <typename T>
+struct G {
+  int X;
+  bool operator==(const G &) const;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+};
+
+template <typename T>
+struct H {
+  int X;
+  friend bool operator==(const H &, const H &);
+};
+} // namespace test_base_definition_not_visible
+
+namespace additional_operators {
+struct A {
+  bool operator<(const A &);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+  bool operator+(const A &);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+  bool operator<<(const A &);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+  bool operator&&(const A &);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+  bool operator,(const A &);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+
+  bool operator<(const int &);
+  bool operator+(const int &);
+  bool operator<<(const int &);
+  bool operator&&(const int &);
+  bool operator,(const int &);
+};
+
+template <typename T>
+struct B {
+  bool operator<(const B &);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+  bool operator+(const B &);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+  bool operator<<(const B &);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+  bool operator&&(const B &);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+  bool operator,(const B &);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+
+  bool operator<(const int &);
+  bool operator+(const int &);
+  bool operator<<(const int &);
+  bool operator&&(const int &);
+  bool operator,(const int &);
+};
+
+} // namespace additional_operators
+
+namespace test_noexcept {
+
+struct A {
+  int X;
+  bool operator==(const A &) const noexcept = default;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+  // CHECK-FIXES: friend bool operator==(const A&, const A&) noexcept = default;
+};
+
+struct A2 {
+  int X;
+  bool operator==(const A2 &rhs) const noexcept = default;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+  // CHECK-FIXES: friend bool operator==(const A2&, const A2&) noexcept = default;
+};
+} // namespace test_noexcept
+
+namespace llvm_omp_testcase {
+template <typename T>
+using SetVector = ::std::vector<T>;
+
+enum class ChangeStatus {
+  CHANGED,
+  UNCHANGED,
+};
+
+ChangeStatus operator|(ChangeStatus l, ChangeStatus r);
+ChangeStatus &operator|=(ChangeStatus &l, ChangeStatus r);
+ChangeStatus operator&(ChangeStatus l, ChangeStatus r);
+ChangeStatus &operator&=(ChangeStatus &l, ChangeStatus r);
+
+struct AbstractState {
+  virtual ~AbstractState() = default;
+};
+
+template <typename base_ty, base_ty BestState, base_ty WorstState>
+struct IntegerStateBase : public AbstractState {
+  using base_t = base_ty;
+
+  IntegerStateBase() = default;
+  IntegerStateBase(base_t Assumed) : Assumed(Assumed) {}
+
+  static constexpr base_t getBestState() { return BestState; }
+  static constexpr base_t getBestState(const IntegerStateBase &) {
+    return getBestState();
+  }
+
+  static constexpr base_t getWorstState() { return WorstState; }
+  static constexpr base_t getWorstState(const IntegerStateBase &) {
+    return getWorstState();
+  }
+
+  base_t getKnown() const { return Known; }
+
+  base_t getAssumed() const { return Assumed; }
+
+  bool
+  operator==(const IntegerStateBase<base_t, BestState, WorstState> &R) const {
+    return this->getAssumed() == R.getAssumed() &&
+           this->getKnown() == R.getKnown();
+  }
+  // CHECK-MESSAGES: :[[@LINE-5]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+
+  bool
+  operator!=(const IntegerStateBase<base_t, BestState, WorstState> &R) const {
+    return !(*this == R);
+  }
+  // CHECK-MESSAGES: :[[@LINE-4]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+
+protected:
+  virtual void handleNewAssumedValue(base_t Value) = 0;
+
+  virtual void handleNewKnownValue(base_t Value) = 0;
+
+  base_t Known = getWorstState();
+
+  base_t Assumed = getBestState();
+};
+
+struct BooleanState : public IntegerStateBase<bool, true, false> {
+  using super = IntegerStateBase<bool, true, false>;
+  using base_t = IntegerStateBase::base_t;
+
+  BooleanState() = default;
+  BooleanState(base_t Assumed) : super(Assumed) {}
+};
+
+template <typename Ty, bool InsertInvalidates = true>
+struct BooleanStateWithSetVector : public BooleanState {
+  bool operator==(const BooleanStateWithSetVector &RHS) const {
+    return BooleanState::operator==(RHS) && Set == RHS.Set;
+  }
+  // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+  bool operator!=(const BooleanStateWithSetVector &RHS) const {
+    return !(*this == RHS);
+  }
+  // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: symmetric binary operator should be a friend or free operator function [cppcoreguidelines-symmetric-binary-operator]
+
+private:
+  SetVector<Ty> Set;
+};
+
+} // namespace llvm_omp_testcase