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