compilerplugins/clang/empty.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
   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 #ifndef LO_CLANG_SHARED_PLUGINS
  11
  12 #include <cassert>
  13
  14 #include "check.hxx"
  15 #include "plugin.hxx"
  16
  17 // Warn about checks whether a container is empty done via an (expensive) call to obtain the
  18 // container's size.  For now only handles cases involving strlen.
  19
  20 namespace
  21 {
  22 BinaryOperatorKind reverse(BinaryOperatorKind op)
  23 {
  24     switch (op)
  25     {
  26         case BO_LT:
  27             return BO_GE;
  28         case BO_GT:
  29             return BO_LE;
  30         case BO_LE:
  31             return BO_GT;
  32         case BO_GE:
  33             return BO_LT;
  34         case BO_EQ:
  35         case BO_NE:
  36             return op;
  37         default:
  38             abort();
  39     }
  40 }
  41
  42 class Empty : public loplugin::FilteringPlugin<Empty>
  43 {
  44 public:
  45     explicit Empty(loplugin::InstantiationData const& data)
  46         : FilteringPlugin(data)
  47     {
  48     }
  49
  50     bool VisitBinaryOperator(BinaryOperator const* expr)
  51     {
  52         if (expr->isRelationalOp() || expr->isEqualityOp())
  53         {
  54             visitComparison(expr);
  55         }
  56         return true;
  57     }
  58
  59 private:
  60     void run() override { TraverseDecl(compiler.getASTContext().getTranslationUnitDecl()); }
  61
  62     void visitComparison(BinaryOperator const* expr, CallExpr const* lhs, Expr const* rhs,
  63                          BinaryOperatorKind op)
  64     {
  65         auto const fdecl = lhs->getDirectCallee();
  66         if (fdecl == nullptr)
  67         {
  68             return;
  69         }
  70         loplugin::DeclCheck dc(fdecl);
  71         if (!(dc.Function("strlen").StdNamespace() || dc.Function("strlen").GlobalNamespace()))
  72         {
  73             return;
  74         }
  75         if (rhs->isValueDependent())
  76         {
  77             return;
  78         }
  79         auto const val = rhs->getIntegerConstantExpr(compiler.getASTContext());
  80         if (!val)
  81         {
  82             return;
  83         }
  84         switch (op)
  85         {
  86             case BO_LT:
  87                 if (val->getExtValue() == 1)
  88                 {
  89                     report(DiagnosticsEngine::Warning,
  90                            "replace a comparison like 'strlen(e) < 1' with 'e[0] == '\\0''",
  91                            expr->getExprLoc())
  92                         << expr->getSourceRange();
  93                 }
  94                 break;
  95             case BO_GT:
  96                 if (val->getExtValue() == 0)
  97                 {
  98                     report(DiagnosticsEngine::Warning,
  99                            "replace a comparison like 'strlen(e) > 0' with 'e[0] != '\\0''",
 100                            expr->getExprLoc())
 101                         << expr->getSourceRange();
 102                 }
 103                 break;
 104             case BO_LE:
 105                 if (val->getExtValue() == 0)
 106                 {
 107                     report(DiagnosticsEngine::Warning,
 108                            "replace a comparison like 'strlen(e) <= 0' with 'e[0] == '\\0''",
 109                            expr->getExprLoc())
 110                         << expr->getSourceRange();
 111                 }
 112                 break;
 113             case BO_GE:
 114                 if (val->getExtValue() == 1)
 115                 {
 116                     report(DiagnosticsEngine::Warning,
 117                            "replace a comparison like 'strlen(e) >= 1' with 'e[0] != '\\0''",
 118                            expr->getExprLoc())
 119                         << expr->getSourceRange();
 120                 }
 121                 break;
 122             case BO_EQ:
 123                 if (val->getExtValue() == 0)
 124                 {
 125                     report(DiagnosticsEngine::Warning,
 126                            "replace a comparison like 'strlen(e) == 0' with 'e[0] == '\\0''",
 127                            expr->getExprLoc())
 128                         << expr->getSourceRange();
 129                 }
 130                 break;
 131             case BO_NE:
 132                 if (val->getExtValue() == 0)
 133                 {
 134                     report(DiagnosticsEngine::Warning,
 135                            "replace a comparison like 'strlen(e) != 0' with 'e[0] != '\\0''",
 136                            expr->getExprLoc())
 137                         << expr->getSourceRange();
 138                 }
 139                 break;
 140             default:
 141                 assert(false);
 142         }
 143     }
 144
 145     void visitComparison(BinaryOperator const* expr)
 146     {
 147         if (ignoreLocation(expr))
 148         {
 149             return;
 150         }
 151         if (auto const call = dyn_cast<CallExpr>(expr->getLHS()->IgnoreParenImpCasts()))
 152         {
 153             visitComparison(expr, call, expr->getRHS(), expr->getOpcode());
 154         }
 155         else if (auto const call = dyn_cast<CallExpr>(expr->getRHS()->IgnoreParenImpCasts()))
 156         {
 157             visitComparison(expr, call, expr->getLHS(), reverse(expr->getOpcode()));
 158         }
 159     }
 160 };
 161
 162 loplugin::Plugin::Registration<Empty> emptyRegistration("empty");
 163 }
 164
 165 #endif // LO_CLANG_SHARED_PLUGINS
 166
 167 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */