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 "ClangSACheckers.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 (Stmt::const_child_iterator I=S->child_begin(),E=S->child_end(); I!=E;++I)
  61     Scan(M, *I);
  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 (ObjCContainerDecl::instmeth_iterator I = D->instmeth_begin(),
  81        E = D->instmeth_end(); I!=E; ++I)
  82     Scan(M, (*I)->getBody());
  83
  84   if (const ObjCImplementationDecl *ID = dyn_cast<ObjCImplementationDecl>(D)) {
  85     // Scan for @synthesized property methods that act as setters/getters
  86     // to an ivar.
  87     for (ObjCImplementationDecl::propimpl_iterator I = ID->propimpl_begin(),
  88          E = ID->propimpl_end(); I!=E; ++I)
  89       Scan(M, *I);
  90
  91     // Scan the associated categories as well.
  92     for (ObjCInterfaceDecl::visible_categories_iterator
  93            Cat = ID->getClassInterface()->visible_categories_begin(),
  94            CatEnd = ID->getClassInterface()->visible_categories_end();
  95          Cat != CatEnd; ++Cat) {
  96       if (const ObjCCategoryImplDecl *CID = Cat->getImplementation())
  97         Scan(M, CID);
  98     }
  99   }
 100 }
 101
 102 static void Scan(IvarUsageMap &M, const DeclContext *C, const FileID FID,
 103                  SourceManager &SM) {
 104   for (DeclContext::decl_iterator I=C->decls_begin(), E=C->decls_end();
 105        I!=E; ++I)
 106     if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
 107       SourceLocation L = FD->getLocStart();
 108       if (SM.getFileID(L) == FID)
 109         Scan(M, FD->getBody());
 110     }
 111 }
 112
 113 static void checkObjCUnusedIvar(const ObjCImplementationDecl *D,
 114                                 BugReporter &BR) {
 115
 116   const ObjCInterfaceDecl *ID = D->getClassInterface();
 117   IvarUsageMap M;
 118
 119   // Iterate over the ivars.
 120   for (ObjCInterfaceDecl::ivar_iterator I=ID->ivar_begin(),
 121         E=ID->ivar_end(); I!=E; ++I) {
 122
 123     const ObjCIvarDecl *ID = *I;
 124
 125     // Ignore ivars that...
 126     // (a) aren't private
 127     // (b) explicitly marked unused
 128     // (c) are iboutlets
 129     // (d) are unnamed bitfields
 130     if (ID->getAccessControl() != ObjCIvarDecl::Private ||
 131         ID->getAttr<UnusedAttr>() || ID->getAttr<IBOutletAttr>() ||
 132         ID->getAttr<IBOutletCollectionAttr>() ||
 133         ID->isUnnamedBitfield())
 134       continue;
 135
 136     M[ID] = Unused;
 137   }
 138
 139   if (M.empty())
 140     return;
 141
 142   // Now scan the implementation declaration.
 143   Scan(M, D);
 144
 145   // Any potentially unused ivars?
 146   bool hasUnused = false;
 147   for (IvarUsageMap::iterator I = M.begin(), E = M.end(); I!=E; ++I)
 148     if (I->second == Unused) {
 149       hasUnused = true;
 150       break;
 151     }
 152
 153   if (!hasUnused)
 154     return;
 155
 156   // We found some potentially unused ivars.  Scan the entire translation unit
 157   // for functions inside the @implementation that reference these ivars.
 158   // FIXME: In the future hopefully we can just use the lexical DeclContext
 159   // to go from the ObjCImplementationDecl to the lexically "nested"
 160   // C functions.
 161   SourceManager &SM = BR.getSourceManager();
 162   Scan(M, D->getDeclContext(), SM.getFileID(D->getLocation()), SM);
 163
 164   // Find ivars that are unused.
 165   for (IvarUsageMap::iterator I = M.begin(), E = M.end(); I!=E; ++I)
 166     if (I->second == Unused) {
 167       std::string sbuf;
 168       llvm::raw_string_ostream os(sbuf);
 169       os << "Instance variable '" << *I->first << "' in class '" << *ID
 170          << "' is never used by the methods in its @implementation "
 171             "(although it may be used by category methods).";
 172
 173       PathDiagnosticLocation L =
 174         PathDiagnosticLocation::create(I->first, BR.getSourceManager());
 175       BR.EmitBasicReport(D, "Unused instance variable", "Optimization",
 176                          os.str(), L);
 177     }
 178 }
 179
 180 //===----------------------------------------------------------------------===//
 181 // ObjCUnusedIvarsChecker
 182 //===----------------------------------------------------------------------===//
 183
 184 namespace {
 185 class ObjCUnusedIvarsChecker : public Checker<
 186                                       check::ASTDecl<ObjCImplementationDecl> > {
 187 public:
 188   void checkASTDecl(const ObjCImplementationDecl *D, AnalysisManager& mgr,
 189                     BugReporter &BR) const {
 190     checkObjCUnusedIvar(D, BR);
 191   }
 192 };
 193 }
 194
 195 void ento::registerObjCUnusedIvarsChecker(CheckerManager &mgr) {
 196   mgr.registerChecker<ObjCUnusedIvarsChecker>();
 197 }