Debian Codegraph @

llvm-project/clang-tools-extra/clang-tidy/cppcoreguidelines/SpecialMemberFunctionsCheck.cpp

raw
1 //===--- SpecialMemberFunctionsCheck.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 "SpecialMemberFunctionsCheck.h"
10
11 #include "clang/AST/ASTContext.h"
12 #include "clang/ASTMatchers/ASTMatchFinder.h"
13 #include "llvm/ADT/DenseMapInfo.h"
14 #include "llvm/ADT/StringExtras.h"
15
16 #define DEBUG_TYPE "clang-tidy"
17
18 using namespace clang::ast_matchers;
19
20 namespace clang::tidy::cppcoreguidelines {
21
22 SpecialMemberFunctionsCheck::SpecialMemberFunctionsCheck(
23 StringRef Name, ClangTidyContext *Context)
24 : ClangTidyCheck(Name, Context), AllowMissingMoveFunctions(Options.get(
25 "AllowMissingMoveFunctions", false)),
26 AllowSoleDefaultDtor(Options.get("AllowSoleDefaultDtor", false)),
27 AllowMissingMoveFunctionsWhenCopyIsDeleted(
28 Options.get("AllowMissingMoveFunctionsWhenCopyIsDeleted", false)) {}
29
30 void SpecialMemberFunctionsCheck::storeOptions(
31 ClangTidyOptions::OptionMap &Opts) {
32 Options.store(Opts, "AllowMissingMoveFunctions", AllowMissingMoveFunctions);
33 Options.store(Opts, "AllowSoleDefaultDtor", AllowSoleDefaultDtor);
34 Options.store(Opts, "AllowMissingMoveFunctionsWhenCopyIsDeleted",
35 AllowMissingMoveFunctionsWhenCopyIsDeleted);
36 }
37
38 void SpecialMemberFunctionsCheck::registerMatchers(MatchFinder *Finder) {
39 Finder->addMatcher(
40 cxxRecordDecl(
41 eachOf(has(cxxDestructorDecl().bind("dtor")),
42 has(cxxConstructorDecl(isCopyConstructor()).bind("copy-ctor")),
43 has(cxxMethodDecl(isCopyAssignmentOperator())
44 .bind("copy-assign")),
45 has(cxxConstructorDecl(isMoveConstructor()).bind("move-ctor")),
46 has(cxxMethodDecl(isMoveAssignmentOperator())
47 .bind("move-assign"))))
48 .bind("class-def"),
49 this);
50 }
51
52 static llvm::StringRef
53 toString(SpecialMemberFunctionsCheck::SpecialMemberFunctionKind K) {
54 switch (K) {
55 case SpecialMemberFunctionsCheck::SpecialMemberFunctionKind::Destructor:
56 return "a destructor";
57 case SpecialMemberFunctionsCheck::SpecialMemberFunctionKind::
58 DefaultDestructor:
59 return "a default destructor";
60 case SpecialMemberFunctionsCheck::SpecialMemberFunctionKind::
61 NonDefaultDestructor:
62 return "a non-default destructor";
63 case SpecialMemberFunctionsCheck::SpecialMemberFunctionKind::CopyConstructor:
64 return "a copy constructor";
65 case SpecialMemberFunctionsCheck::SpecialMemberFunctionKind::CopyAssignment:
66 return "a copy assignment operator";
67 case SpecialMemberFunctionsCheck::SpecialMemberFunctionKind::MoveConstructor:
68 return "a move constructor";
69 case SpecialMemberFunctionsCheck::SpecialMemberFunctionKind::MoveAssignment:
70 return "a move assignment operator";
71 }
72 llvm_unreachable("Unhandled SpecialMemberFunctionKind");
73 }
74
75 static std::string
76 join(ArrayRef<SpecialMemberFunctionsCheck::SpecialMemberFunctionKind> SMFS,
77 llvm::StringRef AndOr) {
78
79 assert(!SMFS.empty() &&
80 "List of defined or undefined members should never be empty.");
81 std::string Buffer;
82 llvm::raw_string_ostream Stream(Buffer);
83
84 Stream << toString(SMFS[0]);
85 size_t LastIndex = SMFS.size() - 1;
86 for (size_t I = 1; I < LastIndex; ++I) {
87 Stream << ", " << toString(SMFS[I]);
88 }
89 if (LastIndex != 0) {
90 Stream << AndOr << toString(SMFS[LastIndex]);
91 }
92 return Stream.str();
93 }
94
95 void SpecialMemberFunctionsCheck::check(
96 const MatchFinder::MatchResult &Result) {
97 const auto *MatchedDecl = Result.Nodes.getNodeAs<CXXRecordDecl>("class-def");
98 if (!MatchedDecl)
99 return;
100
101 ClassDefId ID(MatchedDecl->getLocation(), std::string(MatchedDecl->getName()));
102
103 auto StoreMember = [this, &ID](SpecialMemberFunctionData Data) {
104 llvm::SmallVectorImpl<SpecialMemberFunctionData> &Members =
105 ClassWithSpecialMembers[ID];
106 if (!llvm::is_contained(Members, Data))
107 Members.push_back(std::move(Data));
108 };
109
110 if (const auto *Dtor = Result.Nodes.getNodeAs<CXXMethodDecl>("dtor")) {
111 StoreMember({Dtor->isDefaulted()
112 ? SpecialMemberFunctionKind::DefaultDestructor
113 : SpecialMemberFunctionKind::NonDefaultDestructor,
114 Dtor->isDeleted()});
115 }
116
117 std::initializer_list<std::pair<std::string, SpecialMemberFunctionKind>>
118 Matchers = {{"copy-ctor", SpecialMemberFunctionKind::CopyConstructor},
119 {"copy-assign", SpecialMemberFunctionKind::CopyAssignment},
120 {"move-ctor", SpecialMemberFunctionKind::MoveConstructor},
121 {"move-assign", SpecialMemberFunctionKind::MoveAssignment}};
122
123 for (const auto &KV : Matchers)
124 if (const auto *MethodDecl =
125 Result.Nodes.getNodeAs<CXXMethodDecl>(KV.first)) {
126 StoreMember({KV.second, MethodDecl->isDeleted()});
127 }
128 }
129
130 void SpecialMemberFunctionsCheck::onEndOfTranslationUnit() {
131 for (const auto &C : ClassWithSpecialMembers) {
132 checkForMissingMembers(C.first, C.second);
133 }
134 }
135
136 void SpecialMemberFunctionsCheck::checkForMissingMembers(
137 const ClassDefId &ID,
138 llvm::ArrayRef<SpecialMemberFunctionData> DefinedMembers) {
139 llvm::SmallVector<SpecialMemberFunctionKind, 5> MissingMembers;
140
141 auto HasMember = [&](SpecialMemberFunctionKind Kind) {
142 return llvm::any_of(DefinedMembers, [Kind](const auto &Data) {
143 return Data.FunctionKind == Kind;
144 });
145 };
146
147 auto IsDeleted = [&](SpecialMemberFunctionKind Kind) {
148 return llvm::any_of(DefinedMembers, [Kind](const auto &Data) {
149 return Data.FunctionKind == Kind && Data.IsDeleted;
150 });
151 };
152
153 auto RequireMember = [&](SpecialMemberFunctionKind Kind) {
154 if (!HasMember(Kind))
155 MissingMembers.push_back(Kind);
156 };
157
158 bool RequireThree =
159 HasMember(SpecialMemberFunctionKind::NonDefaultDestructor) ||
160 (!AllowSoleDefaultDtor &&
161 HasMember(SpecialMemberFunctionKind::DefaultDestructor)) ||
162 HasMember(SpecialMemberFunctionKind::CopyConstructor) ||
163 HasMember(SpecialMemberFunctionKind::CopyAssignment) ||
164 HasMember(SpecialMemberFunctionKind::MoveConstructor) ||
165 HasMember(SpecialMemberFunctionKind::MoveAssignment);
166
167 bool RequireFive = (!AllowMissingMoveFunctions && RequireThree &&
168 getLangOpts().CPlusPlus11) ||
169 HasMember(SpecialMemberFunctionKind::MoveConstructor) ||
170 HasMember(SpecialMemberFunctionKind::MoveAssignment);
171
172 if (RequireThree) {
173 if (!HasMember(SpecialMemberFunctionKind::DefaultDestructor) &&
174 !HasMember(SpecialMemberFunctionKind::NonDefaultDestructor))
175 MissingMembers.push_back(SpecialMemberFunctionKind::Destructor);
176
177 RequireMember(SpecialMemberFunctionKind::CopyConstructor);
178 RequireMember(SpecialMemberFunctionKind::CopyAssignment);
179 }
180
181 if (RequireFive &&
182 !(AllowMissingMoveFunctionsWhenCopyIsDeleted &&
183 (IsDeleted(SpecialMemberFunctionKind::CopyConstructor) &&
184 IsDeleted(SpecialMemberFunctionKind::CopyAssignment)))) {
185 assert(RequireThree);
186 RequireMember(SpecialMemberFunctionKind::MoveConstructor);
187 RequireMember(SpecialMemberFunctionKind::MoveAssignment);
188 }
189
190 if (!MissingMembers.empty()) {
191 llvm::SmallVector<SpecialMemberFunctionKind, 5> DefinedMemberKinds;
192 llvm::transform(DefinedMembers, std::back_inserter(DefinedMemberKinds),
193 [](const auto &Data) { return Data.FunctionKind; });
194 diag(ID.first, "class '%0' defines %1 but does not define %2")
195 << ID.second << cppcoreguidelines::join(DefinedMemberKinds, " and ")
196 << cppcoreguidelines::join(MissingMembers, " or ");
197 }
198 }
199
200 } // namespace clang::tidy::cppcoreguidelines