summaryrefslogtreecommitdiffstats
path: root/compilerplugins/clang/noexceptmove.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'compilerplugins/clang/noexceptmove.cxx')
-rw-r--r--compilerplugins/clang/noexceptmove.cxx334
1 files changed, 334 insertions, 0 deletions
diff --git a/compilerplugins/clang/noexceptmove.cxx b/compilerplugins/clang/noexceptmove.cxx
new file mode 100644
index 000000000..b2679024e
--- /dev/null
+++ b/compilerplugins/clang/noexceptmove.cxx
@@ -0,0 +1,334 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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/.
+ */
+// versions before 9.0 didn't have getExceptionSpecType
+
+#include "plugin.hxx"
+
+// clang before V9 does not have API to report exception spec type
+#if CLANG_VERSION >= 90000
+
+#include "check.hxx"
+
+#include <string>
+#include <set>
+
+/**
+ Look for move constructors that can be noexcept.
+*/
+
+namespace
+{
+/// Look for the stuff that can be marked noexcept, but only if we also mark some of the callees noexcept.
+/// Off by default so as not too annoy people.
+constexpr bool bLookForStuffWeCanFix = false;
+
+class NoExceptMove : public loplugin::FilteringPlugin<NoExceptMove>
+{
+public:
+ explicit NoExceptMove(loplugin::InstantiationData const& data)
+ : FilteringPlugin(data)
+ {
+ }
+
+ virtual void run() override
+ {
+ StringRef fn(handler.getMainFileName());
+ // ONDXPagePtr::operator= calls ONDXPage::ReleaseRef which cannot be noexcept
+ if (loplugin::isSamePathname(fn,
+ SRCDIR "/connectivity/source/drivers/dbase/dindexnode.cxx"))
+ return;
+ TraverseDecl(compiler.getASTContext().getTranslationUnitDecl());
+ }
+
+ bool shouldVisitImplicitCode() const { return true; }
+
+ bool TraverseCXXConstructorDecl(CXXConstructorDecl*);
+ bool TraverseCXXMethodDecl(CXXMethodDecl*);
+ bool VisitCallExpr(const CallExpr*);
+ bool VisitCXXConstructExpr(const CXXConstructExpr*);
+ bool VisitVarDecl(const VarDecl*);
+
+private:
+ llvm::Optional<bool> IsCallThrows(const CallExpr* callExpr);
+ std::vector<bool> m_ConstructorThrows;
+ std::vector<std::vector<const Decl*>> m_Exclusions;
+ std::vector<bool> m_CannotFix;
+};
+
+bool NoExceptMove::TraverseCXXConstructorDecl(CXXConstructorDecl* constructorDecl)
+{
+ const bool isMove = constructorDecl->isMoveConstructor()
+ && constructorDecl->getExceptionSpecType() == EST_None
+ && !constructorDecl->isDefaulted() && !constructorDecl->isDeleted()
+ && !ignoreLocation(constructorDecl)
+ && constructorDecl->isThisDeclarationADefinition()
+ && constructorDecl->getBody() != nullptr;
+ if (isMove)
+ {
+ m_ConstructorThrows.push_back(false);
+ m_Exclusions.emplace_back();
+ m_CannotFix.push_back(false);
+ }
+ bool rv = RecursiveASTVisitor::TraverseCXXConstructorDecl(constructorDecl);
+ if (isMove)
+ {
+ if (!m_ConstructorThrows.back())
+ {
+ report(DiagnosticsEngine::Warning, "move constructor can be noexcept",
+ constructorDecl->getSourceRange().getBegin())
+ << constructorDecl->getSourceRange();
+ auto canonicalDecl = constructorDecl->getCanonicalDecl();
+ if (canonicalDecl != constructorDecl)
+ report(DiagnosticsEngine::Note, "declaration here",
+ canonicalDecl->getSourceRange().getBegin())
+ << canonicalDecl->getSourceRange();
+ }
+ else if (bLookForStuffWeCanFix && !m_CannotFix.back())
+ {
+ report(DiagnosticsEngine::Warning, "move constructor can be noexcept",
+ constructorDecl->getSourceRange().getBegin())
+ << constructorDecl->getSourceRange();
+ auto canonicalDecl = constructorDecl->getCanonicalDecl();
+ if (canonicalDecl != constructorDecl)
+ report(DiagnosticsEngine::Note, "declaration here",
+ canonicalDecl->getSourceRange().getBegin())
+ << canonicalDecl->getSourceRange();
+ for (const Decl* callDecl : m_Exclusions.back())
+ report(DiagnosticsEngine::Warning, "but need to fix this to be noexcept",
+ callDecl->getSourceRange().getBegin())
+ << callDecl->getSourceRange();
+ }
+ m_ConstructorThrows.pop_back();
+ m_Exclusions.pop_back();
+ m_CannotFix.pop_back();
+ }
+ return rv;
+}
+
+bool NoExceptMove::TraverseCXXMethodDecl(CXXMethodDecl* methodDecl)
+{
+ bool isMove = methodDecl->isMoveAssignmentOperator()
+ && methodDecl->getExceptionSpecType() == EST_None && !methodDecl->isDefaulted()
+ && !methodDecl->isDeleted() && !ignoreLocation(methodDecl)
+ && methodDecl->isThisDeclarationADefinition() && methodDecl->getBody() != nullptr;
+ if (isMove)
+ {
+ StringRef fn = getFilenameOfLocation(
+ compiler.getSourceManager().getSpellingLoc(compat::getBeginLoc(methodDecl)));
+ // SfxObjectShellLock::operator= calls SotObject::OwnerLock which in turn calls stuff which cannot be noexcept
+ if (loplugin::isSamePathname(fn, SRCDIR "/include/sfx2/objsh.hxx"))
+ isMove = false;
+ }
+ if (isMove)
+ {
+ m_ConstructorThrows.push_back(false);
+ m_Exclusions.emplace_back();
+ m_CannotFix.push_back(false);
+ }
+ bool rv = RecursiveASTVisitor::TraverseCXXMethodDecl(methodDecl);
+ if (isMove)
+ {
+ if (!m_ConstructorThrows.back())
+ {
+ report(DiagnosticsEngine::Warning, "move operator= can be noexcept",
+ methodDecl->getSourceRange().getBegin())
+ << methodDecl->getSourceRange();
+ auto canonicalDecl = methodDecl->getCanonicalDecl();
+ if (canonicalDecl != methodDecl)
+ report(DiagnosticsEngine::Note, "declaration here",
+ canonicalDecl->getSourceRange().getBegin())
+ << canonicalDecl->getSourceRange();
+ }
+ else if (bLookForStuffWeCanFix && !m_CannotFix.back())
+ {
+ report(DiagnosticsEngine::Warning, "move operator= can be noexcept",
+ methodDecl->getSourceRange().getBegin())
+ << methodDecl->getSourceRange();
+ auto canonicalDecl = methodDecl->getCanonicalDecl();
+ if (canonicalDecl != methodDecl)
+ report(DiagnosticsEngine::Note, "declaration here",
+ canonicalDecl->getSourceRange().getBegin())
+ << canonicalDecl->getSourceRange();
+ for (const Decl* callDecl : m_Exclusions.back())
+ report(DiagnosticsEngine::Warning, "but need to fix this to be noexcept",
+ callDecl->getSourceRange().getBegin())
+ << callDecl->getSourceRange();
+ }
+ m_ConstructorThrows.pop_back();
+ m_Exclusions.pop_back();
+ m_CannotFix.pop_back();
+ }
+ return rv;
+}
+
+bool NoExceptMove::VisitCallExpr(const CallExpr* callExpr)
+{
+ if (ignoreLocation(callExpr))
+ return true;
+ if (m_ConstructorThrows.empty())
+ return true;
+ llvm::Optional<bool> bCallThrows = IsCallThrows(callExpr);
+ if (!bCallThrows)
+ {
+ callExpr->dump();
+ if (callExpr->getCalleeDecl())
+ callExpr->getCalleeDecl()->dump();
+ report(DiagnosticsEngine::Warning, "what's up doc?", callExpr->getSourceRange().getBegin())
+ << callExpr->getSourceRange();
+ m_ConstructorThrows.back() = true;
+ return true;
+ }
+ if (*bCallThrows)
+ m_ConstructorThrows.back() = true;
+ return true;
+}
+
+static bool IsCallThrowsSpec(clang::ExceptionSpecificationType est)
+{
+ return !(est == EST_DynamicNone || est == EST_NoThrow || est == EST_BasicNoexcept
+ || est == EST_NoexceptTrue);
+}
+
+bool NoExceptMove::VisitCXXConstructExpr(const CXXConstructExpr* constructExpr)
+{
+ if (ignoreLocation(constructExpr))
+ return true;
+ if (m_ConstructorThrows.empty())
+ return true;
+ auto constructorDecl = constructExpr->getConstructor();
+ auto est = constructorDecl->getExceptionSpecType();
+ if (constructorDecl->isDefaulted() && est == EST_None)
+ ; // ok, non-throwing
+ else if (IsCallThrowsSpec(est))
+ {
+ if (bLookForStuffWeCanFix)
+ {
+ if (est == EST_None && !ignoreLocation(constructorDecl))
+ m_Exclusions.back().push_back(constructorDecl);
+ else
+ m_CannotFix.back() = true;
+ }
+ m_ConstructorThrows.back() = true;
+ }
+ return true;
+}
+
+bool NoExceptMove::VisitVarDecl(const VarDecl* varDecl)
+{
+ if (varDecl->getLocation().isValid() && ignoreLocation(varDecl))
+ return true;
+ if (m_ConstructorThrows.empty())
+ return true;
+ // The clang AST does not show me implicit calls to destructors at the end of a block,
+ // so assume any local var decls of class type will call their destructor.
+ if (!varDecl->getType()->isRecordType())
+ return true;
+ auto cxxRecordDecl = varDecl->getType()->getAsCXXRecordDecl();
+ if (!cxxRecordDecl)
+ return true;
+ auto destructorDecl = cxxRecordDecl->getDestructor();
+ if (!destructorDecl)
+ return true;
+ auto est = destructorDecl->getExceptionSpecType();
+ if (destructorDecl->isDefaulted() && est == EST_None)
+ ; // ok, non-throwing
+ else if (IsCallThrowsSpec(est))
+ {
+ if (bLookForStuffWeCanFix)
+ {
+ if (est == EST_None && !ignoreLocation(destructorDecl))
+ m_Exclusions.back().push_back(destructorDecl);
+ else
+ m_CannotFix.back() = true;
+ }
+ m_ConstructorThrows.back() = true;
+ }
+ return true;
+}
+
+llvm::Optional<bool> NoExceptMove::IsCallThrows(const CallExpr* callExpr)
+{
+ const FunctionDecl* calleeFunctionDecl = callExpr->getDirectCallee();
+ if (calleeFunctionDecl)
+ {
+ auto est = calleeFunctionDecl->getExceptionSpecType();
+ if (bLookForStuffWeCanFix)
+ {
+ if (est == EST_None && !ignoreLocation(calleeFunctionDecl))
+ m_Exclusions.back().push_back(calleeFunctionDecl);
+ else
+ m_CannotFix.back() = true;
+ }
+ // Whitelist of functions that could be noexcept, but we can't change them because of backwards-compatibility reasons
+ // css::uno::XInterface::acquire
+ // css::uno::XInterface::release
+ if (calleeFunctionDecl->getIdentifier())
+ {
+ auto name = calleeFunctionDecl->getName();
+ if (auto cxxMethodDecl = dyn_cast<CXXMethodDecl>(calleeFunctionDecl))
+ if (loplugin::ContextCheck(cxxMethodDecl->getParent()->getDeclContext())
+ .Namespace("uno")
+ .Namespace("star")
+ .Namespace("sun")
+ .Namespace("com")
+ .GlobalNamespace()
+ && (name == "acquire" || name == "release"))
+ return false;
+ if (name == "osl_releasePipe" || name == "osl_destroySocketAddr")
+ return false;
+ }
+ return IsCallThrowsSpec(est);
+ }
+
+ auto calleeExpr = callExpr->getCallee();
+ if (isa<CXXDependentScopeMemberExpr>(calleeExpr) || isa<UnresolvedLookupExpr>(calleeExpr))
+ {
+ m_CannotFix.back() = true;
+ return true;
+ }
+
+ // check for call via function-pointer
+ clang::QualType calleeType;
+ if (auto fieldDecl = dyn_cast_or_null<FieldDecl>(callExpr->getCalleeDecl()))
+ calleeType = fieldDecl->getType();
+ else if (auto varDecl = dyn_cast_or_null<VarDecl>(callExpr->getCalleeDecl()))
+ calleeType = varDecl->getType();
+ else
+ {
+ m_CannotFix.back() = true;
+ return llvm::Optional<bool>();
+ }
+
+ // whitelist of functions that could be noexcept, but we can't change them because of backwards-compatibility reasons
+ if (auto typedefType = calleeType->getAs<TypedefType>())
+ if (typedefType->getDecl()->getName() == "uno_ReleaseMappingFunc")
+ return false;
+
+ if (calleeType->isPointerType())
+ calleeType = calleeType->getPointeeType();
+ auto funcProto = calleeType->getAs<FunctionProtoType>();
+ if (!funcProto)
+ {
+ m_CannotFix.back() = true;
+ return llvm::Optional<bool>();
+ }
+
+ auto est = funcProto->getExceptionSpecType();
+ if (bLookForStuffWeCanFix)
+ {
+ m_CannotFix.back() = true; // TODO, could improve
+ }
+ return IsCallThrowsSpec(est);
+}
+
+loplugin::Plugin::Registration<NoExceptMove> noexceptmove("noexceptmove");
+}
+
+#endif // CLANG_VERSION
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */