Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

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: */