1 | //===--- MissingStdForwardCheck.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 "MissingStdForwardCheck.h" |
10 | #include "../utils/Matchers.h" |
11 | #include "clang/AST/ASTContext.h" |
12 | #include "clang/AST/ExprConcepts.h" |
13 | #include "clang/ASTMatchers/ASTMatchFinder.h" |
14 | |
15 | using namespace clang::ast_matchers; |
16 | |
17 | namespace clang::tidy::cppcoreguidelines { |
18 | |
19 | namespace { |
20 | |
21 | using matchers::hasUnevaluatedContext; |
22 | |
23 | AST_MATCHER_P(QualType, possiblyPackExpansionOf, |
24 | ast_matchers::internal::Matcher<QualType>, InnerMatcher) { |
25 | return InnerMatcher.matches(Node: Node.getNonPackExpansionType(), Finder, Builder); |
26 | } |
27 | |
28 | AST_MATCHER(ParmVarDecl, isTemplateTypeParameter) { |
29 | ast_matchers::internal::Matcher<QualType> Inner = possiblyPackExpansionOf( |
30 | InnerMatcher: qualType(rValueReferenceType(), |
31 | references(InnerMatcher: templateTypeParmType( |
32 | hasDeclaration(InnerMatcher: templateTypeParmDecl()))), |
33 | unless(references(InnerMatcher: qualType(isConstQualified()))))); |
34 | if (!Inner.matches(Node: Node.getType(), Finder, Builder)) |
35 | return false; |
36 | |
37 | const auto *Function = dyn_cast<FunctionDecl>(Node.getDeclContext()); |
38 | if (!Function) |
39 | return false; |
40 | |
41 | const FunctionTemplateDecl *FuncTemplate = |
42 | Function->getDescribedFunctionTemplate(); |
43 | if (!FuncTemplate) |
44 | return false; |
45 | |
46 | QualType ParamType = |
47 | Node.getType().getNonPackExpansionType()->getPointeeType(); |
48 | const auto *TemplateType = ParamType->getAs<TemplateTypeParmType>(); |
49 | if (!TemplateType) |
50 | return false; |
51 | |
52 | return TemplateType->getDepth() == |
53 | FuncTemplate->getTemplateParameters()->getDepth(); |
54 | } |
55 | |
56 | AST_MATCHER_P(NamedDecl, hasSameNameAsBoundNode, std::string, BindingID) { |
57 | IdentifierInfo *II = Node.getIdentifier(); |
58 | if (nullptr == II) |
59 | return false; |
60 | StringRef Name = II->getName(); |
61 | |
62 | return Builder->removeBindings( |
63 | Predicate: [this, Name](const ast_matchers::internal::BoundNodesMap &Nodes) { |
64 | const DynTypedNode &BN = Nodes.getNode(ID: this->BindingID); |
65 | if (const auto *ND = BN.get<NamedDecl>()) { |
66 | if (!isa<FieldDecl, CXXMethodDecl, VarDecl>(Val: ND)) |
67 | return true; |
68 | return ND->getName() != Name; |
69 | } |
70 | return true; |
71 | }); |
72 | } |
73 | |
74 | AST_MATCHER_P(LambdaCapture, hasCaptureKind, LambdaCaptureKind, Kind) { |
75 | return Node.getCaptureKind() == Kind; |
76 | } |
77 | |
78 | AST_MATCHER_P(LambdaExpr, hasCaptureDefaultKind, LambdaCaptureDefault, Kind) { |
79 | return Node.getCaptureDefault() == Kind; |
80 | } |
81 | |
82 | } // namespace |
83 | |
84 | void MissingStdForwardCheck::registerMatchers(MatchFinder *Finder) { |
85 | auto RefToParmImplicit = allOf( |
86 | equalsBoundNode(ID: "var" ), hasInitializer(InnerMatcher: ignoringParenImpCasts( |
87 | InnerMatcher: declRefExpr(to(InnerMatcher: equalsBoundNode(ID: "param" )))))); |
88 | auto RefToParm = capturesVar( |
89 | InnerMatcher: varDecl(anyOf(hasSameNameAsBoundNode(BindingID: "param" ), RefToParmImplicit))); |
90 | auto HasRefToParm = hasAnyCapture(InnerMatcher: RefToParm); |
91 | |
92 | auto CaptureInRef = |
93 | allOf(hasCaptureDefaultKind(Kind: LambdaCaptureDefault::LCD_ByRef), |
94 | unless(hasAnyCapture( |
95 | InnerMatcher: capturesVar(InnerMatcher: varDecl(hasSameNameAsBoundNode(BindingID: "param" )))))); |
96 | auto CaptureInCopy = allOf( |
97 | hasCaptureDefaultKind(Kind: LambdaCaptureDefault::LCD_ByCopy), HasRefToParm); |
98 | auto CaptureByRefExplicit = hasAnyCapture( |
99 | InnerMatcher: allOf(hasCaptureKind(Kind: LambdaCaptureKind::LCK_ByRef), RefToParm)); |
100 | |
101 | auto CapturedInBody = |
102 | lambdaExpr(anyOf(CaptureInRef, CaptureInCopy, CaptureByRefExplicit)); |
103 | auto CapturedInCaptureList = hasAnyCapture(InnerMatcher: capturesVar( |
104 | InnerMatcher: varDecl(hasInitializer(InnerMatcher: ignoringParenImpCasts(InnerMatcher: equalsBoundNode(ID: "call" )))))); |
105 | |
106 | auto CapturedInLambda = hasDeclContext(InnerMatcher: cxxRecordDecl( |
107 | isLambda(), |
108 | hasParent(lambdaExpr(forCallable(InnerMatcher: equalsBoundNode(ID: "func" )), |
109 | anyOf(CapturedInCaptureList, CapturedInBody))))); |
110 | |
111 | auto ToParam = hasAnyParameter(InnerMatcher: parmVarDecl(equalsBoundNode(ID: "param" ))); |
112 | |
113 | auto ForwardCallMatcher = callExpr( |
114 | callExpr().bind(ID: "call" ), argumentCountIs(N: 1), |
115 | hasArgument( |
116 | N: 0, InnerMatcher: declRefExpr(to( |
117 | InnerMatcher: varDecl(optionally(equalsBoundNode(ID: "param" ))).bind(ID: "var" )))), |
118 | forCallable(InnerMatcher: anyOf(equalsBoundNode(ID: "func" ), CapturedInLambda)), |
119 | callee(InnerMatcher: unresolvedLookupExpr(hasAnyDeclaration( |
120 | InnerMatcher: namedDecl(hasUnderlyingDecl(InnerMatcher: hasName(Name: "::std::forward" )))))), |
121 | |
122 | unless(anyOf(hasAncestor(typeLoc()), |
123 | hasAncestor(expr(hasUnevaluatedContext()))))); |
124 | |
125 | Finder->addMatcher( |
126 | NodeMatch: parmVarDecl(parmVarDecl().bind(ID: "param" ), isTemplateTypeParameter(), |
127 | hasAncestor(functionDecl().bind(ID: "func" )), |
128 | hasAncestor(functionDecl( |
129 | isDefinition(), equalsBoundNode(ID: "func" ), ToParam, |
130 | unless(hasDescendant(std::move(ForwardCallMatcher)))))), |
131 | Action: this); |
132 | } |
133 | |
134 | void MissingStdForwardCheck::check(const MatchFinder::MatchResult &Result) { |
135 | const auto *Param = Result.Nodes.getNodeAs<ParmVarDecl>(ID: "param" ); |
136 | |
137 | if (!Param) |
138 | return; |
139 | |
140 | diag(Param->getLocation(), |
141 | "forwarding reference parameter %0 is never forwarded " |
142 | "inside the function body" ) |
143 | << Param; |
144 | } |
145 | |
146 | } // namespace clang::tidy::cppcoreguidelines |
147 | |