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
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
82} // namespace
83
84void 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
134void 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

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