summaryrefslogtreecommitdiffstats
path: root/compilerplugins/clang/external.cxx
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--compilerplugins/clang/external.cxx608
1 files changed, 608 insertions, 0 deletions
diff --git a/compilerplugins/clang/external.cxx b/compilerplugins/clang/external.cxx
new file mode 100644
index 000000000..e3bc67f19
--- /dev/null
+++ b/compilerplugins/clang/external.cxx
@@ -0,0 +1,608 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+#ifndef LO_CLANG_SHARED_PLUGINS
+
+#include <algorithm>
+#include <cassert>
+#include <iterator>
+#include <list>
+#include <set>
+
+#include "clang/Sema/SemaDiagnostic.h"
+
+#include "check.hxx"
+#include "plugin.hxx"
+
+namespace
+{
+bool derivesFromTestFixture(CXXRecordDecl const* decl)
+{
+ static auto const pred = [](CXXBaseSpecifier const& spec) {
+ if (auto const t = spec.getType()->getAs<RecordType>())
+ { // (may be a template parameter)
+ return derivesFromTestFixture(dyn_cast<CXXRecordDecl>(t->getDecl()));
+ }
+ return false;
+ };
+ return loplugin::DeclCheck(decl).Class("TestFixture").Namespace("CppUnit").GlobalNamespace()
+ || std::any_of(decl->bases_begin(), decl->bases_end(), pred)
+ || std::any_of(decl->vbases_begin(), decl->vbases_end(), pred);
+}
+
+bool isInjectedFunction(FunctionDecl const* decl)
+{
+ for (auto d = decl->redecls_begin(); d != decl->redecls_end(); ++d)
+ {
+ auto const c = d->getLexicalDeclContext();
+ if (!(c->isFunctionOrMethod() || c->isRecord()))
+ {
+ return false;
+ }
+ }
+ return true;
+}
+
+// Whether type1 mentions type2 (in a way relevant for argument-dependent name lookup):
+bool mentions(QualType type1, QualType type2)
+{
+ auto t1 = type1;
+ for (;;)
+ {
+ if (auto const t2 = t1->getAs<ReferenceType>())
+ {
+ t1 = t2->getPointeeType();
+ }
+ else if (auto const t3 = t1->getAs<clang::PointerType>())
+ {
+ t1 = t3->getPointeeType();
+ }
+ else if (auto const t4 = t1->getAsArrayTypeUnsafe())
+ {
+ t1 = t4->getElementType();
+ }
+ else
+ {
+ break;
+ }
+ }
+ if (t1.getCanonicalType().getTypePtr() == type2.getTypePtr())
+ {
+ return true;
+ }
+ if (auto const t2 = t1->getAs<TemplateSpecializationType>())
+ {
+ for (auto a = t2->begin(); a != t2->end(); ++a)
+ {
+ if (a->getKind() != TemplateArgument::Type)
+ {
+ continue;
+ }
+ if (mentions(a->getAsType(), type2))
+ {
+ return true;
+ }
+ }
+ auto const t3 = t2->desugar();
+ if (t3.getTypePtr() == t2)
+ {
+ return false;
+ }
+ return mentions(t3, type2);
+ }
+ if (auto const t2 = t1->getAs<FunctionProtoType>())
+ {
+ if (mentions(t2->getReturnType(), type2))
+ {
+ return true;
+ }
+ for (auto t3 = t2->param_type_begin(); t3 != t2->param_type_end(); ++t3)
+ {
+ if (mentions(*t3, type2))
+ {
+ return true;
+ }
+ }
+ return false;
+ }
+ if (auto const t2 = t1->getAs<MemberPointerType>())
+ {
+ if (t2->getClass()->getUnqualifiedDesugaredType() == type2.getTypePtr())
+ {
+ return true;
+ }
+ return mentions(t2->getPointeeType(), type2);
+ }
+ return false;
+}
+
+bool hasSalDllpublicExportAttr(Decl const* decl)
+{
+ if (auto const attr = decl->getAttr<VisibilityAttr>())
+ {
+ return attr->getVisibility() == VisibilityAttr::Default;
+ }
+ return decl->hasAttr<DLLExportAttr>();
+}
+
+class External : public loplugin::FilteringPlugin<External>
+{
+public:
+ explicit External(loplugin::InstantiationData const& data)
+ : FilteringPlugin(data)
+ {
+ }
+
+ void run() override { TraverseDecl(compiler.getASTContext().getTranslationUnitDecl()); }
+
+ bool VisitTagDecl(TagDecl* decl)
+ {
+ if (isa<ClassTemplateSpecializationDecl>(decl))
+ {
+ return true;
+ }
+ if (!decl->isThisDeclarationADefinition())
+ {
+ return true;
+ }
+ if (isa<CXXRecordDecl>(decl->getDeclContext()))
+ {
+ return true;
+ }
+ if (!compiler.getLangOpts().CPlusPlus)
+ {
+ return true;
+ }
+ if (auto const d = dyn_cast<CXXRecordDecl>(decl))
+ {
+ if (d->getDescribedClassTemplate() != nullptr)
+ {
+ return true;
+ }
+ if (hasSalDllpublicExportAttr(d))
+ {
+ // If the class definition has explicit default visibility, then assume that it
+ // needs to be present (e.g., a backwards-compatibility stub like in
+ // cppuhelper/source/compat.cxx):
+ return true;
+ }
+ if (derivesFromTestFixture(d))
+ {
+ // The names of CppUnit tests (that can be specified with CPPUNIT_TEST_NAME) are
+ // tied to the fully-qualified names of classes derived from CppUnit::TestFixture,
+ // so avoid unnamed namespaces in those classes' names:
+ return true;
+ }
+ }
+ return handleDeclaration(decl);
+ }
+
+ bool VisitFunctionDecl(FunctionDecl* decl)
+ {
+ if (isa<CXXMethodDecl>(decl))
+ {
+ return true;
+ }
+ if (decl->getTemplatedKind() != FunctionDecl::TK_NonTemplate)
+ {
+ return true;
+ }
+ if (!decl->isThisDeclarationADefinition())
+ {
+ return true;
+ }
+ if (decl->isMain() || decl->isMSVCRTEntryPoint())
+ {
+ return true;
+ }
+ if (loplugin::hasCLanguageLinkageType(decl)
+ && loplugin::DeclCheck(decl).Function("_DllMainCRTStartup").GlobalNamespace())
+ {
+ return true;
+ }
+ // If the function definition is explicit marked SAL_DLLPUBLIC_EXPORT or similar, then
+ // assume that it needs to be present (e.g., only called via dlopen, or a backwards-
+ // compatibility stub like in sal/osl/all/compat.cxx):
+ if (hasSalDllpublicExportAttr(decl))
+ {
+ return true;
+ }
+ auto const canon = decl->getCanonicalDecl();
+ if (loplugin::hasCLanguageLinkageType(canon)
+ && (canon->hasAttr<ConstructorAttr>() || canon->hasAttr<DestructorAttr>()))
+ {
+ return true;
+ }
+ if (compiler.getDiagnostics().getDiagnosticLevel(diag::warn_unused_function,
+ decl->getLocation())
+ < DiagnosticsEngine::Warning)
+ {
+ // Don't warn about e.g.
+ //
+ // G_DEFINE_TYPE (GLOAction, g_lo_action, G_TYPE_OBJECT);
+ //
+ // in vcl/unx/gtk/gloactiongroup.cxx (which expands to non-static g_lo_action_get_type
+ // function definition), which is already wrapped in
+ //
+ // #pragma GCC diagnostic ignored "-Wunused-function"
+ return true;
+ }
+ if (isInjectedFunction(decl))
+ {
+ return true;
+ }
+ return handleDeclaration(decl);
+ }
+
+ bool VisitVarDecl(VarDecl* decl)
+ {
+ if (decl->isStaticDataMember())
+ {
+ return true;
+ }
+ if (isa<VarTemplateSpecializationDecl>(decl))
+ {
+ return true;
+ }
+ if (!decl->isThisDeclarationADefinition())
+ {
+ return true;
+ }
+ if (loplugin::DeclCheck(decl).Var("_pRawDllMain").GlobalNamespace())
+ {
+ return true;
+ }
+ return handleDeclaration(decl);
+ }
+
+ bool VisitClassTemplateDecl(ClassTemplateDecl* decl)
+ {
+ if (!decl->isThisDeclarationADefinition())
+ {
+ return true;
+ }
+ if (isa<CXXRecordDecl>(decl->getDeclContext()))
+ {
+ return true;
+ }
+ return handleDeclaration(decl);
+ }
+
+ bool VisitFunctionTemplateDecl(FunctionTemplateDecl* decl)
+ {
+ if (!decl->isThisDeclarationADefinition())
+ {
+ return true;
+ }
+ if (isa<CXXRecordDecl>(decl->getDeclContext()))
+ {
+ return true;
+ }
+ if (isInjectedFunction(decl->getTemplatedDecl()))
+ {
+ return true;
+ }
+ return handleDeclaration(decl);
+ }
+
+ bool VisitVarTemplateDecl(VarTemplateDecl* decl)
+ {
+ if (!decl->isThisDeclarationADefinition())
+ {
+ return true;
+ }
+ return handleDeclaration(decl);
+ }
+
+private:
+ template <typename T> void reportSpecializations(T specializations)
+ {
+ for (auto const d : specializations)
+ {
+ auto const k = d->getTemplateSpecializationKind();
+ if (isTemplateExplicitInstantiationOrSpecialization(k))
+ {
+ report(DiagnosticsEngine::Note,
+ "explicit %select{instantiation|specialization}0 is here", d->getLocation())
+ << (k == TSK_ExplicitSpecialization) << d->getSourceRange();
+ }
+ }
+ }
+
+ void computeAffectedTypes(Decl const* decl, std::vector<QualType>* affected)
+ {
+ assert(affected != nullptr);
+ if (auto const d = dyn_cast<EnumDecl>(decl))
+ {
+ affected->push_back(compiler.getASTContext().getEnumType(d));
+ }
+ else
+ {
+ //TODO: Derived types are also affected!
+ CXXRecordDecl const* rec;
+ if (auto const d = dyn_cast<ClassTemplateDecl>(decl))
+ {
+ rec = d->getTemplatedDecl();
+ }
+ else
+ {
+ rec = cast<CXXRecordDecl>(decl);
+ }
+ affected->push_back(compiler.getASTContext().getRecordType(rec));
+ for (auto d = rec->decls_begin(); d != rec->decls_end(); ++d)
+ {
+ if (*d != (*d)->getCanonicalDecl())
+ {
+ continue;
+ }
+ if (isa<TagDecl>(*d) || isa<ClassTemplateDecl>(*d))
+ {
+ if (auto const d1 = dyn_cast<RecordDecl>(*d))
+ {
+ if (d1->isInjectedClassName())
+ {
+ continue;
+ }
+ }
+ computeAffectedTypes(*d, affected);
+ }
+ }
+ }
+ }
+
+ void reportAssociatingFunctions(std::vector<QualType> const& affected, Decl* decl)
+ {
+ auto c = decl->getDeclContext();
+ while (isa<LinkageSpecDecl>(c) || c->isInlineNamespace())
+ {
+ c = c->getParent();
+ }
+ assert(c->isTranslationUnit() || c->isNamespace());
+ SmallVector<DeclContext*, 2> parts;
+ c->collectAllContexts(parts);
+ std::list<DeclContext const*> ctxs;
+ std::copy(parts.begin(), parts.end(),
+ std::back_insert_iterator<std::list<DeclContext const*>>(ctxs));
+ if (auto const d = dyn_cast<CXXRecordDecl>(decl))
+ {
+ // To find friend functions declared in the class:
+ ctxs.push_back(d);
+ }
+ std::set<FunctionDecl const*> fdecls; // to report every function just once
+ for (auto ctx = ctxs.begin(); ctx != ctxs.end(); ++ctx)
+ {
+ for (auto i = (*ctx)->decls_begin(); i != (*ctx)->decls_end(); ++i)
+ {
+ auto d = *i;
+ if (auto const d1 = dyn_cast<LinkageSpecDecl>(d))
+ {
+ ctxs.push_back(d1);
+ continue;
+ }
+ if (auto const d1 = dyn_cast<NamespaceDecl>(d))
+ {
+ if (d1->isInline())
+ {
+ ctxs.push_back(d1);
+ }
+ continue;
+ }
+ if (auto const d1 = dyn_cast<FriendDecl>(d))
+ {
+ d = d1->getFriendDecl();
+ if (d == nullptr) // happens for 'friend struct S;'
+ {
+ continue;
+ }
+ }
+ FunctionDecl const* f;
+ if (auto const d1 = dyn_cast<FunctionTemplateDecl>(d))
+ {
+ f = d1->getTemplatedDecl();
+ }
+ else
+ {
+ f = dyn_cast<FunctionDecl>(d);
+ if (f == nullptr)
+ {
+ continue;
+ }
+ }
+ if (!fdecls.insert(f->getCanonicalDecl()).second)
+ {
+ continue;
+ }
+ if (isa<CXXMethodDecl>(f))
+ {
+ continue;
+ }
+ for (auto const& t : affected)
+ {
+ auto const tc = t.getCanonicalType();
+ for (auto p = f->param_begin(); p != f->param_end(); ++p)
+ {
+ if (mentions((*p)->getType(), tc))
+ {
+ report(DiagnosticsEngine::Note,
+ "a %select{function|function template|function template "
+ "specialization}0 associating %1 is declared here",
+ f->getLocation())
+ << (f->isFunctionTemplateSpecialization()
+ ? 2
+ : f->getDescribedFunctionTemplate() != nullptr ? 1 : 0)
+ << t << f->getSourceRange();
+ for (auto f1 = f->redecls_begin(); f1 != f->redecls_end(); ++f1)
+ {
+ if (*f1 == f)
+ {
+ continue;
+ }
+ report(DiagnosticsEngine::Note, "another declaration is here",
+ f1->getLocation())
+ << f1->getSourceRange();
+ }
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ void reportAssociatingFunctions(Decl* decl)
+ {
+ std::vector<QualType> affected; // enum/class/class template + recursively affected members
+ computeAffectedTypes(decl, &affected);
+ reportAssociatingFunctions(affected, decl);
+ }
+
+ bool handleDeclaration(NamedDecl* decl)
+ {
+ if (ignoreLocation(decl))
+ {
+ return true;
+ }
+ if (decl->getLinkageInternal() < ModuleLinkage)
+ {
+ return true;
+ }
+ // In some cases getLinkageInternal() arguably wrongly reports ExternalLinkage, see the
+ // commit message of <https://github.com/llvm/llvm-project/commit/
+ // df963a38a9e27fc43b485dfdf52bc1b090087e06> "DR1113: anonymous namespaces formally give
+ // their contents internal linkage":
+ //
+ // "We still deviate from the standard in one regard here: extern "C" declarations
+ // in anonymous namespaces are still granted external linkage. Changing those does
+ // not appear to have been an intentional consequence of the standard change in
+ // DR1113."
+ //
+ // Do not warn about such "wrongly external" declarations here:
+ if (decl->isInAnonymousNamespace())
+ {
+ return true;
+ }
+ for (Decl const* d = decl; d != nullptr; d = d->getPreviousDecl())
+ {
+ if (!compiler.getSourceManager().isInMainFile(d->getLocation()))
+ {
+ return true;
+ }
+ }
+ if (compiler.getSourceManager().isMacroBodyExpansion(decl->getLocation()))
+ {
+ if (Lexer::getImmediateMacroName(decl->getLocation(), compiler.getSourceManager(),
+ compiler.getLangOpts())
+ == "MDDS_MTV_DEFINE_ELEMENT_CALLBACKS")
+ {
+ // Even wrapping in an unnamed namespace or sneaking "static" into the macro
+ // wouldn't help, as then some of the functions it defines would be flagged as
+ // unused:
+ return true;
+ }
+ }
+ else if (compiler.getSourceManager().isMacroArgExpansion(decl->getLocation()))
+ {
+ if (Lexer::getImmediateMacroName(decl->getLocation(), compiler.getSourceManager(),
+ compiler.getLangOpts())
+ == "DEFINE_GUID")
+ {
+ // Windows, guiddef.h:
+ return true;
+ }
+ }
+ TypedefNameDecl const* typedefed = nullptr;
+ if (auto const d = dyn_cast<TagDecl>(decl))
+ {
+ typedefed = d->getTypedefNameForAnonDecl();
+ }
+ bool canStatic;
+ if (auto const d = dyn_cast<CXXRecordDecl>(decl))
+ {
+ canStatic = d->isUnion() && d->isAnonymousStructOrUnion();
+ }
+ else
+ {
+ canStatic = isa<FunctionDecl>(decl) || isa<VarDecl>(decl)
+ || isa<FunctionTemplateDecl>(decl) || isa<VarTemplateDecl>(decl);
+ }
+ // In general, moving functions into an unnamed namespace can: break ADL like in
+ //
+ // struct S1 { int f() { return 1; } };
+ // int f(S1 s) { return s.f(); }
+ // namespace N {
+ // struct S2: S1 { int f() { return 0; } };
+ // int f(S2 s) { return s.f(); } // [*]
+ // }
+ // int main() { return f(N::S2()); }
+ //
+ // changing from returning 0 to returning 1 when [*] is moved into an unnamed namespace; can
+ // conflict with function declarations in the moved function like in
+ //
+ // int f(int) { return 0; }
+ // namespace { int f(int) { return 1; } }
+ // int g() { // [*]
+ // int f(int);
+ // return f(0);
+ // }
+ // int main() { return g(); }
+ //
+ // changing from returning 0 to returning 1 when [*] is moved into an unnamed namespace; and
+ // can conflict with overload resolution in general like in
+ //
+ // int f(int) { return 0; }
+ // namespace { int f(...) { return 1; } }
+ // int g() { return f(0); } // [*]
+ // int main() { return g(); }
+ //
+ // changing from returning 0 to returning 1 when [*] is moved into an unnamed namespace:
+ auto const canUnnamed = compiler.getLangOpts().CPlusPlus
+ && !(isa<FunctionDecl>(decl) || isa<FunctionTemplateDecl>(decl));
+ assert(canStatic || canUnnamed);
+ report(
+ DiagnosticsEngine::Warning,
+ ("externally available%select{| typedef'ed}0 entity %1 is not previously declared in an"
+ " included file (if it is only used in this translation unit,"
+ " %select{|make it static}2%select{| or }3%select{|put it in an unnamed namespace}4;"
+ " otherwise, provide a declaration of it in an included file)"),
+ decl->getLocation())
+ << (typedefed != nullptr) << (typedefed == nullptr ? decl : typedefed) << canStatic
+ << (canStatic && canUnnamed) << canUnnamed << decl->getSourceRange();
+ for (auto d = decl->redecls_begin(); d != decl->redecls_end(); ++d)
+ {
+ if (*d == decl)
+ {
+ continue;
+ }
+ report(DiagnosticsEngine::Note, "another declaration is here", d->getLocation())
+ << d->getSourceRange();
+ }
+ //TODO: Class template specializations can be in the enclosing namespace, so no need to
+ // list them here (as they won't need to be put into the unnamed namespace too, unlike for
+ // specializations of function and variable templates); and explicit function template
+ // specializations cannot have storage-class specifiers, so as we only suggest to make
+ // function templates static (but not to move them into an unnamed namespace), no need to
+ // list function template specializations here, either:
+ if (auto const d = dyn_cast<VarTemplateDecl>(decl))
+ {
+ reportSpecializations(d->specializations());
+ }
+ if (isa<TagDecl>(decl) || isa<ClassTemplateDecl>(decl))
+ {
+ reportAssociatingFunctions(decl);
+ }
+ return true;
+ }
+};
+
+loplugin::Plugin::Registration<External> external("external");
+
+} // namespace
+
+#endif // LO_CLANG_SHARED_PLUGINS
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */