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