contrib/llvm/tools/clang/lib/StaticAnalyzer/Checkers/ObjCUnusedIVarsChecker.cpp

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