clang-tools 10.0.0

ParentVirtualCallCheck.cpp
Go to the documentation of this file.
1 //===--- ParentVirtualCallCheck.cpp - clang-tidy---------------------------===//
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 "ParentVirtualCallCheck.h"
10 #include "clang/AST/ASTContext.h"
11 #include "clang/ASTMatchers/ASTMatchFinder.h"
12 #include "clang/Tooling/FixIt.h"
13 #include "llvm/ADT/STLExtras.h"
14 #include "llvm/ADT/SmallVector.h"
15 #include <algorithm>
16 #include <cctype>
17
18 using namespace clang::ast_matchers;
19
20 namespace clang {
21 namespace tidy {
22 namespace bugprone {
23
24 using BasesVector = llvm::SmallVector<const CXXRecordDecl *, 5>;
25
26 static bool isParentOf(const CXXRecordDecl &Parent,
27 const CXXRecordDecl &ThisClass) {
28 if (Parent.getCanonicalDecl() == ThisClass.getCanonicalDecl())
29 return true;
30 const CXXRecordDecl *ParentCanonicalDecl = Parent.getCanonicalDecl();
31 return ThisClass.bases_end() !=
32 llvm::find_if(ThisClass.bases(), [=](const CXXBaseSpecifier &Base) {
33 auto *BaseDecl = Base.getType()->getAsCXXRecordDecl();
34 assert(BaseDecl);
35 return ParentCanonicalDecl == BaseDecl->getCanonicalDecl();
36 });
37 }
38
39 static BasesVector getParentsByGrandParent(const CXXRecordDecl &GrandParent,
40 const CXXRecordDecl &ThisClass,
41 const CXXMethodDecl &MemberDecl) {
42 BasesVector Result;
43 for (const auto &Base : ThisClass.bases()) {
44 const auto *BaseDecl = Base.getType()->getAsCXXRecordDecl();
45 const CXXMethodDecl *ActualMemberDecl =
46 MemberDecl.getCorrespondingMethodInClass(BaseDecl);
47 if (!ActualMemberDecl)
48 continue;
49 // TypePtr is the nearest base class to ThisClass between ThisClass and
50 // GrandParent, where MemberDecl is overridden. TypePtr is the class the
51 // check proposes to fix to.
52 const Type *TypePtr = ActualMemberDecl->getThisType().getTypePtr();
53 const CXXRecordDecl *RecordDeclType = TypePtr->getPointeeCXXRecordDecl();
54 assert(RecordDeclType && "TypePtr is not a pointer to CXXRecordDecl!");
55 if (RecordDeclType->getCanonicalDecl()->isDerivedFrom(&GrandParent))
56 Result.emplace_back(RecordDeclType);
57 }
58
59 return Result;
60 }
61
62 static std::string getNameAsString(const NamedDecl *Decl) {
63 std::string QualName;
64 llvm::raw_string_ostream OS(QualName);
65 PrintingPolicy PP(Decl->getASTContext().getPrintingPolicy());
66 PP.SuppressUnwrittenScope = true;
67 Decl->printQualifiedName(OS, PP);
68 return OS.str();
69 }
70
71 // Returns E as written in the source code. Used to handle 'using' and
72 // 'typedef'ed names of grand-parent classes.
73 static std::string getExprAsString(const clang::Expr &E,
74 clang::ASTContext &AC) {
75 std::string Text = tooling::fixit::getText(E, AC).str();
76 Text.erase(
77 llvm::remove_if(
78 Text,
79 [](char C) { return std::isspace(static_cast<unsigned char>(C)); }),
80 Text.end());
81 return Text;
82 }
83
84 void ParentVirtualCallCheck::registerMatchers(MatchFinder *Finder) {
85 Finder->addMatcher(
86 cxxMemberCallExpr(
87 callee(memberExpr(hasDescendant(implicitCastExpr(
88 hasImplicitDestinationType(pointsTo(
89 type(anything()).bind("castToType"))),
90 hasSourceExpression(cxxThisExpr(hasType(
91 type(anything()).bind("thisType")))))))
92 .bind("member")),
93 callee(cxxMethodDecl(isVirtual()))),
94 this);
95 }
96
97 void ParentVirtualCallCheck::check(const MatchFinder::MatchResult &Result) {
98 const auto *Member = Result.Nodes.getNodeAs<MemberExpr>("member");
99 assert(Member);
100
101 if (!Member->getQualifier())
102 return;
103
104 const auto *MemberDecl = cast<CXXMethodDecl>(Member->getMemberDecl());
105
106 const auto *ThisTypePtr = Result.Nodes.getNodeAs<PointerType>("thisType");
107 assert(ThisTypePtr);
108
109 const auto *ThisType = ThisTypePtr->getPointeeCXXRecordDecl();
110 assert(ThisType);
111
112 const auto *CastToTypePtr = Result.Nodes.getNodeAs<Type>("castToType");
113 assert(CastToTypePtr);
114
115 const auto *CastToType = CastToTypePtr->getAsCXXRecordDecl();
116 assert(CastToType);
117
118 if (isParentOf(*CastToType, *ThisType))
119 return;
120
121 const BasesVector Parents =
122 getParentsByGrandParent(*CastToType, *ThisType, *MemberDecl);
123
124 if (Parents.empty())
125 return;
126
127 std::string ParentsStr;
128 ParentsStr.reserve(30 * Parents.size());
129 for (const CXXRecordDecl *Parent : Parents) {
130 if (!ParentsStr.empty())
131 ParentsStr.append(" or ");
132 ParentsStr.append("'").append(getNameAsString(Parent)).append("'");
133 }
134
135 assert(Member->getQualifierLoc().getSourceRange().getBegin().isValid());
136 auto Diag = diag(Member->getQualifierLoc().getSourceRange().getBegin(),
137 "qualified name '%0' refers to a member overridden "
138 "in subclass%1; did you mean %2?")
139 << getExprAsString(*Member, *Result.Context)
140 << (Parents.size() > 1 ? "es" : "") << ParentsStr;
141
142 // Propose a fix if there's only one parent class...
143 if (Parents.size() == 1 &&
144 // ...unless parent class is templated
145 !isa<ClassTemplateSpecializationDecl>(Parents.front()))
146 Diag << FixItHint::CreateReplacement(
147 Member->getQualifierLoc().getSourceRange(),
148 getNameAsString(Parents.front()) + "::");
149 }
150
151 } // namespace bugprone
152 } // namespace tidy
153 } // namespace clang
clang::ast_matchers
Definition: AbseilMatcher.h:14
Decl
const FunctionDecl * Decl
Definition: AvoidBindCheck.cpp:93
Text
std::string Text
Definition: HTMLGenerator.cpp:80
clang::tidy::bugprone::isParentOf
static bool isParentOf(const CXXRecordDecl &Parent, const CXXRecordDecl &ThisClass)
Definition: ParentVirtualCallCheck.cpp:26
clang::tidy::bugprone::BasesVector
llvm::SmallVector< const CXXRecordDecl *, 5 > BasesVector
Definition: ParentVirtualCallCheck.cpp:24
Parent
const Node * Parent
Definition: ExtractFunction.cpp:148
clang::tidy::bugprone::getExprAsString
static std::string getExprAsString(const clang::Expr &E, clang::ASTContext &AC)
Definition: ParentVirtualCallCheck.cpp:73
clang::tidy::bugprone::getNameAsString
static std::string getNameAsString(const NamedDecl *Decl)
Definition: ParentVirtualCallCheck.cpp:62
clang::tidy::bugprone::getParentsByGrandParent
static BasesVector getParentsByGrandParent(const CXXRecordDecl &GrandParent, const CXXRecordDecl &ThisClass, const CXXMethodDecl &MemberDecl)
Definition: ParentVirtualCallCheck.cpp:39
ParentVirtualCallCheck.h
clang
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Definition: ApplyReplacements.h:27
clang::tidy::bugprone::PP
static Preprocessor * PP
Definition: BadSignalToKillThreadCheck.cpp:28
E
const Expr * E
Definition: AvoidBindCheck.cpp:82
Base
std::unique_ptr< GlobalCompilationDatabase > Base
Definition: GlobalCompilationDatabaseTests.cpp:83
Type
NodeType Type
Definition: HTMLGenerator.cpp:73