compilerplugins/clang/unusedmethods.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #include <cassert>
  11 #include <string>
  12 #include <iostream>
  13 #include <fstream>
  14 #include <set>
  15 #include <unordered_map>
  16
  17
  18 #include "clang/AST/Attr.h"
  19
  20 #include "plugin.hxx"
  21 #include "compat.hxx"
  22
  23 /**
  24 This plugin performs 3 different analyses:
  25
  26 (1) Find unused methods
  27 (2) Find methods whose return types are never evaluated
  28 (3) Find methods which are public, but are never called from outside the class i.e. they can be private
  29
  30 It does so, by dumping various call/definition/use info to a log file.
  31 Then we will post-process the various lists and find the set of unused methods.
  32
  33 Be warned that it produces around 15G of log file.
  34
  35 The process goes something like this:
  36   $ make check
  37   $ make FORCE_COMPILE_ALL=1 COMPILER_PLUGIN_TOOL='unusedmethods' check
  38   $ ./compilerplugins/clang/unusedmethods.py
  39
  40 and then
  41   $ for dir in *; do make FORCE_COMPILE_ALL=1 UPDATE_FILES=$dir COMPILER_PLUGIN_TOOL='unusedmethodsremove' $dir; done
  42 to auto-remove the method declarations
  43
  44 Note that the actual process may involve a fair amount of undoing, hand editing, and general messing around
  45 to get it to work :-)
  46
  47 */
  48
  49 namespace {
  50
  51 struct MyFuncInfo
  52 {
  53     std::string access;
  54     std::string returnType;
  55     std::string nameAndParams;
  56     std::string sourceLocation;
  57     std::string virtualness;
  58
  59 };
  60 bool operator < (const MyFuncInfo &lhs, const MyFuncInfo &rhs)
  61 {
  62     return std::tie(lhs.returnType, lhs.nameAndParams)
  63          < std::tie(rhs.returnType, rhs.nameAndParams);
  64 }
  65
  66 // try to limit the voluminous output a little
  67
  68 // for the "unused method" analysis
  69 static std::set<MyFuncInfo> callSet;
  70 static std::set<MyFuncInfo> definitionSet;
  71 // for the "unused return type" analysis
  72 static std::set<MyFuncInfo> usedReturnSet;
  73 // for the "can be private" analysis
  74 static std::set<MyFuncInfo> calledFromOutsideSet;
  75
  76
  77 class UnusedMethods:
  78     public RecursiveASTVisitor<UnusedMethods>, public loplugin::Plugin
  79 {
  80 public:
  81     explicit UnusedMethods(InstantiationData const & data): Plugin(data) {}
  82
  83     virtual void run() override
  84     {
  85         TraverseDecl(compiler.getASTContext().getTranslationUnitDecl());
  86
  87         // dump all our output in one write call - this is to try and limit IO "crosstalk" between multiple processes
  88         // writing to the same logfile
  89
  90         std::string output;
  91         for (const MyFuncInfo & s : definitionSet)
  92             output += "definition:\t" + s.access + "\t" + s.returnType + "\t" + s.nameAndParams
  93                       + "\t" + s.sourceLocation + "\t" + s.virtualness + "\n";
  94         // for the "unused method" analysis
  95         for (const MyFuncInfo & s : callSet)
  96             output += "call:\t" + s.returnType + "\t" + s.nameAndParams + "\n";
  97         // for the "unused return type" analysis
  98         for (const MyFuncInfo & s : usedReturnSet)
  99             output += "usedReturn:\t" + s.returnType + "\t" + s.nameAndParams + "\n";
 100         // for the "method can be private" analysis
 101         for (const MyFuncInfo & s : calledFromOutsideSet)
 102             output += "outside:\t" + s.returnType + "\t" + s.nameAndParams + "\n";
 103         ofstream myfile;
 104         myfile.open( SRCDIR "/loplugin.unusedmethods.log", ios::app | ios::out);
 105         myfile << output;
 106         myfile.close();
 107     }
 108
 109     bool shouldVisitTemplateInstantiations () const { return true; }
 110     bool shouldVisitImplicitCode() const { return true; }
 111
 112     bool VisitCallExpr(CallExpr* );
 113     bool VisitFunctionDecl( const FunctionDecl* decl );
 114     bool VisitDeclRefExpr( const DeclRefExpr* );
 115     bool VisitCXXConstructExpr( const CXXConstructExpr* );
 116 private:
 117     void logCallToRootMethods(const FunctionDecl* functionDecl, std::set<MyFuncInfo>& funcSet);
 118     MyFuncInfo niceName(const FunctionDecl* functionDecl);
 119     std::string toString(SourceLocation loc);
 120     void functionTouchedFromExpr( const FunctionDecl* calleeFunctionDecl, const Expr* expr );
 121 };
 122
 123 MyFuncInfo UnusedMethods::niceName(const FunctionDecl* functionDecl)
 124 {
 125     if (functionDecl->getInstantiatedFromMemberFunction())
 126         functionDecl = functionDecl->getInstantiatedFromMemberFunction();
 127     else if (functionDecl->getClassScopeSpecializationPattern())
 128         functionDecl = functionDecl->getClassScopeSpecializationPattern();
 129 // workaround clang-3.5 issue
 130 #if CLANG_VERSION >= 30600
 131     else if (functionDecl->getTemplateInstantiationPattern())
 132         functionDecl = functionDecl->getTemplateInstantiationPattern();
 133 #endif
 134
 135     MyFuncInfo aInfo;
 136     switch (functionDecl->getAccess())
 137     {
 138     case AS_public: aInfo.access = "public"; break;
 139     case AS_private: aInfo.access = "private"; break;
 140     case AS_protected: aInfo.access = "protected"; break;
 141     default: aInfo.access = "unknown"; break;
 142     }
 143     if (!isa<CXXConstructorDecl>(functionDecl)) {
 144         aInfo.returnType = compat::getReturnType(*functionDecl).getCanonicalType().getAsString();
 145     } else {
 146         aInfo.returnType = "";
 147     }
 148
 149     if (const CXXMethodDecl* methodDecl = dyn_cast<CXXMethodDecl>(functionDecl)) {
 150         const CXXRecordDecl* recordDecl = methodDecl->getParent();
 151         aInfo.nameAndParams += recordDecl->getQualifiedNameAsString();
 152         aInfo.nameAndParams += "::";
 153         if (methodDecl->isVirtual())
 154             aInfo.virtualness = "virtual";
 155     }
 156     aInfo.nameAndParams += functionDecl->getNameAsString() + "(";
 157     bool bFirst = true;
 158     for (const ParmVarDecl *pParmVarDecl : compat::parameters(*functionDecl)) {
 159         if (bFirst)
 160             bFirst = false;
 161         else
 162             aInfo.nameAndParams += ",";
 163         aInfo.nameAndParams += pParmVarDecl->getType().getCanonicalType().getAsString();
 164     }
 165     aInfo.nameAndParams += ")";
 166     if (isa<CXXMethodDecl>(functionDecl) && dyn_cast<CXXMethodDecl>(functionDecl)->isConst()) {
 167         aInfo.nameAndParams += " const";
 168     }
 169
 170     aInfo.sourceLocation = toString( functionDecl->getLocation() );
 171
 172     return aInfo;
 173 }
 174
 175 std::string UnusedMethods::toString(SourceLocation loc)
 176 {
 177     SourceLocation expansionLoc = compiler.getSourceManager().getExpansionLoc( loc );
 178     StringRef name = compiler.getSourceManager().getFilename(expansionLoc);
 179     std::string sourceLocation = std::string(name.substr(strlen(SRCDIR)+1)) + ":" + std::to_string(compiler.getSourceManager().getSpellingLineNumber(expansionLoc));
 180     normalizeDotDotInFilePath(sourceLocation);
 181     return sourceLocation;
 182 }
 183
 184 // For virtual/overriding methods, we need to pretend we called the root method(s),
 185 // so that they get marked as used.
 186 void UnusedMethods::logCallToRootMethods(const FunctionDecl* functionDecl, std::set<MyFuncInfo>& funcSet)
 187 {
 188     functionDecl = functionDecl->getCanonicalDecl();
 189     bool bCalledSuperMethod = false;
 190     if (isa<CXXMethodDecl>(functionDecl)) {
 191         const CXXMethodDecl* methodDecl = dyn_cast<CXXMethodDecl>(functionDecl);
 192         for(CXXMethodDecl::method_iterator it = methodDecl->begin_overridden_methods();
 193             it != methodDecl->end_overridden_methods(); ++it)
 194         {
 195             logCallToRootMethods(*it, funcSet);
 196             bCalledSuperMethod = true;
 197         }
 198     }
 199     if (!bCalledSuperMethod)
 200     {
 201         while (functionDecl->getTemplateInstantiationPattern())
 202             functionDecl = functionDecl->getTemplateInstantiationPattern();
 203         if (functionDecl->getLocation().isValid() && !ignoreLocation( functionDecl )
 204              && !functionDecl->isExternC())
 205             funcSet.insert(niceName(functionDecl));
 206     }
 207 }
 208
 209 bool UnusedMethods::VisitCallExpr(CallExpr* expr)
 210 {
 211     // Note that I don't ignore ANYTHING here, because I want to get calls to my code that result
 212     // from template instantiation deep inside the STL and other external code
 213
 214     FunctionDecl* calleeFunctionDecl = expr->getDirectCallee();
 215     if (calleeFunctionDecl == nullptr) {
 216         Expr* callee = expr->getCallee()->IgnoreParenImpCasts();
 217         DeclRefExpr* dr = dyn_cast<DeclRefExpr>(callee);
 218         if (dr) {
 219             calleeFunctionDecl = dyn_cast<FunctionDecl>(dr->getDecl());
 220             if (calleeFunctionDecl)
 221                 goto gotfunc;
 222         }
 223         /*
 224         expr->dump();
 225         throw "Can't touch this";
 226         */
 227         return true;
 228     }
 229
 230 gotfunc:
 231     logCallToRootMethods(calleeFunctionDecl, callSet);
 232
 233     const Stmt* parent = parentStmt(expr);
 234
 235     // Now do the checks necessary for the "can be private" analysis
 236     CXXMethodDecl* calleeMethodDecl = dyn_cast<CXXMethodDecl>(calleeFunctionDecl);
 237     if (calleeMethodDecl && calleeMethodDecl->getAccess() != AS_private)
 238     {
 239         const FunctionDecl* parentFunctionOfCallSite = parentFunctionDecl(expr);
 240         if (parentFunctionOfCallSite != calleeFunctionDecl) {
 241             if (!parentFunctionOfCallSite || !ignoreLocation(parentFunctionOfCallSite)) {
 242                 calledFromOutsideSet.insert(niceName(calleeFunctionDecl));
 243             }
 244         }
 245     }
 246
 247     // Now do the checks necessary for the "unused return value" analysis
 248     if (compat::getReturnType(*calleeFunctionDecl)->isVoidType()) {
 249         return true;
 250     }
 251     if (!parent) {
 252         // we will get null parent if it's under a CXXConstructExpr node
 253         logCallToRootMethods(calleeFunctionDecl, usedReturnSet);
 254         return true;
 255     }
 256     if (isa<Expr>(parent) || isa<ReturnStmt>(parent) || isa<DeclStmt>(parent)
 257         || isa<IfStmt>(parent) || isa<SwitchStmt>(parent) || isa<ForStmt>(parent)
 258         || isa<WhileStmt>(parent) || isa<DoStmt>(parent)
 259         || isa<CXXForRangeStmt>(parent))
 260     {
 261         logCallToRootMethods(calleeFunctionDecl, usedReturnSet);
 262         return true;
 263     }
 264     if (isa<CompoundStmt>(parent) || isa<DefaultStmt>(parent) || isa<CaseStmt>(parent)
 265         || isa<LabelStmt>(parent))
 266     {
 267         return true;
 268     }
 269     parent->dump();
 270     return true;
 271 }
 272
 273 bool UnusedMethods::VisitCXXConstructExpr( const CXXConstructExpr* constructExpr )
 274 {
 275     // Note that I don't ignore ANYTHING here, because I want to get calls to my code that result
 276     // from template instantiation deep inside the STL and other external code
 277
 278     const CXXConstructorDecl* constructorDecl = constructExpr->getConstructor();
 279     constructorDecl = constructorDecl->getCanonicalDecl();
 280
 281     if (!constructorDecl->getLocation().isValid() || ignoreLocation(constructorDecl)) {
 282         return true;
 283     }
 284
 285     logCallToRootMethods(constructorDecl, callSet);
 286
 287     return true;
 288 }
 289
 290 bool UnusedMethods::VisitFunctionDecl( const FunctionDecl* functionDecl )
 291 {
 292     // ignore stuff that forms part of the stable URE interface
 293     if (isInUnoIncludeFile(functionDecl)) {
 294         return true;
 295     }
 296     const FunctionDecl* canonicalFunctionDecl = functionDecl->getCanonicalDecl();
 297     if (isa<CXXDestructorDecl>(functionDecl)) {
 298         return true;
 299     }
 300     if (functionDecl->isDeleted() || functionDecl->isDefaulted()) {
 301         return true;
 302     }
 303     if (isa<CXXConstructorDecl>(functionDecl)
 304         && dyn_cast<CXXConstructorDecl>(functionDecl)->isCopyOrMoveConstructor())
 305     {
 306         return true;
 307     }
 308     if (!canonicalFunctionDecl->getLocation().isValid() || ignoreLocation(canonicalFunctionDecl)) {
 309         return true;
 310     }
 311     // ignore method overrides, since the call will show up as being directed to the root method
 312     const CXXMethodDecl* methodDecl = dyn_cast<CXXMethodDecl>(functionDecl);
 313     if (methodDecl && (methodDecl->size_overridden_methods() != 0 || methodDecl->hasAttr<OverrideAttr>())) {
 314         return true;
 315     }
 316     if (!functionDecl->isExternC()) {
 317         MyFuncInfo funcInfo = niceName(canonicalFunctionDecl);
 318         definitionSet.insert(funcInfo);
 319     }
 320     return true;
 321 }
 322
 323 bool UnusedMethods::VisitDeclRefExpr( const DeclRefExpr* declRefExpr )
 324 {
 325     const FunctionDecl* functionDecl = dyn_cast<FunctionDecl>(declRefExpr->getDecl());
 326     if (!functionDecl) {
 327         return true;
 328     }
 329     logCallToRootMethods(functionDecl->getCanonicalDecl(), callSet);
 330     logCallToRootMethods(functionDecl->getCanonicalDecl(), usedReturnSet);
 331
 332     // Now do the checks necessary for the "can be private" analysis
 333     const CXXMethodDecl* methodDecl = dyn_cast<CXXMethodDecl>(functionDecl);
 334     if (methodDecl && methodDecl->getAccess() != AS_private)
 335     {
 336         const FunctionDecl* parentFunctionOfCallSite = parentFunctionDecl(declRefExpr);
 337         if (parentFunctionOfCallSite != functionDecl) {
 338             if (!parentFunctionOfCallSite || !ignoreLocation(parentFunctionOfCallSite)) {
 339                 calledFromOutsideSet.insert(niceName(functionDecl));
 340             }
 341         }
 342     }
 343
 344     return true;
 345 }
 346
 347 loplugin::Plugin::Registration< UnusedMethods > X("unusedmethods", false);
 348
 349 }
 350
 351 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */