xref: /freebsd/contrib/llvm-project/clang/lib/StaticAnalyzer/Checkers/ObjCUnusedIVarsChecker.cpp (revision c66ec88fed842fbaad62c30d510644ceb7bd2d71)
1 //==- ObjCUnusedIVarsChecker.cpp - Check for unused ivars --------*- C++ -*-==//
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 //  This file defines a CheckObjCUnusedIvars, a checker that
10 //  analyzes an Objective-C class's interface/implementation to determine if it
11 //  has any ivars that are never accessed.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
16 #include "clang/Analysis/PathDiagnostic.h"
17 #include "clang/AST/Attr.h"
18 #include "clang/AST/DeclObjC.h"
19 #include "clang/AST/Expr.h"
20 #include "clang/AST/ExprObjC.h"
21 #include "clang/Basic/LangOptions.h"
22 #include "clang/Basic/SourceManager.h"
23 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
24 #include "clang/StaticAnalyzer/Core/Checker.h"
25 
26 using namespace clang;
27 using namespace ento;
28 
29 enum IVarState { Unused, Used };
30 typedef llvm::DenseMap<const ObjCIvarDecl*,IVarState> IvarUsageMap;
31 
32 static void Scan(IvarUsageMap& M, const Stmt *S) {
33   if (!S)
34     return;
35 
36   if (const ObjCIvarRefExpr *Ex = dyn_cast<ObjCIvarRefExpr>(S)) {
37     const ObjCIvarDecl *D = Ex->getDecl();
38     IvarUsageMap::iterator I = M.find(D);
39     if (I != M.end())
40       I->second = Used;
41     return;
42   }
43 
44   // Blocks can reference an instance variable of a class.
45   if (const BlockExpr *BE = dyn_cast<BlockExpr>(S)) {
46     Scan(M, BE->getBody());
47     return;
48   }
49 
50   if (const PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(S))
51     for (PseudoObjectExpr::const_semantics_iterator
52         i = POE->semantics_begin(), e = POE->semantics_end(); i != e; ++i) {
53       const Expr *sub = *i;
54       if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(sub))
55         sub = OVE->getSourceExpr();
56       Scan(M, sub);
57     }
58 
59   for (const Stmt *SubStmt : S->children())
60     Scan(M, SubStmt);
61 }
62 
63 static void Scan(IvarUsageMap& M, const ObjCPropertyImplDecl *D) {
64   if (!D)
65     return;
66 
67   const ObjCIvarDecl *ID = D->getPropertyIvarDecl();
68 
69   if (!ID)
70     return;
71 
72   IvarUsageMap::iterator I = M.find(ID);
73   if (I != M.end())
74     I->second = Used;
75 }
76 
77 static void Scan(IvarUsageMap& M, const ObjCContainerDecl *D) {
78   // Scan the methods for accesses.
79   for (const auto *I : D->instance_methods())
80     Scan(M, I->getBody());
81 
82   if (const ObjCImplementationDecl *ID = dyn_cast<ObjCImplementationDecl>(D)) {
83     // Scan for @synthesized property methods that act as setters/getters
84     // to an ivar.
85     for (const auto *I : ID->property_impls())
86       Scan(M, I);
87 
88     // Scan the associated categories as well.
89     for (const auto *Cat : ID->getClassInterface()->visible_categories()) {
90       if (const ObjCCategoryImplDecl *CID = Cat->getImplementation())
91         Scan(M, CID);
92     }
93   }
94 }
95 
96 static void Scan(IvarUsageMap &M, const DeclContext *C, const FileID FID,
97                  const SourceManager &SM) {
98   for (const auto *I : C->decls())
99     if (const auto *FD = dyn_cast<FunctionDecl>(I)) {
100       SourceLocation L = FD->getBeginLoc();
101       if (SM.getFileID(L) == FID)
102         Scan(M, FD->getBody());
103     }
104 }
105 
106 static void checkObjCUnusedIvar(const ObjCImplementationDecl *D,
107                                 BugReporter &BR,
108                                 const CheckerBase *Checker) {
109 
110   const ObjCInterfaceDecl *ID = D->getClassInterface();
111   IvarUsageMap M;
112 
113   // Iterate over the ivars.
114   for (const auto *Ivar : ID->ivars()) {
115     // Ignore ivars that...
116     // (a) aren't private
117     // (b) explicitly marked unused
118     // (c) are iboutlets
119     // (d) are unnamed bitfields
120     if (Ivar->getAccessControl() != ObjCIvarDecl::Private ||
121         Ivar->hasAttr<UnusedAttr>() || Ivar->hasAttr<IBOutletAttr>() ||
122         Ivar->hasAttr<IBOutletCollectionAttr>() ||
123         Ivar->isUnnamedBitfield())
124       continue;
125 
126     M[Ivar] = Unused;
127   }
128 
129   if (M.empty())
130     return;
131 
132   // Now scan the implementation declaration.
133   Scan(M, D);
134 
135   // Any potentially unused ivars?
136   bool hasUnused = false;
137   for (IvarUsageMap::iterator I = M.begin(), E = M.end(); I!=E; ++I)
138     if (I->second == Unused) {
139       hasUnused = true;
140       break;
141     }
142 
143   if (!hasUnused)
144     return;
145 
146   // We found some potentially unused ivars.  Scan the entire translation unit
147   // for functions inside the @implementation that reference these ivars.
148   // FIXME: In the future hopefully we can just use the lexical DeclContext
149   // to go from the ObjCImplementationDecl to the lexically "nested"
150   // C functions.
151   const SourceManager &SM = BR.getSourceManager();
152   Scan(M, D->getDeclContext(), SM.getFileID(D->getLocation()), SM);
153 
154   // Find ivars that are unused.
155   for (IvarUsageMap::iterator I = M.begin(), E = M.end(); I!=E; ++I)
156     if (I->second == Unused) {
157       std::string sbuf;
158       llvm::raw_string_ostream os(sbuf);
159       os << "Instance variable '" << *I->first << "' in class '" << *ID
160          << "' is never used by the methods in its @implementation "
161             "(although it may be used by category methods).";
162 
163       PathDiagnosticLocation L =
164         PathDiagnosticLocation::create(I->first, BR.getSourceManager());
165       BR.EmitBasicReport(D, Checker, "Unused instance variable", "Optimization",
166                          os.str(), L);
167     }
168 }
169 
170 //===----------------------------------------------------------------------===//
171 // ObjCUnusedIvarsChecker
172 //===----------------------------------------------------------------------===//
173 
174 namespace {
175 class ObjCUnusedIvarsChecker : public Checker<
176                                       check::ASTDecl<ObjCImplementationDecl> > {
177 public:
178   void checkASTDecl(const ObjCImplementationDecl *D, AnalysisManager& mgr,
179                     BugReporter &BR) const {
180     checkObjCUnusedIvar(D, BR, this);
181   }
182 };
183 }
184 
185 void ento::registerObjCUnusedIvarsChecker(CheckerManager &mgr) {
186   mgr.registerChecker<ObjCUnusedIvarsChecker>();
187 }
188 
189 bool ento::shouldRegisterObjCUnusedIvarsChecker(const CheckerManager &mgr) {
190   return true;
191 }
192