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/ASTMatchers/ASTMatchFinder.h"
13#include "clang/Basic/IdentifierTable.h"
14
15using namespace clang::ast_matchers;
16
17namespace clang::tidy::cppcoreguidelines {
18
19namespace {
20
21using matchers::hasUnevaluatedContext;
22
23AST_MATCHER_P(QualType, possiblyPackExpansionOf,
24 ast_matchers::internal::Matcher<QualType>, InnerMatcher) {
25 return InnerMatcher.matches(Node: Node.getNonPackExpansionType(), Finder, Builder);
26}
27
28AST_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
56AST_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
74AST_MATCHER_P(LambdaCapture, hasCaptureKind, LambdaCaptureKind, Kind) {
75 return Node.getCaptureKind() == Kind;
76}
77
78AST_MATCHER_P(LambdaExpr, hasCaptureDefaultKind, LambdaCaptureDefault, Kind) {
79 return Node.getCaptureDefault() == Kind;
80}
81
82AST_MATCHER(VarDecl, hasIdentifier) {
83 const IdentifierInfo *ID = Node.getIdentifier();
84 return ID != NULL && !ID->isPlaceholder();
85}
86
87} // namespace
88
89void MissingStdForwardCheck::registerMatchers(MatchFinder *Finder) {
90 auto RefToParmImplicit = allOf(
91 equalsBoundNode(ID: "var"), hasInitializer(InnerMatcher: ignoringParenImpCasts(
92 InnerMatcher: declRefExpr(to(InnerMatcher: equalsBoundNode(ID: "param"))))));
93 auto RefToParm = capturesVar(
94 InnerMatcher: varDecl(anyOf(hasSameNameAsBoundNode(BindingID: "param"), RefToParmImplicit)));
95 auto HasRefToParm = hasAnyCapture(InnerMatcher: RefToParm);
96
97 auto CaptureInRef =
98 allOf(hasCaptureDefaultKind(Kind: LambdaCaptureDefault::LCD_ByRef),
99 unless(hasAnyCapture(
100 InnerMatcher: capturesVar(InnerMatcher: varDecl(hasSameNameAsBoundNode(BindingID: "param"))))));
101 auto CaptureInCopy = allOf(
102 hasCaptureDefaultKind(Kind: LambdaCaptureDefault::LCD_ByCopy), HasRefToParm);
103 auto CaptureByRefExplicit = hasAnyCapture(
104 InnerMatcher: allOf(hasCaptureKind(Kind: LambdaCaptureKind::LCK_ByRef), RefToParm));
105
106 auto CapturedInBody =
107 lambdaExpr(anyOf(CaptureInRef, CaptureInCopy, CaptureByRefExplicit));
108 auto CapturedInCaptureList = hasAnyCapture(InnerMatcher: capturesVar(
109 InnerMatcher: varDecl(hasInitializer(InnerMatcher: ignoringParenImpCasts(InnerMatcher: equalsBoundNode(ID: "call"))))));
110
111 auto CapturedInLambda = hasDeclContext(InnerMatcher: cxxRecordDecl(
112 isLambda(),
113 hasParent(lambdaExpr(forCallable(InnerMatcher: equalsBoundNode(ID: "func")),
114 anyOf(CapturedInCaptureList, CapturedInBody)))));
115
116 auto ToParam = hasAnyParameter(InnerMatcher: parmVarDecl(equalsBoundNode(ID: "param")));
117
118 auto ForwardCallMatcher = callExpr(
119 callExpr().bind(ID: "call"), argumentCountIs(N: 1),
120 hasArgument(N: 0, InnerMatcher: declRefExpr(to(InnerMatcher: varDecl().bind(ID: "var")))),
121 forCallable(
122 InnerMatcher: anyOf(allOf(equalsBoundNode(ID: "func"),
123 functionDecl(hasAnyParameter(InnerMatcher: parmVarDecl(allOf(
124 equalsBoundNode(ID: "param"), equalsBoundNode(ID: "var")))))),
125 CapturedInLambda)),
126 callee(InnerMatcher: unresolvedLookupExpr(hasAnyDeclaration(
127 InnerMatcher: namedDecl(hasUnderlyingDecl(InnerMatcher: hasName(Name: "::std::forward")))))),
128
129 unless(anyOf(hasAncestor(typeLoc()),
130 hasAncestor(expr(hasUnevaluatedContext())))));
131
132 Finder->addMatcher(
133 parmVarDecl(
134 parmVarDecl().bind("param"), hasIdentifier(),
135 unless(hasAttr(attr::Kind::Unused)), isTemplateTypeParameter(),
136 hasAncestor(functionDecl().bind("func")),
137 hasAncestor(functionDecl(
138 isDefinition(), equalsBoundNode("func"), ToParam,
139 unless(anyOf(isDeleted(),
140 hasDescendant(std::move(ForwardCallMatcher))))))),
141 this);
142}
143
144void MissingStdForwardCheck::check(const MatchFinder::MatchResult &Result) {
145 const auto *Param = Result.Nodes.getNodeAs<ParmVarDecl>(ID: "param");
146
147 if (!Param)
148 return;
149
150 diag(Param->getLocation(),
151 "forwarding reference parameter %0 is never forwarded "
152 "inside the function body")
153 << Param;
154}
155
156} // namespace clang::tidy::cppcoreguidelines
157

source code of clang-tools-extra/clang-tidy/cppcoreguidelines/MissingStdForwardCheck.cpp