compilerplugins/clang/oncevar.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 <unordered_map>
  14 #include <unordered_set>
  15
  16 #include "plugin.hxx"
  17 #include "check.hxx"
  18 #include "clang/AST/CXXInheritance.h"
  19 #include "clang/AST/StmtVisitor.h"
  20
  21 // Original idea from tml.
  22 // Look for variables that are (a) initialised from zero or one constants. (b) only used in one spot.
  23 // In which case, we might as well inline it.
  24
  25 namespace
  26 {
  27
  28 Expr const * lookThroughInitListExpr(Expr const * expr) {
  29     if (auto const ile = dyn_cast<InitListExpr>(expr->IgnoreParenImpCasts())) {
  30         if (ile->getNumInits() == 1) {
  31             return ile->getInit(0);
  32         }
  33     }
  34     return expr;
  35 }
  36
  37 class ConstantValueDependentExpressionVisitor:
  38     public ConstStmtVisitor<ConstantValueDependentExpressionVisitor, bool>
  39 {
  40     ASTContext const & context_;
  41
  42 public:
  43     ConstantValueDependentExpressionVisitor(ASTContext const & context):
  44         context_(context) {}
  45
  46     bool Visit(Stmt const * stmt) {
  47         assert(isa<Expr>(stmt));
  48         auto const expr = cast<Expr>(stmt);
  49         if (!expr->isValueDependent()) {
  50             return expr->isEvaluatable(context_);
  51         }
  52         return ConstStmtVisitor::Visit(stmt);
  53     }
  54
  55     bool VisitParenExpr(ParenExpr const * expr)
  56     { return Visit(expr->getSubExpr()); }
  57
  58     bool VisitCastExpr(CastExpr const * expr) {
  59         return Visit(expr->getSubExpr());
  60     }
  61
  62     bool VisitUnaryOperator(UnaryOperator const * expr)
  63     { return Visit(expr->getSubExpr()); }
  64
  65     bool VisitBinaryOperator(BinaryOperator const * expr) {
  66         return Visit(expr->getLHS()) && Visit(expr->getRHS());
  67     }
  68
  69     bool VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr const *) {
  70         return true;
  71     }
  72 };
  73
  74 class OnceVar:
  75     public loplugin::FilteringPlugin<OnceVar>
  76 {
  77 public:
  78     explicit OnceVar(loplugin::InstantiationData const & data): FilteringPlugin(data) {}
  79
  80     virtual void run() override {
  81         // ignore some files with problematic macros
  82         std::string fn(handler.getMainFileName());
  83         loplugin::normalizeDotDotInFilePath(fn);
  84         // platform-specific stuff
  85         if (fn == SRCDIR "/sal/osl/unx/thread.cxx"
  86             || fn == SRCDIR "/sot/source/base/formats.cxx"
  87             || fn == SRCDIR "/svl/source/config/languageoptions.cxx"
  88             || fn == SRCDIR "/sfx2/source/appl/appdde.cxx"
  89             || fn == SRCDIR "/configmgr/source/components.cxx"
  90             || fn == SRCDIR "/embeddedobj/source/msole/oleembed.cxx")
  91              return;
  92         // some of this is necessary
  93         if (loplugin::hasPathnamePrefix( fn, SRCDIR "/sal/qa/"))
  94              return;
  95         if (loplugin::hasPathnamePrefix( fn, SRCDIR "/comphelper/qa/"))
  96              return;
  97         // TODO need to check calls via function pointer
  98         if (fn == SRCDIR "/i18npool/source/textconversion/textconversion_zh.cxx"
  99             || fn == SRCDIR "/i18npool/source/localedata/localedata.cxx")
 100              return;
 101         // debugging stuff
 102         if (fn == SRCDIR "/sc/source/core/data/dpcache.cxx"
 103             || fn == SRCDIR "/sw/source/core/layout/dbg_lay.cxx"
 104             || fn == SRCDIR "/sw/source/core/layout/ftnfrm.cxx")
 105              return;
 106         // TODO taking local reference to variable
 107         if (fn == SRCDIR "/sc/source/filter/excel/xechart.cxx")
 108              return;
 109         // macros managing to generate to a valid warning
 110         if (fn == SRCDIR "/solenv/bin/concat-deps.c")
 111              return;
 112         // TODO bug in the plugin
 113         if (fn == SRCDIR "/vcl/unx/generic/app/saldisp.cxx")
 114             return;
 115
 116         TraverseDecl(compiler.getASTContext().getTranslationUnitDecl());
 117
 118         for (auto const & varDecl : maVarDeclSet)
 119         {
 120             if (maVarDeclToIgnoreSet.find(varDecl) != maVarDeclToIgnoreSet.end())
 121                 continue;
 122             int noUses = 0;
 123             auto it = maVarUsesMap.find(varDecl);
 124             if (it != maVarUsesMap.end())
 125                 noUses = it->second;
 126             if (noUses > 1)
 127                 continue;
 128             report(DiagnosticsEngine::Warning,
 129                    "var used only once, should be inlined or declared const",
 130                    varDecl->getLocation())
 131                 << varDecl->getSourceRange();
 132             if (it != maVarUsesMap.end())
 133                 report(DiagnosticsEngine::Note,
 134                        "used here",
 135                        maVarUseSourceRangeMap[varDecl].getBegin())
 136                     << maVarUseSourceRangeMap[varDecl];
 137         }
 138     }
 139
 140     bool VisitMemberExpr(MemberExpr const * expr) {
 141         // ignore cases like:
 142         //     const OUString("xxx") xxx;
 143         //     rtl_something(xxx.pData);
 144         // where we cannot inline the declaration.
 145         if (isa<FieldDecl>(expr->getMemberDecl())) {
 146             recordIgnore(expr);
 147         }
 148         return true;
 149     }
 150
 151     bool VisitUnaryOperator(UnaryOperator const * expr) {
 152         // if we take the address of it, or we modify it, ignore it
 153         UnaryOperator::Opcode op = expr->getOpcode();
 154         if (op == UO_AddrOf || op == UO_PreInc || op == UO_PostInc
 155             || op == UO_PreDec || op == UO_PostDec)
 156         {
 157             recordIgnore(expr->getSubExpr());
 158         }
 159         return true;
 160     }
 161
 162     bool VisitBinaryOperator(BinaryOperator const * expr) {
 163         // if we assign it another value, or modify it, ignore it
 164         BinaryOperator::Opcode op = expr->getOpcode();
 165         if (op == BO_Assign || op == BO_PtrMemD || op == BO_PtrMemI || op == BO_MulAssign
 166             || op == BO_DivAssign || op == BO_RemAssign || op == BO_AddAssign
 167             || op == BO_SubAssign || op == BO_ShlAssign || op == BO_ShrAssign
 168             || op == BO_AndAssign || op == BO_XorAssign || op == BO_OrAssign)
 169         {
 170             recordIgnore(expr->getLHS());
 171         }
 172         return true;
 173     }
 174
 175     bool VisitCallExpr(CallExpr const * expr) {
 176         unsigned firstArg = 0;
 177         if (auto const cmce = dyn_cast<CXXMemberCallExpr>(expr)) {
 178             if (auto const e1 = cmce->getMethodDecl()) {
 179                 if (!(e1->isConst() || e1->isStatic())) {
 180                     recordIgnore(cmce->getImplicitObjectArgument());
 181                 }
 182             } else if (auto const e2 = dyn_cast<BinaryOperator>(
 183                            cmce->getCallee()->IgnoreParenImpCasts()))
 184             {
 185                 switch (e2->getOpcode()) {
 186                 case BO_PtrMemD:
 187                 case BO_PtrMemI:
 188                     if (!e2->getRHS()->getType()->getAs<MemberPointerType>()
 189                         ->getPointeeType()->getAs<FunctionProtoType>()
 190                         ->isConst())
 191                     {
 192                         recordIgnore(e2->getLHS());
 193                     }
 194                     break;
 195                 default:
 196                     break;
 197                 }
 198             }
 199         } else if (auto const coce = dyn_cast<CXXOperatorCallExpr>(expr)) {
 200             if (auto const cmd = dyn_cast_or_null<CXXMethodDecl>(
 201                     coce->getDirectCallee()))
 202             {
 203                 if (!cmd->isStatic()) {
 204                     assert(coce->getNumArgs() != 0);
 205                     if (!cmd->isConst()) {
 206                         recordIgnore(coce->getArg(0));
 207                     }
 208                     firstArg = 1;
 209                 }
 210             }
 211         }
 212         // ignore those ones we are passing by reference
 213         const FunctionDecl* calleeFunctionDecl = expr->getDirectCallee();
 214         if (calleeFunctionDecl) {
 215             for (unsigned i = firstArg; i < expr->getNumArgs(); ++i) {
 216                 if (i < calleeFunctionDecl->getNumParams()) {
 217                     QualType qt { calleeFunctionDecl->getParamDecl(i)->getType() };
 218                     if (loplugin::TypeCheck(qt).LvalueReference().NonConst()) {
 219                         recordIgnore(expr->getArg(i));
 220                     }
 221                     if (loplugin::TypeCheck(qt).Pointer().NonConst()) {
 222                         recordIgnore(expr->getArg(i));
 223                     }
 224                 }
 225             }
 226         }
 227         return true;
 228     }
 229
 230     bool VisitCXXConstructExpr(CXXConstructExpr const * expr) {
 231         // ignore those ones we are passing by reference
 232         const CXXConstructorDecl* cxxConstructorDecl = expr->getConstructor();
 233         for (unsigned i = 0; i < expr->getNumArgs(); ++i) {
 234             if (i < cxxConstructorDecl->getNumParams()) {
 235                 QualType qt { cxxConstructorDecl->getParamDecl(i)->getType() };
 236                 if (loplugin::TypeCheck(qt).LvalueReference().NonConst()) {
 237                     recordIgnore(expr->getArg(i));
 238                 }
 239                 if (loplugin::TypeCheck(qt).Pointer().NonConst()) {
 240                     recordIgnore(expr->getArg(i));
 241                 }
 242             }
 243         }
 244         return true;
 245     }
 246
 247     bool VisitDeclRefExpr( const DeclRefExpr* );
 248     bool VisitVarDecl( const VarDecl* );
 249     bool TraverseFunctionDecl( FunctionDecl* functionDecl );
 250
 251 private:
 252     std::unordered_set<VarDecl const *> maVarDeclSet;
 253     std::unordered_set<VarDecl const *> maVarDeclToIgnoreSet;
 254     std::unordered_map<VarDecl const *, int> maVarUsesMap;
 255     std::unordered_map<VarDecl const *, SourceRange> maVarUseSourceRangeMap;
 256
 257     bool isConstantValueDependentExpression(Expr const * expr) {
 258         return ConstantValueDependentExpressionVisitor(compiler.getASTContext())
 259             .Visit(expr);
 260     }
 261
 262     void recordIgnore(Expr const * expr) {
 263         for (;;) {
 264             expr = expr->IgnoreParenImpCasts();
 265             if (auto const e = dyn_cast<MemberExpr>(expr)) {
 266                 if (isa<FieldDecl>(e->getMemberDecl())) {
 267                     expr = e->getBase();
 268                     continue;
 269                 }
 270             }
 271             if (auto const e = dyn_cast<ArraySubscriptExpr>(expr)) {
 272                 expr = e->getBase();
 273                 continue;
 274             }
 275             if (auto const e = dyn_cast<BinaryOperator>(expr)) {
 276                 if (e->getOpcode() == BO_PtrMemD) {
 277                     expr = e->getLHS();
 278                     continue;
 279                 }
 280             }
 281             break;
 282         }
 283         auto const dre = dyn_cast<DeclRefExpr>(expr);
 284         if (dre == nullptr) {
 285             return;
 286         }
 287         auto const var = dyn_cast<VarDecl>(dre->getDecl());
 288         if (var == nullptr) {
 289             return;
 290         }
 291         maVarDeclToIgnoreSet.insert(var);
 292     }
 293 };
 294
 295 bool OnceVar::TraverseFunctionDecl( FunctionDecl* functionDecl )
 296 {
 297     // Ignore functions that contains #ifdef-ery, can be quite tricky
 298     // to make useful changes when this plugin fires in such functions
 299     if (containsPreprocessingConditionalInclusion(
 300             functionDecl->getSourceRange()))
 301         return true;
 302     return RecursiveASTVisitor::TraverseFunctionDecl(functionDecl);
 303 }
 304
 305 bool OnceVar::VisitVarDecl( const VarDecl* varDecl )
 306 {
 307     if (ignoreLocation(varDecl)) {
 308         return true;
 309     }
 310     if (auto const init = varDecl->getInit()) {
 311         recordIgnore(lookThroughInitListExpr(init));
 312     }
 313     if (varDecl->isExceptionVariable() || isa<ParmVarDecl>(varDecl)) {
 314         return true;
 315     }
 316     // ignore stuff in header files (which should really not be there, but anyhow)
 317     if (!compiler.getSourceManager().isInMainFile(varDecl->getLocation())) {
 318         return true;
 319     }
 320     // Ignore macros like FD_ZERO
 321     if (compiler.getSourceManager().isMacroBodyExpansion(compat::getBeginLoc(varDecl))) {
 322         return true;
 323     }
 324     if (varDecl->hasGlobalStorage()) {
 325         return true;
 326     }
 327     auto const tc = loplugin::TypeCheck(varDecl->getType());
 328     if (!varDecl->getType().isCXX11PODType(compiler.getASTContext())
 329         && !tc.Class("OString").Namespace("rtl").GlobalNamespace()
 330         && !tc.Class("OUString").Namespace("rtl").GlobalNamespace()
 331         && !tc.Class("OStringBuffer").Namespace("rtl").GlobalNamespace()
 332         && !tc.Class("OUStringBuffer").Namespace("rtl").GlobalNamespace()
 333         && !tc.Class("Color").GlobalNamespace()
 334         && !tc.Class("Pair").GlobalNamespace()
 335         && !tc.Class("Point").GlobalNamespace()
 336         && !tc.Class("Size").GlobalNamespace()
 337         && !tc.Class("Range").GlobalNamespace()
 338         && !tc.Class("Selection").GlobalNamespace()
 339         && !tc.Class("Rectangle").Namespace("tools").GlobalNamespace())
 340     {
 341         return true;
 342     }
 343     if (varDecl->getType()->isPointerType())
 344         return true;
 345     // if it's declared const, ignore it, it's there to make the code easier to read
 346     if (tc.Const())
 347         return true;
 348
 349     if (!varDecl->hasInit())
 350         return true;
 351
 352     // check for string or scalar literals
 353     bool foundStringLiteral = false;
 354     const Expr * initExpr = varDecl->getInit();
 355     if (auto e = dyn_cast<ExprWithCleanups>(initExpr)) {
 356         initExpr = e->getSubExpr();
 357     }
 358     if (isa<clang::StringLiteral>(initExpr)) {
 359         foundStringLiteral = true;
 360     } else if (auto constructExpr = dyn_cast<CXXConstructExpr>(initExpr)) {
 361         if (constructExpr->getNumArgs() == 0) {
 362             foundStringLiteral = true; // i.e., empty string
 363         } else {
 364             auto stringLit2 = dyn_cast<clang::StringLiteral>(constructExpr->getArg(0));
 365             foundStringLiteral = stringLit2 != nullptr;
 366         }
 367     }
 368     if (!foundStringLiteral) {
 369         auto const init = varDecl->getInit();
 370         if (!(init->isValueDependent()
 371               ? isConstantValueDependentExpression(init)
 372               : init->isConstantInitializer(
 373                   compiler.getASTContext(), false/*ForRef*/)))
 374         {
 375             return true;
 376         }
 377     }
 378
 379     maVarDeclSet.insert(varDecl);
 380
 381     return true;
 382 }
 383
 384 bool OnceVar::VisitDeclRefExpr( const DeclRefExpr* declRefExpr )
 385 {
 386     if (ignoreLocation(declRefExpr)) {
 387         return true;
 388     }
 389     const Decl* decl = declRefExpr->getDecl();
 390     if (!isa<VarDecl>(decl) || isa<ParmVarDecl>(decl)) {
 391         return true;
 392     }
 393     const VarDecl * varDecl = dyn_cast<VarDecl>(decl)->getCanonicalDecl();
 394     // ignore stuff in header files (which should really not be there, but anyhow)
 395     if (!compiler.getSourceManager().isInMainFile(varDecl->getLocation())) {
 396         return true;
 397     }
 398
 399     if (maVarUsesMap.find(varDecl) == maVarUsesMap.end()) {
 400         maVarUsesMap[varDecl] = 1;
 401         maVarUseSourceRangeMap[varDecl] = declRefExpr->getSourceRange();
 402     } else {
 403         maVarUsesMap[varDecl]++;
 404     }
 405
 406     return true;
 407 }
 408
 409 loplugin::Plugin::Registration< OnceVar > X("oncevar", false);
 410
 411 }
 412
 413 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */