clang-tools  14.0.0git
UnusedUsingDeclsCheck.cpp
Go to the documentation of this file.
1 //===--- UnusedUsingDeclsCheck.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/ASTMatchers/ASTMatchFinder.h"
12 #include "clang/Lex/Lexer.h"
13 
14 using namespace clang::ast_matchers;
15 
16 namespace clang {
17 namespace tidy {
18 namespace misc {
19 
20 namespace {
21 // FIXME: Move ASTMatcher library.
22 AST_POLYMORPHIC_MATCHER_P(
23  forEachTemplateArgument,
24  AST_POLYMORPHIC_SUPPORTED_TYPES(ClassTemplateSpecializationDecl,
25  TemplateSpecializationType, FunctionDecl),
26  clang::ast_matchers::internal::Matcher<TemplateArgument>, InnerMatcher) {
27  ArrayRef<TemplateArgument> TemplateArgs =
28  clang::ast_matchers::internal::getTemplateSpecializationArgs(Node);
29  clang::ast_matchers::internal::BoundNodesTreeBuilder Result;
30  bool Matched = false;
31  for (const auto &Arg : TemplateArgs) {
32  clang::ast_matchers::internal::BoundNodesTreeBuilder ArgBuilder(*Builder);
33  if (InnerMatcher.matches(Arg, Finder, &ArgBuilder)) {
34  Matched = true;
35  Result.addMatch(ArgBuilder);
36  }
37  }
38  *Builder = std::move(Result);
39  return Matched;
40 }
41 
42 AST_MATCHER_P(DeducedTemplateSpecializationType, refsToTemplatedDecl,
43  clang::ast_matchers::internal::Matcher<NamedDecl>, DeclMatcher) {
44  if (const auto *TD = Node.getTemplateName().getAsTemplateDecl())
45  return DeclMatcher.matches(*TD, Finder, Builder);
46  return false;
47 }
48 } // namespace
49 
50 // A function that helps to tell whether a TargetDecl in a UsingDecl will be
51 // checked. Only variable, function, function template, class template, class,
52 // enum declaration and enum constant declaration are considered.
53 static bool shouldCheckDecl(const Decl *TargetDecl) {
54  return isa<RecordDecl>(TargetDecl) || isa<ClassTemplateDecl>(TargetDecl) ||
55  isa<FunctionDecl>(TargetDecl) || isa<VarDecl>(TargetDecl) ||
56  isa<FunctionTemplateDecl>(TargetDecl) || isa<EnumDecl>(TargetDecl) ||
57  isa<EnumConstantDecl>(TargetDecl);
58 }
59 
60 void UnusedUsingDeclsCheck::registerMatchers(MatchFinder *Finder) {
61  Finder->addMatcher(usingDecl(isExpansionInMainFile()).bind("using"), this);
62  auto DeclMatcher = hasDeclaration(namedDecl().bind("used"));
63  Finder->addMatcher(loc(enumType(DeclMatcher)), this);
64  Finder->addMatcher(loc(recordType(DeclMatcher)), this);
65  Finder->addMatcher(loc(templateSpecializationType(DeclMatcher)), this);
66  Finder->addMatcher(loc(deducedTemplateSpecializationType(
67  refsToTemplatedDecl(namedDecl().bind("used")))),
68  this);
69  Finder->addMatcher(declRefExpr().bind("used"), this);
70  Finder->addMatcher(callExpr(callee(unresolvedLookupExpr().bind("used"))),
71  this);
72  Finder->addMatcher(
73  callExpr(hasDeclaration(functionDecl(
74  forEachTemplateArgument(templateArgument().bind("used"))))),
75  this);
76  Finder->addMatcher(loc(templateSpecializationType(forEachTemplateArgument(
77  templateArgument().bind("used")))),
78  this);
79 }
80 
81 void UnusedUsingDeclsCheck::check(const MatchFinder::MatchResult &Result) {
82  if (Result.Context->getDiagnostics().hasUncompilableErrorOccurred())
83  return;
84 
85  if (const auto *Using = Result.Nodes.getNodeAs<UsingDecl>("using")) {
86  // Ignores using-declarations defined in macros.
87  if (Using->getLocation().isMacroID())
88  return;
89 
90  // Ignores using-declarations defined in class definition.
91  if (isa<CXXRecordDecl>(Using->getDeclContext()))
92  return;
93 
94  // FIXME: We ignore using-decls defined in function definitions at the
95  // moment because of false positives caused by ADL and different function
96  // scopes.
97  if (isa<FunctionDecl>(Using->getDeclContext()))
98  return;
99 
100  UsingDeclContext Context(Using);
101  Context.UsingDeclRange = CharSourceRange::getCharRange(
102  Using->getBeginLoc(),
103  Lexer::findLocationAfterToken(
104  Using->getEndLoc(), tok::semi, *Result.SourceManager, getLangOpts(),
105  /*SkipTrailingWhitespaceAndNewLine=*/true));
106  for (const auto *UsingShadow : Using->shadows()) {
107  const auto *TargetDecl = UsingShadow->getTargetDecl()->getCanonicalDecl();
108  if (shouldCheckDecl(TargetDecl))
109  Context.UsingTargetDecls.insert(TargetDecl);
110  }
111  if (!Context.UsingTargetDecls.empty())
112  Contexts.push_back(Context);
113  return;
114  }
115 
116  // Mark a corresponding using declaration as used.
117  auto RemoveNamedDecl = [&](const NamedDecl *Used) {
118  removeFromFoundDecls(Used);
119  // Also remove variants of Used.
120  if (const auto *FD = dyn_cast<FunctionDecl>(Used)) {
121  removeFromFoundDecls(FD->getPrimaryTemplate());
122  } else if (const auto *Specialization =
123  dyn_cast<ClassTemplateSpecializationDecl>(Used)) {
124  removeFromFoundDecls(Specialization->getSpecializedTemplate());
125  } else if (const auto *FD = dyn_cast<FunctionDecl>(Used)) {
126  if (const auto *FDT = FD->getPrimaryTemplate())
127  removeFromFoundDecls(FDT);
128  } else if (const auto *ECD = dyn_cast<EnumConstantDecl>(Used)) {
129  if (const auto *ET = ECD->getType()->getAs<EnumType>())
130  removeFromFoundDecls(ET->getDecl());
131  }
132  };
133  // We rely on the fact that the clang AST is walked in order, usages are only
134  // marked after a corresponding using decl has been found.
135  if (const auto *Used = Result.Nodes.getNodeAs<NamedDecl>("used")) {
136  RemoveNamedDecl(Used);
137  return;
138  }
139 
140  if (const auto *Used = Result.Nodes.getNodeAs<TemplateArgument>("used")) {
141  if (Used->getKind() == TemplateArgument::Template) {
142  if (const auto *TD = Used->getAsTemplate().getAsTemplateDecl())
143  removeFromFoundDecls(TD);
144  } else if (Used->getKind() == TemplateArgument::Type) {
145  if (auto *RD = Used->getAsType()->getAsCXXRecordDecl())
146  removeFromFoundDecls(RD);
147  } else if (Used->getKind() == TemplateArgument::Declaration) {
148  RemoveNamedDecl(Used->getAsDecl());
149  }
150  return;
151  }
152 
153  if (const auto *DRE = Result.Nodes.getNodeAs<DeclRefExpr>("used")) {
154  RemoveNamedDecl(DRE->getDecl());
155  return;
156  }
157  // Check the uninstantiated template function usage.
158  if (const auto *ULE = Result.Nodes.getNodeAs<UnresolvedLookupExpr>("used")) {
159  for (const NamedDecl *ND : ULE->decls()) {
160  if (const auto *USD = dyn_cast<UsingShadowDecl>(ND))
161  removeFromFoundDecls(USD->getTargetDecl()->getCanonicalDecl());
162  }
163  }
164 }
165 
166 void UnusedUsingDeclsCheck::removeFromFoundDecls(const Decl *D) {
167  if (!D)
168  return;
169  // FIXME: Currently, we don't handle the using-decls being used in different
170  // scopes (such as different namespaces, different functions). Instead of
171  // giving an incorrect message, we mark all of them as used.
172  //
173  // FIXME: Use a more efficient way to find a matching context.
174  for (auto &Context : Contexts) {
175  if (Context.UsingTargetDecls.contains(D->getCanonicalDecl()))
176  Context.IsUsed = true;
177  }
178 }
179 
180 void UnusedUsingDeclsCheck::onEndOfTranslationUnit() {
181  for (const auto &Context : Contexts) {
182  if (!Context.IsUsed) {
183  diag(Context.FoundUsingDecl->getLocation(), "using decl %0 is unused")
184  << Context.FoundUsingDecl;
185  // Emit a fix and a fix description of the check;
186  diag(Context.FoundUsingDecl->getLocation(),
187  /*Description=*/"remove the using", DiagnosticIDs::Note)
188  << FixItHint::CreateRemoval(Context.UsingDeclRange);
189  }
190  }
191  Contexts.clear();
192 }
193 
194 } // namespace misc
195 } // namespace tidy
196 } // namespace clang
clang::tidy::misc::shouldCheckDecl
static bool shouldCheckDecl(const Decl *TargetDecl)
Definition: UnusedUsingDeclsCheck.cpp:53
Type
NodeType Type
Definition: HTMLGenerator.cpp:73
clang::ast_matchers
Definition: AbseilMatcher.h:14
ns1::ns2::D
@ D
Definition: CategoricalFeature.h:3
Decl
const FunctionDecl * Decl
Definition: AvoidBindCheck.cpp:100
UnusedUsingDeclsCheck.h
Builder
CodeCompletionBuilder Builder
Definition: CodeCompletionStringsTests.cpp:36
clang::clangd::check
bool check(llvm::StringRef File, llvm::function_ref< bool(const Position &)> ShouldCheckLine, const ThreadsafeFS &TFS, const ClangdLSPServer::Options &Opts, bool EnableCodeCompletion)
Definition: Check.cpp:259
clang
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Definition: ApplyReplacements.h:27
clang::tidy::bugprone::AST_MATCHER_P
AST_MATCHER_P(FunctionDecl, parameterCountGE, unsigned, N)
Matches functions that have at least the specified amount of parameters.
Definition: EasilySwappableParametersCheck.cpp:1877