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