compilerplugins/clang/passparamsbyref.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 #ifndef LO_CLANG_SHARED_PLUGINS
  10
  11 #include <string>
  12 #include <unordered_set>
  13
  14 #include "check.hxx"
  15 #include "compat.hxx"
  16 #include "plugin.hxx"
  17
  18 // Find places where parameters are passed by value
  19 // It's not very efficient, because we generally end up copying it twice - once into the parameter and
  20 // again into the destination.
  21 // They should rather be passed by reference.
  22 //
  23 // Generally recommending lambda capture by-ref rather than by-copy is even more
  24 // problematic than with function parameters, as a lambda instance can easily
  25 // outlive a referenced variable. So once lambdas start to get used in more
  26 // sophisticated ways than passing them into standard algorithms, this plugin's
  27 // advice, at least for explicit captures, will need to be revisited.
  28
  29 namespace {
  30
  31 class PassParamsByRef:
  32     public loplugin::FilteringPlugin<PassParamsByRef>
  33 {
  34 public:
  35     explicit PassParamsByRef(loplugin::InstantiationData const & data): FilteringPlugin(data), mbInsideFunctionDecl(false) {}
  36
  37     virtual void run() override { TraverseDecl(compiler.getASTContext().getTranslationUnitDecl()); }
  38
  39     // When warning about function params of primitive type that could be passed
  40     // by value instead of by reference, make sure not to warn if the parameter
  41     // is ever bound to a reference; on the one hand, this needs scaffolding in
  42     // all Traverse*Decl functions (indirectly) derived from FunctionDecl; and
  43     // on the other hand, use a hack of ignoring just the DeclRefExprs nested in
  44     // LValueToRValue ImplicitCastExprs when determining whether a param is
  45     // bound to a reference:
  46     bool PreTraverseFunctionDecl(FunctionDecl *);
  47     bool PostTraverseFunctionDecl(FunctionDecl *, bool);
  48     bool TraverseFunctionDecl(FunctionDecl *);
  49     bool PreTraverseCXXMethodDecl(CXXMethodDecl *);
  50     bool PostTraverseCXXMethodDecl(CXXMethodDecl *, bool);
  51     bool TraverseCXXMethodDecl(CXXMethodDecl *);
  52     bool PreTraverseCXXConstructorDecl(CXXConstructorDecl *);
  53     bool PostTraverseCXXConstructorDecl(CXXConstructorDecl *, bool);
  54     bool TraverseCXXConstructorDecl(CXXConstructorDecl *);
  55     bool PreTraverseImplicitCastExpr(ImplicitCastExpr *);
  56     bool TraverseImplicitCastExpr(ImplicitCastExpr *);
  57
  58     bool VisitBinaryOperator(BinaryOperator const *);
  59     bool VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *);
  60     bool VisitCallExpr(const CallExpr *);
  61     bool VisitCXXMemberCallExpr(const CXXMemberCallExpr *);
  62
  63 private:
  64     bool isFat(QualType type);
  65
  66     bool mbInsideFunctionDecl;
  67     std::unordered_set<ParmVarDecl const *> mParamExclusions;
  68 };
  69
  70 bool PassParamsByRef::PreTraverseFunctionDecl(FunctionDecl* functionDecl)
  71 {
  72     if (ignoreLocation(functionDecl))
  73         return false;
  74     if (functionDecl->isDeleted()
  75         || functionDecl->isFunctionTemplateSpecialization())
  76     {
  77         return false;
  78     }
  79     // Ignore virtual methods, sometimes we want to pass by value, and we cannot tell from
  80     // the limited info available at an individual site.
  81     const CXXMethodDecl * methodDecl = dyn_cast<CXXMethodDecl>(functionDecl);
  82     if (methodDecl && methodDecl->isVirtual())
  83         return false;
  84
  85     // Only warn on the definition of the function:
  86     if (!functionDecl->doesThisDeclarationHaveABody())
  87         return false;
  88
  89     mbInsideFunctionDecl = true;
  90     mParamExclusions.clear();
  91     return true;
  92 }
  93
  94 bool PassParamsByRef::PostTraverseFunctionDecl(FunctionDecl* functionDecl, bool)
  95 {
  96     mbInsideFunctionDecl = false;
  97
  98     unsigned n = functionDecl->getNumParams();
  99     for (unsigned i = 0; i != n; ++i) {
 100         const ParmVarDecl * pvDecl = functionDecl->getParamDecl(i);
 101         auto const t = pvDecl->getType();
 102         if (!isFat(t))
 103             continue;
 104         if (mParamExclusions.find(pvDecl) != mParamExclusions.end())
 105             continue;
 106         report(
 107             DiagnosticsEngine::Warning,
 108             ("passing %0 by value, rather pass by const lvalue reference"),
 109             pvDecl->getLocation())
 110             << t << pvDecl->getSourceRange();
 111         auto can = functionDecl->getCanonicalDecl();
 112         if (can->getLocation() != functionDecl->getLocation()) {
 113             report(
 114                 DiagnosticsEngine::Note, "function is declared here:",
 115                 can->getLocation())
 116                 << can->getSourceRange();
 117         }
 118     }
 119     return true;
 120 }
 121
 122 bool PassParamsByRef::TraverseFunctionDecl(FunctionDecl* functionDecl)
 123 {
 124     bool ret = true;
 125     if (PreTraverseFunctionDecl(functionDecl))
 126     {
 127         ret = RecursiveASTVisitor::TraverseFunctionDecl(functionDecl);
 128         PostTraverseFunctionDecl(functionDecl, ret);
 129     }
 130     return ret;
 131 }
 132
 133 bool PassParamsByRef::PreTraverseCXXMethodDecl(CXXMethodDecl* functionDecl)
 134 {
 135     return PreTraverseFunctionDecl(functionDecl);
 136 }
 137
 138 bool PassParamsByRef::PostTraverseCXXMethodDecl(CXXMethodDecl* functionDecl, bool b)
 139 {
 140     return PostTraverseFunctionDecl(functionDecl, b);
 141 }
 142
 143 bool PassParamsByRef::TraverseCXXMethodDecl(CXXMethodDecl* functionDecl)
 144 {
 145     bool ret = true;
 146     if (PreTraverseCXXMethodDecl(functionDecl))
 147     {
 148         ret = RecursiveASTVisitor::TraverseCXXMethodDecl(functionDecl);
 149         PostTraverseCXXMethodDecl(functionDecl, ret);
 150     }
 151     return ret;
 152 }
 153
 154 bool PassParamsByRef::PreTraverseCXXConstructorDecl(CXXConstructorDecl* functionDecl)
 155 {
 156     return PreTraverseFunctionDecl(functionDecl);
 157 }
 158
 159 bool PassParamsByRef::PostTraverseCXXConstructorDecl(CXXConstructorDecl* functionDecl, bool b)
 160 {
 161     return PostTraverseFunctionDecl(functionDecl, b);
 162 }
 163
 164 bool PassParamsByRef::TraverseCXXConstructorDecl(CXXConstructorDecl* functionDecl)
 165 {
 166     bool ret = true;
 167     if (PreTraverseCXXConstructorDecl(functionDecl))
 168     {
 169         ret = RecursiveASTVisitor::TraverseCXXConstructorDecl(functionDecl);
 170         PostTraverseCXXConstructorDecl(functionDecl, ret);
 171     }
 172     return ret;
 173 }
 174
 175 bool PassParamsByRef::PreTraverseImplicitCastExpr(ImplicitCastExpr * expr)
 176 {
 177     if (ignoreLocation(expr))
 178         return false;
 179     if (expr->getCastKind() == CK_LValueToRValue
 180          && isa<DeclRefExpr>(expr->getSubExpr()->IgnoreParenImpCasts()))
 181         return false;
 182     return true;
 183 }
 184
 185 bool PassParamsByRef::TraverseImplicitCastExpr(ImplicitCastExpr * expr)
 186 {
 187     bool ret = true;
 188     if (PreTraverseImplicitCastExpr(expr))
 189     {
 190         ret = RecursiveASTVisitor::TraverseImplicitCastExpr(expr);
 191     }
 192     return ret;
 193 }
 194
 195 bool PassParamsByRef::VisitBinaryOperator(const BinaryOperator * binaryOperator)
 196 {
 197     if (binaryOperator->getOpcode() != BO_Assign) {
 198         return true;
 199     }
 200     if (!mbInsideFunctionDecl)
 201         return true;
 202     // if we are assigning to a parameter, it can be inconvenient to make the param pass-by-ref
 203     if (auto declRefExpr = dyn_cast<DeclRefExpr>(binaryOperator->getLHS()))
 204     {
 205         if (auto parmVarDecl = dyn_cast<ParmVarDecl>(declRefExpr->getDecl()))
 206             mParamExclusions.emplace(parmVarDecl);
 207     }
 208     return true;
 209 }
 210
 211 bool PassParamsByRef::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr * cxxOperatorCallExpr )
 212 {
 213     if (!mbInsideFunctionDecl)
 214         return true;
 215     // if we are assigning to a parameter, it can be inconvenient to make the param pass-by-ref
 216     auto op = cxxOperatorCallExpr->getOperator();
 217     if ( op != clang::OverloadedOperatorKind::OO_Equal
 218          && op != clang::OverloadedOperatorKind::OO_SlashEqual
 219          && op != clang::OverloadedOperatorKind::OO_StarEqual
 220          && op != clang::OverloadedOperatorKind::OO_MinusEqual
 221          && op != clang::OverloadedOperatorKind::OO_PlusEqual)
 222         return true;
 223     auto declRefExpr = dyn_cast<DeclRefExpr>(cxxOperatorCallExpr->getArg(0));
 224     if (!declRefExpr)
 225         return true;
 226     if (auto parmVarDecl = dyn_cast<ParmVarDecl>(declRefExpr->getDecl()))
 227         mParamExclusions.emplace(parmVarDecl);
 228     return true;
 229 }
 230
 231 bool PassParamsByRef::VisitCallExpr(const CallExpr * callExpr )
 232 {
 233     if (!mbInsideFunctionDecl)
 234         return true;
 235     if (loplugin::DeclCheck(callExpr->getCalleeDecl()).Function("move").StdNamespace())
 236         if (auto declRefExpr = dyn_cast<DeclRefExpr>(callExpr->getArg(0)))
 237         {
 238             if (auto parmVarDecl = dyn_cast<ParmVarDecl>(declRefExpr->getDecl()))
 239                 mParamExclusions.emplace(parmVarDecl);
 240         }
 241     if (auto const fun = callExpr->getDirectCallee())
 242     {
 243         unsigned const n = std::min(fun->getNumParams(), callExpr->getNumArgs());
 244         for (unsigned i = 0; i != n; ++i)
 245         {
 246             if (!loplugin::TypeCheck(fun->getParamDecl(i)->getType())
 247                      .LvalueReference()
 248                      .NonConstVolatile())
 249                 continue;
 250             auto a = callExpr->getArg(i)->IgnoreParenImpCasts();
 251             if (auto declRefExpr = dyn_cast<DeclRefExpr>(a))
 252                 if (auto parmVarDecl = dyn_cast<ParmVarDecl>(declRefExpr->getDecl()))
 253                     mParamExclusions.emplace(parmVarDecl);
 254         }
 255     }
 256     return true;
 257 }
 258
 259 bool PassParamsByRef::VisitCXXMemberCallExpr(const CXXMemberCallExpr * callExpr )
 260 {
 261     if (!mbInsideFunctionDecl)
 262         return true;
 263     // exclude cases where we call a non-const method on the parameter i.e. potentially mutating it
 264     if (auto const e1 = callExpr->getMethodDecl())
 265         if (!e1->isConst())
 266         {
 267             auto a = callExpr->getImplicitObjectArgument()->IgnoreParenImpCasts();
 268             if (auto declRefExpr = dyn_cast<DeclRefExpr>(a))
 269                 if (auto parmVarDecl = dyn_cast<ParmVarDecl>(declRefExpr->getDecl()))
 270                     mParamExclusions.emplace(parmVarDecl);
 271         }
 272     return true;
 273 }
 274
 275 bool PassParamsByRef::isFat(QualType type) {
 276     if (!type->isRecordType()) {
 277         return false;
 278     }
 279     loplugin::TypeCheck tc(type);
 280     if ((tc.Class("Reference").Namespace("uno").Namespace("star")
 281             .Namespace("sun").Namespace("com").GlobalNamespace())
 282         || (tc.Class("Sequence").Namespace("uno").Namespace("star")
 283             .Namespace("sun").Namespace("com").GlobalNamespace())
 284         || tc.Class("OString").Namespace("rtl").GlobalNamespace()
 285         || tc.Class("OUString").Namespace("rtl").GlobalNamespace()
 286         || tc.Class("Reference").Namespace("rtl").GlobalNamespace())
 287     {
 288         return true;
 289     }
 290     if (type->isIncompleteType()) {
 291         return false;
 292     }
 293     clang::Type const * t2 = type.getTypePtrOrNull();
 294     return t2 != nullptr
 295         && compiler.getASTContext().getTypeSizeInChars(t2).getQuantity() > 64;
 296 }
 297
 298 loplugin::Plugin::Registration< PassParamsByRef > passparamsbyref("passparamsbyref");
 299
 300 } // namespace
 301
 302 #endif // LO_CLANG_SHARED_PLUGINS
 303
 304 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */