clang-tools 19.0.0git
UnusedParametersCheck.cpp
Go to the documentation of this file.
1//===--- UnusedParametersCheck.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
10#include "clang/AST/ASTContext.h"
11#include "clang/AST/ASTLambda.h"
12#include "clang/AST/RecursiveASTVisitor.h"
13#include "clang/ASTMatchers/ASTMatchFinder.h"
14#include "clang/Lex/Lexer.h"
15#include "llvm/ADT/STLExtras.h"
16#include <unordered_map>
17#include <unordered_set>
18
19using namespace clang::ast_matchers;
20
21namespace clang::tidy::misc {
22
23namespace {
24bool isOverrideMethod(const FunctionDecl *Function) {
25 if (const auto *MD = dyn_cast<CXXMethodDecl>(Function))
26 return MD->size_overridden_methods() > 0 || MD->hasAttr<OverrideAttr>();
27 return false;
28}
29} // namespace
30
31void UnusedParametersCheck::registerMatchers(MatchFinder *Finder) {
32 Finder->addMatcher(functionDecl(isDefinition(), hasBody(stmt()),
33 hasAnyParameter(decl()),
34 unless(hasAttr(attr::Kind::Naked)))
35 .bind("function"),
36 this);
37}
38
39template <typename T>
40static CharSourceRange removeNode(const MatchFinder::MatchResult &Result,
41 const T *PrevNode, const T *Node,
42 const T *NextNode) {
43 if (NextNode)
44 return CharSourceRange::getCharRange(Node->getBeginLoc(),
45 NextNode->getBeginLoc());
46
47 if (PrevNode)
48 return CharSourceRange::getTokenRange(
49 Lexer::getLocForEndOfToken(PrevNode->getEndLoc(), 0,
50 *Result.SourceManager,
51 Result.Context->getLangOpts()),
52 Node->getEndLoc());
53
54 return CharSourceRange::getTokenRange(Node->getSourceRange());
55}
56
57static FixItHint removeParameter(const MatchFinder::MatchResult &Result,
58 const FunctionDecl *Function, unsigned Index) {
59 return FixItHint::CreateRemoval(removeNode(
60 Result, Index > 0 ? Function->getParamDecl(Index - 1) : nullptr,
61 Function->getParamDecl(Index),
62 Index + 1 < Function->getNumParams() ? Function->getParamDecl(Index + 1)
63 : nullptr));
64}
65
66static FixItHint removeArgument(const MatchFinder::MatchResult &Result,
67 const CallExpr *Call, unsigned Index) {
68 return FixItHint::CreateRemoval(removeNode(
69 Result, Index > 0 ? Call->getArg(Index - 1) : nullptr,
70 Call->getArg(Index),
71 Index + 1 < Call->getNumArgs() ? Call->getArg(Index + 1) : nullptr));
72}
73
75 : public RecursiveASTVisitor<IndexerVisitor> {
76public:
77 IndexerVisitor(ASTContext &Ctx) { TraverseAST(Ctx); }
78
79 const std::unordered_set<const CallExpr *> &
80 getFnCalls(const FunctionDecl *Fn) {
81 return Index[Fn->getCanonicalDecl()].Calls;
82 }
83
84 const std::unordered_set<const DeclRefExpr *> &
85 getOtherRefs(const FunctionDecl *Fn) {
86 return Index[Fn->getCanonicalDecl()].OtherRefs;
87 }
88
89 bool shouldTraversePostOrder() const { return true; }
90
91 bool WalkUpFromDeclRefExpr(DeclRefExpr *DeclRef) {
92 if (const auto *Fn = dyn_cast<FunctionDecl>(DeclRef->getDecl())) {
93 Fn = Fn->getCanonicalDecl();
94 Index[Fn].OtherRefs.insert(DeclRef);
95 }
96 return true;
97 }
98
99 bool WalkUpFromCallExpr(CallExpr *Call) {
100 if (const auto *Fn =
101 dyn_cast_or_null<FunctionDecl>(Call->getCalleeDecl())) {
102 Fn = Fn->getCanonicalDecl();
103 if (const auto *Ref =
104 dyn_cast<DeclRefExpr>(Call->getCallee()->IgnoreImplicit())) {
105 Index[Fn].OtherRefs.erase(Ref);
106 }
107 Index[Fn].Calls.insert(Call);
108 }
109 return true;
110 }
111
112private:
113 struct IndexEntry {
114 std::unordered_set<const CallExpr *> Calls;
115 std::unordered_set<const DeclRefExpr *> OtherRefs;
116 };
117
118 std::unordered_map<const FunctionDecl *, IndexEntry> Index;
119};
120
122
124 ClangTidyContext *Context)
125 : ClangTidyCheck(Name, Context),
126 StrictMode(Options.getLocalOrGlobal("StrictMode", false)),
127 IgnoreVirtual(Options.get("IgnoreVirtual", false)) {}
128
130 Options.store(Opts, "StrictMode", StrictMode);
131 Options.store(Opts, "IgnoreVirtual", IgnoreVirtual);
132}
133
134void UnusedParametersCheck::warnOnUnusedParameter(
135 const MatchFinder::MatchResult &Result, const FunctionDecl *Function,
136 unsigned ParamIndex) {
137 const auto *Param = Function->getParamDecl(ParamIndex);
138 // Don't bother to diagnose invalid parameters as being unused.
139 if (Param->isInvalidDecl())
140 return;
141 auto MyDiag = diag(Param->getLocation(), "parameter %0 is unused") << Param;
142
143 if (!Indexer) {
144 Indexer = std::make_unique<IndexerVisitor>(*Result.Context);
145 }
146
147 // Cannot remove parameter for non-local functions.
148 if (Function->isExternallyVisible() ||
149 !Result.SourceManager->isInMainFile(Function->getLocation()) ||
150 !Indexer->getOtherRefs(Function).empty() || isOverrideMethod(Function) ||
151 isLambdaCallOperator(Function)) {
152
153 // It is illegal to omit parameter name here in C code, so early-out.
154 if (!Result.Context->getLangOpts().CPlusPlus)
155 return;
156
157 SourceRange RemovalRange(Param->getLocation());
158 // Note: We always add a space before the '/*' to not accidentally create
159 // a '*/*' for pointer types, which doesn't start a comment. clang-format
160 // will clean this up afterwards.
161 MyDiag << FixItHint::CreateReplacement(
162 RemovalRange, (Twine(" /*") + Param->getName() + "*/").str());
163 return;
164 }
165
166 // Fix all redeclarations.
167 for (const FunctionDecl *FD : Function->redecls())
168 if (FD->param_size())
169 MyDiag << removeParameter(Result, FD, ParamIndex);
170
171 // Fix all call sites.
172 for (const CallExpr *Call : Indexer->getFnCalls(Function))
173 if (ParamIndex < Call->getNumArgs()) // See PR38055 for example.
174 MyDiag << removeArgument(Result, Call, ParamIndex);
175}
176
177void UnusedParametersCheck::check(const MatchFinder::MatchResult &Result) {
178 const auto *Function = Result.Nodes.getNodeAs<FunctionDecl>("function");
179 if (!Function->hasWrittenPrototype() || Function->isTemplateInstantiation())
180 return;
181 if (const auto *Method = dyn_cast<CXXMethodDecl>(Function)) {
182 if (IgnoreVirtual && Method->isVirtual())
183 return;
184 if (Method->isLambdaStaticInvoker())
185 return;
186 }
187 for (unsigned I = 0, E = Function->getNumParams(); I != E; ++I) {
188 const auto *Param = Function->getParamDecl(I);
189 if (Param->isUsed() || Param->isReferenced() || !Param->getDeclName() ||
190 Param->hasAttr<UnusedAttr>())
191 continue;
192
193 // In non-strict mode ignore function definitions with empty bodies
194 // (constructor initializer counts for non-empty body).
195 if (StrictMode || !Function->getBody()->children().empty() ||
196 (isa<CXXConstructorDecl>(Function) &&
197 cast<CXXConstructorDecl>(Function)->getNumCtorInitializers() > 0))
198 warnOnUnusedParameter(Result, Function, I);
199 }
200}
201
202} // namespace clang::tidy::misc
const Expr * E
llvm::SmallString< 256U > Name
::clang::DynTypedNode Node
const DeclRefExpr * DeclRef
void store(ClangTidyOptions::OptionMap &Options, StringRef LocalName, StringRef Value) const
Stores an option with the check-local name LocalName with string value Value to Options.
Base class for all clang-tidy checks.
DiagnosticBuilder diag(SourceLocation Loc, StringRef Description, DiagnosticIDs::Level Level=DiagnosticIDs::Warning)
Add a diagnostic with the check's name.
Every ClangTidyCheck reports errors through a DiagnosticsEngine provided by this context.
const std::unordered_set< const CallExpr * > & getFnCalls(const FunctionDecl *Fn)
const std::unordered_set< const DeclRefExpr * > & getOtherRefs(const FunctionDecl *Fn)
void check(const ast_matchers::MatchFinder::MatchResult &Result) override
ClangTidyChecks that register ASTMatchers should do the actual work in here.
void storeOptions(ClangTidyOptions::OptionMap &Opts) override
Should store all options supported by this check with their current values or default values for opti...
UnusedParametersCheck(StringRef Name, ClangTidyContext *Context)
void registerMatchers(ast_matchers::MatchFinder *Finder) override
Override this to register AST matchers with Finder.
static FixItHint removeParameter(const MatchFinder::MatchResult &Result, const FunctionDecl *Function, unsigned Index)
static CharSourceRange removeNode(const MatchFinder::MatchResult &Result, const T *PrevNode, const T *Node, const T *NextNode)
static FixItHint removeArgument(const MatchFinder::MatchResult &Result, const CallExpr *Call, unsigned Index)
llvm::StringMap< ClangTidyValue > OptionMap