compilerplugins/clang/mergeclasses.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 <set>
  12 #include <string>
  13 #include <iostream>
  14 #include "plugin.hxx"
  15 #include <fstream>
  16
  17 /**
  18
  19 Idea from Norbert (shm_get) - look for classes that are
  20 (a) not instantiated
  21 (b) have zero or one subclasses
  22 and warn about them - would allow us to remove a bunch of abstract classes
  23 that can be merged into one class and simplified.
  24
  25 Dump a list of
  26 - unique classes that exist (A)
  27 - unique classes that are instantiated (B)
  28 - unique class-subclass relationships (C)
  29 Then
  30    let D = A minus B
  31    for each class in D, look in C and count the entries, then dump it if no-entries == 1
  32
  33 The process goes something like this:
  34   $ make check
  35   $ make FORCE_COMPILE_ALL=1 COMPILER_PLUGIN_TOOL='mergeclasses' check
  36   $ ./compilerplugins/clang/mergeclasses.py
  37
  38 FIXME exclude 'static-only' classes, which some people may use/have used instead of a namespace to tie together a bunch of functions
  39
  40 */
  41
  42 namespace {
  43
  44 // try to limit the voluminous output a little
  45 static std::set<std::string> instantiatedSet;
  46 static std::set<std::pair<std::string,std::string> > childToParentClassSet; // childClassName -> parentClassName
  47 static std::map<std::string,std::string> definitionMap;  // className -> filename
  48
  49 class MergeClasses:
  50     public loplugin::FilteringPlugin<MergeClasses>
  51 {
  52 public:
  53     explicit MergeClasses(loplugin::InstantiationData const & data):
  54         FilteringPlugin(data) {}
  55
  56     virtual void run() override
  57     {
  58         TraverseDecl(compiler.getASTContext().getTranslationUnitDecl());
  59
  60         // dump all our output in one write call - this is to try and limit IO "crosstalk" between multiple processes
  61         // writing to the same logfile
  62         std::string output;
  63         for (const std::string & s : instantiatedSet)
  64             output += "instantiated:\t" + s + "\n";
  65         for (const std::pair<std::string,std::string> & s : childToParentClassSet)
  66             output += "has-subclass:\t" + s.first + "\t" + s.second + "\n";
  67         for (const std::pair<std::string,std::string> & s : definitionMap)
  68             output += "definition:\t" + s.first + "\t" + s.second + "\n";
  69         std::ofstream myfile;
  70         myfile.open( WORKDIR "/loplugin.mergeclasses.log", std::ios::app | std::ios::out);
  71         myfile << output;
  72         myfile.close();
  73     }
  74
  75     bool shouldVisitTemplateInstantiations () const { return true; }
  76
  77     bool VisitVarDecl(const VarDecl *);
  78     bool VisitFieldDecl(const FieldDecl *);
  79     bool VisitCXXConstructExpr( const CXXConstructExpr* var );
  80     bool VisitCXXRecordDecl( const CXXRecordDecl* decl);
  81 };
  82
  83 bool startsWith(const std::string& rStr, const char* pSubStr) {
  84     return rStr.compare(0, strlen(pSubStr), pSubStr) == 0;
  85 }
  86
  87 bool ignoreClass(StringRef s)
  88 {
  89     // ignore stuff in the standard library, and UNO stuff we can't touch.
  90     if (startsWith(s, "rtl::") || startsWith(s, "sal::") || startsWith(s, "com::sun::")
  91         || startsWith(s, "std::") || startsWith(s, "boost::")
  92         || s == "OString" || s == "OUString" || s == "bad_alloc")
  93     {
  94         return true;
  95     }
  96     // ignore instantiations of pointers and arrays
  97     if (s.endswith("*") || s.endswith("]")) {
  98         return true;
  99     }
 100     return false;
 101 }
 102
 103 // check for implicit construction
 104 bool MergeClasses::VisitVarDecl( const VarDecl* pVarDecl )
 105 {
 106     if (ignoreLocation(pVarDecl)) {
 107         return true;
 108     }
 109     std::string s = pVarDecl->getType().getAsString();
 110     if (!ignoreClass(s))
 111         instantiatedSet.insert(s);
 112     return true;
 113 }
 114
 115 // check for implicit construction
 116 bool MergeClasses::VisitFieldDecl( const FieldDecl* pFieldDecl )
 117 {
 118     if (ignoreLocation(pFieldDecl)) {
 119         return true;
 120     }
 121     std::string s = pFieldDecl->getType().getAsString();
 122     if (!ignoreClass(s))
 123         instantiatedSet.insert(s);
 124     return true;
 125 }
 126
 127 bool MergeClasses::VisitCXXConstructExpr( const CXXConstructExpr* pCXXConstructExpr )
 128 {
 129     if (ignoreLocation(pCXXConstructExpr)) {
 130         return true;
 131     }
 132     // ignore calls when a sub-class is constructing its superclass
 133     if (pCXXConstructExpr->getConstructionKind() != CXXConstructExpr::ConstructionKind::CK_Complete) {
 134         return true;
 135     }
 136     const CXXConstructorDecl* pCXXConstructorDecl = pCXXConstructExpr->getConstructor();
 137     const CXXRecordDecl* pParentCXXRecordDecl = pCXXConstructorDecl->getParent();
 138     std::string s = pParentCXXRecordDecl->getQualifiedNameAsString();
 139     if (!ignoreClass(s))
 140         instantiatedSet.insert(s);
 141     return true;
 142 }
 143
 144 bool MergeClasses::VisitCXXRecordDecl(const CXXRecordDecl* decl)
 145 {
 146     if (ignoreLocation(decl)) {
 147         return true;
 148     }
 149     if (decl->isThisDeclarationADefinition())
 150     {
 151         SourceLocation spellingLocation = compiler.getSourceManager().getSpellingLoc(compat::getBeginLoc(decl));
 152         std::string filename = getFilenameOfLocation(spellingLocation);
 153         filename = filename.substr(strlen(SRCDIR));
 154         std::string s = decl->getQualifiedNameAsString();
 155         if (ignoreClass(s))
 156             return true;
 157         definitionMap.insert( std::pair<std::string,std::string>(s, filename) );
 158         for (auto it = decl->bases_begin(); it != decl->bases_end(); ++it)
 159         {
 160             const CXXBaseSpecifier spec = *it;
 161             // need to look through typedefs, hence the getUnqualifiedDesugaredType
 162             QualType baseType = spec.getType().getDesugaredType(compiler.getASTContext());
 163             childToParentClassSet.insert( std::pair<std::string,std::string>(s, baseType.getAsString()) );
 164         }
 165     }
 166     return true;
 167 }
 168
 169 loplugin::Plugin::Registration< MergeClasses > X("mergeclasses", false);
 170
 171 }
 172
 173 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */