1 | //===--- UseAfterMoveCheck.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 "UseAfterMoveCheck.h" |
10 | |
11 | #include "clang/AST/Expr.h" |
12 | #include "clang/AST/ExprCXX.h" |
13 | #include "clang/ASTMatchers/ASTMatchers.h" |
14 | #include "clang/Analysis/Analyses/CFGReachabilityAnalysis.h" |
15 | #include "clang/Analysis/CFG.h" |
16 | #include "clang/Lex/Lexer.h" |
17 | #include "llvm/ADT/STLExtras.h" |
18 | #include "llvm/ADT/SmallPtrSet.h" |
19 | |
20 | #include "../utils/ExprSequence.h" |
21 | #include "../utils/Matchers.h" |
22 | #include <optional> |
23 | |
24 | using namespace clang::ast_matchers; |
25 | using namespace clang::tidy::utils; |
26 | |
27 | namespace clang::tidy::bugprone { |
28 | |
29 | using matchers::hasUnevaluatedContext; |
30 | |
31 | namespace { |
32 | |
33 | /// Contains information about a use-after-move. |
34 | struct UseAfterMove { |
35 | // The DeclRefExpr that constituted the use of the object. |
36 | const DeclRefExpr *DeclRef; |
37 | |
38 | // Is the order in which the move and the use are evaluated undefined? |
39 | bool EvaluationOrderUndefined = false; |
40 | |
41 | // Does the use happen in a later loop iteration than the move? |
42 | // |
43 | // We default to false and change it to true if required in find(). |
44 | bool UseHappensInLaterLoopIteration = false; |
45 | }; |
46 | |
47 | /// Finds uses of a variable after a move (and maintains state required by the |
48 | /// various internal helper functions). |
49 | class UseAfterMoveFinder { |
50 | public: |
51 | UseAfterMoveFinder(ASTContext *TheContext); |
52 | |
53 | // Within the given code block, finds the first use of 'MovedVariable' that |
54 | // occurs after 'MovingCall' (the expression that performs the move). If a |
55 | // use-after-move is found, writes information about it to 'TheUseAfterMove'. |
56 | // Returns whether a use-after-move was found. |
57 | std::optional<UseAfterMove> find(Stmt *CodeBlock, const Expr *MovingCall, |
58 | const DeclRefExpr *MovedVariable); |
59 | |
60 | private: |
61 | std::optional<UseAfterMove> findInternal(const CFGBlock *Block, |
62 | const Expr *MovingCall, |
63 | const ValueDecl *MovedVariable); |
64 | void getUsesAndReinits(const CFGBlock *Block, const ValueDecl *MovedVariable, |
65 | llvm::SmallVectorImpl<const DeclRefExpr *> *Uses, |
66 | llvm::SmallPtrSetImpl<const Stmt *> *Reinits); |
67 | void getDeclRefs(const CFGBlock *Block, const Decl *MovedVariable, |
68 | llvm::SmallPtrSetImpl<const DeclRefExpr *> *DeclRefs); |
69 | void getReinits(const CFGBlock *Block, const ValueDecl *MovedVariable, |
70 | llvm::SmallPtrSetImpl<const Stmt *> *Stmts, |
71 | llvm::SmallPtrSetImpl<const DeclRefExpr *> *DeclRefs); |
72 | |
73 | ASTContext *Context; |
74 | std::unique_ptr<ExprSequence> Sequence; |
75 | std::unique_ptr<StmtToBlockMap> BlockMap; |
76 | llvm::SmallPtrSet<const CFGBlock *, 8> Visited; |
77 | }; |
78 | |
79 | } // namespace |
80 | |
81 | // Matches nodes that are |
82 | // - Part of a decltype argument or class template argument (we check this by |
83 | // seeing if they are children of a TypeLoc), or |
84 | // - Part of a function template argument (we check this by seeing if they are |
85 | // children of a DeclRefExpr that references a function template). |
86 | // DeclRefExprs that fulfill these conditions should not be counted as a use or |
87 | // move. |
88 | static StatementMatcher inDecltypeOrTemplateArg() { |
89 | return anyOf(hasAncestor(typeLoc()), |
90 | hasAncestor(declRefExpr( |
91 | to(InnerMatcher: functionDecl(ast_matchers::isTemplateInstantiation())))), |
92 | hasAncestor(expr(hasUnevaluatedContext()))); |
93 | } |
94 | |
95 | UseAfterMoveFinder::UseAfterMoveFinder(ASTContext *TheContext) |
96 | : Context(TheContext) {} |
97 | |
98 | std::optional<UseAfterMove> |
99 | UseAfterMoveFinder::find(Stmt *CodeBlock, const Expr *MovingCall, |
100 | const DeclRefExpr *MovedVariable) { |
101 | // Generate the CFG manually instead of through an AnalysisDeclContext because |
102 | // it seems the latter can't be used to generate a CFG for the body of a |
103 | // lambda. |
104 | // |
105 | // We include implicit and temporary destructors in the CFG so that |
106 | // destructors marked [[noreturn]] are handled correctly in the control flow |
107 | // analysis. (These are used in some styles of assertion macros.) |
108 | CFG::BuildOptions Options; |
109 | Options.AddImplicitDtors = true; |
110 | Options.AddTemporaryDtors = true; |
111 | std::unique_ptr<CFG> TheCFG = |
112 | CFG::buildCFG(D: nullptr, AST: CodeBlock, C: Context, BO: Options); |
113 | if (!TheCFG) |
114 | return std::nullopt; |
115 | |
116 | Sequence = std::make_unique<ExprSequence>(args: TheCFG.get(), args&: CodeBlock, args&: Context); |
117 | BlockMap = std::make_unique<StmtToBlockMap>(args: TheCFG.get(), args&: Context); |
118 | Visited.clear(); |
119 | |
120 | const CFGBlock *MoveBlock = BlockMap->blockContainingStmt(MovingCall); |
121 | if (!MoveBlock) { |
122 | // This can happen if MovingCall is in a constructor initializer, which is |
123 | // not included in the CFG because the CFG is built only from the function |
124 | // body. |
125 | MoveBlock = &TheCFG->getEntry(); |
126 | } |
127 | |
128 | auto TheUseAfterMove = |
129 | findInternal(Block: MoveBlock, MovingCall, MovedVariable: MovedVariable->getDecl()); |
130 | |
131 | if (TheUseAfterMove) { |
132 | if (const CFGBlock *UseBlock = |
133 | BlockMap->blockContainingStmt(S: TheUseAfterMove->DeclRef)) { |
134 | // Does the use happen in a later loop iteration than the move? |
135 | // - If they are in the same CFG block, we know the use happened in a |
136 | // later iteration if we visited that block a second time. |
137 | // - Otherwise, we know the use happened in a later iteration if the |
138 | // move is reachable from the use. |
139 | CFGReverseBlockReachabilityAnalysis CFA(*TheCFG); |
140 | TheUseAfterMove->UseHappensInLaterLoopIteration = |
141 | UseBlock == MoveBlock ? Visited.contains(Ptr: UseBlock) |
142 | : CFA.isReachable(Src: UseBlock, Dst: MoveBlock); |
143 | } |
144 | } |
145 | return TheUseAfterMove; |
146 | } |
147 | |
148 | std::optional<UseAfterMove> |
149 | UseAfterMoveFinder::findInternal(const CFGBlock *Block, const Expr *MovingCall, |
150 | const ValueDecl *MovedVariable) { |
151 | if (Visited.count(Ptr: Block)) |
152 | return std::nullopt; |
153 | |
154 | // Mark the block as visited (except if this is the block containing the |
155 | // std::move() and it's being visited the first time). |
156 | if (!MovingCall) |
157 | Visited.insert(Ptr: Block); |
158 | |
159 | // Get all uses and reinits in the block. |
160 | llvm::SmallVector<const DeclRefExpr *, 1> Uses; |
161 | llvm::SmallPtrSet<const Stmt *, 1> Reinits; |
162 | getUsesAndReinits(Block, MovedVariable, Uses: &Uses, Reinits: &Reinits); |
163 | |
164 | // Ignore all reinitializations where the move potentially comes after the |
165 | // reinit. |
166 | // If `Reinit` is identical to `MovingCall`, we're looking at a move-to-self |
167 | // (e.g. `a = std::move(a)`). Count these as reinitializations. |
168 | llvm::SmallVector<const Stmt *, 1> ReinitsToDelete; |
169 | for (const Stmt *Reinit : Reinits) { |
170 | if (MovingCall && Reinit != MovingCall && |
171 | Sequence->potentiallyAfter(MovingCall, Reinit)) |
172 | ReinitsToDelete.push_back(Elt: Reinit); |
173 | } |
174 | for (const Stmt *Reinit : ReinitsToDelete) { |
175 | Reinits.erase(Ptr: Reinit); |
176 | } |
177 | |
178 | // Find all uses that potentially come after the move. |
179 | for (const DeclRefExpr *Use : Uses) { |
180 | if (!MovingCall || Sequence->potentiallyAfter(Use, MovingCall)) { |
181 | // Does the use have a saving reinit? A reinit is saving if it definitely |
182 | // comes before the use, i.e. if there's no potential that the reinit is |
183 | // after the use. |
184 | bool HaveSavingReinit = false; |
185 | for (const Stmt *Reinit : Reinits) { |
186 | if (!Sequence->potentiallyAfter(Reinit, Use)) |
187 | HaveSavingReinit = true; |
188 | } |
189 | |
190 | if (!HaveSavingReinit) { |
191 | UseAfterMove TheUseAfterMove; |
192 | TheUseAfterMove.DeclRef = Use; |
193 | |
194 | // Is this a use-after-move that depends on order of evaluation? |
195 | // This is the case if the move potentially comes after the use (and we |
196 | // already know that use potentially comes after the move, which taken |
197 | // together tells us that the ordering is unclear). |
198 | TheUseAfterMove.EvaluationOrderUndefined = |
199 | MovingCall != nullptr && |
200 | Sequence->potentiallyAfter(MovingCall, Use); |
201 | |
202 | return TheUseAfterMove; |
203 | } |
204 | } |
205 | } |
206 | |
207 | // If the object wasn't reinitialized, call ourselves recursively on all |
208 | // successors. |
209 | if (Reinits.empty()) { |
210 | for (const auto &Succ : Block->succs()) { |
211 | if (Succ) { |
212 | if (auto Found = findInternal(Block: Succ, MovingCall: nullptr, MovedVariable)) { |
213 | return Found; |
214 | } |
215 | } |
216 | } |
217 | } |
218 | |
219 | return std::nullopt; |
220 | } |
221 | |
222 | void UseAfterMoveFinder::getUsesAndReinits( |
223 | const CFGBlock *Block, const ValueDecl *MovedVariable, |
224 | llvm::SmallVectorImpl<const DeclRefExpr *> *Uses, |
225 | llvm::SmallPtrSetImpl<const Stmt *> *Reinits) { |
226 | llvm::SmallPtrSet<const DeclRefExpr *, 1> DeclRefs; |
227 | llvm::SmallPtrSet<const DeclRefExpr *, 1> ReinitDeclRefs; |
228 | |
229 | getDeclRefs(Block, MovedVariable, &DeclRefs); |
230 | getReinits(Block, MovedVariable, Stmts: Reinits, DeclRefs: &ReinitDeclRefs); |
231 | |
232 | // All references to the variable that aren't reinitializations are uses. |
233 | Uses->clear(); |
234 | for (const DeclRefExpr *DeclRef : DeclRefs) { |
235 | if (!ReinitDeclRefs.count(Ptr: DeclRef)) |
236 | Uses->push_back(Elt: DeclRef); |
237 | } |
238 | |
239 | // Sort the uses by their occurrence in the source code. |
240 | llvm::sort(C&: *Uses, Comp: [](const DeclRefExpr *D1, const DeclRefExpr *D2) { |
241 | return D1->getExprLoc() < D2->getExprLoc(); |
242 | }); |
243 | } |
244 | |
245 | static bool isStandardSmartPointer(const ValueDecl *VD) { |
246 | const Type *TheType = VD->getType().getNonReferenceType().getTypePtrOrNull(); |
247 | if (!TheType) |
248 | return false; |
249 | |
250 | const CXXRecordDecl *RecordDecl = TheType->getAsCXXRecordDecl(); |
251 | if (!RecordDecl) |
252 | return false; |
253 | |
254 | const IdentifierInfo *ID = RecordDecl->getIdentifier(); |
255 | if (!ID) |
256 | return false; |
257 | |
258 | StringRef Name = ID->getName(); |
259 | if (Name != "unique_ptr" && Name != "shared_ptr" && Name != "weak_ptr" ) |
260 | return false; |
261 | |
262 | return RecordDecl->getDeclContext()->isStdNamespace(); |
263 | } |
264 | |
265 | void UseAfterMoveFinder::getDeclRefs( |
266 | const CFGBlock *Block, const Decl *MovedVariable, |
267 | llvm::SmallPtrSetImpl<const DeclRefExpr *> *DeclRefs) { |
268 | DeclRefs->clear(); |
269 | for (const auto &Elem : *Block) { |
270 | std::optional<CFGStmt> S = Elem.getAs<CFGStmt>(); |
271 | if (!S) |
272 | continue; |
273 | |
274 | auto AddDeclRefs = [this, Block, |
275 | DeclRefs](const ArrayRef<BoundNodes> Matches) { |
276 | for (const auto &Match : Matches) { |
277 | const auto *DeclRef = Match.getNodeAs<DeclRefExpr>(ID: "declref" ); |
278 | const auto *Operator = Match.getNodeAs<CXXOperatorCallExpr>(ID: "operator" ); |
279 | if (DeclRef && BlockMap->blockContainingStmt(DeclRef) == Block) { |
280 | // Ignore uses of a standard smart pointer that don't dereference the |
281 | // pointer. |
282 | if (Operator || !isStandardSmartPointer(VD: DeclRef->getDecl())) { |
283 | DeclRefs->insert(Ptr: DeclRef); |
284 | } |
285 | } |
286 | } |
287 | }; |
288 | |
289 | auto DeclRefMatcher = declRefExpr(hasDeclaration(InnerMatcher: equalsNode(Other: MovedVariable)), |
290 | unless(inDecltypeOrTemplateArg())) |
291 | .bind(ID: "declref" ); |
292 | |
293 | AddDeclRefs(match(Matcher: traverse(TK: TK_AsIs, InnerMatcher: findAll(Matcher: DeclRefMatcher)), Node: *S->getStmt(), |
294 | Context&: *Context)); |
295 | AddDeclRefs(match(Matcher: findAll(Matcher: cxxOperatorCallExpr( |
296 | hasAnyOverloadedOperatorName("*" , "->" , "[]" ), |
297 | hasArgument(N: 0, InnerMatcher: DeclRefMatcher)) |
298 | .bind(ID: "operator" )), |
299 | Node: *S->getStmt(), Context&: *Context)); |
300 | } |
301 | } |
302 | |
303 | void UseAfterMoveFinder::getReinits( |
304 | const CFGBlock *Block, const ValueDecl *MovedVariable, |
305 | llvm::SmallPtrSetImpl<const Stmt *> *Stmts, |
306 | llvm::SmallPtrSetImpl<const DeclRefExpr *> *DeclRefs) { |
307 | auto DeclRefMatcher = |
308 | declRefExpr(hasDeclaration(equalsNode(MovedVariable))).bind("declref" ); |
309 | |
310 | auto StandardContainerTypeMatcher = hasType(InnerMatcher: hasUnqualifiedDesugaredType( |
311 | InnerMatcher: recordType(hasDeclaration(InnerMatcher: cxxRecordDecl(hasAnyName( |
312 | "::std::basic_string" , "::std::vector" , "::std::deque" , |
313 | "::std::forward_list" , "::std::list" , "::std::set" , "::std::map" , |
314 | "::std::multiset" , "::std::multimap" , "::std::unordered_set" , |
315 | "::std::unordered_map" , "::std::unordered_multiset" , |
316 | "::std::unordered_multimap" )))))); |
317 | |
318 | auto StandardResettableOwnerTypeMatcher = hasType( |
319 | InnerMatcher: hasUnqualifiedDesugaredType(InnerMatcher: recordType(hasDeclaration(InnerMatcher: cxxRecordDecl( |
320 | hasAnyName("::std::unique_ptr" , "::std::shared_ptr" , |
321 | "::std::weak_ptr" , "::std::optional" , "::std::any" )))))); |
322 | |
323 | // Matches different types of reinitialization. |
324 | auto ReinitMatcher = |
325 | stmt(anyOf( |
326 | // Assignment. In addition to the overloaded assignment operator, |
327 | // test for built-in assignment as well, since template functions |
328 | // may be instantiated to use std::move() on built-in types. |
329 | binaryOperation(hasOperatorName("=" ), hasLHS(DeclRefMatcher)), |
330 | // Declaration. We treat this as a type of reinitialization too, |
331 | // so we don't need to treat it separately. |
332 | declStmt(hasDescendant(equalsNode(MovedVariable))), |
333 | // clear() and assign() on standard containers. |
334 | cxxMemberCallExpr( |
335 | on(expr(DeclRefMatcher, StandardContainerTypeMatcher)), |
336 | // To keep the matcher simple, we check for assign() calls |
337 | // on all standard containers, even though only vector, |
338 | // deque, forward_list and list have assign(). If assign() |
339 | // is called on any of the other containers, this will be |
340 | // flagged by a compile error anyway. |
341 | callee(cxxMethodDecl(hasAnyName("clear" , "assign" )))), |
342 | // reset() on standard smart pointers. |
343 | cxxMemberCallExpr( |
344 | on(expr(DeclRefMatcher, StandardResettableOwnerTypeMatcher)), |
345 | callee(cxxMethodDecl(hasName("reset" )))), |
346 | // Methods that have the [[clang::reinitializes]] attribute. |
347 | cxxMemberCallExpr( |
348 | on(DeclRefMatcher), |
349 | callee(cxxMethodDecl(hasAttr(clang::attr::Reinitializes)))), |
350 | // Passing variable to a function as a non-const pointer. |
351 | callExpr(forEachArgumentWithParam( |
352 | unaryOperator(hasOperatorName("&" ), |
353 | hasUnaryOperand(DeclRefMatcher)), |
354 | unless(parmVarDecl(hasType(pointsTo(isConstQualified())))))), |
355 | // Passing variable to a function as a non-const lvalue reference |
356 | // (unless that function is std::move()). |
357 | callExpr(forEachArgumentWithParam( |
358 | traverse(TK_AsIs, DeclRefMatcher), |
359 | unless(parmVarDecl(hasType( |
360 | references(qualType(isConstQualified())))))), |
361 | unless(callee(functionDecl( |
362 | hasAnyName("::std::move" , "::std::forward" ))))))) |
363 | .bind("reinit" ); |
364 | |
365 | Stmts->clear(); |
366 | DeclRefs->clear(); |
367 | for (const auto &Elem : *Block) { |
368 | std::optional<CFGStmt> S = Elem.getAs<CFGStmt>(); |
369 | if (!S) |
370 | continue; |
371 | |
372 | SmallVector<BoundNodes, 1> Matches = |
373 | match(findAll(ReinitMatcher), *S->getStmt(), *Context); |
374 | |
375 | for (const auto &Match : Matches) { |
376 | const auto *TheStmt = Match.getNodeAs<Stmt>("reinit" ); |
377 | const auto *TheDeclRef = Match.getNodeAs<DeclRefExpr>("declref" ); |
378 | if (TheStmt && BlockMap->blockContainingStmt(TheStmt) == Block) { |
379 | Stmts->insert(TheStmt); |
380 | |
381 | // We count DeclStmts as reinitializations, but they don't have a |
382 | // DeclRefExpr associated with them -- so we need to check 'TheDeclRef' |
383 | // before adding it to the set. |
384 | if (TheDeclRef) |
385 | DeclRefs->insert(TheDeclRef); |
386 | } |
387 | } |
388 | } |
389 | } |
390 | |
391 | enum class MoveType { |
392 | Move, // std::move |
393 | Forward, // std::forward |
394 | }; |
395 | |
396 | static MoveType determineMoveType(const FunctionDecl *FuncDecl) { |
397 | if (FuncDecl->getName() == "move" ) |
398 | return MoveType::Move; |
399 | if (FuncDecl->getName() == "forward" ) |
400 | return MoveType::Forward; |
401 | |
402 | llvm_unreachable("Invalid move type" ); |
403 | } |
404 | |
405 | static void emitDiagnostic(const Expr *MovingCall, const DeclRefExpr *MoveArg, |
406 | const UseAfterMove &Use, ClangTidyCheck *Check, |
407 | ASTContext *Context, MoveType Type) { |
408 | const SourceLocation UseLoc = Use.DeclRef->getExprLoc(); |
409 | const SourceLocation MoveLoc = MovingCall->getExprLoc(); |
410 | |
411 | const bool IsMove = (Type == MoveType::Move); |
412 | |
413 | Check->diag(Loc: UseLoc, Description: "'%0' used after it was %select{forwarded|moved}1" ) |
414 | << MoveArg->getDecl()->getName() << IsMove; |
415 | Check->diag(Loc: MoveLoc, Description: "%select{forward|move}0 occurred here" , |
416 | Level: DiagnosticIDs::Note) |
417 | << IsMove; |
418 | if (Use.EvaluationOrderUndefined) { |
419 | Check->diag( |
420 | Loc: UseLoc, |
421 | Description: "the use and %select{forward|move}0 are unsequenced, i.e. " |
422 | "there is no guarantee about the order in which they are evaluated" , |
423 | Level: DiagnosticIDs::Note) |
424 | << IsMove; |
425 | } else if (Use.UseHappensInLaterLoopIteration) { |
426 | Check->diag(Loc: UseLoc, |
427 | Description: "the use happens in a later loop iteration than the " |
428 | "%select{forward|move}0" , |
429 | Level: DiagnosticIDs::Note) |
430 | << IsMove; |
431 | } |
432 | } |
433 | |
434 | void UseAfterMoveCheck::registerMatchers(MatchFinder *Finder) { |
435 | // try_emplace is a common maybe-moving function that returns a |
436 | // bool to tell callers whether it moved. Ignore std::move inside |
437 | // try_emplace to avoid false positives as we don't track uses of |
438 | // the bool. |
439 | auto TryEmplaceMatcher = |
440 | cxxMemberCallExpr(callee(InnerMatcher: cxxMethodDecl(hasName(Name: "try_emplace" )))); |
441 | auto CallMoveMatcher = |
442 | callExpr(argumentCountIs(N: 1), |
443 | callee(InnerMatcher: functionDecl(hasAnyName("::std::move" , "::std::forward" )) |
444 | .bind(ID: "move-decl" )), |
445 | hasArgument(N: 0, InnerMatcher: declRefExpr().bind(ID: "arg" )), |
446 | unless(inDecltypeOrTemplateArg()), |
447 | unless(hasParent(TryEmplaceMatcher)), expr().bind(ID: "call-move" ), |
448 | anyOf(hasAncestor(compoundStmt( |
449 | hasParent(lambdaExpr().bind(ID: "containing-lambda" )))), |
450 | hasAncestor(functionDecl(anyOf( |
451 | cxxConstructorDecl( |
452 | hasAnyConstructorInitializer(InnerMatcher: withInitializer( |
453 | InnerMatcher: expr(anyOf(equalsBoundNode(ID: "call-move" ), |
454 | hasDescendant(expr( |
455 | equalsBoundNode(ID: "call-move" ))))) |
456 | .bind(ID: "containing-ctor-init" )))) |
457 | .bind(ID: "containing-ctor" ), |
458 | functionDecl().bind(ID: "containing-func" )))))); |
459 | |
460 | Finder->addMatcher( |
461 | NodeMatch: traverse( |
462 | TK: TK_AsIs, |
463 | // To find the Stmt that we assume performs the actual move, we look |
464 | // for the direct ancestor of the std::move() that isn't one of the |
465 | // node types ignored by ignoringParenImpCasts(). |
466 | InnerMatcher: stmt( |
467 | forEach(expr(ignoringParenImpCasts(InnerMatcher: CallMoveMatcher))), |
468 | // Don't allow an InitListExpr to be the moving call. An |
469 | // InitListExpr has both a syntactic and a semantic form, and the |
470 | // parent-child relationships are different between the two. This |
471 | // could cause an InitListExpr to be analyzed as the moving call |
472 | // in addition to the Expr that we actually want, resulting in two |
473 | // diagnostics with different code locations for the same move. |
474 | unless(initListExpr()), |
475 | unless(expr(ignoringParenImpCasts(InnerMatcher: equalsBoundNode(ID: "call-move" ))))) |
476 | .bind(ID: "moving-call" )), |
477 | Action: this); |
478 | } |
479 | |
480 | void UseAfterMoveCheck::check(const MatchFinder::MatchResult &Result) { |
481 | const auto *ContainingCtor = |
482 | Result.Nodes.getNodeAs<CXXConstructorDecl>(ID: "containing-ctor" ); |
483 | const auto *ContainingCtorInit = |
484 | Result.Nodes.getNodeAs<Expr>(ID: "containing-ctor-init" ); |
485 | const auto *ContainingLambda = |
486 | Result.Nodes.getNodeAs<LambdaExpr>(ID: "containing-lambda" ); |
487 | const auto *ContainingFunc = |
488 | Result.Nodes.getNodeAs<FunctionDecl>(ID: "containing-func" ); |
489 | const auto *CallMove = Result.Nodes.getNodeAs<CallExpr>(ID: "call-move" ); |
490 | const auto *MovingCall = Result.Nodes.getNodeAs<Expr>(ID: "moving-call" ); |
491 | const auto *Arg = Result.Nodes.getNodeAs<DeclRefExpr>(ID: "arg" ); |
492 | const auto *MoveDecl = Result.Nodes.getNodeAs<FunctionDecl>(ID: "move-decl" ); |
493 | |
494 | if (!MovingCall || !MovingCall->getExprLoc().isValid()) |
495 | MovingCall = CallMove; |
496 | |
497 | // Ignore the std::move if the variable that was passed to it isn't a local |
498 | // variable. |
499 | if (!Arg->getDecl()->getDeclContext()->isFunctionOrMethod()) |
500 | return; |
501 | |
502 | // Collect all code blocks that could use the arg after move. |
503 | llvm::SmallVector<Stmt *> CodeBlocks{}; |
504 | if (ContainingCtor) { |
505 | CodeBlocks.push_back(Elt: ContainingCtor->getBody()); |
506 | if (ContainingCtorInit) { |
507 | // Collect the constructor initializer expressions. |
508 | bool BeforeMove{true}; |
509 | for (CXXCtorInitializer *Init : ContainingCtor->inits()) { |
510 | if (BeforeMove && Init->getInit()->IgnoreImplicit() == |
511 | ContainingCtorInit->IgnoreImplicit()) |
512 | BeforeMove = false; |
513 | if (!BeforeMove) |
514 | CodeBlocks.push_back(Init->getInit()); |
515 | } |
516 | } |
517 | } else if (ContainingLambda) { |
518 | CodeBlocks.push_back(Elt: ContainingLambda->getBody()); |
519 | } else if (ContainingFunc) { |
520 | CodeBlocks.push_back(Elt: ContainingFunc->getBody()); |
521 | } |
522 | |
523 | for (Stmt *CodeBlock : CodeBlocks) { |
524 | UseAfterMoveFinder Finder(Result.Context); |
525 | if (auto Use = Finder.find(CodeBlock, MovingCall, MovedVariable: Arg)) |
526 | emitDiagnostic(MovingCall, MoveArg: Arg, Use: *Use, Check: this, Context: Result.Context, |
527 | Type: determineMoveType(FuncDecl: MoveDecl)); |
528 | } |
529 | } |
530 | |
531 | } // namespace clang::tidy::bugprone |
532 | |