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 revert(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             assert(false);
  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 VisitBinLT(BinaryOperator const* expr)
  51     {
  52         visitComparison(expr);
  53         return true;
  54     }
  55
  56     bool VisitBinGT(BinaryOperator const* expr)
  57     {
  58         visitComparison(expr);
  59         return true;
  60     }
  61
  62     bool VisitBinLE(BinaryOperator const* expr)
  63     {
  64         visitComparison(expr);
  65         return true;
  66     }
  67
  68     bool VisitBinGE(BinaryOperator const* expr)
  69     {
  70         visitComparison(expr);
  71         return true;
  72     }
  73
  74     bool VisitBinEQ(BinaryOperator const* expr)
  75     {
  76         visitComparison(expr);
  77         return true;
  78     }
  79
  80     bool VisitBinNE(BinaryOperator const* expr)
  81     {
  82         visitComparison(expr);
  83         return true;
  84     }
  85
  86 private:
  87     void run() override { TraverseDecl(compiler.getASTContext().getTranslationUnitDecl()); }
  88
  89     void visitComparison(BinaryOperator const* expr, CallExpr const* lhs, Expr const* rhs,
  90                          BinaryOperatorKind op)
  91     {
  92         auto const fdecl = lhs->getDirectCallee();
  93         if (fdecl == nullptr)
  94         {
  95             return;
  96         }
  97         loplugin::DeclCheck dc(fdecl);
  98         if (!(dc.Function("strlen").StdNamespace() || dc.Function("strlen").GlobalNamespace()))
  99         {
 100             return;
 101         }
 102         APSInt val;
 103         if (rhs->isValueDependent() || !rhs->isIntegerConstantExpr(val, compiler.getASTContext()))
 104         {
 105             return;
 106         }
 107         switch (op)
 108         {
 109             case BO_LT:
 110                 if (val.getExtValue() == 1)
 111                 {
 112                     report(DiagnosticsEngine::Warning,
 113                            "replace a comparison like 'strlen(e) < 1' with 'e[0] == '\\0''",
 114                            expr->getExprLoc())
 115                         << expr->getSourceRange();
 116                 }
 117                 break;
 118             case BO_GT:
 119                 if (val.getExtValue() == 0)
 120                 {
 121                     report(DiagnosticsEngine::Warning,
 122                            "replace a comparison like 'strlen(e) > 0' with 'e[0] != '\\0''",
 123                            expr->getExprLoc())
 124                         << expr->getSourceRange();
 125                 }
 126                 break;
 127             case BO_LE:
 128                 if (val.getExtValue() == 0)
 129                 {
 130                     report(DiagnosticsEngine::Warning,
 131                            "replace a comparison like 'strlen(e) <= 0' with 'e[0] == '\\0''",
 132                            expr->getExprLoc())
 133                         << expr->getSourceRange();
 134                 }
 135                 break;
 136             case BO_GE:
 137                 if (val.getExtValue() == 1)
 138                 {
 139                     report(DiagnosticsEngine::Warning,
 140                            "replace a comparison like 'strlen(e) >= 1' with 'e[0] != '\\0''",
 141                            expr->getExprLoc())
 142                         << expr->getSourceRange();
 143                 }
 144                 break;
 145             case BO_EQ:
 146                 if (val.getExtValue() == 0)
 147                 {
 148                     report(DiagnosticsEngine::Warning,
 149                            "replace a comparison like 'strlen(e) == 0' with 'e[0] == '\\0''",
 150                            expr->getExprLoc())
 151                         << expr->getSourceRange();
 152                 }
 153                 break;
 154             case BO_NE:
 155                 if (val.getExtValue() == 0)
 156                 {
 157                     report(DiagnosticsEngine::Warning,
 158                            "replace a comparison like 'strlen(e) != 0' with 'e[0] != '\\0''",
 159                            expr->getExprLoc())
 160                         << expr->getSourceRange();
 161                 }
 162                 break;
 163             default:
 164                 assert(false);
 165         }
 166     }
 167
 168     void visitComparison(BinaryOperator const* expr)
 169     {
 170         if (ignoreLocation(expr))
 171         {
 172             return;
 173         }
 174         if (auto const call = dyn_cast<CallExpr>(expr->getLHS()->IgnoreParenImpCasts()))
 175         {
 176             visitComparison(expr, call, expr->getRHS(), expr->getOpcode());
 177         }
 178         else if (auto const call = dyn_cast<CallExpr>(expr->getRHS()->IgnoreParenImpCasts()))
 179         {
 180             visitComparison(expr, call, expr->getLHS(), revert(expr->getOpcode()));
 181         }
 182     }
 183 };
 184
 185 loplugin::Plugin::Registration<Empty> emptyRegistration("empty");
 186 }
 187
 188 #endif // LO_CLANG_SHARED_PLUGINS
 189
 190 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */