compilerplugins/clang/unusedmember.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 // A more aggressive check for unused C struct/C++ class members than what plain Clang offers.  On
  11 // the one hand, unlike -Wunused-private-field, it warns about all members regardless of access
  12 // specifiers, if all code that can use a class has been seen.  On the other hand, it warns about
  13 // all kinds of members.  But it uses some heuristics (the type showing up in sizeof, alignof,
  14 // offsetof, certain casts) to determine that seemingly unused data members are probably used after
  15 // all; the used heuristics were enough to not require any explicit [[maybe_unused]] decorations
  16 // across the existing code base.
  17
  18 #include <cassert>
  19 #include <set>
  20
  21 #include "config_clang.h"
  22
  23 #include "check.hxx"
  24 #include "plugin.hxx"
  25
  26 namespace
  27 {
  28 // Whether the CXXRecordDecl itself or one of its enclosing classes is a template:
  29 bool isTemplated(CXXRecordDecl const* decl)
  30 {
  31     if (decl->getDescribedClassTemplate() != nullptr)
  32     {
  33         return true;
  34     }
  35     if (auto const d = dyn_cast<CXXRecordDecl>(decl->getParent()))
  36     {
  37         return isTemplated(d);
  38     }
  39     return false;
  40 }
  41
  42 bool isWarnUnusedType(QualType type)
  43 {
  44     if (auto const t = type->getAs<RecordType>())
  45     {
  46         if (t->getDecl()->hasAttr<WarnUnusedAttr>())
  47         {
  48             return true;
  49         }
  50     }
  51     return loplugin::isExtraWarnUnusedType(type);
  52 }
  53
  54 class UnusedMember final : public loplugin::FilteringPlugin<UnusedMember>
  55 {
  56 public:
  57     explicit UnusedMember(loplugin::InstantiationData const& data)
  58         : FilteringPlugin(data)
  59     {
  60     }
  61
  62 #if CLANG_VERSION < 60000
  63
  64     bool TraverseAlignedAttr(AlignedAttr* attr)
  65     {
  66         bool ret = FilteringPlugin::TraverseAlignedAttr(attr);
  67         PostTraverseAlignedAttr(attr, ret);
  68         return ret;
  69     }
  70
  71     bool PostTraverseAlignedAttr(AlignedAttr* attr, bool run)
  72     {
  73         if (!run)
  74         {
  75             return false;
  76         }
  77         if (attr->isAlignmentExpr())
  78         {
  79             if (!TraverseStmt(attr->getAlignmentExpr()))
  80             {
  81                 return false;
  82             }
  83         }
  84         else if (auto const tsi = attr->getAlignmentType())
  85         {
  86             if (!TraverseTypeLoc(tsi->getTypeLoc()))
  87             {
  88                 return false;
  89             }
  90         }
  91         return true;
  92     }
  93
  94 #endif
  95
  96     bool VisitCXXRecordDecl(CXXRecordDecl const* decl) //TODO: non-CXX RecordDecl?
  97     {
  98         if (ignoreLocation(decl))
  99         {
 100             return true;
 101         }
 102         if (!decl->isThisDeclarationADefinition())
 103         {
 104             return true;
 105         }
 106         if (!handler.isAllRelevantCodeDefined(decl))
 107         {
 108             return true;
 109         }
 110         if (!compiler.getSourceManager().isInMainFile(decl->getLocation()))
 111         {
 112             // include/rtl/instance.hxx declares entities in an unnamed namespace
 113             return true;
 114         }
 115         if (isTemplated(decl) || isa<ClassTemplatePartialSpecializationDecl>(decl))
 116         {
 117             return true;
 118         }
 119         if (decl->isUnion() && decl->getIdentifier() == nullptr)
 120         {
 121             return true; //TODO
 122         }
 123         for (auto i = decl->decls_begin(); i != decl->decls_end(); ++i)
 124         {
 125             auto const d = *i;
 126             if (d->isImplicit() || isa<AccessSpecDecl>(d) || isa<UsingDecl>(d))
 127             {
 128                 //TODO: only filter out UsingDecls that are actually used (if only to silence
 129                 // -Woverloaded-virtual)
 130                 continue;
 131             }
 132             if (isa<ClassTemplateDecl>(d) || isa<FunctionTemplateDecl>(d))
 133             {
 134                 //TODO: only filter out ones that are not instantiated at all
 135                 continue;
 136             }
 137             if (auto const d1 = dyn_cast<FriendDecl>(d))
 138             {
 139                 //TODO: determine whether the friendship is actually required
 140                 auto const d2 = d1->getFriendDecl();
 141                 if (d2 == nullptr)
 142                 { // happens for "friend class C;"
 143                     continue;
 144                 }
 145                 if (auto const d3 = dyn_cast<FunctionDecl>(d2))
 146                 {
 147 #if 0 //TODO: friend function definitions are not marked as referenced even if used?
 148                     if (!d3->isThisDeclarationADefinition()) //TODO: do this check for all kinds?
 149 #endif
 150                     {
 151                         continue;
 152                     }
 153                 }
 154             }
 155             if (d->isReferenced())
 156             {
 157                 continue;
 158             }
 159             if (d->hasAttr<UnusedAttr>())
 160             {
 161                 continue;
 162             }
 163             // Check individual members instead of the whole CXXRecordDecl for coming from a macro,
 164             // as CppUnit's CPPUNIT_TEST_SUITE_END (cppunit/extensions/HelperMacros.h) contains a
 165             // partial member list ending in
 166             //
 167             //    private: /* dummy typedef so that the macro can still end with ';'*/
 168             //      typedef int CppUnitDummyTypedefForSemiColonEnding__
 169             //
 170             if (compiler.getSourceManager().isMacroBodyExpansion(d->getLocation()))
 171             {
 172                 return true;
 173             }
 174             if (auto const d1 = dyn_cast<FieldDecl>(d))
 175             {
 176                 if (d1->isUnnamedBitfield())
 177                 {
 178                     continue;
 179                 }
 180                 if (!isWarnWhenUnusedType(d1->getType()))
 181                 {
 182                     continue;
 183                 }
 184                 deferred_.insert(d1);
 185                 continue;
 186             }
 187             if (auto const d1 = dyn_cast<FunctionDecl>(d))
 188             {
 189                 if (d1->isDeletedAsWritten()) // TODO: just isDeleted?
 190                 {
 191                     continue;
 192                 }
 193                 if (d1->isExplicitlyDefaulted())
 194                 {
 195                     continue;
 196                 }
 197             }
 198             else if (auto const d2 = dyn_cast<TagDecl>(d))
 199             {
 200                 if (d2->getIdentifier() == nullptr)
 201                 {
 202                     continue;
 203                 }
 204                 if (isa<EnumDecl>(d2))
 205                 {
 206                     deferred_.insert(d2);
 207                     continue;
 208                 }
 209             }
 210             else if (auto const d3 = dyn_cast<TypedefNameDecl>(d))
 211             {
 212                 // Some types, like (specializations of) std::iterator_traits, have specific
 213                 // requirements on their members; only covers std::iterator_traits for now (TODO:
 214                 // check that at least some member is actually used)
 215                 // (isa<ClassTemplatePartialSpecializationDecl>(decl) is already filtered out
 216                 // above):
 217                 if (isa<ClassTemplateSpecializationDecl>(decl)
 218                     && loplugin::DeclCheck(decl).Struct("iterator_traits").StdNamespace())
 219                 {
 220                     auto const id = d3->getIdentifier();
 221                     assert(id != nullptr);
 222                     auto const n = id->getName();
 223                     if (n == "difference_type" || n == "iterator_category" || n == "pointer"
 224                         || n == "reference" || n == "value_type")
 225                     {
 226                         continue;
 227                     }
 228                 }
 229             }
 230             report(DiagnosticsEngine::Warning, "unused class member", d->getLocation())
 231                 << d->getSourceRange();
 232         }
 233         return true;
 234     }
 235
 236     bool VisitOffsetOfExpr(OffsetOfExpr const* expr)
 237     {
 238         if (ignoreLocation(expr))
 239         {
 240             return true;
 241         }
 242         recordRecordDeclAndBases(expr->getTypeSourceInfo()->getType()->castAs<RecordType>());
 243         return true;
 244     }
 245
 246     bool VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr const* expr)
 247     {
 248         if (ignoreLocation(expr))
 249         {
 250             return true;
 251         }
 252         switch (expr->getKind())
 253         {
 254             case UETT_SizeOf:
 255             case UETT_AlignOf:
 256 #if CLANG_VERSION >= 80000
 257             case UETT_PreferredAlignOf:
 258 #endif
 259                 break;
 260             default:
 261                 return true;
 262         }
 263         if (!expr->isArgumentType())
 264         {
 265             return true;
 266         }
 267         auto t = expr->getArgumentType();
 268         if (auto const t1 = t->getAs<ReferenceType>())
 269         {
 270             t = t1->getPointeeType();
 271         }
 272         if (auto const t1 = t->getAsArrayTypeUnsafe())
 273         {
 274             t = compiler.getASTContext().getBaseElementType(t1);
 275         }
 276         if (auto const t1 = t->getAs<RecordType>())
 277         {
 278             recordRecordDeclAndBases(t1);
 279         }
 280         return true;
 281     }
 282
 283     // Handling implicit, C-style, static and reinterpret casts between void* and record types
 284     // (though reinterpret_cast would be ruled out by loplugin:redundantcast):
 285     bool VisitCastExpr(CastExpr const* expr)
 286     {
 287         if (ignoreLocation(expr))
 288         {
 289             return true;
 290         }
 291         auto const t1 = expr->getType();
 292         auto const t2 = expr->getSubExprAsWritten()->getType();
 293         if (loplugin::TypeCheck(t1).Pointer().Void())
 294         {
 295             recordCastedRecordDecl(t2);
 296         }
 297         else if (loplugin::TypeCheck(t2).Pointer().Void())
 298         {
 299             recordCastedRecordDecl(t1);
 300         }
 301         return true;
 302     }
 303
 304     bool VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr const* expr)
 305     {
 306         if (ignoreLocation(expr))
 307         {
 308             return true;
 309         }
 310         recordCastedRecordDecl(expr->getTypeAsWritten());
 311         recordCastedRecordDecl(expr->getSubExprAsWritten()->getType());
 312         return true;
 313     }
 314
 315     bool VisitElaboratedTypeLoc(ElaboratedTypeLoc tloc)
 316     {
 317         if (ignoreLocation(tloc))
 318         {
 319             return true;
 320         }
 321         auto const tl = tloc.getNamedTypeLoc().getAs<TagTypeLoc>();
 322         if (tl.isNull())
 323         {
 324             return true;
 325         }
 326         if (tl.isDefinition())
 327         {
 328             return true;
 329         }
 330         if (auto const d = dyn_cast<EnumDecl>(tl.getDecl()))
 331         {
 332             // For some reason, using an elaborated type specifier in (at least) a FieldDecl, as in
 333             //
 334             //   enum E { ... };
 335             //   enum E e;
 336             //
 337             // doesn't cause the EnumDecl to be marked as referenced.  (This should fix it, but note
 338             // the warning at <https://github.com/llvm/llvm-project/commit/
 339             // b96ec568715450106b4f1dd4a20c1c14e9bca6c4#diff-019094457f96a6ed0ee072731d447073R396>:
 340             // "[...] a type written 'struct foo' should be represented as an ElaboratedTypeLoc.  We
 341             // currently only do that when C++ is enabled [...]"
 342             deferred_.erase(d->getCanonicalDecl());
 343         }
 344         return true;
 345     }
 346
 347     void postRun() override
 348     {
 349         for (auto const d : deferred_)
 350         {
 351             if (auto const d1 = dyn_cast<FieldDecl>(d))
 352             {
 353                 bool layout = false;
 354                 for (auto d2 = d1->getParent();;)
 355                 {
 356                     if (layout_.find(d2->getCanonicalDecl()) != layout_.end())
 357                     {
 358                         layout = true;
 359                         break;
 360                     }
 361                     // Heuristic to recursively check parent RecordDecl if given RecordDecl is
 362                     // unnamed and either an anonymous struct (or union, but which are already
 363                     // filtered out anyway), or defined in a non-static data member declaration
 364                     // (TODO: which is erroneously approximated here with getTypedefNameForAnonDecl
 365                     // for now, which fails to filter out RecordDecls in static data member
 366                     // declarations):
 367                     if (!(d2->getDeclName().isEmpty()
 368                           && (d2->isAnonymousStructOrUnion()
 369                               || d2->getTypedefNameForAnonDecl() == nullptr)))
 370                     {
 371                         break;
 372                     }
 373                     d2 = dyn_cast<RecordDecl>(d2->getParent());
 374                     if (d2 == nullptr)
 375                     {
 376                         break;
 377                     }
 378                 }
 379                 if (layout)
 380                 {
 381                     continue;
 382                 }
 383             }
 384             report(DiagnosticsEngine::Warning, "unused class member", d->getLocation())
 385                 << d->getSourceRange();
 386         }
 387     }
 388
 389 private:
 390     void run() override
 391     {
 392         if (TraverseDecl(compiler.getASTContext().getTranslationUnitDecl()))
 393         {
 394             postRun();
 395         }
 396     }
 397
 398     bool isWarnWhenUnusedType(QualType type)
 399     {
 400         auto t = type;
 401         if (auto const t1 = t->getAs<ReferenceType>())
 402         {
 403             t = t1->getPointeeType();
 404         }
 405         return t.isTrivialType(compiler.getASTContext()) || isWarnUnusedType(t);
 406     }
 407
 408     void recordRecordDeclAndBases(RecordType const* type)
 409     {
 410         auto const d1 = type->getDecl();
 411         if (!layout_.insert(d1->getCanonicalDecl()).second)
 412         {
 413             return;
 414         }
 415         if (auto const d2 = dyn_cast_or_null<CXXRecordDecl>(d1->getDefinition()))
 416         {
 417             for (auto i = d2->bases_begin(); i != d2->bases_end(); ++i)
 418             {
 419                 recordRecordDeclAndBases(i->getType()->castAs<RecordType>());
 420             }
 421             //TODO: doesn't iterate vbases, but presence of such would run counter to the layout
 422             // heuristic anyway
 423         }
 424     }
 425
 426     void recordCastedRecordDecl(QualType type)
 427     {
 428         for (auto t = type;;)
 429         {
 430             if (auto const t1 = t->getAs<clang::PointerType>())
 431             {
 432                 t = t1->getPointeeType();
 433                 continue;
 434             }
 435             if (auto const t1 = t->getAs<RecordType>())
 436             {
 437                 recordRecordDeclAndBases(t1);
 438             }
 439             break;
 440         }
 441     }
 442
 443     // RecordDecls whose layout (i.e., contained FieldDecls) must presumably not be changed:
 444     std::set<TagDecl const*> layout_;
 445
 446     std::set<Decl const*> deferred_;
 447 };
 448
 449 loplugin::Plugin::Registration<UnusedMember> unusedmember("unusedmember");
 450 }
 451
 452 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */