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