compilerplugins/clang/stringviewparam.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #include <cassert>
  11 #include <set>
  12 #include <vector>
  13
  14 #include "check.hxx"
  15 #include "compat.hxx"
  16 #include "functionaddress.hxx"
  17 #include "plugin.hxx"
  18
  19 // Find functions that take rtl::O[U]String parameters that can be generalized to take
  20 // std::[u16]string_view instead.
  21
  22 //TODO: At least theoretically, there are issues with replacing parameters that are being assigned
  23 // to, as in
  24 //
  25 //  void f(OUString s) {
  26 //    {
  27 //      OUString t = ...;
  28 //      s = t;
  29 //    }
  30 //    ... use s ... // if s is now std::u16string_view, it points into destroyed contents of t
  31 //  }
  32
  33 namespace
  34 {
  35 bool hasSalDllpublicExportAttr(FunctionDecl const* decl)
  36 {
  37     if (auto const attr = decl->getAttr<VisibilityAttr>())
  38     {
  39         return attr->getVisibility() == VisibilityAttr::Default;
  40     }
  41     return decl->hasAttr<DLLExportAttr>();
  42 }
  43
  44 enum class StringType
  45 {
  46     None,
  47     RtlOstring,
  48     RtlOustring
  49 };
  50
  51 StringType relevantStringType(QualType type)
  52 {
  53     loplugin::TypeCheck const c(type);
  54     if (c.Class("OString").Namespace("rtl"))
  55     {
  56         return StringType::RtlOstring;
  57     }
  58     else if (c.Class("OUString").Namespace("rtl"))
  59     {
  60         return StringType::RtlOustring;
  61     }
  62     else
  63     {
  64         return StringType::None;
  65     }
  66 }
  67
  68 bool relevantParmVarDecl(ParmVarDecl const* decl)
  69 {
  70     auto const t1 = decl->getType();
  71     if (auto const t2 = t1->getAs<LValueReferenceType>())
  72     {
  73         if (!t2->getPointeeType().isConstQualified())
  74         {
  75             return false;
  76         }
  77     }
  78     if (relevantStringType(t1.getNonReferenceType()) == StringType::None)
  79     {
  80         return false;
  81     }
  82     if (decl->hasAttr<UnusedAttr>())
  83     {
  84         return false;
  85     }
  86     return true;
  87 }
  88
  89 DeclRefExpr const* relevantDeclRefExpr(Expr const* expr)
  90 {
  91     //TODO: Look through BO_Comma and AbstractConditionalOperator
  92     auto const e = dyn_cast<DeclRefExpr>(expr->IgnoreParenImpCasts());
  93     if (e == nullptr)
  94     {
  95         return nullptr;
  96     }
  97     auto const d = dyn_cast<ParmVarDecl>(e->getDecl());
  98     if (d == nullptr)
  99     {
 100         return nullptr;
 101     }
 102     if (!relevantParmVarDecl(d))
 103     {
 104         return nullptr;
 105     }
 106     return e;
 107 }
 108
 109 bool isStringView(QualType qt)
 110 {
 111     return bool(loplugin::TypeCheck(qt).ClassOrStruct("basic_string_view").StdNamespace());
 112 }
 113
 114 DeclRefExpr const* relevantImplicitCastExpr(ImplicitCastExpr const* expr)
 115 {
 116     if (!isStringView(expr->getType()))
 117     {
 118         return nullptr;
 119     }
 120     return relevantDeclRefExpr(expr->getSubExprAsWritten());
 121 }
 122
 123 DeclRefExpr const* relevantCXXMemberCallExpr(CXXMemberCallExpr const* expr)
 124 {
 125     StringType t = relevantStringType(compat::getObjectType(expr));
 126     if (t == StringType::None)
 127     {
 128         return nullptr;
 129     }
 130     bool good = false;
 131     auto const d = expr->getMethodDecl();
 132     if (d->getOverloadedOperator() == OO_Subscript)
 133     {
 134         good = true;
 135     }
 136     else if (auto const i = d->getIdentifier())
 137     {
 138         auto const n = i->getName();
 139         if (n == "endsWith" || n == "isEmpty" || n == "startsWith" || n == "subView")
 140         {
 141             good = true;
 142         }
 143 #if 0
 144         //TODO: rtl::O[U]String::getLength would be awkward to replace with
 145         // std::[u16]string_view::length/size due to the sal_Int32 vs. std::size_t return type
 146         // mismatch (C++20 ssize might make that easier, though); and while rtl::OString::getStr is
 147         // documented to be NUL-terminated (so not eligible for replacement with
 148         // std::string_view::data in general), rtl::OUString::getStr is not (so should be eligible
 149         // for replacement with std::u16string_view::data, but some call sites might nevertheless
 150         // incorrectly rely on NUL termination, so any replacement would need careful review):
 151         if (n == "getLength" || (t == StringType::RtlOustring && n == "getStr"))
 152         {
 153             good = true;
 154         }
 155 #endif
 156     }
 157     if (!good)
 158     {
 159         return nullptr;
 160     }
 161     return relevantDeclRefExpr(expr->getImplicitObjectArgument());
 162 }
 163
 164 SmallVector<DeclRefExpr const*, 2> wrap(DeclRefExpr const* expr)
 165 {
 166     if (expr == nullptr)
 167     {
 168         return {};
 169     }
 170     return { expr };
 171 }
 172
 173 SmallVector<DeclRefExpr const*, 2> relevantCXXOperatorCallExpr(CXXOperatorCallExpr const* expr)
 174 {
 175     auto const op = expr->getOperator();
 176     if (op == OO_Subscript)
 177     {
 178         auto const e = expr->getArg(0);
 179         if (relevantStringType(e->getType()) == StringType::None)
 180         {
 181             return {};
 182         }
 183         return wrap(relevantDeclRefExpr(e));
 184     }
 185     if (compat::isComparisonOp(expr) || (op == OO_Plus && expr->getNumArgs() == 2))
 186     {
 187         SmallVector<DeclRefExpr const*, 2> v;
 188         if (auto const e = relevantDeclRefExpr(expr->getArg(0)))
 189         {
 190             v.push_back(e);
 191         }
 192         if (auto const e = relevantDeclRefExpr(expr->getArg(1)))
 193         {
 194             v.push_back(e);
 195         }
 196         return v;
 197     }
 198     if (op == OO_PlusEqual)
 199     {
 200         if (relevantStringType(expr->getArg(0)->getType()) != StringType::RtlOustring)
 201         {
 202             return {};
 203         }
 204         return wrap(relevantDeclRefExpr(expr->getArg(1)));
 205     }
 206     return {};
 207 }
 208
 209 //TODO: current implementation is not at all general, just tests what we encounter in practice:
 210 bool hasStringViewOverload(ParmVarDecl const* decl)
 211 {
 212     auto const d1 = cast<FunctionDecl>(decl->getDeclContext());
 213     auto const ctx = d1->getDeclContext();
 214     if (!ctx->isLookupContext())
 215     {
 216         return false;
 217     }
 218     auto const res = ctx->lookup(d1->getDeclName());
 219     auto const idx = decl->getFunctionScopeIndex();
 220     auto const n = d1->getNumParams();
 221     assert(n > idx);
 222     for (auto i = res.begin(); i != res.end(); ++i)
 223     {
 224         auto const d2 = dyn_cast<FunctionDecl>(*i);
 225         if (d2 == nullptr)
 226         {
 227             continue;
 228         }
 229         if (d2->getNumParams() != n)
 230         {
 231             continue;
 232         }
 233         auto match = true;
 234         for (unsigned j = 0; j != n; ++j)
 235         {
 236             if (j == idx)
 237             {
 238                 //TODO: check for exactly std::string_view or std::u16string_view:
 239                 if (!isStringView(d2->getParamDecl(j)->getType()))
 240                 {
 241                     match = false;
 242                     break;
 243                 }
 244             }
 245             else if (d1->getParamDecl(j)->getType().getCanonicalType()
 246                      != d2->getParamDecl(j)->getType().getCanonicalType())
 247             {
 248                 match = false;
 249                 break;
 250             }
 251         }
 252         if (match)
 253         {
 254             return true;
 255         }
 256     }
 257     return false;
 258 }
 259
 260 class StringViewParam final
 261     : public loplugin::FunctionAddress<loplugin::FilteringPlugin<StringViewParam>>
 262 {
 263 public:
 264     explicit StringViewParam(loplugin::InstantiationData const& data)
 265         : FunctionAddress(data)
 266     {
 267     }
 268
 269     //TODO: Also check lambdas
 270     bool TraverseFunctionDecl(FunctionDecl* decl)
 271     {
 272         if (ignoreLocation(decl))
 273         {
 274             return true;
 275         }
 276         if (!relevantFunctionDecl(decl))
 277         {
 278             return FunctionAddress::TraverseFunctionDecl(decl);
 279         }
 280         auto const oldParams = currentParams_;
 281         auto const n = decl->getNumParams();
 282         for (unsigned i = 0; i != n; ++i)
 283         {
 284             auto const d = decl->getParamDecl(i);
 285             if (relevantParmVarDecl(d))
 286             {
 287                 currentParams_.insert(d);
 288             }
 289         }
 290         auto const ret = FunctionAddress::TraverseFunctionDecl(decl);
 291         if (ret)
 292         {
 293             for (unsigned i = 0; i != n; ++i)
 294             {
 295                 auto const d1 = decl->getParamDecl(i);
 296                 if (currentParams_.find(d1) == currentParams_.end())
 297                 {
 298                     continue;
 299                 }
 300                 if (containsPreprocessingConditionalInclusion(decl->getSourceRange()))
 301                 {
 302                     break;
 303                 }
 304                 badParams_.push_back(d1);
 305             }
 306         }
 307         currentParams_ = oldParams;
 308         return ret;
 309     }
 310
 311     bool TraverseCXXMethodDecl(CXXMethodDecl* decl)
 312     {
 313         if (ignoreLocation(decl))
 314         {
 315             return true;
 316         }
 317         if (!relevantFunctionDecl(decl))
 318         {
 319             return FunctionAddress::TraverseCXXMethodDecl(decl);
 320         }
 321         auto const oldParams = currentParams_;
 322         auto const n = decl->getNumParams();
 323         for (unsigned i = 0; i != n; ++i)
 324         {
 325             auto const d = decl->getParamDecl(i);
 326             if (relevantParmVarDecl(d))
 327             {
 328                 currentParams_.insert(d);
 329             }
 330         }
 331         auto const ret = FunctionAddress::TraverseCXXMethodDecl(decl);
 332         if (ret)
 333         {
 334             for (unsigned i = 0; i != n; ++i)
 335             {
 336                 auto const d1 = decl->getParamDecl(i);
 337                 if (currentParams_.find(d1) == currentParams_.end())
 338                 {
 339                     continue;
 340                 }
 341                 if (containsPreprocessingConditionalInclusion(decl->getSourceRange()))
 342                 {
 343                     break;
 344                 }
 345                 badParams_.push_back(d1);
 346             }
 347         }
 348         currentParams_ = oldParams;
 349         return ret;
 350     }
 351
 352     bool TraverseCXXConstructorDecl(CXXConstructorDecl* decl)
 353     {
 354         if (ignoreLocation(decl))
 355         {
 356             return true;
 357         }
 358         if (!relevantFunctionDecl(decl))
 359         {
 360             return FunctionAddress::TraverseCXXConstructorDecl(decl);
 361         }
 362         auto const oldParams = currentParams_;
 363         auto const n = decl->getNumParams();
 364         for (unsigned i = 0; i != n; ++i)
 365         {
 366             auto const d = decl->getParamDecl(i);
 367             if (relevantParmVarDecl(d))
 368             {
 369                 currentParams_.insert(d);
 370             }
 371         }
 372         auto const ret = FunctionAddress::TraverseCXXConstructorDecl(decl);
 373         if (ret)
 374         {
 375             for (unsigned i = 0; i != n; ++i)
 376             {
 377                 auto const d1 = decl->getParamDecl(i);
 378                 if (currentParams_.find(d1) == currentParams_.end())
 379                 {
 380                     continue;
 381                 }
 382                 if (containsPreprocessingConditionalInclusion(decl->getSourceRange()))
 383                 {
 384                     break;
 385                 }
 386                 badParams_.push_back(d1);
 387             }
 388         }
 389         currentParams_ = oldParams;
 390         return ret;
 391     }
 392
 393     bool TraverseImplicitCastExpr(ImplicitCastExpr* expr)
 394     {
 395         if (ignoreLocation(expr))
 396         {
 397             return true;
 398         }
 399         auto const e = relevantImplicitCastExpr(expr);
 400         if (e == nullptr)
 401         {
 402             return FunctionAddress::TraverseImplicitCastExpr(expr);
 403         }
 404         currentGoodUses_.insert(e);
 405         auto const ret = FunctionAddress::TraverseImplicitCastExpr(expr);
 406         currentGoodUses_.erase(e);
 407         return ret;
 408     }
 409
 410     bool TraverseCXXMemberCallExpr(CXXMemberCallExpr* expr)
 411     {
 412         if (ignoreLocation(expr))
 413         {
 414             return true;
 415         }
 416         auto const e = relevantCXXMemberCallExpr(expr);
 417         if (e == nullptr)
 418         {
 419             return FunctionAddress::TraverseCXXMemberCallExpr(expr);
 420         }
 421         currentGoodUses_.insert(e);
 422         auto const ret = FunctionAddress::TraverseCXXMemberCallExpr(expr);
 423         currentGoodUses_.erase(e);
 424         return ret;
 425     }
 426
 427     bool TraverseCXXOperatorCallExpr(CXXOperatorCallExpr* expr)
 428     {
 429         if (ignoreLocation(expr))
 430         {
 431             return true;
 432         }
 433         auto const es = relevantCXXOperatorCallExpr(expr);
 434         if (es.empty())
 435         {
 436             return FunctionAddress::TraverseCXXOperatorCallExpr(expr);
 437         }
 438         currentGoodUses_.insert(es.begin(), es.end());
 439         auto const ret = FunctionAddress::TraverseCXXOperatorCallExpr(expr);
 440         for (auto const i : es)
 441         {
 442             currentGoodUses_.erase(i);
 443         }
 444         return ret;
 445     }
 446
 447     bool VisitDeclRefExpr(DeclRefExpr* expr)
 448     {
 449         if (!FunctionAddress::VisitDeclRefExpr(expr))
 450         {
 451             return false;
 452         }
 453         if (ignoreLocation(expr))
 454         {
 455             return true;
 456         }
 457         if (currentGoodUses_.find(expr) != currentGoodUses_.end())
 458         {
 459             return true;
 460         }
 461         if (auto const d = dyn_cast<ParmVarDecl>(expr->getDecl()))
 462         {
 463             currentParams_.erase(d);
 464         }
 465         return true;
 466     }
 467
 468 private:
 469     void run() override
 470     {
 471         if (!compiler.getLangOpts().CPlusPlus)
 472         {
 473             return;
 474         }
 475         if (compiler.getPreprocessor().getIdentifierInfo("NDEBUG")->hasMacroDefinition())
 476         {
 477             return;
 478         }
 479         StringRef fn(handler.getMainFileName());
 480         // leave the string QA tests alone
 481         if (loplugin::hasPathnamePrefix(fn, SRCDIR "/sal/qa/"))
 482         {
 483             return;
 484         }
 485         if (!TraverseDecl(compiler.getASTContext().getTranslationUnitDecl()))
 486         {
 487             return;
 488         }
 489         auto const ignoredFns = getFunctionsWithAddressTaken();
 490         for (auto const i : badParams_)
 491         {
 492             auto const d1 = cast<FunctionDecl>(i->getDeclContext());
 493             if (ignoredFns.find(d1) != ignoredFns.end())
 494             {
 495                 continue;
 496             }
 497             if (hasStringViewOverload(i))
 498             {
 499                 continue;
 500             }
 501             auto const t = relevantStringType(i->getType().getNonReferenceType());
 502             assert(t != StringType::None);
 503             report(DiagnosticsEngine::Warning,
 504                    "replace function parameter of type %0 with "
 505                    "'%select{std::string_view|std::u16string_view}1'",
 506                    i->getLocation())
 507                 << i->getType() << (int(t) - 1) << i->getSourceRange();
 508             for (auto d2 = d1;;)
 509             {
 510                 d2 = d2->getPreviousDecl();
 511                 if (d2 == nullptr)
 512                 {
 513                     break;
 514                 }
 515                 auto const d3 = d2->getParamDecl(i->getFunctionScopeIndex());
 516                 report(DiagnosticsEngine::Note, "previous declaration is here", d3->getLocation())
 517                     << d3->getSourceRange();
 518             }
 519         }
 520     }
 521
 522     bool relevantFunctionDecl(FunctionDecl const* decl)
 523     {
 524         if (!decl->doesThisDeclarationHaveABody())
 525         {
 526             return false;
 527         }
 528         if (decl->getBody() == nullptr) // unparsed template
 529         {
 530             return false;
 531         }
 532         if (auto const d = dyn_cast<CXXMethodDecl>(decl))
 533         {
 534             if (d->isVirtual())
 535             {
 536                 return false;
 537             }
 538         }
 539         if (decl->isFunctionTemplateSpecialization())
 540         {
 541             return false;
 542         }
 543         if (decl->getLocation().isMacroID())
 544         {
 545             return false;
 546         }
 547         // Filter out functions that are presumably meant to be called dynamically (e.g., via
 548         // dlopen, or backwards compatibility stubs in cppuhelper/cppu/sal compat.cxx):
 549         if (decl->getPreviousDecl() == nullptr && !decl->isInlined()
 550             && hasSalDllpublicExportAttr(decl)
 551             && compiler.getSourceManager().isInMainFile(decl->getLocation()))
 552         {
 553             return false;
 554         }
 555         if (isInUnoIncludeFile(compiler.getSourceManager().getSpellingLoc(decl->getLocation())))
 556         {
 557             return false;
 558         }
 559         return true;
 560     }
 561
 562     std::set<ParmVarDecl const*> currentParams_;
 563     std::set<DeclRefExpr const*> currentGoodUses_;
 564     std::vector<ParmVarDecl const*> badParams_;
 565 };
 566
 567 static loplugin::Plugin::Registration<StringViewParam> reg("stringviewparam");
 568 }
 569
 570 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */