compilerplugins/clang/casttovoid.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 #include <algorithm>
  11 #include <cassert>
  12 #include <map>
  13 #include <stack>
  14
  15 #include "clang/AST/Attr.h"
  16
  17 #include "check.hxx"
  18 #include "plugin.hxx"
  19
  20 namespace {
  21
  22 bool isWarnUnusedType(QualType type) {
  23     if (auto const t = type->getAs<TypedefType>()) {
  24         if (t->getDecl()->hasAttr<WarnUnusedAttr>()) {
  25             return true;
  26         }
  27     }
  28     if (auto const t = type->getAs<RecordType>()) {
  29         if (t->getDecl()->hasAttr<WarnUnusedAttr>()) {
  30             return true;
  31         }
  32     }
  33     return loplugin::isExtraWarnUnusedType(type);
  34 }
  35
  36 Expr const * lookThroughInitListExpr(Expr const * expr) {
  37     if (auto const ile = dyn_cast<InitListExpr>(expr->IgnoreParenImpCasts())) {
  38         if (ile->getNumInits() == 1) {
  39             return ile->getInit(0);
  40         }
  41     }
  42     return expr;
  43 }
  44
  45 class CastToVoid final:
  46     public loplugin::FilteringPlugin<CastToVoid>
  47 {
  48 public:
  49     explicit CastToVoid(loplugin::InstantiationData const & data):
  50         FilteringPlugin(data) {}
  51
  52     bool TraverseCStyleCastExpr(CStyleCastExpr * expr) {
  53         auto const dre = checkCast(expr);
  54         if (dre != nullptr) {
  55             castToVoid_.push({expr, dre});
  56         }
  57         auto const ret = RecursiveASTVisitor::TraverseCStyleCastExpr(expr);
  58         if (dre != nullptr) {
  59             assert(!castToVoid_.empty());
  60             assert(castToVoid_.top().cast == expr);
  61             assert(castToVoid_.top().sub == dre);
  62             castToVoid_.pop();
  63         }
  64         return ret;
  65     }
  66
  67     bool TraverseCXXStaticCastExpr(CXXStaticCastExpr * expr) {
  68         auto const dre = checkCast(expr);
  69         if (dre != nullptr) {
  70             castToVoid_.push({expr, dre});
  71         }
  72         auto const ret = RecursiveASTVisitor::TraverseCXXStaticCastExpr(expr);
  73         if (dre != nullptr) {
  74             assert(!castToVoid_.empty());
  75             assert(castToVoid_.top().cast == expr);
  76             assert(castToVoid_.top().sub == dre);
  77             castToVoid_.pop();
  78         }
  79         return ret;
  80     }
  81
  82     bool TraverseCXXFunctionalCastExpr(CXXFunctionalCastExpr * expr) {
  83         auto const dre = checkCast(expr);
  84         if (dre != nullptr) {
  85             castToVoid_.push({expr, dre});
  86         }
  87         auto const ret = RecursiveASTVisitor::TraverseCXXFunctionalCastExpr(
  88             expr);
  89         if (dre != nullptr) {
  90             assert(!castToVoid_.empty());
  91             assert(castToVoid_.top().cast == expr);
  92             assert(castToVoid_.top().sub == dre);
  93             castToVoid_.pop();
  94         }
  95         return ret;
  96     }
  97
  98     bool TraverseFunctionDecl(FunctionDecl * decl) {
  99         returnTypes_.push(decl->getReturnType());
 100         auto const ret = RecursiveASTVisitor::TraverseFunctionDecl(decl);
 101         assert(!returnTypes_.empty());
 102         assert(returnTypes_.top() == decl->getReturnType());
 103         returnTypes_.pop();
 104         return ret;
 105     }
 106
 107     bool TraverseCXXDeductionGuideDecl(CXXDeductionGuideDecl * decl) {
 108         returnTypes_.push(decl->getReturnType());
 109         auto const ret = RecursiveASTVisitor::TraverseCXXDeductionGuideDecl(
 110             decl);
 111         assert(!returnTypes_.empty());
 112         assert(returnTypes_.top() == decl->getReturnType());
 113         returnTypes_.pop();
 114         return ret;
 115     }
 116
 117     bool TraverseCXXMethodDecl(CXXMethodDecl * decl) {
 118         returnTypes_.push(decl->getReturnType());
 119         auto const ret = RecursiveASTVisitor::TraverseCXXMethodDecl(decl);
 120         assert(!returnTypes_.empty());
 121         assert(returnTypes_.top() == decl->getReturnType());
 122         returnTypes_.pop();
 123         return ret;
 124     }
 125
 126     bool TraverseCXXConstructorDecl(CXXConstructorDecl * decl) {
 127         returnTypes_.push(decl->getReturnType());
 128         auto const ret = RecursiveASTVisitor::TraverseCXXConstructorDecl(decl);
 129         assert(!returnTypes_.empty());
 130         assert(returnTypes_.top() == decl->getReturnType());
 131         returnTypes_.pop();
 132         return ret;
 133     }
 134
 135     bool TraverseCXXDestructorDecl(CXXDestructorDecl * decl) {
 136         returnTypes_.push(decl->getReturnType());
 137         auto const ret = RecursiveASTVisitor::TraverseCXXDestructorDecl(decl);
 138         assert(!returnTypes_.empty());
 139         assert(returnTypes_.top() == decl->getReturnType());
 140         returnTypes_.pop();
 141         return ret;
 142     }
 143
 144     bool TraverseCXXConversionDecl(CXXConversionDecl * decl) {
 145         returnTypes_.push(decl->getReturnType());
 146         auto const ret = RecursiveASTVisitor::TraverseCXXConversionDecl(decl);
 147         assert(!returnTypes_.empty());
 148         assert(returnTypes_.top() == decl->getReturnType());
 149         returnTypes_.pop();
 150         return ret;
 151     }
 152
 153     bool TraverseObjCMethodDecl(ObjCMethodDecl * decl) {
 154         returnTypes_.push(decl->getReturnType());
 155         auto const ret = RecursiveASTVisitor::TraverseObjCMethodDecl(decl);
 156         assert(!returnTypes_.empty());
 157         assert(returnTypes_.top() == decl->getReturnType());
 158         returnTypes_.pop();
 159         return ret;
 160     }
 161
 162     bool TraverseConstructorInitializer(CXXCtorInitializer * init) {
 163         if (auto const field = init->getAnyMember()) {
 164             if (loplugin::TypeCheck(field->getType()).LvalueReference()) {
 165                 recordConsumption(lookThroughInitListExpr(init->getInit()));
 166             }
 167         }
 168         return RecursiveASTVisitor::TraverseConstructorInitializer(init);
 169     }
 170
 171     bool TraverseLambdaExpr(LambdaExpr * expr, DataRecursionQueue * queue = nullptr) {
 172         if (!shouldTraversePostOrder()) {
 173             if (!WalkUpFromLambdaExpr(expr)) {
 174                 return false;
 175             }
 176         }
 177         auto const n = expr->capture_size();
 178         for (unsigned i = 0; i != n; ++i) {
 179             auto const c = expr->capture_begin() + i;
 180             if (c->isExplicit() || shouldVisitImplicitCode()) {
 181                 if (!TraverseLambdaCapture(expr, c, expr->capture_init_begin()[i])) {
 182                     return false;
 183                 }
 184             }
 185         }
 186         if (!TraverseCXXRecordDecl(expr->getLambdaClass())) {
 187             return false;
 188         }
 189         if (!queue && shouldTraversePostOrder()) {
 190             if (!WalkUpFromLambdaExpr(expr)) {
 191                 return false;
 192             }
 193         }
 194         return true;
 195     }
 196
 197     bool VisitDeclRefExpr(DeclRefExpr const * expr) {
 198         if (ignoreLocation(expr)) {
 199             return true;
 200         }
 201         auto const var = dyn_cast<VarDecl>(expr->getDecl());
 202         if (var == nullptr) {
 203             return true;
 204         }
 205         if (var->getType().isVolatileQualified()) {
 206             return true;
 207         }
 208         auto & usage = vars_[var->getCanonicalDecl()];
 209         if (!castToVoid_.empty() && castToVoid_.top().sub == expr) {
 210             usage.castToVoid.push_back(castToVoid_.top().cast);
 211         } else {
 212             usage.mentioned = true;
 213         }
 214         return true;
 215     }
 216
 217     bool VisitImplicitCastExpr(ImplicitCastExpr const * expr) {
 218         if (ignoreLocation(expr)) {
 219             return true;
 220         }
 221         if (expr->getCastKind() != CK_LValueToRValue) {
 222             return true;
 223         }
 224         recordConsumption(expr->getSubExpr());
 225         return true;
 226     }
 227
 228     bool VisitCallExpr(CallExpr const * expr) {
 229         if (ignoreLocation(expr)) {
 230             return true;
 231         }
 232         unsigned firstArg = 0;
 233         if (auto const cmce = dyn_cast<CXXMemberCallExpr>(expr)) {
 234             if (auto const e1 = cmce->getMethodDecl()) {
 235                 if (e1->isConst() || e1->isStatic()) {
 236                     recordConsumption(cmce->getImplicitObjectArgument());
 237                 }
 238             } else if (auto const e2 = dyn_cast<BinaryOperator>(
 239                            cmce->getCallee()->IgnoreParenImpCasts()))
 240             {
 241                 switch (e2->getOpcode()) {
 242                 case BO_PtrMemD:
 243                 case BO_PtrMemI:
 244                     if (e2->getRHS()->getType()->getAs<MemberPointerType>()
 245                         ->getPointeeType()->getAs<FunctionProtoType>()
 246                         ->isConst())
 247                     {
 248                         recordConsumption(e2->getLHS());
 249                     }
 250                     break;
 251                 default:
 252                     break;
 253                 }
 254             }
 255         } else if (isa<CXXOperatorCallExpr>(expr)) {
 256             if (auto const cmd = dyn_cast_or_null<CXXMethodDecl>(
 257                     expr->getDirectCallee()))
 258             {
 259                 if (!cmd->isStatic()) {
 260                     assert(expr->getNumArgs() != 0);
 261                     if (cmd->isConst()) {
 262                         recordConsumption(expr->getArg(0));
 263                     }
 264                     firstArg = 1;
 265                 }
 266             }
 267         }
 268         auto fun = expr->getDirectCallee();
 269         if (fun == nullptr) {
 270             return true;
 271         }
 272         unsigned const n = std::min(fun->getNumParams(), expr->getNumArgs());
 273         for (unsigned i = firstArg; i < n; ++i) {
 274             if (!loplugin::TypeCheck(fun->getParamDecl(i)->getType())
 275                 .LvalueReference().Const())
 276             {
 277                 continue;
 278             }
 279             recordConsumption(lookThroughInitListExpr(expr->getArg(i)));
 280         }
 281         return true;
 282     }
 283
 284     bool VisitCXXConstructExpr(CXXConstructExpr const * expr) {
 285         if (ignoreLocation(expr)) {
 286             return true;
 287         }
 288         auto const ctor = expr->getConstructor();
 289         unsigned const n = std::min(ctor->getNumParams(), expr->getNumArgs());
 290         for (unsigned i = 0; i != n; ++i) {
 291             if (!loplugin::TypeCheck(ctor->getParamDecl(i)->getType())
 292                 .LvalueReference().Const())
 293             {
 294                 continue;
 295             }
 296             recordConsumption(lookThroughInitListExpr(expr->getArg(i)));
 297         }
 298         return true;
 299     }
 300
 301     bool VisitReturnStmt(ReturnStmt const * stmt) {
 302         if (ignoreLocation(stmt)) {
 303             return true;
 304         }
 305         assert(!returnTypes_.empty());
 306         if (!loplugin::TypeCheck(returnTypes_.top()).LvalueReference().Const())
 307         {
 308             return true;
 309         }
 310         auto const ret = stmt->getRetValue();
 311         if (ret == nullptr) {
 312             return true;
 313         }
 314         recordConsumption(lookThroughInitListExpr(ret));
 315         return true;
 316     }
 317
 318     bool VisitVarDecl(VarDecl const * decl) {
 319         if (ignoreLocation(decl)) {
 320             return true;
 321         }
 322         if (!loplugin::TypeCheck(decl->getType()).LvalueReference()) {
 323             return true;
 324         }
 325         auto const init = decl->getInit();
 326         if (init == nullptr) {
 327             return true;
 328         }
 329         recordConsumption(lookThroughInitListExpr(init));
 330         return true;
 331     }
 332
 333     bool VisitFieldDecl(FieldDecl const * decl) {
 334         if (ignoreLocation(decl)) {
 335             return true;
 336         }
 337         if (!loplugin::TypeCheck(decl->getType()).LvalueReference()) {
 338             return true;
 339         }
 340         auto const init = decl->getInClassInitializer();
 341         if (init == nullptr) {
 342             return true;
 343         }
 344         recordConsumption(lookThroughInitListExpr(init));
 345         return true;
 346     }
 347
 348 private:
 349     struct Usage {
 350         std::vector<ExplicitCastExpr const *> castToVoid;
 351         bool mentioned = false;
 352         DeclRefExpr const * firstConsumption = nullptr;
 353     };
 354
 355     struct Cast {
 356         ExplicitCastExpr const * cast;
 357         DeclRefExpr const * sub;
 358     };
 359
 360     std::map<VarDecl const *, Usage> vars_;
 361     std::stack<Cast> castToVoid_;
 362     std::stack<QualType> returnTypes_;
 363
 364     void run() override {
 365         if (compiler.getPreprocessor().getIdentifierInfo("NDEBUG")->hasMacroDefinition()) {
 366             return;
 367         }
 368         if (!TraverseDecl(compiler.getASTContext().getTranslationUnitDecl())) {
 369             return;
 370         }
 371         for (auto const & i: vars_) {
 372             if (i.second.firstConsumption == nullptr) {
 373                 if (i.second.mentioned) {
 374                     continue;
 375                 }
 376                 if (isa<ParmVarDecl>(i.first)) {
 377                     if (!compiler.getLangOpts().CPlusPlus
 378                         || isSharedCAndCppCode(i.first))
 379                     {
 380                         continue;
 381                     }
 382                     auto const ctxt = i.first->getDeclContext();
 383                     if (dyn_cast_or_null<ObjCMethodDecl>(ctxt) != nullptr) {
 384                         continue;
 385                     }
 386                     auto const fun = dyn_cast_or_null<FunctionDecl>(ctxt);
 387                     assert(fun != nullptr);
 388                     if (containsPreprocessingConditionalInclusion(
 389                             fun->getSourceRange()))
 390                     {
 391                         continue;
 392                     }
 393                     auto const meth = dyn_cast<CXXMethodDecl>(fun);
 394                     report(
 395                         DiagnosticsEngine::Warning,
 396                         "unused%select{| virtual function}0 parameter name",
 397                         i.first->getLocation())
 398                         << (meth != nullptr && meth->isVirtual())
 399                         << i.first->getSourceRange();
 400                     for (auto const j: i.second.castToVoid) {
 401                         report(
 402                             DiagnosticsEngine::Note, "cast to void here",
 403                             j->getExprLoc())
 404                             << j->getSourceRange();
 405                     }
 406                 } else if (!i.second.castToVoid.empty()
 407                            && !isWarnUnusedType(i.first->getType()))
 408                 {
 409                     auto const fun = dyn_cast_or_null<FunctionDecl>(i.first->getDeclContext());
 410                     assert(fun != nullptr);
 411                     if (containsPreprocessingConditionalInclusion(fun->getSourceRange())) {
 412                         continue;
 413                     }
 414                     report(
 415                         DiagnosticsEngine::Warning,
 416                         "unused variable %select{declaration|name}0",
 417                         i.first->getLocation())
 418                         << i.first->isExceptionVariable()
 419                         << i.first->getSourceRange();
 420                     for (auto const j: i.second.castToVoid) {
 421                         report(
 422                             DiagnosticsEngine::Note, "cast to void here",
 423                             j->getExprLoc())
 424                             << j->getSourceRange();
 425                     }
 426                 }
 427             } else {
 428                 for (auto const j: i.second.castToVoid) {
 429                     report(
 430                         DiagnosticsEngine::Warning, "unnecessary cast to void",
 431                         j->getExprLoc())
 432                         << j->getSourceRange();
 433                     report(
 434                         DiagnosticsEngine::Note, "first consumption is here",
 435                         i.second.firstConsumption->getExprLoc())
 436                         << i.second.firstConsumption->getSourceRange();
 437                 }
 438             }
 439         }
 440     }
 441
 442     bool isFromCIncludeFile(SourceLocation spellingLocation) const {
 443         return !compiler.getSourceManager().isInMainFile(spellingLocation)
 444             && (StringRef(
 445                     compiler.getSourceManager().getPresumedLoc(spellingLocation)
 446                     .getFilename())
 447                 .endswith(".h"));
 448     }
 449
 450     bool isSharedCAndCppCode(VarDecl const * decl) const {
 451         auto loc = decl->getLocation();
 452         while (compiler.getSourceManager().isMacroArgExpansion(loc)) {
 453             loc = compiler.getSourceManager().getImmediateMacroCallerLoc(loc);
 454         }
 455         // Assume that code is intended to be shared between C and C++ if it
 456         // comes from an include file ending in .h, and is either in an extern
 457         // "C" context or the body of a macro definition:
 458         return
 459             isFromCIncludeFile(compiler.getSourceManager().getSpellingLoc(loc))
 460             && (decl->isInExternCContext()
 461                 || compiler.getSourceManager().isMacroBodyExpansion(loc));
 462     }
 463
 464     DeclRefExpr const * checkCast(ExplicitCastExpr const * expr) {
 465         if (!loplugin::TypeCheck(expr->getTypeAsWritten()).Void()) {
 466             return nullptr;
 467         }
 468         if (compiler.getSourceManager().isMacroBodyExpansion(
 469                 expr->getBeginLoc()))
 470         {
 471             return nullptr;
 472         }
 473         return dyn_cast<DeclRefExpr>(expr->getSubExpr()->IgnoreParenImpCasts());
 474     }
 475
 476     void recordConsumption(Expr const * expr) {
 477         for (;;) {
 478             expr = expr->IgnoreParenImpCasts();
 479             if (auto const e = dyn_cast<MemberExpr>(expr)) {
 480                 expr = e->getBase();
 481                 continue;
 482             }
 483             if (auto const e = dyn_cast<ArraySubscriptExpr>(expr)) {
 484                 expr = e->getBase();
 485                 continue;
 486             }
 487             if (auto const e = dyn_cast<BinaryOperator>(expr)) {
 488                 if (e->getOpcode() == BO_PtrMemD) {
 489                     expr = e->getLHS();
 490                     continue;
 491                 }
 492             }
 493             break;
 494         }
 495         auto const dre = dyn_cast<DeclRefExpr>(expr);
 496         if (dre == nullptr) {
 497             return;
 498         }
 499         // In C (but not in C++)
 500         //
 501         //   (void) x
 502         //
 503         // contains an implicit lvalue-to-rvalue cast, so VisitImplicitCastExpr
 504         // would record that as a consumption if we didn't filter it out here:
 505         if (!castToVoid_.empty() && castToVoid_.top().sub == dre) {
 506             return;
 507         }
 508         auto const var = dyn_cast<VarDecl>(dre->getDecl());
 509         if (var == nullptr) {
 510             return;
 511         }
 512         if (var->getType().isVolatileQualified()) {
 513             return;
 514         }
 515         auto & usage = vars_[var->getCanonicalDecl()];
 516         if (usage.firstConsumption != nullptr) {
 517             return;
 518         }
 519         auto const loc = dre->getBeginLoc();
 520         if (compiler.getSourceManager().isMacroArgExpansion(loc)
 521             && (Lexer::getImmediateMacroNameForDiagnostics(
 522                     loc, compiler.getSourceManager(), compiler.getLangOpts())
 523                 == "assert"))
 524         {
 525             return;
 526         }
 527         usage.firstConsumption = dre;
 528     }
 529 };
 530
 531 static loplugin::Plugin::Registration<CastToVoid> reg("casttovoid");
 532
 533 }
 534
 535 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */