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 100