new loplugin:unuseddefaultparams

Change-Id: I2c3e7d66be9e3883ea2801ff394948cc580d1e44

4 files changed, 306 insertions, 20 deletions

diff --git a/compilerplugins/clang/unuseddefaultparams.cxx b/compilerplugins/clang/unuseddefaultparams.cxx
new file mode 100644
index 000000000000..1e33feae6330
--- /dev/null
+++ b/compilerplugins/clang/unuseddefaultparams.cxx
@@ -0,0 +1,215 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <string>
+#include <set>
+#include <iostream>
+#include <fstream>
+
+#include "plugin.hxx"
+#include "compat.hxx"
+
+/*
+ Find methods with default params, where the callers never specify the default param i.e.
+ might as well remove it.
+
+ The process goes something like this:
+  $ make check
+  $ make FORCE_COMPILE_ALL=1 COMPILER_PLUGIN_TOOL='unusedmethods' check
+  $ ./compilerplugins/clang/unuseddefaultparams.py unuseddefaultparams.log
+*/
+
+namespace {
+
+struct MyFuncInfo
+{
+    std::string access;
+    std::string returnType;
+    std::string nameAndParams;
+    std::string sourceLocation;
+};
+bool operator < (const MyFuncInfo &lhs, const MyFuncInfo &rhs)
+{
+    return lhs.sourceLocation < rhs.sourceLocation;
+}
+
+
+// try to limit the voluminous output a little
+static std::set<MyFuncInfo> callSet;
+static std::set<MyFuncInfo> definitionSet;
+
+class UnusedDefaultParams:
+    public RecursiveASTVisitor<UnusedDefaultParams>, public loplugin::Plugin
+{
+public:
+    explicit UnusedDefaultParams(InstantiationData const & data): Plugin(data) {}
+
+    virtual void run() override
+    {
+        TraverseDecl(compiler.getASTContext().getTranslationUnitDecl());
+
+        // dump all our output in one write call - this is to try and limit IO "crosstalk" between multiple processes
+        // writing to the same logfile
+
+        std::string output;
+        for (const MyFuncInfo & s : definitionSet)
+            output += "defn:\t" + s.access + "\t" + s.returnType + "\t" + s.nameAndParams + "\t" + s.sourceLocation + "\n";
+        for (const MyFuncInfo & s : callSet)
+            output += "call:\t" + s.returnType + "\t" + s.nameAndParams + "\n";
+        ofstream myfile;
+        myfile.open( SRCDIR "/unuseddefaultparams.log", ios::app | ios::out);
+        myfile << output;
+        myfile.close();
+    }
+
+    bool VisitCallExpr(CallExpr * callExpr);
+    bool VisitFunctionDecl( const FunctionDecl* functionDecl );
+private:
+    MyFuncInfo niceName(const FunctionDecl* functionDecl);
+};
+
+MyFuncInfo UnusedDefaultParams::niceName(const FunctionDecl* functionDecl)
+{
+    if (functionDecl->getInstantiatedFromMemberFunction())
+        functionDecl = functionDecl->getInstantiatedFromMemberFunction();
+    else if (functionDecl->getClassScopeSpecializationPattern())
+        functionDecl = functionDecl->getClassScopeSpecializationPattern();
+// workaround clang-3.5 issue
+#if __clang_major__ > 3 || ( __clang_major__ == 3 && __clang_minor__ >= 6 )
+    else if (functionDecl->getTemplateInstantiationPattern())
+        functionDecl = functionDecl->getTemplateInstantiationPattern();
+#endif
+
+    MyFuncInfo aInfo;
+    switch (functionDecl->getAccess())
+    {
+    case AS_public: aInfo.access = "public"; break;
+    case AS_private: aInfo.access = "private"; break;
+    case AS_protected: aInfo.access = "protected"; break;
+    default: aInfo.access = "unknown"; break;
+    }
+    aInfo.returnType = compat::getReturnType(*functionDecl).getCanonicalType().getAsString();
+
+    if (isa<CXXMethodDecl>(functionDecl)) {
+        const CXXRecordDecl* recordDecl = dyn_cast<CXXMethodDecl>(functionDecl)->getParent();
+        aInfo.nameAndParams += recordDecl->getQualifiedNameAsString();
+        aInfo.nameAndParams += "::";
+    }
+    aInfo.nameAndParams += functionDecl->getNameAsString() + "(";
+    bool bFirst = true;
+    for (const ParmVarDecl *pParmVarDecl : functionDecl->params()) {
+        if (bFirst)
+            bFirst = false;
+        else
+            aInfo.nameAndParams += ",";
+        aInfo.nameAndParams += pParmVarDecl->getType().getCanonicalType().getAsString();
+    }
+    aInfo.nameAndParams += ")";
+    if (isa<CXXMethodDecl>(functionDecl) && dyn_cast<CXXMethodDecl>(functionDecl)->isConst()) {
+        aInfo.nameAndParams += " const";
+    }
+
+    SourceLocation expansionLoc = compiler.getSourceManager().getExpansionLoc( functionDecl->getLocation() );
+    StringRef name = compiler.getSourceManager().getFilename(expansionLoc);
+    aInfo.sourceLocation = std::string(name.substr(strlen(SRCDIR)+1)) + ":" + std::to_string(compiler.getSourceManager().getSpellingLineNumber(expansionLoc));
+
+    return aInfo;
+}
+
+bool UnusedDefaultParams::VisitCallExpr(CallExpr * callExpr) {
+    if (ignoreLocation(callExpr)) {
+        return true;
+    }
+    if (callExpr->getDirectCallee() == nullptr) {
+        return true;
+    }
+    const FunctionDecl* functionDecl = callExpr->getDirectCallee()->getCanonicalDecl();
+    auto n = functionDecl->getNumParams();
+    if (n == 0 || !functionDecl->getParamDecl(n - 1)->hasDefaultArg()) {
+        return true;
+    }
+    // method overrides don't always specify the same default params (althogh they probably should)
+    // so we need to work our way up to the root method
+    while (isa<CXXMethodDecl>(functionDecl)) {
+        const CXXMethodDecl* methodDecl = dyn_cast<CXXMethodDecl>(functionDecl);
+        if (methodDecl->size_overridden_methods()==0)
+            break;
+        functionDecl = *methodDecl->begin_overridden_methods();
+    }
+    assert(callExpr->getNumArgs() <= n); // can be < in template code
+    for (unsigned i = callExpr->getNumArgs(); i != 0;) {
+        --i;
+        Expr* arg = callExpr->getArg(i);
+        if (arg->isDefaultArgument()) {
+            continue;
+        }
+        // ignore this, it seems to trigger an infinite recursion
+        if (isa<UnaryExprOrTypeTraitExpr>(arg))
+            break;
+        const ParmVarDecl* parmVarDecl = functionDecl->getParamDecl(i);
+        if (!parmVarDecl->hasDefaultArg()
+            || parmVarDecl->hasUninstantiatedDefaultArg())
+        {
+            break;
+        }
+        const Expr* defaultArgExpr = parmVarDecl->getDefaultArg();
+        if (!defaultArgExpr) {
+            break;
+        }
+        MyFuncInfo funcInfo = niceName(functionDecl);
+        callSet.insert(funcInfo);
+        break;
+    }
+    return true;
+}
+
+bool UnusedDefaultParams::VisitFunctionDecl( const FunctionDecl* functionDecl )
+{
+    functionDecl = functionDecl->getCanonicalDecl();
+    if( !functionDecl || !functionDecl->getLocation().isValid() || ignoreLocation( functionDecl )) {
+        return true;
+    }
+    const CXXMethodDecl* methodDecl = dyn_cast_or_null<CXXMethodDecl>(functionDecl);
+
+    // ignore method overrides, since the call will show up as being directed to the root method
+    if (methodDecl && (methodDecl->size_overridden_methods() != 0 || methodDecl->hasAttr<OverrideAttr>())) {
+        return true;
+    }
+    // ignore stuff that forms part of the stable URE interface
+    if (isInUnoIncludeFile(compiler.getSourceManager().getSpellingLoc(
+                              functionDecl->getNameInfo().getLoc()))) {
+        return true;
+    }
+    if (isa<CXXDestructorDecl>(functionDecl)) {
+        return true;
+    }
+    if (isa<CXXConstructorDecl>(functionDecl)) {
+        return true;
+    }
+    if (functionDecl->isDeleted()) {
+        return true;
+    }
+    auto n = functionDecl->getNumParams();
+    if (n == 0 || !functionDecl->getParamDecl(n - 1)->hasDefaultArg()) {
+        return true;
+    }
+
+    if( functionDecl->getLocation().isValid() )
+    {
+        MyFuncInfo funcInfo = niceName(functionDecl);
+        definitionSet.insert(funcInfo);
+    }
+    return true;
+}
+
+loplugin::Plugin::Registration< UnusedDefaultParams > X("unuseddefaultparams", true);
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/compilerplugins/clang/unuseddefaultparams.py b/compilerplugins/clang/unuseddefaultparams.py
new file mode 100755
index 000000000000..7fdce2c60641
--- /dev/null
+++ b/compilerplugins/clang/unuseddefaultparams.py
@@ -0,0 +1,78 @@
+#!/usr/bin/python
+
+import sys
+import re
+import io
+
+definitionSet = set()
+definitionToSourceLocationMap = dict()
+callSet = set()
+
+# things we need to exclude for reasons like :
+# - it's a weird template thingy that confuses the plugin
+exclusionSet = set()
+
+# clang does not always use exactly the same numbers in the type-parameter vars it generates
+# so I need to substitute them to ensure we can match correctly.
+normalizeTypeParamsRegex = re.compile(r"type-parameter-\d+-\d+")
+def normalizeTypeParams( line ):
+    return normalizeTypeParamsRegex.sub("type-parameter-?-?", line)
+
+# The parsing here is designed to avoid grabbing stuff which is mixed in from gbuild.
+# I have not yet found a way of suppressing the gbuild output.
+with io.open(sys.argv[1], "rb", buffering=1024*1024) as txt:
+    for line in txt:
+        if line.startswith("defn:\t"):
+            idx1 = line.find("\t",6)
+            idx2 = line.find("\t",idx1+1)
+            idx3 = line.find("\t",idx2+1)
+            access = line[6:idx1]
+            returnType = line[idx1+1:idx2]
+            nameAndParams = line[idx2+1:idx3]
+            sourceLocation = line[idx3+1:].strip()
+            funcInfo = (normalizeTypeParams(returnType), normalizeTypeParams(nameAndParams))
+            definitionSet.add(funcInfo)
+            definitionToSourceLocationMap[funcInfo] = sourceLocation
+        elif line.startswith("call:\t"):
+            idx1 = line.find("\t",6)
+            returnType = line[6:idx1]
+            nameAndParams = line[idx1+1:].strip()
+            callSet.add((normalizeTypeParams(returnType), normalizeTypeParams(nameAndParams)))
+
+# Invert the definitionToSourceLocationMap.
+# If we see more than one method at the same sourceLocation, it's being autogenerated as part of a template
+# and we should just ignore it.
+sourceLocationToDefinitionMap = {}
+for k, v in definitionToSourceLocationMap.iteritems():
+    sourceLocationToDefinitionMap[v] = sourceLocationToDefinitionMap.get(v, [])
+    sourceLocationToDefinitionMap[v].append(k)
+for k, definitions in sourceLocationToDefinitionMap.iteritems():
+    if len(definitions) > 1:
+        for d in definitions:
+            definitionSet.remove(d)
+
+    
+tmp1set = set()
+for d in definitionSet:
+    clazz = d[0] + " " + d[1]
+    if clazz in exclusionSet:
+        continue
+    if d in callSet:
+        continue
+    tmp1set.add((clazz, definitionToSourceLocationMap[d]))
+
+# sort the results using a "natural order" so sequences like [item1,item2,item10] sort nicely
+def natural_sort_key(s, _nsre=re.compile('([0-9]+)')):
+    return [int(text) if text.isdigit() else text.lower()
+            for text in re.split(_nsre, s)]
+
+# sort results by name and line number
+tmp1list = sorted(tmp1set, key=lambda v: natural_sort_key(v[1]))
+
+# print out the results
+with open("unused.defaultparams", "wt") as f:
+    for t in tmp1list:
+        f.write(t[1] + "\n")
+        f.write("    " + t[0] + "\n")
+
+
diff --git a/compilerplugins/clang/unusedfields.cxx b/compilerplugins/clang/unusedfields.cxx
index 2667485620c6..dd928d302772 100644
--- a/compilerplugins/clang/unusedfields.cxx
+++ b/compilerplugins/clang/unusedfields.cxx
@@ -47,17 +47,16 @@ struct MyFieldInfo
     std::string fieldName;
     std::string fieldType;
     std::string sourceLocation;
-
-    bool operator < (const MyFieldInfo &other) const
-    {
-        if (parentClass < other.parentClass)
-            return true;
-        else if (parentClass == other.parentClass)
-            return fieldName < other.fieldName;
-        else
-            return false;
-    }
 };
+bool operator < (const MyFieldInfo &lhs, const MyFieldInfo &rhs)
+{
+    if (lhs.parentClass < rhs.parentClass)
+        return true;
+    else if (lhs.parentClass == rhs.parentClass)
+         return lhs.fieldName < rhs.fieldName;
+    else
+        return false;
+}
 
 
 // try to limit the voluminous output a little
diff --git a/compilerplugins/clang/unusedmethods.cxx b/compilerplugins/clang/unusedmethods.cxx
index 3649fc6c24dc..c2785dd771ea 100644
--- a/compilerplugins/clang/unusedmethods.cxx
+++ b/compilerplugins/clang/unusedmethods.cxx
@@ -52,17 +52,11 @@ struct MyFuncInfo
     std::string nameAndParams;
     std::string sourceLocation;
 
-    bool operator < (const MyFuncInfo &other) const
-    {
-        if (returnType < other.returnType)
-            return true;
-        else if (returnType == other.returnType)
-            return nameAndParams < other.nameAndParams;
-        else
-            return false;
-    }
 };
-
+bool operator < (const MyFuncInfo &lhs, const MyFuncInfo &rhs)
+{
+    return lhs.sourceLocation < rhs.sourceLocation;
+}
 
 // try to limit the voluminous output a little