clang-tools-extra/clang-tidy/misc/UnconventionalAssignOperatorCheck.cpp

   1 //===--- UnconventionalAssignOperatorCheck.cpp - clang-tidy -----*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "UnconventionalAssignOperatorCheck.h"
  10 #include "clang/ASTMatchers/ASTMatchFinder.h"
  11 #include "clang/ASTMatchers/ASTMatchers.h"
  12
  13 using namespace clang::ast_matchers;
  14
  15 namespace clang::tidy::misc {
  16
  17 namespace {
  18
  19 AST_MATCHER_P(CXXMethodDecl, firstParameter,
  20               ast_matchers::internal::Matcher<ParmVarDecl>, InnerMatcher) {
  21   unsigned N = Node.isExplicitObjectMemberFunction() ? 1 : 0;
  22   return (N < Node.parameters().size() &&
  23           InnerMatcher.matches(*Node.parameters()[N], Finder, Builder));
  24 }
  25 } // namespace
  26
  27 void UnconventionalAssignOperatorCheck::registerMatchers(
  28     ast_matchers::MatchFinder *Finder) {
  29   const auto HasGoodReturnType =
  30       cxxMethodDecl(returns(hasCanonicalType(lValueReferenceType(pointee(
  31           unless(isConstQualified()),
  32           anyOf(autoType(), hasDeclaration(equalsBoundNode("class"))))))));
  33
  34   const auto IsSelf = qualType(hasCanonicalType(
  35       anyOf(hasDeclaration(equalsBoundNode("class")),
  36             referenceType(pointee(hasDeclaration(equalsBoundNode("class")))))));
  37   const auto IsAssign =
  38       cxxMethodDecl(unless(anyOf(isDeleted(), isPrivate(), isImplicit())),
  39                     hasName("operator="), ofClass(recordDecl().bind("class")))
  40           .bind("method");
  41   const auto IsSelfAssign =
  42       cxxMethodDecl(IsAssign, firstParameter(parmVarDecl(hasType(IsSelf))))
  43           .bind("method");
  44
  45   Finder->addMatcher(
  46       cxxMethodDecl(IsAssign, unless(HasGoodReturnType)).bind("ReturnType"),
  47       this);
  48
  49   const auto BadSelf = qualType(hasCanonicalType(referenceType(
  50       anyOf(lValueReferenceType(pointee(unless(isConstQualified()))),
  51             rValueReferenceType(pointee(isConstQualified()))))));
  52
  53   Finder->addMatcher(
  54       cxxMethodDecl(IsSelfAssign, firstParameter(parmVarDecl(hasType(BadSelf))))
  55           .bind("ArgumentType"),
  56       this);
  57
  58   Finder->addMatcher(
  59       cxxMethodDecl(IsSelfAssign, anyOf(isConst(), isVirtual())).bind("cv"),
  60       this);
  61
  62   const auto IsBadReturnStatement = returnStmt(unless(has(ignoringParenImpCasts(
  63       anyOf(unaryOperator(hasOperatorName("*"), hasUnaryOperand(cxxThisExpr())),
  64             cxxOperatorCallExpr(argumentCountIs(1),
  65                                 callee(unresolvedLookupExpr()),
  66                                 hasArgument(0, cxxThisExpr())),
  67             cxxOperatorCallExpr(
  68                 hasOverloadedOperatorName("="),
  69                 hasArgument(
  70                     0, unaryOperator(hasOperatorName("*"),
  71                                      hasUnaryOperand(cxxThisExpr())))))))));
  72   const auto IsGoodAssign = cxxMethodDecl(IsAssign, HasGoodReturnType);
  73
  74   Finder->addMatcher(returnStmt(IsBadReturnStatement, forFunction(IsGoodAssign))
  75                          .bind("returnStmt"),
  76                      this);
  77 }
  78
  79 void UnconventionalAssignOperatorCheck::check(
  80     const MatchFinder::MatchResult &Result) {
  81   if (const auto *RetStmt = Result.Nodes.getNodeAs<ReturnStmt>("returnStmt")) {
  82     diag(RetStmt->getBeginLoc(), "operator=() should always return '*this'");
  83   } else {
  84     const auto *Method = Result.Nodes.getNodeAs<CXXMethodDecl>("method");
  85     if (Result.Nodes.getNodeAs<CXXMethodDecl>("ReturnType"))
  86       diag(Method->getBeginLoc(), "operator=() should return '%0&'")
  87           << Method->getParent()->getName();
  88     if (Result.Nodes.getNodeAs<CXXMethodDecl>("ArgumentType"))
  89       diag(Method->getBeginLoc(),
  90            "operator=() should take '%0 const&'%select{|, '%0&&'}1 or '%0'")
  91           << Method->getParent()->getName() << getLangOpts().CPlusPlus11;
  92     if (Result.Nodes.getNodeAs<CXXMethodDecl>("cv"))
  93       diag(Method->getBeginLoc(),
  94            "operator=() should not be marked '%select{const|virtual}0'")
  95           << !Method->isConst();
  96   }
  97 }
  98
  99 } // namespace clang::tidy::misc