diff options
Diffstat (limited to '')
| -rw-r--r-- | compilerplugins/clang/stringconstant.cxx | 2217 |
1 files changed, 2217 insertions, 0 deletions
diff --git a/compilerplugins/clang/stringconstant.cxx b/compilerplugins/clang/stringconstant.cxx new file mode 100644 index 000000000..389691796 --- /dev/null +++ b/compilerplugins/clang/stringconstant.cxx @@ -0,0 +1,2217 @@ +/* -*- 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/. + */ + +#include <algorithm> +#include <cassert> +#include <cstdint> +#include <cstdlib> +#include <iomanip> +#include <limits> +#include <sstream> +#include <stack> +#include <string> +#include <vector> +#include <iostream> + +#include "check.hxx" +#include "compat.hxx" +#include "plugin.hxx" + +// Define a "string constant" to be a constant expression either of type "array +// of N char" where each array element is a non-NULL ASCII character---except +// that the last array element may be NULL, or, in some situations, of type char +// with an ASCII value (including NULL). Note that the former includes +// expressions denoting narrow string literals like "foo", and, with toolchains +// that support constexpr, constexpr variables declared like +// +// constexpr char str[] = "bar"; +// +// This plugin flags uses of OUString functions with string constant arguments +// that can be rewritten more directly, like +// +// OUString::createFromAscii("foo") -> "foo" +// +// and +// +// s.equals(OUString("bar")) -> s == "bar" + +namespace { + +SourceLocation getMemberLocation(Expr const * expr) { + CallExpr const * e1 = dyn_cast<CallExpr>(expr); + MemberExpr const * e2 = e1 == nullptr + ? nullptr : dyn_cast<MemberExpr>(e1->getCallee()); + return e2 == nullptr ? expr->getExprLoc()/*TODO*/ : e2->getMemberLoc(); +} + +bool isLhsOfAssignment(FunctionDecl const * decl, unsigned parameter) { + if (parameter != 0) { + return false; + } + auto oo = decl->getOverloadedOperator(); + return oo == OO_Equal + || (oo >= OO_PlusEqual && oo <= OO_GreaterGreaterEqual); +} + +bool hasOverloads(FunctionDecl const * decl, unsigned arguments) { + int n = 0; + auto ctx = decl->getDeclContext(); + if (ctx->getDeclKind() == Decl::LinkageSpec) { + ctx = ctx->getParent(); + } + auto res = ctx->lookup(decl->getDeclName()); + for (auto d = res.begin(); d != res.end(); ++d) { + FunctionDecl const * f = dyn_cast<FunctionDecl>(*d); + if (f != nullptr && f->getMinRequiredArguments() <= arguments + && f->getNumParams() >= arguments) + { + auto consDecl = dyn_cast<CXXConstructorDecl>(f); + if (consDecl && consDecl->isCopyOrMoveConstructor()) { + continue; + } + ++n; + if (n == 2) { + return true; + } + } + } + return false; +} + +CXXConstructExpr const * lookForCXXConstructExpr(Expr const * expr) { + if (auto e = dyn_cast<MaterializeTemporaryExpr>(expr)) { + expr = compat::getSubExpr(e); + } + if (auto e = dyn_cast<CXXFunctionalCastExpr>(expr)) { + expr = e->getSubExpr(); + } + if (auto e = dyn_cast<CXXBindTemporaryExpr>(expr)) { + expr = e->getSubExpr(); + } + return dyn_cast<CXXConstructExpr>(expr); +} + +char const * adviseNonArray(bool nonArray) { + return nonArray + ? ", and turn the non-array string constant into an array" : ""; +} + +class StringConstant: + public loplugin::FilteringRewritePlugin<StringConstant> +{ +public: + explicit StringConstant(loplugin::InstantiationData const & data): + FilteringRewritePlugin(data) {} + + void run() override; + + bool TraverseFunctionDecl(FunctionDecl * decl) { + returnTypes_.push(compat::getDeclaredReturnType(decl)); + auto const ret = RecursiveASTVisitor::TraverseFunctionDecl(decl); + assert(!returnTypes_.empty()); + assert(returnTypes_.top() == compat::getDeclaredReturnType(decl)); + returnTypes_.pop(); + return ret; + } + + bool TraverseCXXDeductionGuideDecl(CXXDeductionGuideDecl * decl) { + returnTypes_.push(compat::getDeclaredReturnType(decl)); + auto const ret = RecursiveASTVisitor::TraverseCXXDeductionGuideDecl( + decl); + assert(!returnTypes_.empty()); + assert(returnTypes_.top() == compat::getDeclaredReturnType(decl)); + returnTypes_.pop(); + return ret; + } + + bool TraverseCXXMethodDecl(CXXMethodDecl * decl) { + returnTypes_.push(compat::getDeclaredReturnType(decl)); + auto const ret = RecursiveASTVisitor::TraverseCXXMethodDecl(decl); + assert(!returnTypes_.empty()); + assert(returnTypes_.top() == compat::getDeclaredReturnType(decl)); + returnTypes_.pop(); + return ret; + } + + bool TraverseCXXConstructorDecl(CXXConstructorDecl * decl) { + returnTypes_.push(compat::getDeclaredReturnType(decl)); + auto const ret = RecursiveASTVisitor::TraverseCXXConstructorDecl(decl); + assert(!returnTypes_.empty()); + assert(returnTypes_.top() == compat::getDeclaredReturnType(decl)); + returnTypes_.pop(); + return ret; + } + + bool TraverseCXXDestructorDecl(CXXDestructorDecl * decl) { + returnTypes_.push(compat::getDeclaredReturnType(decl)); + auto const ret = RecursiveASTVisitor::TraverseCXXDestructorDecl(decl); + assert(!returnTypes_.empty()); + assert(returnTypes_.top() == compat::getDeclaredReturnType(decl)); + returnTypes_.pop(); + return ret; + } + + bool TraverseCXXConversionDecl(CXXConversionDecl * decl) { + returnTypes_.push(compat::getDeclaredReturnType(decl)); + auto const ret = RecursiveASTVisitor::TraverseCXXConversionDecl(decl); + assert(!returnTypes_.empty()); + assert(returnTypes_.top() == compat::getDeclaredReturnType(decl)); + returnTypes_.pop(); + return ret; + } + + bool TraverseObjCMethodDecl(ObjCMethodDecl * decl) { + returnTypes_.push(decl->getReturnType()); + auto const ret = RecursiveASTVisitor::TraverseObjCMethodDecl(decl); + assert(!returnTypes_.empty()); + assert(returnTypes_.top() == decl->getReturnType()); + returnTypes_.pop(); + return ret; + } + + bool TraverseCallExpr(CallExpr * expr); + + bool TraverseCXXMemberCallExpr(CXXMemberCallExpr * expr); + + bool TraverseCXXOperatorCallExpr(CXXOperatorCallExpr * expr); + + bool TraverseCXXConstructExpr(CXXConstructExpr * expr); + + bool VisitCallExpr(CallExpr const * expr); + + bool VisitCXXConstructExpr(CXXConstructExpr const * expr); + + bool VisitReturnStmt(ReturnStmt const * stmt); + +private: + enum class ContentKind { Ascii, Utf8, Arbitrary }; + + enum class TreatEmpty { DefaultCtor, CheckEmpty, Error }; + + enum class ChangeKind { Char, CharLen, SingleChar, OUStringChar }; + + enum class PassThrough { No, EmptyConstantString, NonEmptyConstantString }; + + std::string describeChangeKind(ChangeKind kind); + + bool isStringConstant( + Expr const * expr, unsigned * size, bool * nonArray, + ContentKind * content, bool * embeddedNuls, bool * terminatingNul, + std::vector<char32_t> * utf8Content = nullptr); + + bool isZero(Expr const * expr); + + void reportChange( + Expr const * expr, ChangeKind kind, std::string const & original, + std::string const & replacement, PassThrough pass, bool nonArray, + char const * rewriteFrom, char const * rewriteTo); + + void checkEmpty( + CallExpr const * expr, FunctionDecl const * callee, + TreatEmpty treatEmpty, unsigned size, std::string * replacement); + + void handleChar( + CallExpr const * expr, unsigned arg, FunctionDecl const * callee, + std::string const & replacement, TreatEmpty treatEmpty, bool literal, + char const * rewriteFrom = nullptr, char const * rewriteTo = nullptr); + + void handleCharLen( + CallExpr const * expr, unsigned arg1, unsigned arg2, + FunctionDecl const * callee, std::string const & replacement, + TreatEmpty treatEmpty); + + void handleOUStringCtor( + CallExpr const * expr, unsigned arg, FunctionDecl const * callee, + bool explicitFunctionalCastNotation); + + void handleOStringCtor( + CallExpr const * expr, unsigned arg, FunctionDecl const * callee, + bool explicitFunctionalCastNotation); + + void handleOUStringCtor( + Expr const * expr, Expr const * argExpr, FunctionDecl const * callee, + bool explicitFunctionalCastNotation); + + void handleOStringCtor( + Expr const * expr, Expr const * argExpr, FunctionDecl const * callee, + bool explicitFunctionalCastNotation); + + enum class StringKind { Unicode, Char }; + void handleStringCtor( + Expr const * expr, Expr const * argExpr, FunctionDecl const * callee, + bool explicitFunctionalCastNotation, StringKind stringKind); + + void handleFunArgOstring( + CallExpr const * expr, unsigned arg, FunctionDecl const * callee); + + std::stack<QualType> returnTypes_; + std::stack<Expr const *> calls_; +}; + +void StringConstant::run() { + if (compiler.getLangOpts().CPlusPlus + && compiler.getPreprocessor().getIdentifierInfo( + "LIBO_INTERNAL_ONLY")->hasMacroDefinition()) + //TODO: some parts of it are useful for external code, too + { + TraverseDecl(compiler.getASTContext().getTranslationUnitDecl()); + } +} + +bool StringConstant::TraverseCallExpr(CallExpr * expr) { + if (!WalkUpFromCallExpr(expr)) { + return false; + } + calls_.push(expr); + bool bRes = true; + for (auto * e: expr->children()) { + if (!TraverseStmt(e)) { + bRes = false; + break; + } + } + calls_.pop(); + return bRes; +} + +bool StringConstant::TraverseCXXMemberCallExpr(CXXMemberCallExpr * expr) { + if (!WalkUpFromCXXMemberCallExpr(expr)) { + return false; + } + calls_.push(expr); + bool bRes = true; + for (auto * e: expr->children()) { + if (!TraverseStmt(e)) { + bRes = false; + break; + } + } + calls_.pop(); + return bRes; +} + +bool StringConstant::TraverseCXXOperatorCallExpr(CXXOperatorCallExpr * expr) +{ + if (!WalkUpFromCXXOperatorCallExpr(expr)) { + return false; + } + calls_.push(expr); + bool bRes = true; + for (auto * e: expr->children()) { + if (!TraverseStmt(e)) { + bRes = false; + break; + } + } + calls_.pop(); + return bRes; +} + +bool StringConstant::TraverseCXXConstructExpr(CXXConstructExpr * expr) { + if (!WalkUpFromCXXConstructExpr(expr)) { + return false; + } + calls_.push(expr); + bool bRes = true; + for (auto * e: expr->children()) { + if (!TraverseStmt(e)) { + bRes = false; + break; + } + } + calls_.pop(); + return bRes; +} + +bool StringConstant::VisitCallExpr(CallExpr const * expr) { + if (ignoreLocation(expr)) { + return true; + } + FunctionDecl const * fdecl = expr->getDirectCallee(); + if (fdecl == nullptr) { + return true; + } + for (unsigned i = 0; i != fdecl->getNumParams(); ++i) { + auto t = fdecl->getParamDecl(i)->getType(); + if (loplugin::TypeCheck(t).NotSubstTemplateTypeParmType() + .LvalueReference().Const().NotSubstTemplateTypeParmType() + .Class("OUString").Namespace("rtl").GlobalNamespace()) + { + if (!(isLhsOfAssignment(fdecl, i) + || hasOverloads(fdecl, expr->getNumArgs()))) + { + handleOUStringCtor(expr, i, fdecl, true); + } + } + if (loplugin::TypeCheck(t).NotSubstTemplateTypeParmType() + .LvalueReference().Const().NotSubstTemplateTypeParmType() + .Class("OString").Namespace("rtl").GlobalNamespace()) + { + if (!(isLhsOfAssignment(fdecl, i) + || hasOverloads(fdecl, expr->getNumArgs()))) + { + handleOStringCtor(expr, i, fdecl, true); + } + } + } + loplugin::DeclCheck dc(fdecl); + //TODO: u.compareToAscii("foo") -> u.???("foo") + //TODO: u.compareToIgnoreAsciiCaseAscii("foo") -> u.???("foo") + if ((dc.Function("createFromAscii").Class("OUString").Namespace("rtl") + .GlobalNamespace()) + && fdecl->getNumParams() == 1) + { + // OUString::createFromAscii("foo") -> OUString("foo") + handleChar( + expr, 0, fdecl, "rtl::OUString constructor", + TreatEmpty::DefaultCtor, true); + return true; + } + if ((dc.Function("endsWithAsciiL").Class("OUString").Namespace("rtl") + .GlobalNamespace()) + && fdecl->getNumParams() == 2) + { + // u.endsWithAsciiL("foo", 3) -> u.endsWith("foo"): + handleCharLen( + expr, 0, 1, fdecl, "rtl::OUString::endsWith", TreatEmpty::Error); + return true; + } + if ((dc.Function("endsWithIgnoreAsciiCaseAsciiL").Class("OUString") + .Namespace("rtl").GlobalNamespace()) + && fdecl->getNumParams() == 2) + { + // u.endsWithIgnoreAsciiCaseAsciiL("foo", 3) -> + // u.endsWithIgnoreAsciiCase("foo"): + handleCharLen( + expr, 0, 1, fdecl, "rtl::OUString::endsWithIgnoreAsciiCase", + TreatEmpty::Error); + return true; + } + if ((dc.Function("equalsAscii").Class("OUString").Namespace("rtl") + .GlobalNamespace()) + && fdecl->getNumParams() == 1) + { + // u.equalsAscii("foo") -> u == "foo": + handleChar( + expr, 0, fdecl, "operator ==", TreatEmpty::CheckEmpty, false); + return true; + } + if ((dc.Function("equalsAsciiL").Class("OUString").Namespace("rtl") + .GlobalNamespace()) + && fdecl->getNumParams() == 2) + { + // u.equalsAsciiL("foo", 3) -> u == "foo": + handleCharLen(expr, 0, 1, fdecl, "operator ==", TreatEmpty::CheckEmpty); + return true; + } + if ((dc.Function("equalsIgnoreAsciiCaseAscii").Class("OUString") + .Namespace("rtl").GlobalNamespace()) + && fdecl->getNumParams() == 1) + { + // u.equalsIgnoreAsciiCaseAscii("foo") -> + // u.equalsIngoreAsciiCase("foo"): + + auto file = getFilenameOfLocation( + compiler.getSourceManager().getSpellingLoc(compat::getBeginLoc(expr))); + if (loplugin::isSamePathname( + file, SRCDIR "/sal/qa/rtl/strings/test_oustring_compare.cxx")) + { + return true; + } + handleChar( + expr, 0, fdecl, "rtl::OUString::equalsIgnoreAsciiCase", + TreatEmpty::CheckEmpty, false); + return true; + } + if ((dc.Function("equalsIgnoreAsciiCaseAsciiL").Class("OUString") + .Namespace("rtl").GlobalNamespace()) + && fdecl->getNumParams() == 2) + { + // u.equalsIgnoreAsciiCaseAsciiL("foo", 3) -> + // u.equalsIngoreAsciiCase("foo"): + auto file = getFilenameOfLocation( + compiler.getSourceManager().getSpellingLoc(compat::getBeginLoc(expr))); + if (loplugin::isSamePathname( + file, SRCDIR "/sal/qa/rtl/strings/test_oustring_compare.cxx")) + { + return true; + } + handleCharLen( + expr, 0, 1, fdecl, "rtl::OUString::equalsIgnoreAsciiCase", + TreatEmpty::CheckEmpty); + return true; + } + if ((dc.Function("indexOfAsciiL").Class("OUString").Namespace("rtl") + .GlobalNamespace()) + && fdecl->getNumParams() == 3) + { + assert(expr->getNumArgs() == 3); + // u.indexOfAsciiL("foo", 3, i) -> u.indexOf("foo", i): + handleCharLen( + expr, 0, 1, fdecl, "rtl::OUString::indexOf", TreatEmpty::Error); + return true; + } + if ((dc.Function("lastIndexOfAsciiL").Class("OUString").Namespace("rtl") + .GlobalNamespace()) + && fdecl->getNumParams() == 2) + { + // u.lastIndexOfAsciiL("foo", 3) -> u.lastIndexOf("foo"): + handleCharLen( + expr, 0, 1, fdecl, "rtl::OUString::lastIndexOf", TreatEmpty::Error); + return true; + } + if ((dc.Function("matchAsciiL").Class("OUString").Namespace("rtl") + .GlobalNamespace()) + && fdecl->getNumParams() == 3) + { + assert(expr->getNumArgs() == 3); + // u.matchAsciiL("foo", 3, i) -> u.match("foo", i): + handleCharLen( + expr, 0, 1, fdecl, + (isZero(expr->getArg(2)) + ? std::string("rtl::OUString::startsWith") + : std::string("rtl::OUString::match")), + TreatEmpty::Error); + return true; + } + if ((dc.Function("matchIgnoreAsciiCaseAsciiL").Class("OUString") + .Namespace("rtl").GlobalNamespace()) + && fdecl->getNumParams() == 3) + { + assert(expr->getNumArgs() == 3); + // u.matchIgnoreAsciiCaseAsciiL("foo", 3, i) -> + // u.matchIgnoreAsciiCase("foo", i): + handleCharLen( + expr, 0, 1, fdecl, + (isZero(expr->getArg(2)) + ? std::string("rtl::OUString::startsWithIgnoreAsciiCase") + : std::string("rtl::OUString::matchIgnoreAsciiCase")), + TreatEmpty::Error); + return true; + } + if ((dc.Function("reverseCompareToAsciiL").Class("OUString") + .Namespace("rtl").GlobalNamespace()) + && fdecl->getNumParams() == 2) + { + // u.reverseCompareToAsciiL("foo", 3) -> u.reverseCompareTo("foo"): + handleCharLen( + expr, 0, 1, fdecl, "rtl::OUString::reverseCompareTo", + TreatEmpty::Error); + return true; + } + if ((dc.Function("reverseCompareTo").Class("OUString").Namespace("rtl") + .GlobalNamespace()) + && fdecl->getNumParams() == 1) + { + handleOUStringCtor(expr, 0, fdecl, false); + return true; + } + if ((dc.Function("equalsIgnoreAsciiCase").Class("OUString").Namespace("rtl") + .GlobalNamespace()) + && fdecl->getNumParams() == 1) + { + handleOUStringCtor(expr, 0, fdecl, false); + return true; + } + if ((dc.Function("match").Class("OUString").Namespace("rtl") + .GlobalNamespace()) + && fdecl->getNumParams() == 2) + { + handleOUStringCtor(expr, 0, fdecl, false); + return true; + } + if ((dc.Function("matchIgnoreAsciiCase").Class("OUString").Namespace("rtl") + .GlobalNamespace()) + && fdecl->getNumParams() == 2) + { + handleOUStringCtor(expr, 0, fdecl, false); + return true; + } + if ((dc.Function("startsWith").Class("OUString").Namespace("rtl") + .GlobalNamespace()) + && fdecl->getNumParams() == 2) + { + handleOUStringCtor(expr, 0, fdecl, false); + return true; + } + if ((dc.Function("startsWithIgnoreAsciiCase").Class("OUString") + .Namespace("rtl").GlobalNamespace()) + && fdecl->getNumParams() == 2) + { + handleOUStringCtor(expr, 0, fdecl, false); + return true; + } + if ((dc.Function("endsWith").Class("OUString").Namespace("rtl") + .GlobalNamespace()) + && fdecl->getNumParams() == 2) + { + handleOUStringCtor(expr, 0, fdecl, false); + return true; + } + if ((dc.Function("endsWithIgnoreAsciiCase").Class("OUString") + .Namespace("rtl").GlobalNamespace()) + && fdecl->getNumParams() == 2) + { + handleOUStringCtor(expr, 0, fdecl, false); + return true; + } + if ((dc.Function("indexOf").Class("OUString").Namespace("rtl") + .GlobalNamespace()) + && fdecl->getNumParams() == 2) + { + handleOUStringCtor(expr, 0, fdecl, false); + return true; + } + if ((dc.Function("lastIndexOf").Class("OUString").Namespace("rtl") + .GlobalNamespace()) + && fdecl->getNumParams() == 1) + { + handleOUStringCtor(expr, 0, fdecl, false); + return true; + } + if ((dc.Function("replaceFirst").Class("OUString").Namespace("rtl") + .GlobalNamespace()) + && fdecl->getNumParams() == 3) + { + handleOUStringCtor(expr, 0, fdecl, false); + handleOUStringCtor(expr, 1, fdecl, false); + return true; + } + if ((dc.Function("replaceAll").Class("OUString").Namespace("rtl") + .GlobalNamespace()) + && (fdecl->getNumParams() == 2 || fdecl->getNumParams() == 3)) + { + handleOUStringCtor(expr, 0, fdecl, false); + handleOUStringCtor(expr, 1, fdecl, false); + return true; + } + if ((dc.Operator(OO_PlusEqual).Class("OUString").Namespace("rtl") + .GlobalNamespace()) + && fdecl->getNumParams() == 1) + { + handleOUStringCtor( + expr, dyn_cast<CXXOperatorCallExpr>(expr) == nullptr ? 0 : 1, + fdecl, false); + return true; + } + if ((dc.Function("equals").Class("OUString").Namespace("rtl") + .GlobalNamespace()) + && fdecl->getNumParams() == 1) + { + unsigned n; + bool nonArray; + ContentKind cont; + bool emb; + bool trm; + if (!isStringConstant( + expr->getArg(0)->IgnoreParenImpCasts(), &n, &nonArray, &cont, + &emb, &trm)) + { + return true; + } + if (cont != ContentKind::Ascii) { + report( + DiagnosticsEngine::Warning, + ("call of '%0' with string constant argument containing" + " non-ASCII characters"), + expr->getExprLoc()) + << fdecl->getQualifiedNameAsString() << expr->getSourceRange(); + } + if (emb) { + report( + DiagnosticsEngine::Warning, + ("call of '%0' with string constant argument containing" + " embedded NULLs"), + expr->getExprLoc()) + << fdecl->getQualifiedNameAsString() << expr->getSourceRange(); + } + if (n == 0) { + report( + DiagnosticsEngine::Warning, + ("rewrite call of '%0' with empty string constant argument as" + " call of 'rtl::OUString::isEmpty'"), + expr->getExprLoc()) + << fdecl->getQualifiedNameAsString() << expr->getSourceRange(); + return true; + } + } + if (dc.Operator(OO_EqualEqual).Namespace("rtl").GlobalNamespace() + && fdecl->getNumParams() == 2) + { + for (unsigned i = 0; i != 2; ++i) { + unsigned n; + bool nonArray; + ContentKind cont; + bool emb; + bool trm; + if (!isStringConstant( + expr->getArg(i)->IgnoreParenImpCasts(), &n, &nonArray, + &cont, &emb, &trm)) + { + continue; + } + if (cont != ContentKind::Ascii) { + report( + DiagnosticsEngine::Warning, + ("call of '%0' with string constant argument containing" + " non-ASCII characters"), + expr->getExprLoc()) + << fdecl->getQualifiedNameAsString() + << expr->getSourceRange(); + } + if (emb) { + report( + DiagnosticsEngine::Warning, + ("call of '%0' with string constant argument containing" + " embedded NULLs"), + expr->getExprLoc()) + << fdecl->getQualifiedNameAsString() + << expr->getSourceRange(); + } + if (n == 0) { + report( + DiagnosticsEngine::Warning, + ("rewrite call of '%0' with empty string constant argument" + " as call of 'rtl::OUString::isEmpty'"), + expr->getExprLoc()) + << fdecl->getQualifiedNameAsString() + << expr->getSourceRange(); + } + } + return true; + } + if (dc.Operator(OO_ExclaimEqual).Namespace("rtl").GlobalNamespace() + && fdecl->getNumParams() == 2) + { + for (unsigned i = 0; i != 2; ++i) { + unsigned n; + bool nonArray; + ContentKind cont; + bool emb; + bool trm; + if (!isStringConstant( + expr->getArg(i)->IgnoreParenImpCasts(), &n, &nonArray, + &cont, &emb, &trm)) + { + continue; + } + if (cont != ContentKind::Ascii) { + report( + DiagnosticsEngine::Warning, + ("call of '%0' with string constant argument containing" + " non-ASCII characters"), + expr->getExprLoc()) + << fdecl->getQualifiedNameAsString() + << expr->getSourceRange(); + } + if (emb) { + report( + DiagnosticsEngine::Warning, + ("call of '%0' with string constant argument containing" + " embedded NULLs"), + expr->getExprLoc()) + << fdecl->getQualifiedNameAsString() + << expr->getSourceRange(); + } + if (n == 0) { + report( + DiagnosticsEngine::Warning, + ("rewrite call of '%0' with empty string constant argument" + " as call of '!rtl::OUString::isEmpty'"), + expr->getExprLoc()) + << fdecl->getQualifiedNameAsString() + << expr->getSourceRange(); + } + } + return true; + } + if (dc.Operator(OO_Equal).Namespace("rtl").GlobalNamespace() + && fdecl->getNumParams() == 1) + { + unsigned n; + bool nonArray; + ContentKind cont; + bool emb; + bool trm; + if (!isStringConstant( + expr->getArg(1)->IgnoreParenImpCasts(), &n, &nonArray, &cont, + &emb, &trm)) + { + return true; + } + if (cont != ContentKind::Ascii) { + report( + DiagnosticsEngine::Warning, + ("call of '%0' with string constant argument containing" + " non-ASCII characters"), + expr->getExprLoc()) + << fdecl->getQualifiedNameAsString() << expr->getSourceRange(); + } + if (emb) { + report( + DiagnosticsEngine::Warning, + ("call of '%0' with string constant argument containing" + " embedded NULLs"), + expr->getExprLoc()) + << fdecl->getQualifiedNameAsString() << expr->getSourceRange(); + } + if (n == 0) { + report( + DiagnosticsEngine::Warning, + ("rewrite call of '%0' with empty string constant argument as" + " call of 'rtl::OUString::clear'"), + expr->getExprLoc()) + << fdecl->getQualifiedNameAsString() << expr->getSourceRange(); + return true; + } + return true; + } + if (dc.Function("append").Class("OUStringBuffer").Namespace("rtl").GlobalNamespace() + && fdecl->getNumParams() == 1) + { + handleChar(expr, 0, fdecl, "", TreatEmpty::Error, false); + return true; + } + if ((dc.Function("appendAscii").Class("OUStringBuffer").Namespace("rtl") + .GlobalNamespace()) + && fdecl->getNumParams() == 1) + { + // u.appendAscii("foo") -> u.append("foo") + handleChar( + expr, 0, fdecl, "rtl::OUStringBuffer::append", TreatEmpty::Error, + true, "appendAscii", "append"); + return true; + } + if ((dc.Function("appendAscii").Class("OUStringBuffer").Namespace("rtl") + .GlobalNamespace()) + && fdecl->getNumParams() == 2) + { + // u.appendAscii("foo", 3) -> u.append("foo"): + handleCharLen( + expr, 0, 1, fdecl, "rtl::OUStringBuffer::append", + TreatEmpty::Error); + return true; + } + if (dc.Function("append").Class("OStringBuffer").Namespace("rtl") + .GlobalNamespace()) + { + switch (fdecl->getNumParams()) { + case 1: + handleFunArgOstring(expr, 0, fdecl); + break; + case 2: + { + // b.append("foo", 3) -> b.append("foo"): + auto file = getFilenameOfLocation( + compiler.getSourceManager().getSpellingLoc( + compat::getBeginLoc(expr))); + if (loplugin::isSamePathname( + file, + SRCDIR "/sal/qa/OStringBuffer/rtl_OStringBuffer.cxx")) + { + return true; + } + handleCharLen( + expr, 0, 1, fdecl, "rtl::OStringBuffer::append", + TreatEmpty::Error); + } + break; + default: + break; + } + return true; + } + if (dc.Function("insert").Class("OStringBuffer").Namespace("rtl") + .GlobalNamespace()) + { + switch (fdecl->getNumParams()) { + case 2: + handleFunArgOstring(expr, 1, fdecl); + break; + case 3: + { + // b.insert(i, "foo", 3) -> b.insert(i, "foo"): + handleCharLen( + expr, 1, 2, fdecl, "rtl::OStringBuffer::insert", + TreatEmpty::Error); + break; + } + default: + break; + } + return true; + } + return true; +} + +bool StringConstant::VisitCXXConstructExpr(CXXConstructExpr const * expr) { + if (ignoreLocation(expr)) { + return true; + } + auto classdecl = expr->getConstructor()->getParent(); + if (loplugin::DeclCheck(classdecl) + .Class("OUString").Namespace("rtl").GlobalNamespace()) + { + ChangeKind kind; + PassThrough pass; + bool simplify; + switch (expr->getConstructor()->getNumParams()) { + case 1: + if (!loplugin::TypeCheck( + expr->getConstructor()->getParamDecl(0)->getType()) + .Typedef("sal_Unicode").GlobalNamespace()) + { + return true; + } + kind = ChangeKind::SingleChar; + pass = PassThrough::NonEmptyConstantString; + simplify = false; + break; + case 2: + { + auto arg = expr->getArg(0); + if (loplugin::TypeCheck(arg->getType()) + .Class("OUStringChar_").Namespace("rtl") + .GlobalNamespace()) + { + kind = ChangeKind::OUStringChar; + pass = PassThrough::NonEmptyConstantString; + simplify = false; + } else { + unsigned n; + bool nonArray; + ContentKind cont; + bool emb; + bool trm; + if (!isStringConstant( + arg->IgnoreParenImpCasts(), &n, &nonArray, &cont, + &emb, &trm)) + { + return true; + } + // OSL_THIS_FUNC may be defined as "" or as something other + // than a string literal in include/osl/diagnose.h: + auto loc = compat::getBeginLoc(arg); + if (compiler.getSourceManager().isMacroBodyExpansion(loc) + && (Lexer::getImmediateMacroName( + loc, compiler.getSourceManager(), + compiler.getLangOpts()) + == "OSL_THIS_FUNC")) + { + return true; + } + if (cont != ContentKind::Ascii) { + report( + DiagnosticsEngine::Warning, + ("construction of %0 with string constant argument" + " containing non-ASCII characters"), + expr->getExprLoc()) + << classdecl << expr->getSourceRange(); + } + if (emb) { + report( + DiagnosticsEngine::Warning, + ("construction of %0 with string constant argument" + " containing embedded NULLs"), + expr->getExprLoc()) + << classdecl << expr->getSourceRange(); + } + kind = ChangeKind::Char; + pass = n == 0 + ? PassThrough::EmptyConstantString + : PassThrough::NonEmptyConstantString; + simplify = false; + } + break; + } + case 4: + { + unsigned n; + bool nonArray; + ContentKind cont; + bool emb; + bool trm; + std::vector<char32_t> utf8Cont; + if (!isStringConstant( + expr->getArg(0)->IgnoreParenImpCasts(), &n, &nonArray, + &cont, &emb, &trm, &utf8Cont)) + { + return true; + } + APSInt res; + if (!compat::EvaluateAsInt(expr->getArg(1), + res, compiler.getASTContext())) + { + return true; + } + if (res != n) { + report( + DiagnosticsEngine::Warning, + ("suspicious 'rtl::OUString' constructor with literal" + " of length %0 and non-matching length argument %1"), + expr->getExprLoc()) + << n << res.toString(10) << expr->getSourceRange(); + return true; + } + APSInt enc; + if (!compat::EvaluateAsInt(expr->getArg(2), + enc, compiler.getASTContext())) + { + return true; + } + auto const encIsAscii = enc == 11; // RTL_TEXTENCODING_ASCII_US + auto const encIsUtf8 = enc == 76; // RTL_TEXTENCODING_UTF8 + if (!compat::EvaluateAsInt(expr->getArg(3), + res, compiler.getASTContext()) + || res != 0x333) // OSTRING_TO_OUSTRING_CVTFLAGS + { + return true; + } + if (!encIsAscii && cont == ContentKind::Ascii) { + report( + DiagnosticsEngine::Warning, + ("suspicious 'rtl::OUString' constructor with text" + " encoding %0 but plain ASCII content; use" + " 'RTL_TEXTENCODING_ASCII_US' instead"), + expr->getArg(2)->getExprLoc()) + << enc.toString(10) << expr->getSourceRange(); + return true; + } + if (encIsUtf8) { + if (cont == ContentKind::Arbitrary) { + report( + DiagnosticsEngine::Warning, + ("suspicious 'rtl::OUString' constructor with text" + " encoding 'RTL_TEXTENCODING_UTF8' but non-UTF-8" + " content"), + expr->getArg(0)->getExprLoc()) + << expr->getSourceRange(); + } else { + assert(cont == ContentKind::Utf8); + //TODO: keep original content as much as possible + std::ostringstream s; + for (auto const c: utf8Cont) { + if (c == '\\') { + s << "\\\\"; + } else if (c == '"') { + s << "\\\""; + } else if (c == '\a') { + s << "\\a"; + } else if (c == '\b') { + s << "\\b"; + } else if (c == '\f') { + s << "\\f"; + } else if (c == '\n') { + s << "\\n"; + } else if (c == '\r') { + s << "\\r"; + } else if (c == '\t') { + s << "\\r"; + } else if (c == '\v') { + s << "\\v"; + } else if (c <= 0x1F || c == 0x7F) { + s << "\\x" << std::oct << std::setw(3) + << std::setfill('0') + << static_cast<std::uint_least32_t>(c); + } else if (c < 0x7F) { + s << char(c); + } else if (c <= 0xFFFF) { + s << "\\u" << std::hex << std::uppercase + << std::setw(4) << std::setfill('0') + << static_cast<std::uint_least32_t>(c); + } else { + assert(c <= 0x10FFFF); + s << "\\U" << std::hex << std::uppercase + << std::setw(8) << std::setfill('0') + << static_cast<std::uint_least32_t>(c); + } + } + report( + DiagnosticsEngine::Warning, + ("simplify construction of %0 with UTF-8 content as" + " OUString(u\"%1\")"), + expr->getExprLoc()) + << classdecl << s.str() << expr->getSourceRange(); + + } + return true; + } + if (cont != ContentKind::Ascii || emb) { + // cf. remaining uses of RTL_CONSTASCII_USTRINGPARAM + return true; + } + kind = ChangeKind::Char; + pass = n == 0 + ? PassThrough::EmptyConstantString + : PassThrough::NonEmptyConstantString; + simplify = true; + break; + } + default: + return true; + } + if (!calls_.empty()) { + Expr const * call = calls_.top(); + CallExpr::const_arg_iterator argsBeg; + CallExpr::const_arg_iterator argsEnd; + if (isa<CallExpr>(call)) { + argsBeg = cast<CallExpr>(call)->arg_begin(); + argsEnd = cast<CallExpr>(call)->arg_end(); + } else if (isa<CXXConstructExpr>(call)) { + argsBeg = cast<CXXConstructExpr>(call)->arg_begin(); + argsEnd = cast<CXXConstructExpr>(call)->arg_end(); + } else { + assert(false); + } + for (auto i(argsBeg); i != argsEnd; ++i) { + Expr const * e = (*i)->IgnoreParenImpCasts(); + if (isa<MaterializeTemporaryExpr>(e)) { + e = compat::getSubExpr(cast<MaterializeTemporaryExpr>(e)) + ->IgnoreParenImpCasts(); + } + if (isa<CXXFunctionalCastExpr>(e)) { + e = cast<CXXFunctionalCastExpr>(e)->getSubExpr() + ->IgnoreParenImpCasts(); + } + if (isa<CXXBindTemporaryExpr>(e)) { + e = cast<CXXBindTemporaryExpr>(e)->getSubExpr() + ->IgnoreParenImpCasts(); + } + if (e == expr) { + if (isa<CallExpr>(call)) { + FunctionDecl const * fdecl + = cast<CallExpr>(call)->getDirectCallee(); + if (fdecl == nullptr) { + break; + } + loplugin::DeclCheck dc(fdecl); + if (pass == PassThrough::EmptyConstantString) { + if ((dc.Function("equals").Class("OUString") + .Namespace("rtl").GlobalNamespace()) + || (dc.Operator(OO_EqualEqual).Namespace("rtl") + .GlobalNamespace())) + { + report( + DiagnosticsEngine::Warning, + ("rewrite call of '%0' with construction of" + " %1 with empty string constant argument" + " as call of 'rtl::OUString::isEmpty'"), + getMemberLocation(call)) + << fdecl->getQualifiedNameAsString() + << classdecl << call->getSourceRange(); + return true; + } + if (dc.Operator(OO_ExclaimEqual).Namespace("rtl") + .GlobalNamespace()) + { + report( + DiagnosticsEngine::Warning, + ("rewrite call of '%0' with construction of" + " %1 with empty string constant argument" + " as call of '!rtl::OUString::isEmpty'"), + getMemberLocation(call)) + << fdecl->getQualifiedNameAsString() + << classdecl << call->getSourceRange(); + return true; + } + if ((dc.Operator(OO_Plus).Namespace("rtl") + .GlobalNamespace()) + || (dc.Operator(OO_Plus).Class("OUString") + .Namespace("rtl").GlobalNamespace())) + { + report( + DiagnosticsEngine::Warning, + ("call of '%0' with suspicious construction" + " of %1 with empty string constant" + " argument"), + getMemberLocation(call)) + << fdecl->getQualifiedNameAsString() + << classdecl << call->getSourceRange(); + return true; + } + if (dc.Operator(OO_Equal).Class("OUString") + .Namespace("rtl").GlobalNamespace()) + { + report( + DiagnosticsEngine::Warning, + ("rewrite call of '%0' with construction of" + " %1 with empty string constant argument" + " as call of 'rtl::OUString::clear'"), + getMemberLocation(call)) + << fdecl->getQualifiedNameAsString() + << classdecl << call->getSourceRange(); + return true; + } + } else { + assert(pass == PassThrough::NonEmptyConstantString); + if (dc.Function("equals").Class("OUString") + .Namespace("rtl").GlobalNamespace()) + { + report( + DiagnosticsEngine::Warning, + ("rewrite call of '%0' with construction of" + " %1 with %2 as 'operator =='"), + getMemberLocation(call)) + << fdecl->getQualifiedNameAsString() + << classdecl << describeChangeKind(kind) + << call->getSourceRange(); + return true; + } + if ((dc.Operator(OO_Plus).Namespace("rtl") + .GlobalNamespace()) + || (dc.Operator(OO_Plus).Class("OUString") + .Namespace("rtl").GlobalNamespace()) + || (dc.Operator(OO_EqualEqual).Namespace("rtl") + .GlobalNamespace()) + || (dc.Operator(OO_ExclaimEqual) + .Namespace("rtl").GlobalNamespace())) + { + if (dc.Operator(OO_Plus).Namespace("rtl") + .GlobalNamespace()) + { + auto file = getFilenameOfLocation( + compiler.getSourceManager() + .getSpellingLoc( + compat::getBeginLoc(expr))); + if (loplugin::isSamePathname( + file, + (SRCDIR + "/sal/qa/rtl/strings/test_ostring_concat.cxx")) + || loplugin::isSamePathname( + file, + (SRCDIR + "/sal/qa/rtl/strings/test_oustring_concat.cxx"))) + { + return true; + } + } + auto loc = compat::getBeginLoc(expr->getArg(0)); + while (compiler.getSourceManager() + .isMacroArgExpansion(loc)) + { + loc = compiler.getSourceManager() + .getImmediateMacroCallerLoc(loc); + } + if ((compiler.getSourceManager() + .isMacroBodyExpansion(loc)) + && (Lexer::getImmediateMacroName( + loc, compiler.getSourceManager(), + compiler.getLangOpts()) + == "OSL_THIS_FUNC")) + { + return true; + } + if (kind == ChangeKind::SingleChar) { + report( + DiagnosticsEngine::Warning, + ("rewrite construction of %0 with %1 in" + " call of '%2' as construction of" + " 'OUStringChar'"), + getMemberLocation(expr)) + << classdecl << describeChangeKind(kind) + << fdecl->getQualifiedNameAsString() + << expr->getSourceRange(); + } else { + report( + DiagnosticsEngine::Warning, + ("elide construction of %0 with %1 in" + " call of '%2'"), + getMemberLocation(expr)) + << classdecl << describeChangeKind(kind) + << fdecl->getQualifiedNameAsString() + << expr->getSourceRange(); + } + return true; + } + } + } else if (isa<CXXConstructExpr>(call)) { + } else { + assert(false); + } + } + } + } + if (simplify) { + report( + DiagnosticsEngine::Warning, + "simplify construction of %0 with %1", expr->getExprLoc()) + << classdecl << describeChangeKind(kind) + << expr->getSourceRange(); + } + return true; + } + + auto consDecl = expr->getConstructor(); + for (unsigned i = 0; i != consDecl->getNumParams(); ++i) { + auto t = consDecl->getParamDecl(i)->getType(); + if (loplugin::TypeCheck(t).NotSubstTemplateTypeParmType() + .LvalueReference().Const().NotSubstTemplateTypeParmType() + .Class("OUString").Namespace("rtl").GlobalNamespace()) + { + auto argExpr = expr->getArg(i); + if (argExpr && i <= consDecl->getNumParams()) + { + if (!hasOverloads(consDecl, expr->getNumArgs())) + { + handleOUStringCtor(expr, argExpr, consDecl, true); + } + } + } + if (loplugin::TypeCheck(t).NotSubstTemplateTypeParmType() + .LvalueReference().Const().NotSubstTemplateTypeParmType() + .Class("OString").Namespace("rtl").GlobalNamespace()) + { + auto argExpr = expr->getArg(i); + if (argExpr && i <= consDecl->getNumParams()) + { + if (!hasOverloads(consDecl, expr->getNumArgs())) + { + handleOStringCtor(expr, argExpr, consDecl, true); + } + } + } + } + + return true; +} + +bool StringConstant::VisitReturnStmt(ReturnStmt const * stmt) { + if (ignoreLocation(stmt)) { + return true; + } + auto const e1 = stmt->getRetValue(); + if (e1 == nullptr) { + return true; + } + auto const tc1 = loplugin::TypeCheck(e1->getType().getTypePtr()); + if (!(tc1.Class("OString").Namespace("rtl").GlobalNamespace() + || tc1.Class("OUString").Namespace("rtl").GlobalNamespace())) + { + return true; + } + assert(!returnTypes_.empty()); + auto const tc2 = loplugin::TypeCheck(returnTypes_.top().getTypePtr()); + if (!(tc2.Class("OString").Namespace("rtl").GlobalNamespace() + || tc2.Class("OUString").Namespace("rtl").GlobalNamespace())) + { + return true; + } + auto const e2 = dyn_cast<CXXFunctionalCastExpr>(e1->IgnoreImplicit()); + if (e2 == nullptr) { + return true; + } + auto const e3 = dyn_cast<CXXBindTemporaryExpr>(e2->getSubExpr()); + if (e3 == nullptr) { + return true; + } + auto const e4 = dyn_cast<CXXConstructExpr>(e3->getSubExpr()); + if (e4 == nullptr) { + return true; + } + if (e4->getNumArgs() != 2) { + return true; + } + auto const e5 = e4->getArg(1); + if (!(isa<CXXDefaultArgExpr>(e5) + && (loplugin::TypeCheck(e5->getType()).Struct("Dummy").Namespace("libreoffice_internal") + .Namespace("rtl").GlobalNamespace()))) + { + return true; + } + report(DiagnosticsEngine::Warning, "elide constructor call", compat::getBeginLoc(e1)) + << e1->getSourceRange(); + return true; +} + +std::string StringConstant::describeChangeKind(ChangeKind kind) { + switch (kind) { + case ChangeKind::Char: + return "string constant argument"; + case ChangeKind::CharLen: + return "string constant and matching length arguments"; + case ChangeKind::SingleChar: + return "sal_Unicode argument"; + case ChangeKind::OUStringChar: + return "OUStringChar argument"; + } + llvm_unreachable("unknown change kind"); +} + +bool StringConstant::isStringConstant( + Expr const * expr, unsigned * size, bool * nonArray, ContentKind * content, + bool * embeddedNuls, bool * terminatingNul, + std::vector<char32_t> * utf8Content) +{ + assert(expr != nullptr); + assert(size != nullptr); + assert(nonArray != nullptr); + assert(content != nullptr); + assert(embeddedNuls != nullptr); + assert(terminatingNul != nullptr); + QualType t = expr->getType(); + // Look inside RTL_CONSTASCII_STRINGPARAM: + if (loplugin::TypeCheck(t).Pointer().Const().Char()) { + auto e2 = dyn_cast<UnaryOperator>(expr); + if (e2 != nullptr && e2->getOpcode() == UO_AddrOf) { + auto e3 = dyn_cast<ArraySubscriptExpr>( + e2->getSubExpr()->IgnoreParenImpCasts()); + if (e3 == nullptr || !isZero(e3->getIdx()->IgnoreParenImpCasts())) { + return false; + } + expr = e3->getBase()->IgnoreParenImpCasts(); + t = expr->getType(); + } + } + if (!t.isConstQualified()) { + return false; + } + DeclRefExpr const * dre = dyn_cast<DeclRefExpr>(expr); + if (dre != nullptr) { + VarDecl const * var = dyn_cast<VarDecl>(dre->getDecl()); + if (var != nullptr) { + Expr const * init = var->getAnyInitializer(); + if (init != nullptr) { + expr = init->IgnoreParenImpCasts(); + } + } + } + bool isPtr; + if (loplugin::TypeCheck(t).Pointer().Const().Char()) { + isPtr = true; + } else if (t->isConstantArrayType() + && (loplugin::TypeCheck( + t->getAsArrayTypeUnsafe()->getElementType()) + .Char())) + { + isPtr = false; + } else { + return false; + } + clang::StringLiteral const * lit = dyn_cast<clang::StringLiteral>(expr); + if (lit != nullptr) { + if (!(lit->isAscii() || lit->isUTF8())) { + return false; + } + unsigned n = lit->getLength(); + ContentKind cont = ContentKind::Ascii; + bool emb = false; + char32_t val = 0; + enum class Utf8State { Start, E0, EB, F0, F4, Trail1, Trail2, Trail3 }; + Utf8State s = Utf8State::Start; + StringRef str = lit->getString(); + for (unsigned i = 0; i != n; ++i) { + auto const c = static_cast<unsigned char>(str[i]); + if (c == '\0') { + emb = true; + } + switch (s) { + case Utf8State::Start: + if (c >= 0x80) { + if (c >= 0xC2 && c <= 0xDF) { + val = c & 0x1F; + s = Utf8State::Trail1; + } else if (c == 0xE0) { + val = c & 0x0F; + s = Utf8State::E0; + } else if ((c >= 0xE1 && c <= 0xEA) + || (c >= 0xEE && c <= 0xEF)) + { + val = c & 0x0F; + s = Utf8State::Trail2; + } else if (c == 0xEB) { + val = c & 0x0F; + s = Utf8State::EB; + } else if (c == 0xF0) { + val = c & 0x03; + s = Utf8State::F0; + } else if (c >= 0xF1 && c <= 0xF3) { + val = c & 0x03; + s = Utf8State::Trail3; + } else if (c == 0xF4) { + val = c & 0x03; + s = Utf8State::F4; + } else { + cont = ContentKind::Arbitrary; + } + } else if (utf8Content != nullptr + && cont != ContentKind::Arbitrary) + { + utf8Content->push_back(c); + } + break; + case Utf8State::E0: + if (c >= 0xA0 && c <= 0xBF) { + val = (val << 6) | (c & 0x3F); + s = Utf8State::Trail1; + } else { + cont = ContentKind::Arbitrary; + s = Utf8State::Start; + } + break; + case Utf8State::EB: + if (c >= 0x80 && c <= 0x9F) { + val = (val << 6) | (c & 0x3F); + s = Utf8State::Trail1; + } else { + cont = ContentKind::Arbitrary; + s = Utf8State::Start; + } + break; + case Utf8State::F0: + if (c >= 0x90 && c <= 0xBF) { + val = (val << 6) | (c & 0x3F); + s = Utf8State::Trail2; + } else { + cont = ContentKind::Arbitrary; + s = Utf8State::Start; + } + break; + case Utf8State::F4: + if (c >= 0x80 && c <= 0x8F) { + val = (val << 6) | (c & 0x3F); + s = Utf8State::Trail2; + } else { + cont = ContentKind::Arbitrary; + s = Utf8State::Start; + } + break; + case Utf8State::Trail1: + if (c >= 0x80 && c <= 0xBF) { + cont = ContentKind::Utf8; + if (utf8Content != nullptr) + { + utf8Content->push_back((val << 6) | (c & 0x3F)); + val = 0; + } + } else { + cont = ContentKind::Arbitrary; + } + s = Utf8State::Start; + break; + case Utf8State::Trail2: + if (c >= 0x80 && c <= 0xBF) { + val = (val << 6) | (c & 0x3F); + s = Utf8State::Trail1; + } else { + cont = ContentKind::Arbitrary; + s = Utf8State::Start; + } + break; + case Utf8State::Trail3: + if (c >= 0x80 && c <= 0xBF) { + val = (val << 6) | (c & 0x3F); + s = Utf8State::Trail2; + } else { + cont = ContentKind::Arbitrary; + s = Utf8State::Start; + } + break; + } + } + *size = n; + *nonArray = isPtr; + *content = cont; + *embeddedNuls = emb; + *terminatingNul = true; + return true; + } + APValue v; + if (!expr->isCXX11ConstantExpr(compiler.getASTContext(), &v)) { + return false; + } + switch (v.getKind()) { + case APValue::LValue: + { + Expr const * e = v.getLValueBase().dyn_cast<Expr const *>(); + if (e == nullptr) { + return false; + } + if (!v.getLValueOffset().isZero()) { + return false; //TODO + } + Expr const * e2 = e->IgnoreParenImpCasts(); + if (e2 != e) { + return isStringConstant( + e2, size, nonArray, content, embeddedNuls, terminatingNul); + } + //TODO: string literals are represented as recursive LValues??? + llvm::APInt n + = compiler.getASTContext().getAsConstantArrayType(t)->getSize(); + assert(n != 0); + --n; + assert(n.ule(std::numeric_limits<unsigned>::max())); + *size = static_cast<unsigned>(n.getLimitedValue()); + *nonArray = isPtr || *nonArray; + *content = ContentKind::Ascii; //TODO + *embeddedNuls = false; //TODO + *terminatingNul = true; + return true; + } + case APValue::Array: + { + if (v.hasArrayFiller()) { //TODO: handle final NULL filler? + return false; + } + unsigned n = v.getArraySize(); + assert(n != 0); + ContentKind cont = ContentKind::Ascii; + bool emb = false; + //TODO: check for ContentType::Utf8 + for (unsigned i = 0; i != n - 1; ++i) { + APValue e(v.getArrayInitializedElt(i)); + if (!e.isInt()) { //TODO: assert? + return false; + } + APSInt iv = e.getInt(); + if (iv == 0) { + emb = true; + } else if (iv.uge(0x80)) { + cont = ContentKind::Arbitrary; + } + } + APValue e(v.getArrayInitializedElt(n - 1)); + if (!e.isInt()) { //TODO: assert? + return false; + } + bool trm = e.getInt() == 0; + *size = trm ? n - 1 : n; + *nonArray = isPtr; + *content = cont; + *embeddedNuls = emb; + *terminatingNul = trm; + return true; + } + default: + assert(false); //TODO??? + return false; + } +} + +bool StringConstant::isZero(Expr const * expr) { + APSInt res; + return compat::EvaluateAsInt(expr, res, compiler.getASTContext()) && res == 0; +} + +void StringConstant::reportChange( + Expr const * expr, ChangeKind kind, std::string const & original, + std::string const & replacement, PassThrough pass, bool nonArray, + char const * rewriteFrom, char const * rewriteTo) +{ + assert((rewriteFrom == nullptr) == (rewriteTo == nullptr)); + if (pass != PassThrough::No && !calls_.empty()) { + Expr const * call = calls_.top(); + CallExpr::const_arg_iterator argsBeg; + CallExpr::const_arg_iterator argsEnd; + if (isa<CallExpr>(call)) { + argsBeg = cast<CallExpr>(call)->arg_begin(); + argsEnd = cast<CallExpr>(call)->arg_end(); + } else if (isa<CXXConstructExpr>(call)) { + argsBeg = cast<CXXConstructExpr>(call)->arg_begin(); + argsEnd = cast<CXXConstructExpr>(call)->arg_end(); + } else { + assert(false); + } + for (auto i(argsBeg); i != argsEnd; ++i) { + Expr const * e = (*i)->IgnoreParenImpCasts(); + if (isa<CXXBindTemporaryExpr>(e)) { + e = cast<CXXBindTemporaryExpr>(e)->getSubExpr() + ->IgnoreParenImpCasts(); + } + if (e == expr) { + if (isa<CallExpr>(call)) { + FunctionDecl const * fdecl + = cast<CallExpr>(call)->getDirectCallee(); + if (fdecl == nullptr) { + break; + } + loplugin::DeclCheck dc(fdecl); + if (pass == PassThrough::EmptyConstantString) { + if ((dc.Function("equals").Class("OUString") + .Namespace("rtl").GlobalNamespace()) + || (dc.Operator(OO_EqualEqual).Namespace("rtl") + .GlobalNamespace())) + { + report( + DiagnosticsEngine::Warning, + ("rewrite call of '%0' with call of %1 with" + " empty string constant argument as call of" + " 'rtl::OUString::isEmpty'"), + getMemberLocation(call)) + << fdecl->getQualifiedNameAsString() << original + << call->getSourceRange(); + return; + } + if (dc.Operator(OO_ExclaimEqual).Namespace("rtl") + .GlobalNamespace()) + { + report( + DiagnosticsEngine::Warning, + ("rewrite call of '%0' with call of %1 with" + " empty string constant argument as call of" + " '!rtl::OUString::isEmpty'"), + getMemberLocation(call)) + << fdecl->getQualifiedNameAsString() << original + << call->getSourceRange(); + return; + } + if ((dc.Operator(OO_Plus).Namespace("rtl") + .GlobalNamespace()) + || (dc.Operator(OO_Plus).Class("OUString") + .Namespace("rtl").GlobalNamespace())) + { + report( + DiagnosticsEngine::Warning, + ("call of '%0' with suspicious call of %1 with" + " empty string constant argument"), + getMemberLocation(call)) + << fdecl->getQualifiedNameAsString() << original + << call->getSourceRange(); + return; + } + if (dc.Operator(OO_Equal).Class("OUString") + .Namespace("rtl").GlobalNamespace()) + { + report( + DiagnosticsEngine::Warning, + ("rewrite call of '%0' with call of %1 with" + " empty string constant argument as call of" + " rtl::OUString::call"), + getMemberLocation(call)) + << fdecl->getQualifiedNameAsString() << original + << call->getSourceRange(); + return; + } + report( + DiagnosticsEngine::Warning, + "TODO call inside %0", getMemberLocation(expr)) + << fdecl->getQualifiedNameAsString() + << expr->getSourceRange(); + return; + } else { + assert(pass == PassThrough::NonEmptyConstantString); + if ((dc.Function("equals").Class("OUString") + .Namespace("rtl").GlobalNamespace()) + || (dc.Operator(OO_Equal).Class("OUString") + .Namespace("rtl").GlobalNamespace()) + || (dc.Operator(OO_EqualEqual).Namespace("rtl") + .GlobalNamespace()) + || (dc.Operator(OO_ExclaimEqual).Namespace("rtl") + .GlobalNamespace())) + { + report( + DiagnosticsEngine::Warning, + "elide call of %0 with %1 in call of '%2'", + getMemberLocation(expr)) + << original << describeChangeKind(kind) + << fdecl->getQualifiedNameAsString() + << expr->getSourceRange(); + return; + } + report( + DiagnosticsEngine::Warning, + ("rewrite call of %0 with %1 in call of '%2' as" + " (implicit) construction of 'OUString'"), + getMemberLocation(expr)) + << original << describeChangeKind(kind) + << fdecl->getQualifiedNameAsString() + << expr->getSourceRange(); + return; + } + } else if (isa<CXXConstructExpr>(call)) { + auto classdecl = cast<CXXConstructExpr>(call) + ->getConstructor()->getParent(); + loplugin::DeclCheck dc(classdecl); + if (dc.Class("OUString").Namespace("rtl").GlobalNamespace() + || (dc.Class("OUStringBuffer").Namespace("rtl") + .GlobalNamespace())) + { + //TODO: propagate further out? + if (pass == PassThrough::EmptyConstantString) { + report( + DiagnosticsEngine::Warning, + ("rewrite construction of %0 with call of %1" + " with empty string constant argument as" + " default construction of %0"), + getMemberLocation(call)) + << classdecl << original + << call->getSourceRange(); + } else { + assert(pass == PassThrough::NonEmptyConstantString); + report( + DiagnosticsEngine::Warning, + ("elide call of %0 with %1 in construction of" + " %2"), + getMemberLocation(expr)) + << original << describeChangeKind(kind) + << classdecl << expr->getSourceRange(); + } + return; + } + } else { + assert(false); + } + } + } + } + if (rewriter != nullptr && !nonArray && rewriteFrom != nullptr) { + SourceLocation loc = getMemberLocation(expr); + while (compiler.getSourceManager().isMacroArgExpansion(loc)) { + loc = compiler.getSourceManager().getImmediateMacroCallerLoc(loc); + } + if (compiler.getSourceManager().isMacroBodyExpansion(loc)) { + loc = compiler.getSourceManager().getSpellingLoc(loc); + } + unsigned n = Lexer::MeasureTokenLength( + loc, compiler.getSourceManager(), compiler.getLangOpts()); + if ((std::string(compiler.getSourceManager().getCharacterData(loc), n) + == rewriteFrom) + && replaceText(loc, n, rewriteTo)) + { + return; + } + } + report( + DiagnosticsEngine::Warning, + "rewrite call of '%0' with %1 as call of '%2'%3", + getMemberLocation(expr)) + << original << describeChangeKind(kind) << replacement + << adviseNonArray(nonArray) << expr->getSourceRange(); +} + +void StringConstant::checkEmpty( + CallExpr const * expr, FunctionDecl const * callee, TreatEmpty treatEmpty, + unsigned size, std::string * replacement) +{ + assert(replacement != nullptr); + if (size == 0) { + switch (treatEmpty) { + case TreatEmpty::DefaultCtor: + *replacement = "rtl::OUString default constructor"; + break; + case TreatEmpty::CheckEmpty: + *replacement = "rtl::OUString::isEmpty"; + break; + case TreatEmpty::Error: + report( + DiagnosticsEngine::Warning, + "call of '%0' with suspicious empty string constant argument", + getMemberLocation(expr)) + << callee->getQualifiedNameAsString() << expr->getSourceRange(); + break; + } + } +} + +void StringConstant::handleChar( + CallExpr const * expr, unsigned arg, FunctionDecl const * callee, + std::string const & replacement, TreatEmpty treatEmpty, bool literal, + char const * rewriteFrom, char const * rewriteTo) +{ + unsigned n; + bool nonArray; + ContentKind cont; + bool emb; + bool trm; + if (!isStringConstant( + expr->getArg(arg)->IgnoreParenImpCasts(), &n, &nonArray, &cont, + &emb, &trm)) + { + return; + } + if (cont != ContentKind::Ascii) { + report( + DiagnosticsEngine::Warning, + ("call of '%0' with string constant argument containing non-ASCII" + " characters"), + getMemberLocation(expr)) + << callee->getQualifiedNameAsString() << expr->getSourceRange(); + return; + } + if (emb) { + report( + DiagnosticsEngine::Warning, + ("call of '%0' with string constant argument containing embedded" + " NULLs"), + getMemberLocation(expr)) + << callee->getQualifiedNameAsString() << expr->getSourceRange(); + return; + } + if (!trm) { + report( + DiagnosticsEngine::Warning, + ("call of '%0' with string constant argument lacking a terminating" + " NULL"), + getMemberLocation(expr)) + << callee->getQualifiedNameAsString() << expr->getSourceRange(); + return; + } + std::string repl(replacement); + checkEmpty(expr, callee, treatEmpty, n, &repl); + if (!repl.empty()) { + reportChange( + expr, ChangeKind::Char, callee->getQualifiedNameAsString(), repl, + (literal + ? (n == 0 + ? PassThrough::EmptyConstantString + : PassThrough::NonEmptyConstantString) + : PassThrough::No), + nonArray, rewriteFrom, rewriteTo); + } +} + +void StringConstant::handleCharLen( + CallExpr const * expr, unsigned arg1, unsigned arg2, + FunctionDecl const * callee, std::string const & replacement, + TreatEmpty treatEmpty) +{ + // Especially for f(RTL_CONSTASCII_STRINGPARAM("foo")), where + // RTL_CONSTASCII_STRINGPARAM expands to complicated expressions involving + // (&(X)[0] sub-expressions (and it might or might not be better to handle + // that at the level of non-expanded macros instead, but I have not found + // out how to do that yet anyway): + unsigned n; + bool nonArray; + ContentKind cont; + bool emb; + bool trm; + if (!(isStringConstant( + expr->getArg(arg1)->IgnoreParenImpCasts(), &n, &nonArray, &cont, + &emb, &trm) + && trm)) + { + return; + } + APSInt res; + if (compat::EvaluateAsInt(expr->getArg(arg2), res, compiler.getASTContext())) { + if (res != n) { + return; + } + } else { + UnaryOperator const * op = dyn_cast<UnaryOperator>( + expr->getArg(arg1)->IgnoreParenImpCasts()); + if (op == nullptr || op->getOpcode() != UO_AddrOf) { + return; + } + ArraySubscriptExpr const * subs = dyn_cast<ArraySubscriptExpr>( + op->getSubExpr()->IgnoreParenImpCasts()); + if (subs == nullptr) { + return; + } + unsigned n2; + bool nonArray2; + ContentKind cont2; + bool emb2; + bool trm2; + if (!(isStringConstant( + subs->getBase()->IgnoreParenImpCasts(), &n2, &nonArray2, + &cont2, &emb2, &trm2) + && n2 == n && cont2 == cont && emb2 == emb && trm2 == trm + //TODO: same strings + && compat::EvaluateAsInt(subs->getIdx(), res, compiler.getASTContext()) + && res == 0)) + { + return; + } + } + if (cont != ContentKind::Ascii) { + report( + DiagnosticsEngine::Warning, + ("call of '%0' with string constant argument containing non-ASCII" + " characters"), + getMemberLocation(expr)) + << callee->getQualifiedNameAsString() << expr->getSourceRange(); + } + if (emb) { + return; + } + std::string repl(replacement); + checkEmpty(expr, callee, treatEmpty, n, &repl); + reportChange( + expr, ChangeKind::CharLen, callee->getQualifiedNameAsString(), repl, + PassThrough::No, nonArray, nullptr, nullptr); +} + +void StringConstant::handleOUStringCtor( + CallExpr const * expr, unsigned arg, FunctionDecl const * callee, + bool explicitFunctionalCastNotation) +{ + handleOUStringCtor(expr, expr->getArg(arg), callee, explicitFunctionalCastNotation); +} + +void StringConstant::handleOStringCtor( + CallExpr const * expr, unsigned arg, FunctionDecl const * callee, + bool explicitFunctionalCastNotation) +{ + handleOStringCtor(expr, expr->getArg(arg), callee, explicitFunctionalCastNotation); +} + +void StringConstant::handleOUStringCtor( + Expr const * expr, Expr const * argExpr, FunctionDecl const * callee, + bool explicitFunctionalCastNotation) +{ + handleStringCtor(expr, argExpr, callee, explicitFunctionalCastNotation, StringKind::Unicode); +} + +void StringConstant::handleOStringCtor( + Expr const * expr, Expr const * argExpr, FunctionDecl const * callee, + bool explicitFunctionalCastNotation) +{ + handleStringCtor(expr, argExpr, callee, explicitFunctionalCastNotation, StringKind::Char); +} + +void StringConstant::handleStringCtor( + Expr const * expr, Expr const * argExpr, FunctionDecl const * callee, + bool explicitFunctionalCastNotation, StringKind stringKind) +{ + auto e0 = argExpr->IgnoreParenImpCasts(); + auto e1 = dyn_cast<CXXFunctionalCastExpr>(e0); + if (e1 == nullptr) { + if (explicitFunctionalCastNotation) { + return; + } + } else { + e0 = e1->getSubExpr()->IgnoreParenImpCasts(); + } + auto e2 = dyn_cast<CXXBindTemporaryExpr>(e0); + if (e2 == nullptr) { + return; + } + auto e3 = dyn_cast<CXXConstructExpr>( + e2->getSubExpr()->IgnoreParenImpCasts()); + if (e3 == nullptr) { + return; + } + if (!loplugin::DeclCheck(e3->getConstructor()).MemberFunction() + .Class(stringKind == StringKind::Unicode ? "OUString" : "OString").Namespace("rtl").GlobalNamespace()) + { + return; + } + if (e3->getNumArgs() == 0) { + report( + DiagnosticsEngine::Warning, + ("in call of '%0', replace default-constructed 'OUString' with an" + " empty string literal"), + e3->getExprLoc()) + << callee->getQualifiedNameAsString() << expr->getSourceRange(); + return; + } + if (e3->getNumArgs() == 1 + && e3->getConstructor()->getNumParams() == 1 + && (loplugin::TypeCheck( + e3->getConstructor()->getParamDecl(0)->getType()) + .Typedef(stringKind == StringKind::Unicode ? "sal_Unicode" : "char").GlobalNamespace())) + { + // It may not be easy to rewrite OUString(c), esp. given there is no + // OUString ctor taking an OUStringChar arg, so don't warn there: + if (!explicitFunctionalCastNotation) { + report( + DiagnosticsEngine::Warning, + ("in call of '%0', replace 'OUString' constructed from a" + " 'sal_Unicode' with an 'OUStringChar'"), + e3->getExprLoc()) + << callee->getQualifiedNameAsString() << expr->getSourceRange(); + } + return; + } + if (e3->getNumArgs() != 2) { + return; + } + unsigned n; + bool nonArray; + ContentKind cont; + bool emb; + bool trm; + if (!isStringConstant( + e3->getArg(0)->IgnoreParenImpCasts(), &n, &nonArray, &cont, &emb, + &trm)) + { + return; + } + //TODO: cont, emb, trm + if (rewriter != nullptr) { + auto loc1 = compat::getBeginLoc(e3); + auto range = e3->getParenOrBraceRange(); + if (loc1.isFileID() && range.getBegin().isFileID() + && range.getEnd().isFileID()) + { + auto loc2 = range.getBegin(); + for (bool first = true;; first = false) { + unsigned n = Lexer::MeasureTokenLength( + loc2, compiler.getSourceManager(), compiler.getLangOpts()); + if (!first) { + StringRef s( + compiler.getSourceManager().getCharacterData(loc2), n); + while (s.startswith("\\\n")) { + s = s.drop_front(2); + while (!s.empty() + && (s.front() == ' ' || s.front() == '\t' + || s.front() == '\n' || s.front() == '\v' + || s.front() == '\f')) + { + s = s.drop_front(1); + } + } + if (!(s.empty() || s.startswith("/*") || s.startswith("//") + || s == "\\")) + { + break; + } + } + loc2 = loc2.getLocWithOffset(std::max<unsigned>(n, 1)); + } + auto loc3 = range.getEnd(); + for (;;) { + auto l = Lexer::GetBeginningOfToken( + loc3.getLocWithOffset(-1), compiler.getSourceManager(), + compiler.getLangOpts()); + unsigned n = Lexer::MeasureTokenLength( + l, compiler.getSourceManager(), compiler.getLangOpts()); + StringRef s(compiler.getSourceManager().getCharacterData(l), n); + while (s.startswith("\\\n")) { + s = s.drop_front(2); + while (!s.empty() + && (s.front() == ' ' || s.front() == '\t' + || s.front() == '\n' || s.front() == '\v' + || s.front() == '\f')) + { + s = s.drop_front(1); + } + } + if (!(s.empty() || s.startswith("/*") || s.startswith("//") + || s == "\\")) + { + break; + } + loc3 = l; + } + if (removeText(CharSourceRange(SourceRange(loc1, loc2), false))) { + if (removeText(SourceRange(loc3, range.getEnd()))) { + return; + } + report(DiagnosticsEngine::Fatal, "Corrupt rewrite", loc3) + << expr->getSourceRange(); + return; + } + } + } + report( + DiagnosticsEngine::Warning, + ("in call of '%0', replace 'OUString' constructed from a string literal" + " directly with the string literal"), + e3->getExprLoc()) + << callee->getQualifiedNameAsString() << expr->getSourceRange(); +} + +void StringConstant::handleFunArgOstring( + CallExpr const * expr, unsigned arg, FunctionDecl const * callee) +{ + auto argExpr = expr->getArg(arg)->IgnoreParenImpCasts(); + unsigned n; + bool nonArray; + ContentKind cont; + bool emb; + bool trm; + if (isStringConstant(argExpr, &n, &nonArray, &cont, &emb, &trm)) { + if (cont != ContentKind::Ascii || emb) { + return; + } + if (!trm) { + report( + DiagnosticsEngine::Warning, + ("call of '%0' with string constant argument lacking a" + " terminating NULL"), + getMemberLocation(expr)) + << callee->getQualifiedNameAsString() << expr->getSourceRange(); + return; + } + std::string repl; + checkEmpty(expr, callee, TreatEmpty::Error, n, &repl); + if (nonArray) { + report( + DiagnosticsEngine::Warning, + ("in call of '%0' with non-array string constant argument," + " turn the non-array string constant into an array"), + getMemberLocation(expr)) + << callee->getQualifiedNameAsString() << expr->getSourceRange(); + } + } else if (auto cexpr = lookForCXXConstructExpr(argExpr)) { + auto classdecl = cexpr->getConstructor()->getParent(); + if (loplugin::DeclCheck(classdecl).Class("OString").Namespace("rtl") + .GlobalNamespace()) + { + switch (cexpr->getConstructor()->getNumParams()) { + case 0: + report( + DiagnosticsEngine::Warning, + ("in call of '%0', replace empty %1 constructor with empty" + " string literal"), + cexpr->getLocation()) + << callee->getQualifiedNameAsString() << classdecl + << expr->getSourceRange(); + break; + case 2: + if (isStringConstant( + cexpr->getArg(0)->IgnoreParenImpCasts(), &n, &nonArray, + &cont, &emb, &trm)) + { + APSInt res; + if (compat::EvaluateAsInt(cexpr->getArg(1), + res, compiler.getASTContext())) + { + if (res == n && !emb && trm) { + report( + DiagnosticsEngine::Warning, + ("in call of '%0', elide explicit %1" + " constructor%2"), + cexpr->getLocation()) + << callee->getQualifiedNameAsString() + << classdecl << adviseNonArray(nonArray) + << expr->getSourceRange(); + } + } else { + if (emb) { + report( + DiagnosticsEngine::Warning, + ("call of %0 constructor with string constant" + " argument containing embedded NULLs"), + cexpr->getLocation()) + << classdecl << cexpr->getSourceRange(); + return; + } + if (!trm) { + report( + DiagnosticsEngine::Warning, + ("call of %0 constructor with string constant" + " argument lacking a terminating NULL"), + cexpr->getLocation()) + << classdecl << cexpr->getSourceRange(); + return; + } + report( + DiagnosticsEngine::Warning, + "in call of '%0', elide explicit %1 constructor%2", + cexpr->getLocation()) + << callee->getQualifiedNameAsString() << classdecl + << adviseNonArray(nonArray) + << expr->getSourceRange(); + } + } + break; + default: + break; + } + } + } +} + +loplugin::Plugin::Registration< StringConstant > X("stringconstant", true); + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |