summaryrefslogtreecommitdiffstats
path: root/compilerplugins/clang/stringviewparam.cxx
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 09:06:44 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 09:06:44 +0000
commited5640d8b587fbcfed7dd7967f3de04b37a76f26 (patch)
tree7a5f7c6c9d02226d7471cb3cc8fbbf631b415303 /compilerplugins/clang/stringviewparam.cxx
parentInitial commit. (diff)
downloadlibreoffice-ed5640d8b587fbcfed7dd7967f3de04b37a76f26.tar.xz
libreoffice-ed5640d8b587fbcfed7dd7967f3de04b37a76f26.zip
Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'compilerplugins/clang/stringviewparam.cxx')
-rw-r--r--compilerplugins/clang/stringviewparam.cxx575
1 files changed, 575 insertions, 0 deletions
diff --git a/compilerplugins/clang/stringviewparam.cxx b/compilerplugins/clang/stringviewparam.cxx
new file mode 100644
index 000000000..eed439d0a
--- /dev/null
+++ b/compilerplugins/clang/stringviewparam.cxx
@@ -0,0 +1,575 @@
+/* -*- 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/.
+ */
+
+#include <cassert>
+#include <set>
+#include <vector>
+
+#include "config_clang.h"
+
+#include "check.hxx"
+#include "functionaddress.hxx"
+#include "plugin.hxx"
+
+// Find functions that take rtl::O[U]String parameters that can be generalized to take
+// std::[u16]string_view instead.
+
+//TODO: At least theoretically, there are issues with replacing parameters that are being assigned
+// to, as in
+//
+// void f(OUString s) {
+// {
+// OUString t = ...;
+// s = t;
+// }
+// ... use s ... // if s is now std::u16string_view, it points into destroyed contents of t
+// }
+
+namespace
+{
+bool hasSalDllpublicExportAttr(FunctionDecl const* decl)
+{
+ if (auto const attr = decl->getAttr<VisibilityAttr>())
+ {
+ return attr->getVisibility() == VisibilityAttr::Default;
+ }
+ return decl->hasAttr<DLLExportAttr>();
+}
+
+enum class StringType
+{
+ None,
+ RtlOstring,
+ RtlOustring
+};
+
+StringType relevantStringType(QualType type)
+{
+ loplugin::TypeCheck const c(type);
+ if (c.Class("OString").Namespace("rtl"))
+ {
+ return StringType::RtlOstring;
+ }
+ else if (c.Class("OUString").Namespace("rtl"))
+ {
+ return StringType::RtlOustring;
+ }
+ else
+ {
+ return StringType::None;
+ }
+}
+
+bool relevantParmVarDecl(ParmVarDecl const* decl)
+{
+ auto const t1 = decl->getType();
+ if (auto const t2 = t1->getAs<LValueReferenceType>())
+ {
+ if (!t2->getPointeeType().isConstQualified())
+ {
+ return false;
+ }
+ }
+ if (relevantStringType(t1.getNonReferenceType()) == StringType::None)
+ {
+ return false;
+ }
+ if (decl->hasAttr<UnusedAttr>())
+ {
+ return false;
+ }
+ return true;
+}
+
+DeclRefExpr const* relevantDeclRefExpr(Expr const* expr)
+{
+ //TODO: Look through BO_Comma and AbstractConditionalOperator
+ auto const e = dyn_cast<DeclRefExpr>(expr->IgnoreParenImpCasts());
+ if (e == nullptr)
+ {
+ return nullptr;
+ }
+ auto const d = dyn_cast<ParmVarDecl>(e->getDecl());
+ if (d == nullptr)
+ {
+ return nullptr;
+ }
+ if (!relevantParmVarDecl(d))
+ {
+ return nullptr;
+ }
+ return e;
+}
+
+bool isStringView(QualType qt)
+{
+ return bool(loplugin::TypeCheck(qt).ClassOrStruct("basic_string_view").StdNamespace());
+}
+
+DeclRefExpr const* relevantImplicitCastExpr(ImplicitCastExpr const* expr)
+{
+ if (!isStringView(expr->getType()))
+ {
+ return nullptr;
+ }
+ return relevantDeclRefExpr(expr->getSubExprAsWritten());
+}
+
+DeclRefExpr const* relevantCXXMemberCallExpr(CXXMemberCallExpr const* expr)
+{
+ StringType t = relevantStringType(expr->getObjectType());
+ if (t == StringType::None)
+ {
+ return nullptr;
+ }
+ bool good = false;
+ auto const d = expr->getMethodDecl();
+ if (d->getOverloadedOperator() == OO_Subscript)
+ {
+ good = true;
+ }
+ else if (auto const i = d->getIdentifier())
+ {
+ auto const n = i->getName();
+ if (n == "endsWith" || n == "isEmpty" || n == "startsWith" || n == "subView"
+ || n == "indexOf" || n == "lastIndexOf" || n == "compareTo" || n == "match"
+ || n == "trim" || n == "toInt32" || n == "toUInt32" || n == "toInt64" || n == "toDouble"
+ || n == "equalsIgnoreAsciiCase" || n == "compareToIgnoreAsciiCase" || n == "getToken"
+ || n == "copy" || n == "equalsAscii" || n == "matchIgnoreAsciiCase")
+ {
+ good = true;
+ }
+#if 0
+ //TODO: rtl::O[U]String::getLength would be awkward to replace with
+ // std::[u16]string_view::length/size due to the sal_Int32 vs. std::size_t return type
+ // mismatch (C++20 ssize might make that easier, though); and while rtl::OString::getStr is
+ // documented to be NUL-terminated (so not eligible for replacement with
+ // std::string_view::data in general), rtl::OUString::getStr is not (so should be eligible
+ // for replacement with std::u16string_view::data, but some call sites might nevertheless
+ // incorrectly rely on NUL termination, so any replacement would need careful review):
+ if (n == "getLength" || (t == StringType::RtlOustring && n == "getStr"))
+ {
+ good = true;
+ }
+#endif
+ }
+ if (!good)
+ {
+ return nullptr;
+ }
+ return relevantDeclRefExpr(expr->getImplicitObjectArgument());
+}
+
+SmallVector<DeclRefExpr const*, 2> wrap(DeclRefExpr const* expr)
+{
+ if (expr == nullptr)
+ {
+ return {};
+ }
+ return { expr };
+}
+
+SmallVector<DeclRefExpr const*, 2> relevantCXXOperatorCallExpr(CXXOperatorCallExpr const* expr)
+{
+ auto const op = expr->getOperator();
+ if (op == OO_Subscript)
+ {
+ auto const e = expr->getArg(0);
+ if (relevantStringType(e->getType()) == StringType::None)
+ {
+ return {};
+ }
+ return wrap(relevantDeclRefExpr(e));
+ }
+ if (expr->isComparisonOp() || (op == OO_Plus && expr->getNumArgs() == 2))
+ {
+ SmallVector<DeclRefExpr const*, 2> v;
+ if (auto const e = relevantDeclRefExpr(expr->getArg(0)))
+ {
+ v.push_back(e);
+ }
+ if (auto const e = relevantDeclRefExpr(expr->getArg(1)))
+ {
+ v.push_back(e);
+ }
+ return v;
+ }
+ if (op == OO_PlusEqual)
+ {
+ if (relevantStringType(expr->getArg(0)->getType()) != StringType::RtlOustring)
+ {
+ return {};
+ }
+ return wrap(relevantDeclRefExpr(expr->getArg(1)));
+ }
+ return {};
+}
+
+//TODO: current implementation is not at all general, just tests what we encounter in practice:
+bool hasStringViewOverload(ParmVarDecl const* decl)
+{
+ auto const d1 = cast<FunctionDecl>(decl->getDeclContext());
+ auto const ctx = d1->getDeclContext();
+ if (!ctx->isLookupContext())
+ {
+ return false;
+ }
+ auto const res = ctx->lookup(d1->getDeclName());
+ auto const idx = decl->getFunctionScopeIndex();
+ auto const n = d1->getNumParams();
+ assert(n > idx);
+ for (auto i = res.begin(); i != res.end(); ++i)
+ {
+ auto const d2 = dyn_cast<FunctionDecl>(*i);
+ if (d2 == nullptr)
+ {
+ continue;
+ }
+ if (d2->getNumParams() != n)
+ {
+ continue;
+ }
+ auto match = true;
+ for (unsigned j = 0; j != n; ++j)
+ {
+ if (j == idx)
+ {
+ //TODO: check for exactly std::string_view or std::u16string_view:
+ if (!isStringView(d2->getParamDecl(j)->getType()))
+ {
+ match = false;
+ break;
+ }
+ }
+ else if (d1->getParamDecl(j)->getType().getCanonicalType()
+ != d2->getParamDecl(j)->getType().getCanonicalType())
+ {
+ match = false;
+ break;
+ }
+ }
+ if (match)
+ {
+ return true;
+ }
+ }
+ return false;
+}
+
+class StringViewParam final
+ : public loplugin::FunctionAddress<loplugin::FilteringPlugin<StringViewParam>>
+{
+public:
+ explicit StringViewParam(loplugin::InstantiationData const& data)
+ : FunctionAddress(data)
+ {
+ }
+
+ //TODO: Also check lambdas
+ bool TraverseFunctionDecl(FunctionDecl* decl)
+ {
+ if (ignoreLocation(decl))
+ {
+ return true;
+ }
+ if (!relevantFunctionDecl(decl))
+ {
+ return FunctionAddress::TraverseFunctionDecl(decl);
+ }
+ auto const oldParams = currentParams_;
+ auto const n = decl->getNumParams();
+ for (unsigned i = 0; i != n; ++i)
+ {
+ auto const d = decl->getParamDecl(i);
+ if (relevantParmVarDecl(d))
+ {
+ currentParams_.insert(d);
+ }
+ }
+ auto const ret = FunctionAddress::TraverseFunctionDecl(decl);
+ if (ret)
+ {
+ for (unsigned i = 0; i != n; ++i)
+ {
+ auto const d1 = decl->getParamDecl(i);
+ if (currentParams_.find(d1) == currentParams_.end())
+ {
+ continue;
+ }
+ if (containsPreprocessingConditionalInclusion(decl->getSourceRange()))
+ {
+ break;
+ }
+ badParams_.push_back(d1);
+ }
+ }
+ currentParams_ = oldParams;
+ return ret;
+ }
+
+ bool TraverseCXXMethodDecl(CXXMethodDecl* decl)
+ {
+ if (ignoreLocation(decl))
+ {
+ return true;
+ }
+ if (!relevantFunctionDecl(decl))
+ {
+ return FunctionAddress::TraverseCXXMethodDecl(decl);
+ }
+ auto const oldParams = currentParams_;
+ auto const n = decl->getNumParams();
+ for (unsigned i = 0; i != n; ++i)
+ {
+ auto const d = decl->getParamDecl(i);
+ if (relevantParmVarDecl(d))
+ {
+ currentParams_.insert(d);
+ }
+ }
+ auto const ret = FunctionAddress::TraverseCXXMethodDecl(decl);
+ if (ret)
+ {
+ for (unsigned i = 0; i != n; ++i)
+ {
+ auto const d1 = decl->getParamDecl(i);
+ if (currentParams_.find(d1) == currentParams_.end())
+ {
+ continue;
+ }
+ if (containsPreprocessingConditionalInclusion(decl->getSourceRange()))
+ {
+ break;
+ }
+ badParams_.push_back(d1);
+ }
+ }
+ currentParams_ = oldParams;
+ return ret;
+ }
+
+ bool TraverseCXXConstructorDecl(CXXConstructorDecl* decl)
+ {
+ if (ignoreLocation(decl))
+ {
+ return true;
+ }
+ if (!relevantFunctionDecl(decl))
+ {
+ return FunctionAddress::TraverseCXXConstructorDecl(decl);
+ }
+ auto const oldParams = currentParams_;
+ auto const n = decl->getNumParams();
+ for (unsigned i = 0; i != n; ++i)
+ {
+ auto const d = decl->getParamDecl(i);
+ if (relevantParmVarDecl(d))
+ {
+ currentParams_.insert(d);
+ }
+ }
+ auto const ret = FunctionAddress::TraverseCXXConstructorDecl(decl);
+ if (ret)
+ {
+ for (unsigned i = 0; i != n; ++i)
+ {
+ auto const d1 = decl->getParamDecl(i);
+ if (currentParams_.find(d1) == currentParams_.end())
+ {
+ continue;
+ }
+ if (containsPreprocessingConditionalInclusion(decl->getSourceRange()))
+ {
+ break;
+ }
+ badParams_.push_back(d1);
+ }
+ }
+ currentParams_ = oldParams;
+ return ret;
+ }
+
+ bool TraverseImplicitCastExpr(ImplicitCastExpr* expr)
+ {
+ if (ignoreLocation(expr))
+ {
+ return true;
+ }
+ auto const e = relevantImplicitCastExpr(expr);
+ if (e == nullptr)
+ {
+ return FunctionAddress::TraverseImplicitCastExpr(expr);
+ }
+ currentGoodUses_.insert(e);
+ auto const ret = FunctionAddress::TraverseImplicitCastExpr(expr);
+ currentGoodUses_.erase(e);
+ return ret;
+ }
+
+ bool TraverseCXXMemberCallExpr(CXXMemberCallExpr* expr)
+ {
+ if (ignoreLocation(expr))
+ {
+ return true;
+ }
+ auto const e = relevantCXXMemberCallExpr(expr);
+ if (e == nullptr)
+ {
+ return FunctionAddress::TraverseCXXMemberCallExpr(expr);
+ }
+ currentGoodUses_.insert(e);
+ auto const ret = FunctionAddress::TraverseCXXMemberCallExpr(expr);
+ currentGoodUses_.erase(e);
+ return ret;
+ }
+
+ bool TraverseCXXOperatorCallExpr(CXXOperatorCallExpr* expr)
+ {
+ if (ignoreLocation(expr))
+ {
+ return true;
+ }
+ auto const es = relevantCXXOperatorCallExpr(expr);
+ if (es.empty())
+ {
+ return FunctionAddress::TraverseCXXOperatorCallExpr(expr);
+ }
+ currentGoodUses_.insert(es.begin(), es.end());
+ auto const ret = FunctionAddress::TraverseCXXOperatorCallExpr(expr);
+ for (auto const i : es)
+ {
+ currentGoodUses_.erase(i);
+ }
+ return ret;
+ }
+
+ bool VisitDeclRefExpr(DeclRefExpr* expr)
+ {
+ if (!FunctionAddress::VisitDeclRefExpr(expr))
+ {
+ return false;
+ }
+ if (ignoreLocation(expr))
+ {
+ return true;
+ }
+ if (currentGoodUses_.find(expr) != currentGoodUses_.end())
+ {
+ return true;
+ }
+ if (auto const d = dyn_cast<ParmVarDecl>(expr->getDecl()))
+ {
+ currentParams_.erase(d);
+ }
+ return true;
+ }
+
+private:
+ void run() override
+ {
+ if (!compiler.getLangOpts().CPlusPlus)
+ {
+ return;
+ }
+ if (compiler.getPreprocessor().getIdentifierInfo("NDEBUG")->hasMacroDefinition())
+ {
+ return;
+ }
+ StringRef fn(handler.getMainFileName());
+ // leave the string QA tests alone
+ if (loplugin::hasPathnamePrefix(fn, SRCDIR "/sal/qa/"))
+ {
+ return;
+ }
+ if (!TraverseDecl(compiler.getASTContext().getTranslationUnitDecl()))
+ {
+ return;
+ }
+ auto const ignoredFns = getFunctionsWithAddressTaken();
+ for (auto const i : badParams_)
+ {
+ auto const d1 = cast<FunctionDecl>(i->getDeclContext());
+ if (ignoredFns.find(d1) != ignoredFns.end())
+ {
+ continue;
+ }
+ if (hasStringViewOverload(i))
+ {
+ continue;
+ }
+ auto const t = relevantStringType(i->getType().getNonReferenceType());
+ assert(t != StringType::None);
+ report(DiagnosticsEngine::Warning,
+ "replace function parameter of type %0 with "
+ "'%select{std::string_view|std::u16string_view}1'",
+ i->getLocation())
+ << i->getType() << (int(t) - 1) << i->getSourceRange();
+ for (auto d2 = d1;;)
+ {
+ d2 = d2->getPreviousDecl();
+ if (d2 == nullptr)
+ {
+ break;
+ }
+ auto const d3 = d2->getParamDecl(i->getFunctionScopeIndex());
+ report(DiagnosticsEngine::Note, "previous declaration is here", d3->getLocation())
+ << d3->getSourceRange();
+ }
+ }
+ }
+
+ bool relevantFunctionDecl(FunctionDecl const* decl)
+ {
+ if (!decl->doesThisDeclarationHaveABody())
+ {
+ return false;
+ }
+ if (decl->getBody() == nullptr) // unparsed template
+ {
+ return false;
+ }
+ if (auto const d = dyn_cast<CXXMethodDecl>(decl))
+ {
+ if (d->isVirtual())
+ {
+ return false;
+ }
+ }
+ if (decl->isFunctionTemplateSpecialization())
+ {
+ return false;
+ }
+ if (decl->getLocation().isMacroID())
+ {
+ return false;
+ }
+ // Filter out functions that are presumably meant to be called dynamically (e.g., via
+ // dlopen, or backwards compatibility stubs in cppuhelper/cppu/sal compat.cxx):
+ if (decl->getPreviousDecl() == nullptr && !decl->isInlined()
+ && hasSalDllpublicExportAttr(decl)
+ && compiler.getSourceManager().isInMainFile(decl->getLocation()))
+ {
+ return false;
+ }
+ if (isInUnoIncludeFile(compiler.getSourceManager().getSpellingLoc(decl->getLocation())))
+ {
+ return false;
+ }
+ return true;
+ }
+
+ std::set<ParmVarDecl const*> currentParams_;
+ std::set<DeclRefExpr const*> currentGoodUses_;
+ std::vector<ParmVarDecl const*> badParams_;
+};
+
+static loplugin::Plugin::Registration<StringViewParam> reg("stringviewparam");
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */