compilerplugins/clang/external.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 #ifndef LO_CLANG_SHARED_PLUGINS
  10
  11 #include <algorithm>
  12 #include <cassert>
  13 #include <iterator>
  14 #include <list>
  15 #include <set>
  16
  17 #include "clang/Sema/SemaDiagnostic.h"
  18
  19 #include "check.hxx"
  20 #include "compat.hxx"
  21 #include "plugin.hxx"
  22
  23 namespace
  24 {
  25 bool derivesFromTestFixture(CXXRecordDecl const* decl)
  26 {
  27     static auto const pred = [](CXXBaseSpecifier const& spec) {
  28         if (auto const t = spec.getType()->getAs<RecordType>())
  29         { // (may be a template parameter)
  30             return derivesFromTestFixture(dyn_cast<CXXRecordDecl>(t->getDecl()));
  31         }
  32         return false;
  33     };
  34     return loplugin::DeclCheck(decl).Class("TestFixture").Namespace("CppUnit").GlobalNamespace()
  35            || std::any_of(decl->bases_begin(), decl->bases_end(), pred)
  36            || std::any_of(decl->vbases_begin(), decl->vbases_end(), pred);
  37 }
  38
  39 bool isInjectedFunction(FunctionDecl const* decl)
  40 {
  41     for (auto d = decl->redecls_begin(); d != decl->redecls_end(); ++d)
  42     {
  43         auto const c = d->getLexicalDeclContext();
  44         if (!(c->isFunctionOrMethod() || c->isRecord()))
  45         {
  46             return false;
  47         }
  48     }
  49     return true;
  50 }
  51
  52 // Whether type1 mentions type2 (in a way relevant for argument-dependent name lookup):
  53 bool mentions(QualType type1, QualType type2)
  54 {
  55     auto t1 = type1;
  56     for (;;)
  57     {
  58         if (auto const t2 = t1->getAs<ReferenceType>())
  59         {
  60             t1 = t2->getPointeeType();
  61         }
  62         else if (auto const t3 = t1->getAs<clang::PointerType>())
  63         {
  64             t1 = t3->getPointeeType();
  65         }
  66         else if (auto const t4 = t1->getAsArrayTypeUnsafe())
  67         {
  68             t1 = t4->getElementType();
  69         }
  70         else
  71         {
  72             break;
  73         }
  74     }
  75     if (t1.getCanonicalType().getTypePtr() == type2.getTypePtr())
  76     {
  77         return true;
  78     }
  79     if (auto const t2 = t1->getAs<TemplateSpecializationType>())
  80     {
  81         auto const args = t2->template_arguments();
  82         for (auto a = args.begin(); a != args.end(); ++a)
  83         {
  84             if (a->getKind() != TemplateArgument::Type)
  85             {
  86                 continue;
  87             }
  88             if (mentions(a->getAsType(), type2))
  89             {
  90                 return true;
  91             }
  92         }
  93         auto const t3 = t2->desugar();
  94         if (t3.getTypePtr() == t2)
  95         {
  96             return false;
  97         }
  98         return mentions(t3, type2);
  99     }
 100     if (auto const t2 = t1->getAs<FunctionProtoType>())
 101     {
 102         if (mentions(t2->getReturnType(), type2))
 103         {
 104             return true;
 105         }
 106         for (auto t3 = t2->param_type_begin(); t3 != t2->param_type_end(); ++t3)
 107         {
 108             if (mentions(*t3, type2))
 109             {
 110                 return true;
 111             }
 112         }
 113         return false;
 114     }
 115     if (auto const t2 = t1->getAs<MemberPointerType>())
 116     {
 117         if (t2->getClass()->getUnqualifiedDesugaredType() == type2.getTypePtr())
 118         {
 119             return true;
 120         }
 121         return mentions(t2->getPointeeType(), type2);
 122     }
 123     return false;
 124 }
 125
 126 bool hasSalDllpublicExportAttr(Decl const* decl)
 127 {
 128     if (auto const attr = decl->getAttr<VisibilityAttr>())
 129     {
 130         return attr->getVisibility() == VisibilityAttr::Default;
 131     }
 132     return decl->hasAttr<DLLExportAttr>();
 133 }
 134
 135 class External : public loplugin::FilteringPlugin<External>
 136 {
 137 public:
 138     explicit External(loplugin::InstantiationData const& data)
 139         : FilteringPlugin(data)
 140     {
 141     }
 142
 143     void run() override { TraverseDecl(compiler.getASTContext().getTranslationUnitDecl()); }
 144
 145     bool VisitTagDecl(TagDecl* decl)
 146     {
 147         if (isa<ClassTemplateSpecializationDecl>(decl))
 148         {
 149             return true;
 150         }
 151         if (!decl->isThisDeclarationADefinition())
 152         {
 153             return true;
 154         }
 155         if (isa<CXXRecordDecl>(decl->getDeclContext()))
 156         {
 157             return true;
 158         }
 159         if (!compiler.getLangOpts().CPlusPlus)
 160         {
 161             return true;
 162         }
 163         if (auto const d = dyn_cast<CXXRecordDecl>(decl))
 164         {
 165             if (d->getDescribedClassTemplate() != nullptr)
 166             {
 167                 return true;
 168             }
 169             if (hasSalDllpublicExportAttr(d))
 170             {
 171                 // If the class definition has explicit default visibility, then assume that it
 172                 // needs to be present (e.g., a backwards-compatibility stub like in
 173                 // cppuhelper/source/compat.cxx):
 174                 return true;
 175             }
 176             if (derivesFromTestFixture(d))
 177             {
 178                 // The names of CppUnit tests (that can be specified with CPPUNIT_TEST_NAME) are
 179                 // tied to the fully-qualified names of classes derived from CppUnit::TestFixture,
 180                 // so avoid unnamed namespaces in those classes' names:
 181                 return true;
 182             }
 183         }
 184         return handleDeclaration(decl);
 185     }
 186
 187     bool VisitFunctionDecl(FunctionDecl* decl)
 188     {
 189         if (isa<CXXMethodDecl>(decl))
 190         {
 191             return true;
 192         }
 193         if (decl->getTemplatedKind() != FunctionDecl::TK_NonTemplate)
 194         {
 195             return true;
 196         }
 197         if (!decl->isThisDeclarationADefinition())
 198         {
 199             return true;
 200         }
 201         if (decl->isMain() || decl->isMSVCRTEntryPoint())
 202         {
 203             return true;
 204         }
 205         if (loplugin::hasCLanguageLinkageType(decl)
 206             && loplugin::DeclCheck(decl).Function("_DllMainCRTStartup").GlobalNamespace())
 207         {
 208             return true;
 209         }
 210         // If the function definition is explicit marked SAL_DLLPUBLIC_EXPORT or similar, then
 211         // assume that it needs to be present (e.g., only called via dlopen, or a backwards-
 212         // compatibility stub like in sal/osl/all/compat.cxx):
 213         if (hasSalDllpublicExportAttr(decl))
 214         {
 215             return true;
 216         }
 217         auto const canon = decl->getCanonicalDecl();
 218         if (loplugin::hasCLanguageLinkageType(canon)
 219             && (canon->hasAttr<ConstructorAttr>() || canon->hasAttr<DestructorAttr>()))
 220         {
 221             return true;
 222         }
 223         if (compiler.getDiagnostics().getDiagnosticLevel(diag::warn_unused_function,
 224                                                          decl->getLocation())
 225             < DiagnosticsEngine::Warning)
 226         {
 227             // Don't warn about e.g.
 228             //
 229             //  G_DEFINE_TYPE (GLOAction, g_lo_action, G_TYPE_OBJECT);
 230             //
 231             // in vcl/unx/gtk/gloactiongroup.cxx (which expands to non-static g_lo_action_get_type
 232             // function definition), which is already wrapped in
 233             //
 234             //  #pragma GCC diagnostic ignored "-Wunused-function"
 235             return true;
 236         }
 237         if (isInjectedFunction(decl))
 238         {
 239             return true;
 240         }
 241         return handleDeclaration(decl);
 242     }
 243
 244     bool VisitVarDecl(VarDecl* decl)
 245     {
 246         if (decl->isStaticDataMember())
 247         {
 248             return true;
 249         }
 250         if (isa<VarTemplateSpecializationDecl>(decl))
 251         {
 252             return true;
 253         }
 254         if (!decl->isThisDeclarationADefinition())
 255         {
 256             return true;
 257         }
 258         if (loplugin::DeclCheck(decl).Var("_pRawDllMain").GlobalNamespace())
 259         {
 260             return true;
 261         }
 262         return handleDeclaration(decl);
 263     }
 264
 265     bool VisitClassTemplateDecl(ClassTemplateDecl* decl)
 266     {
 267         if (!decl->isThisDeclarationADefinition())
 268         {
 269             return true;
 270         }
 271         if (isa<CXXRecordDecl>(decl->getDeclContext()))
 272         {
 273             return true;
 274         }
 275         return handleDeclaration(decl);
 276     }
 277
 278     bool VisitFunctionTemplateDecl(FunctionTemplateDecl* decl)
 279     {
 280         if (!decl->isThisDeclarationADefinition())
 281         {
 282             return true;
 283         }
 284         if (isa<CXXRecordDecl>(decl->getDeclContext()))
 285         {
 286             return true;
 287         }
 288         if (isInjectedFunction(decl->getTemplatedDecl()))
 289         {
 290             return true;
 291         }
 292         return handleDeclaration(decl);
 293     }
 294
 295     bool VisitVarTemplateDecl(VarTemplateDecl* decl)
 296     {
 297         if (!decl->isThisDeclarationADefinition())
 298         {
 299             return true;
 300         }
 301         return handleDeclaration(decl);
 302     }
 303
 304 private:
 305     template <typename T> void reportSpecializations(T specializations)
 306     {
 307         for (auto const d : specializations)
 308         {
 309             auto const k = d->getTemplateSpecializationKind();
 310             if (isTemplateExplicitInstantiationOrSpecialization(k))
 311             {
 312                 report(DiagnosticsEngine::Note,
 313                        "explicit %select{instantiation|specialization}0 is here", d->getLocation())
 314                     << (k == TSK_ExplicitSpecialization) << d->getSourceRange();
 315             }
 316         }
 317     }
 318
 319     void computeAffectedTypes(Decl const* decl, std::vector<QualType>* affected)
 320     {
 321         assert(affected != nullptr);
 322         if (auto const d = dyn_cast<EnumDecl>(decl))
 323         {
 324             affected->push_back(compiler.getASTContext().getEnumType(d));
 325         }
 326         else
 327         {
 328             //TODO: Derived types are also affected!
 329             CXXRecordDecl const* rec;
 330             if (auto const d = dyn_cast<ClassTemplateDecl>(decl))
 331             {
 332                 rec = d->getTemplatedDecl();
 333             }
 334             else
 335             {
 336                 rec = cast<CXXRecordDecl>(decl);
 337             }
 338             affected->push_back(compiler.getASTContext().getRecordType(rec));
 339             for (auto d = rec->decls_begin(); d != rec->decls_end(); ++d)
 340             {
 341                 if (*d != (*d)->getCanonicalDecl())
 342                 {
 343                     continue;
 344                 }
 345                 if (isa<TagDecl>(*d) || isa<ClassTemplateDecl>(*d))
 346                 {
 347                     if (auto const d1 = dyn_cast<RecordDecl>(*d))
 348                     {
 349                         if (d1->isInjectedClassName())
 350                         {
 351                             continue;
 352                         }
 353                     }
 354                     computeAffectedTypes(*d, affected);
 355                 }
 356             }
 357         }
 358     }
 359
 360     void reportAssociatingFunctions(std::vector<QualType> const& affected, Decl* decl)
 361     {
 362         auto c = decl->getDeclContext();
 363         while (isa<LinkageSpecDecl>(c) || c->isInlineNamespace())
 364         {
 365             c = c->getParent();
 366         }
 367         assert(c->isTranslationUnit() || c->isNamespace());
 368         SmallVector<DeclContext*, 2> parts;
 369         c->collectAllContexts(parts);
 370         std::list<DeclContext const*> ctxs;
 371         std::copy(parts.begin(), parts.end(),
 372                   std::back_insert_iterator<std::list<DeclContext const*>>(ctxs));
 373         if (auto const d = dyn_cast<CXXRecordDecl>(decl))
 374         {
 375             // To find friend functions declared in the class:
 376             ctxs.push_back(d);
 377         }
 378         std::set<FunctionDecl const*> fdecls; // to report every function just once
 379         for (auto ctx = ctxs.begin(); ctx != ctxs.end(); ++ctx)
 380         {
 381             for (auto i = (*ctx)->decls_begin(); i != (*ctx)->decls_end(); ++i)
 382             {
 383                 auto d = *i;
 384                 if (auto const d1 = dyn_cast<LinkageSpecDecl>(d))
 385                 {
 386                     ctxs.push_back(d1);
 387                     continue;
 388                 }
 389                 if (auto const d1 = dyn_cast<NamespaceDecl>(d))
 390                 {
 391                     if (d1->isInline())
 392                     {
 393                         ctxs.push_back(d1);
 394                     }
 395                     continue;
 396                 }
 397                 if (auto const d1 = dyn_cast<FriendDecl>(d))
 398                 {
 399                     d = d1->getFriendDecl();
 400                     if (d == nullptr) // happens for 'friend struct S;'
 401                     {
 402                         continue;
 403                     }
 404                 }
 405                 FunctionDecl const* f;
 406                 if (auto const d1 = dyn_cast<FunctionTemplateDecl>(d))
 407                 {
 408                     f = d1->getTemplatedDecl();
 409                 }
 410                 else
 411                 {
 412                     f = dyn_cast<FunctionDecl>(d);
 413                     if (f == nullptr)
 414                     {
 415                         continue;
 416                     }
 417                 }
 418                 if (!fdecls.insert(f->getCanonicalDecl()).second)
 419                 {
 420                     continue;
 421                 }
 422                 if (isa<CXXMethodDecl>(f))
 423                 {
 424                     continue;
 425                 }
 426                 for (auto const& t : affected)
 427                 {
 428                     auto const tc = t.getCanonicalType();
 429                     for (auto p = f->param_begin(); p != f->param_end(); ++p)
 430                     {
 431                         if (mentions((*p)->getType(), tc))
 432                         {
 433                             report(DiagnosticsEngine::Note,
 434                                    "a %select{function|function template|function template "
 435                                    "specialization}0 associating %1 is declared here",
 436                                    f->getLocation())
 437                                 << (f->isFunctionTemplateSpecialization()
 438                                         ? 2
 439                                         : f->getDescribedFunctionTemplate() != nullptr ? 1 : 0)
 440                                 << t << f->getSourceRange();
 441                             for (auto f1 = f->redecls_begin(); f1 != f->redecls_end(); ++f1)
 442                             {
 443                                 if (*f1 == f)
 444                                 {
 445                                     continue;
 446                                 }
 447                                 report(DiagnosticsEngine::Note, "another declaration is here",
 448                                        f1->getLocation())
 449                                     << f1->getSourceRange();
 450                             }
 451                             break;
 452                         }
 453                     }
 454                 }
 455             }
 456         }
 457     }
 458
 459     void reportAssociatingFunctions(Decl* decl)
 460     {
 461         std::vector<QualType> affected; // enum/class/class template + recursively affected members
 462         computeAffectedTypes(decl, &affected);
 463         reportAssociatingFunctions(affected, decl);
 464     }
 465
 466     bool handleDeclaration(NamedDecl* decl)
 467     {
 468         if (ignoreLocation(decl))
 469         {
 470             return true;
 471         }
 472         if (decl->getLinkageInternal() < compat::Linkage::Module)
 473         {
 474             return true;
 475         }
 476         // In some cases getLinkageInternal() arguably wrongly reports ExternalLinkage, see the
 477         // commit message of <https://github.com/llvm/llvm-project/commit/
 478         // df963a38a9e27fc43b485dfdf52bc1b090087e06> "DR1113: anonymous namespaces formally give
 479         // their contents internal linkage":
 480         //
 481         //  "We still deviate from the standard in one regard here: extern "C" declarations
 482         //   in anonymous namespaces are still granted external linkage. Changing those does
 483         //   not appear to have been an intentional consequence of the standard change in
 484         //   DR1113."
 485         //
 486         // Do not warn about such "wrongly external" declarations here:
 487         if (decl->isInAnonymousNamespace())
 488         {
 489             return true;
 490         }
 491         for (Decl const* d = decl; d != nullptr; d = d->getPreviousDecl())
 492         {
 493             if (!compiler.getSourceManager().isInMainFile(d->getLocation()))
 494             {
 495                 return true;
 496             }
 497         }
 498         if (compiler.getSourceManager().isMacroBodyExpansion(decl->getLocation()))
 499         {
 500             if (Lexer::getImmediateMacroName(decl->getLocation(), compiler.getSourceManager(),
 501                                              compiler.getLangOpts())
 502                 == "MDDS_MTV_DEFINE_ELEMENT_CALLBACKS")
 503             {
 504                 // Even wrapping in an unnamed namespace or sneaking "static" into the macro
 505                 // wouldn't help, as then some of the functions it defines would be flagged as
 506                 // unused:
 507                 return true;
 508             }
 509         }
 510         else if (compiler.getSourceManager().isMacroArgExpansion(decl->getLocation()))
 511         {
 512             if (Lexer::getImmediateMacroName(decl->getLocation(), compiler.getSourceManager(),
 513                                              compiler.getLangOpts())
 514                 == "DEFINE_GUID")
 515             {
 516                 // Windows, guiddef.h:
 517                 return true;
 518             }
 519         }
 520         TypedefNameDecl const* typedefed = nullptr;
 521         if (auto const d = dyn_cast<TagDecl>(decl))
 522         {
 523             typedefed = d->getTypedefNameForAnonDecl();
 524         }
 525         bool canStatic;
 526         if (auto const d = dyn_cast<CXXRecordDecl>(decl))
 527         {
 528             canStatic = d->isUnion() && d->isAnonymousStructOrUnion();
 529         }
 530         else
 531         {
 532             canStatic = isa<FunctionDecl>(decl) || isa<VarDecl>(decl)
 533                         || isa<FunctionTemplateDecl>(decl) || isa<VarTemplateDecl>(decl);
 534         }
 535         // In general, moving functions into an unnamed namespace can: break ADL like in
 536         //
 537         //   struct S1 { int f() { return 1; } };
 538         //   int f(S1 s) { return s.f(); }
 539         //   namespace N {
 540         //     struct S2: S1 { int f() { return 0; } };
 541         //     int f(S2 s) { return s.f(); } // [*]
 542         //   }
 543         //   int main() { return f(N::S2()); }
 544         //
 545         // changing from returning 0 to returning 1 when [*] is moved into an unnamed namespace; can
 546         // conflict with function declarations in the moved function like in
 547         //
 548         //   int f(int) { return 0; }
 549         //   namespace { int f(int) { return 1; } }
 550         //   int g() { // [*]
 551         //     int f(int);
 552         //     return f(0);
 553         //   }
 554         //   int main() { return g(); }
 555         //
 556         // changing from returning 0 to returning 1 when [*] is moved into an unnamed namespace; and
 557         // can conflict with overload resolution in general like in
 558         //
 559         //   int f(int) { return 0; }
 560         //   namespace { int f(...) { return 1; } }
 561         //   int g() { return f(0); } // [*]
 562         //   int main() { return g(); }
 563         //
 564         // changing from returning 0 to returning 1 when [*] is moved into an unnamed namespace:
 565         auto const canUnnamed = compiler.getLangOpts().CPlusPlus
 566                                 && !(isa<FunctionDecl>(decl) || isa<FunctionTemplateDecl>(decl));
 567         assert(canStatic || canUnnamed);
 568         report(
 569             DiagnosticsEngine::Warning,
 570             ("externally available%select{| typedef'ed}0 entity %1 is not previously declared in an"
 571              " included file (if it is only used in this translation unit,"
 572              " %select{|make it static}2%select{| or }3%select{|put it in an unnamed namespace}4;"
 573              " otherwise, provide a declaration of it in an included file)"),
 574             decl->getLocation())
 575             << (typedefed != nullptr) << (typedefed == nullptr ? decl : typedefed) << canStatic
 576             << (canStatic && canUnnamed) << canUnnamed << decl->getSourceRange();
 577         for (auto d = decl->redecls_begin(); d != decl->redecls_end(); ++d)
 578         {
 579             if (*d == decl)
 580             {
 581                 continue;
 582             }
 583             report(DiagnosticsEngine::Note, "another declaration is here", d->getLocation())
 584                 << d->getSourceRange();
 585         }
 586         //TODO: Class template specializations can be in the enclosing namespace, so no need to
 587         // list them here (as they won't need to be put into the unnamed namespace too, unlike for
 588         // specializations of function and variable templates); and explicit function template
 589         // specializations cannot have storage-class specifiers, so as we only suggest to make
 590         // function templates static (but not to move them into an unnamed namespace), no need to
 591         // list function template specializations here, either:
 592         if (auto const d = dyn_cast<VarTemplateDecl>(decl))
 593         {
 594             reportSpecializations(d->specializations());
 595         }
 596         if (isa<TagDecl>(decl) || isa<ClassTemplateDecl>(decl))
 597         {
 598             reportAssociatingFunctions(decl);
 599         }
 600         return true;
 601     }
 602 };
 603
 604 loplugin::Plugin::Registration<External> external("external");
 605
 606 } // namespace
 607
 608 #endif // LO_CLANG_SHARED_PLUGINS
 609
 610 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */