compilerplugins/clang/simplifypointertobool.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 <algorithm>
  11 #include <cassert>
  12 #include <deque>
  13 #include <string>
  14 #include <iostream>
  15 #include <fstream>
  16 #include <set>
  17
  18 #include <clang/AST/CXXInheritance.h>
  19
  20 #include "plugin.hxx"
  21 #include "check.hxx"
  22 #include "compat.hxx"
  23
  24 /**
  25   Simplify boolean expressions involving smart pointers e.g.
  26     if (x.get())
  27   can be
  28     if (x)
  29 */
  30 //TODO: Make this a shared plugin for Clang 12 (and possibly even for older Clang) again.
  31
  32 namespace
  33 {
  34 class SimplifyPointerToBool : public loplugin::FilteringRewritePlugin<SimplifyPointerToBool>
  35 {
  36 public:
  37     explicit SimplifyPointerToBool(loplugin::InstantiationData const& data)
  38         : FilteringRewritePlugin(data)
  39     {
  40     }
  41
  42     virtual void run() override
  43     {
  44         if (preRun())
  45             TraverseDecl(compiler.getASTContext().getTranslationUnitDecl());
  46     }
  47
  48     bool VisitImplicitCastExpr(ImplicitCastExpr const*);
  49     bool VisitBinaryOperator(BinaryOperator const*);
  50
  51     bool PreTraverseUnaryOperator(UnaryOperator* expr)
  52     {
  53         if (expr->getOpcode() == UO_LNot)
  54         {
  55             contextuallyConvertedExprs_.push_back(expr->getSubExpr()->IgnoreParenImpCasts());
  56         }
  57         return true;
  58     }
  59
  60     bool PostTraverseUnaryOperator(UnaryOperator* expr, bool)
  61     {
  62         if (expr->getOpcode() == UO_LNot)
  63         {
  64             assert(!contextuallyConvertedExprs_.empty());
  65             contextuallyConvertedExprs_.pop_back();
  66         }
  67         return true;
  68     }
  69
  70     bool TraverseUnaryOperator(UnaryOperator* expr)
  71     {
  72         auto res = PreTraverseUnaryOperator(expr);
  73         assert(res);
  74         res = FilteringRewritePlugin::TraverseUnaryOperator(expr);
  75         PostTraverseUnaryOperator(expr, res);
  76         return res;
  77     }
  78
  79     bool PreTraverseBinaryOperator(BinaryOperator* expr)
  80     {
  81         auto const op = expr->getOpcode();
  82         if (op == BO_LAnd || op == BO_LOr)
  83         {
  84             contextuallyConvertedExprs_.push_back(expr->getLHS()->IgnoreParenImpCasts());
  85             contextuallyConvertedExprs_.push_back(expr->getRHS()->IgnoreParenImpCasts());
  86         }
  87         return true;
  88     }
  89
  90     bool PostTraverseBinaryOperator(BinaryOperator* expr, bool)
  91     {
  92         auto const op = expr->getOpcode();
  93         if (op == BO_LAnd || op == BO_LOr)
  94         {
  95             assert(contextuallyConvertedExprs_.size() >= 2);
  96             contextuallyConvertedExprs_.pop_back();
  97             contextuallyConvertedExprs_.pop_back();
  98         }
  99         return true;
 100     }
 101
 102     bool TraverseBinaryOperator(BinaryOperator* expr)
 103     {
 104         auto res = PreTraverseBinaryOperator(expr);
 105         assert(res);
 106         res = FilteringRewritePlugin::TraverseBinaryOperator(expr);
 107         PostTraverseBinaryOperator(expr, res);
 108         return res;
 109     }
 110
 111     bool PreTraverseConditionalOperator(ConditionalOperator* expr)
 112     {
 113         contextuallyConvertedExprs_.push_back(expr->getCond()->IgnoreParenImpCasts());
 114         return true;
 115     }
 116
 117     bool PostTraverseConditionalOperator(ConditionalOperator*, bool)
 118     {
 119         assert(!contextuallyConvertedExprs_.empty());
 120         contextuallyConvertedExprs_.pop_back();
 121         return true;
 122     }
 123
 124     bool TraverseConditionalOperator(ConditionalOperator* expr)
 125     {
 126         auto res = PreTraverseConditionalOperator(expr);
 127         assert(res);
 128         res = FilteringRewritePlugin::TraverseConditionalOperator(expr);
 129         PostTraverseConditionalOperator(expr, res);
 130         return res;
 131     }
 132
 133     bool PreTraverseIfStmt(IfStmt* stmt)
 134     {
 135         if (auto const cond = stmt->getCond())
 136         {
 137             contextuallyConvertedExprs_.push_back(cond->IgnoreParenImpCasts());
 138         }
 139         return true;
 140     }
 141
 142     bool PostTraverseIfStmt(IfStmt* stmt, bool)
 143     {
 144         if (stmt->getCond() != nullptr)
 145         {
 146             assert(!contextuallyConvertedExprs_.empty());
 147             contextuallyConvertedExprs_.pop_back();
 148         }
 149         return true;
 150     }
 151
 152     bool TraverseIfStmt(IfStmt* stmt)
 153     {
 154         auto res = PreTraverseIfStmt(stmt);
 155         assert(res);
 156         res = FilteringRewritePlugin::TraverseIfStmt(stmt);
 157         PostTraverseIfStmt(stmt, res);
 158         return res;
 159     }
 160
 161     bool PreTraverseWhileStmt(WhileStmt* stmt)
 162     {
 163         contextuallyConvertedExprs_.push_back(stmt->getCond()->IgnoreParenImpCasts());
 164         return true;
 165     }
 166
 167     bool PostTraverseWhileStmt(WhileStmt*, bool)
 168     {
 169         assert(!contextuallyConvertedExprs_.empty());
 170         contextuallyConvertedExprs_.pop_back();
 171         return true;
 172     }
 173
 174     bool TraverseWhileStmt(WhileStmt* stmt)
 175     {
 176         auto res = PreTraverseWhileStmt(stmt);
 177         assert(res);
 178         res = FilteringRewritePlugin::TraverseWhileStmt(stmt);
 179         PostTraverseWhileStmt(stmt, res);
 180         return res;
 181     }
 182
 183     bool PreTraverseDoStmt(DoStmt* stmt)
 184     {
 185         contextuallyConvertedExprs_.push_back(stmt->getCond()->IgnoreParenImpCasts());
 186         return true;
 187     }
 188
 189     bool PostTraverseDoStmt(DoStmt*, bool)
 190     {
 191         assert(!contextuallyConvertedExprs_.empty());
 192         contextuallyConvertedExprs_.pop_back();
 193         return true;
 194     }
 195
 196     bool TraverseDoStmt(DoStmt* stmt)
 197     {
 198         auto res = PreTraverseDoStmt(stmt);
 199         assert(res);
 200         res = FilteringRewritePlugin::TraverseDoStmt(stmt);
 201         PostTraverseDoStmt(stmt, res);
 202         return res;
 203     }
 204
 205     bool PreTraverseForStmt(ForStmt* stmt)
 206     {
 207         auto const e = stmt->getCond();
 208         if (e != nullptr)
 209         {
 210             contextuallyConvertedExprs_.push_back(e->IgnoreParenImpCasts());
 211         }
 212         return true;
 213     }
 214
 215     bool PostTraverseForStmt(ForStmt* stmt, bool)
 216     {
 217         if (stmt->getCond() != nullptr)
 218         {
 219             assert(!contextuallyConvertedExprs_.empty());
 220             contextuallyConvertedExprs_.pop_back();
 221         }
 222         return true;
 223     }
 224
 225     bool TraverseForStmt(ForStmt* stmt)
 226     {
 227         auto res = PreTraverseForStmt(stmt);
 228         assert(res);
 229         res = FilteringRewritePlugin::TraverseForStmt(stmt);
 230         PostTraverseForStmt(stmt, res);
 231         return res;
 232     }
 233
 234 private:
 235     bool isContextuallyConverted(Expr const* expr) const
 236     {
 237         return std::find(contextuallyConvertedExprs_.begin(), contextuallyConvertedExprs_.end(),
 238                          expr)
 239                != contextuallyConvertedExprs_.end();
 240     }
 241
 242     // Get the source range starting at the "."or "->" (plus any preceding non-comment white space):
 243     SourceRange getCallSourceRange(CXXMemberCallExpr const* expr) const
 244     {
 245         if (expr->getImplicitObjectArgument() == nullptr)
 246         {
 247             //TODO: Arguably, such a call of a `get` member function from within some member
 248             // function (so that syntactically no caller is mentioned) should already be handled
 249             // differently when reporting it (just "drop the get()" does not make sense), instead of
 250             // being filtered here:
 251             return {};
 252         }
 253         // CXXMemberCallExpr::getExprLoc happens to return the location following the "." or "->":
 254         auto start = compiler.getSourceManager().getSpellingLoc(expr->getExprLoc());
 255         if (!start.isValid())
 256         {
 257             return {};
 258         }
 259         for (;;)
 260         {
 261             start = Lexer::GetBeginningOfToken(start.getLocWithOffset(-1),
 262                                                compiler.getSourceManager(), compiler.getLangOpts());
 263             auto const s = StringRef(compiler.getSourceManager().getCharacterData(start),
 264                                      Lexer::MeasureTokenLength(start, compiler.getSourceManager(),
 265                                                                compiler.getLangOpts()));
 266             if (s.empty() || compat::starts_with(s, "\\\n"))
 267             {
 268                 continue;
 269             }
 270             if (s != "." && s != "->")
 271             {
 272                 return {};
 273             }
 274             break;
 275         }
 276         for (;;)
 277         {
 278             auto start1 = Lexer::GetBeginningOfToken(
 279                 start.getLocWithOffset(-1), compiler.getSourceManager(), compiler.getLangOpts());
 280             auto const s = StringRef(compiler.getSourceManager().getCharacterData(start1),
 281                                      Lexer::MeasureTokenLength(start1, compiler.getSourceManager(),
 282                                                                compiler.getLangOpts()));
 283             if (!(s.empty() || compat::starts_with(s, "\\\n")))
 284             {
 285                 break;
 286             }
 287             start = start1;
 288         }
 289         return SourceRange(start, compiler.getSourceManager().getSpellingLoc(expr->getEndLoc()));
 290     }
 291
 292     //TODO: There are some more places where an expression is contextually converted to bool, but
 293     // those are probably not relevant for our needs here.
 294     std::deque<Expr const*> contextuallyConvertedExprs_;
 295 };
 296
 297 bool SimplifyPointerToBool::VisitImplicitCastExpr(ImplicitCastExpr const* castExpr)
 298 {
 299     if (ignoreLocation(castExpr))
 300         return true;
 301     if (castExpr->getCastKind() != CK_PointerToBoolean)
 302         return true;
 303     auto memberCallExpr
 304         = dyn_cast<CXXMemberCallExpr>(castExpr->getSubExpr()->IgnoreParenImpCasts());
 305     if (!memberCallExpr)
 306         return true;
 307     auto methodDecl = memberCallExpr->getMethodDecl();
 308     if (!methodDecl || !methodDecl->getIdentifier() || methodDecl->getName() != "get")
 309         return true;
 310     //    castExpr->dump();
 311     //    methodDecl->getParent()->getTypeForDecl()->dump();
 312     if (!loplugin::isSmartPointerType(memberCallExpr->getImplicitObjectArgument()))
 313         return true;
 314     //    if (isa<CXXOperatorCallExpr>(callExpr))
 315     //        return true;
 316     //    const FunctionDecl* functionDecl;
 317     //    if (isa<CXXMemberCallExpr>(callExpr))
 318     //    {
 319     //        functionDecl = dyn_cast<CXXMemberCallExpr>(callExpr)->getMethodDecl();
 320     //    }
 321     //    else
 322     //    {
 323     //        functionDecl = callExpr->getDirectCallee();
 324     //    }
 325     //    if (!functionDecl)
 326     //        return true;
 327     //
 328     //    unsigned len = std::min(callExpr->getNumArgs(), functionDecl->getNumParams());
 329     //    for (unsigned i = 0; i < len; ++i)
 330     //    {
 331     //        auto param = functionDecl->getParamDecl(i);
 332     //        auto paramTC = loplugin::TypeCheck(param->getType());
 333     //        if (!paramTC.AnyBoolean())
 334     //            continue;
 335     //        auto arg = callExpr->getArg(i)->IgnoreImpCasts();
 336     //        auto argTC = loplugin::TypeCheck(arg->getType());
 337     //        if (argTC.AnyBoolean())
 338     //            continue;
 339     //        // sal_Bool is sometimes disguised
 340     //        if (isa<SubstTemplateTypeParmType>(arg->getType()))
 341     //            if (arg->getType()->getUnqualifiedDesugaredType()->isSpecificBuiltinType(
 342     //                    clang::BuiltinType::UChar))
 343     //                continue;
 344     //        if (arg->getType()->isDependentType())
 345     //            continue;
 346     //        if (arg->getType()->isIntegerType())
 347     //        {
 348     //            auto ret = getCallValue(arg);
 349     //            if (ret.hasValue() && (ret.getValue() == 1 || ret.getValue() == 0))
 350     //                continue;
 351     //            // something like: priv->m_nLOKFeatures & LOK_FEATURE_DOCUMENT_PASSWORD
 352     //            if (isa<BinaryOperator>(arg->IgnoreParenImpCasts()))
 353     //                continue;
 354     //            // something like: pbEmbolden ? FcTrue : FcFalse
 355     //            if (isa<ConditionalOperator>(arg->IgnoreParenImpCasts()))
 356     //                continue;
 357     //        }
 358     if (isContextuallyConverted(memberCallExpr))
 359     {
 360         if (rewriter)
 361         {
 362             auto const range = getCallSourceRange(memberCallExpr);
 363             if (range.isValid() && removeText(range))
 364             {
 365                 return true;
 366             }
 367         }
 368         report(DiagnosticsEngine::Warning, "simplify, drop the get()", memberCallExpr->getExprLoc())
 369             << memberCallExpr->getSourceRange();
 370     }
 371     else if (isa<ParenExpr>(castExpr->getSubExpr()))
 372     {
 373         if (rewriter)
 374         {
 375             auto const loc
 376                 = compiler.getSourceManager().getSpellingLoc(memberCallExpr->getBeginLoc());
 377             auto const range = getCallSourceRange(memberCallExpr);
 378             if (loc.isValid() && range.isValid() && insertText(loc, "bool") && removeText(range))
 379             {
 380                 //TODO: atomically only change both or neither
 381                 return true;
 382             }
 383         }
 384         report(DiagnosticsEngine::Warning,
 385                "simplify, drop the get() and turn the surrounding parentheses into a functional "
 386                "cast to bool",
 387                memberCallExpr->getExprLoc())
 388             << memberCallExpr->getSourceRange();
 389         report(DiagnosticsEngine::Note, "surrounding parentheses here",
 390                castExpr->getSubExpr()->getExprLoc())
 391             << castExpr->getSubExpr()->getSourceRange();
 392     }
 393     else
 394     {
 395         if (rewriter)
 396         {
 397             auto const loc
 398                 = compiler.getSourceManager().getSpellingLoc(memberCallExpr->getBeginLoc());
 399             auto const range = getCallSourceRange(memberCallExpr);
 400             if (loc.isValid() && range.isValid() && insertText(loc, "bool(")
 401                 && replaceText(range, ")"))
 402             {
 403                 //TODO: atomically only change both or neither
 404                 return true;
 405             }
 406         }
 407         report(DiagnosticsEngine::Warning,
 408                "simplify, drop the get() and wrap the expression in a functional cast to bool",
 409                memberCallExpr->getExprLoc())
 410             << memberCallExpr->getSourceRange();
 411     }
 412     //        report(DiagnosticsEngine::Note, "method here", param->getLocation())
 413     //            << param->getSourceRange();
 414     return true;
 415 }
 416
 417 bool SimplifyPointerToBool::VisitBinaryOperator(BinaryOperator const* binOp)
 418 {
 419     if (ignoreLocation(binOp))
 420         return true;
 421     auto opCode = binOp->getOpcode();
 422     if (opCode != BO_EQ && opCode != BO_NE)
 423         return true;
 424     const Expr* possibleMemberCall = nullptr;
 425     if (isa<CXXNullPtrLiteralExpr>(binOp->getLHS()->IgnoreParenImpCasts()))
 426         possibleMemberCall = binOp->getRHS();
 427     else if (isa<CXXNullPtrLiteralExpr>(binOp->getRHS()->IgnoreParenImpCasts()))
 428         possibleMemberCall = binOp->getLHS();
 429     else
 430         return true;
 431     auto memberCallExpr = dyn_cast<CXXMemberCallExpr>(possibleMemberCall);
 432     if (!memberCallExpr)
 433         return true;
 434     auto methodDecl = memberCallExpr->getMethodDecl();
 435     if (!methodDecl || !methodDecl->getIdentifier() || methodDecl->getName() != "get")
 436         return true;
 437     if (!loplugin::isSmartPointerType(memberCallExpr->getImplicitObjectArgument()))
 438         return true;
 439     report(DiagnosticsEngine::Warning,
 440            std::string("simplify, convert to ") + (opCode == BO_EQ ? "'!x'" : "'x'"),
 441            binOp->getExprLoc())
 442         << binOp->getSourceRange();
 443     return true;
 444 }
 445
 446 loplugin::Plugin::Registration<SimplifyPointerToBool> simplifypointertobool("simplifypointertobool",
 447                                                                             true);
 448
 449 } // namespace
 450
 451 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */