compilerplugins/clang/stringviewvar.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 various of type  rtl::O[U]String that can be converted to std::[u16]string_view instead.
  21
  22 // This can generate false positives e.g.
  23 //   OUString sSave( aToken );
  24 //   aToken.append("foo");
  25 //   aToken = sSave;
  26 // where the data that is backing the view is modified and then the view is used to assign to
  27 // the same source data.
  28
  29 namespace
  30 {
  31 enum class StringType
  32 {
  33     None,
  34     RtlOstring,
  35     RtlOustring
  36 };
  37
  38 StringType relevantStringType(QualType type)
  39 {
  40     loplugin::TypeCheck const c(type);
  41     if (c.Class("OString").Namespace("rtl"))
  42     {
  43         return StringType::RtlOstring;
  44     }
  45     else if (c.Class("OUString").Namespace("rtl"))
  46     {
  47         return StringType::RtlOustring;
  48     }
  49     else
  50     {
  51         return StringType::None;
  52     }
  53 }
  54
  55 bool relevantVarDecl(VarDecl const* decl)
  56 {
  57     auto const t1 = decl->getType();
  58     if (relevantStringType(t1.getNonReferenceType()) == StringType::None)
  59     {
  60         return false;
  61     }
  62     if (isa<ParmVarDecl>(decl))
  63     {
  64         return false;
  65     }
  66     return true;
  67 }
  68
  69 DeclRefExpr const* relevantDeclRefExpr(Expr const* expr)
  70 {
  71     //TODO: Look through BO_Comma and AbstractConditionalOperator
  72     auto const e = dyn_cast<DeclRefExpr>(expr->IgnoreParenImpCasts());
  73     if (e == nullptr)
  74     {
  75         return nullptr;
  76     }
  77     auto const d = dyn_cast<VarDecl>(e->getDecl());
  78     if (d == nullptr)
  79     {
  80         return nullptr;
  81     }
  82     if (!relevantVarDecl(d))
  83     {
  84         return nullptr;
  85     }
  86     return e;
  87 }
  88
  89 bool isStringView(QualType qt)
  90 {
  91     return bool(loplugin::TypeCheck(qt).ClassOrStruct("basic_string_view").StdNamespace());
  92 }
  93
  94 DeclRefExpr const* relevantImplicitCastExpr(ImplicitCastExpr const* expr)
  95 {
  96     if (!isStringView(expr->getType()))
  97     {
  98         return nullptr;
  99     }
 100     return relevantDeclRefExpr(expr->getSubExprAsWritten());
 101 }
 102
 103 DeclRefExpr const* relevantCStyleCastExpr(CStyleCastExpr const* expr)
 104 {
 105     if (expr->getCastKind() != CK_ToVoid)
 106     {
 107         return nullptr;
 108     }
 109     return relevantDeclRefExpr(expr->getSubExprAsWritten());
 110 }
 111
 112 DeclRefExpr const* relevantCXXMemberCallExpr(CXXMemberCallExpr const* expr)
 113 {
 114     StringType t = relevantStringType(expr->getObjectType());
 115     if (t == StringType::None)
 116     {
 117         return nullptr;
 118     }
 119     bool good = false;
 120     auto const d = expr->getMethodDecl();
 121     if (d->getOverloadedOperator() == OO_Subscript)
 122     {
 123         good = true;
 124     }
 125     else if (auto const i = d->getIdentifier())
 126     {
 127         auto const n = i->getName();
 128         if (n == "endsWith" || n == "isEmpty" || n == "startsWith" || n == "subView"
 129             || n == "indexOf" || n == "lastIndexOf" || n == "compareTo" || n == "match"
 130             || n == "trim" || n == "toInt32" || n == "toInt64" || n == "toDouble"
 131             || n == "equalsIgnoreAsciiCase" || n == "compareToIgnoreAsciiCase" || n == "getToken"
 132             || n == "copy" || n == "iterateCodePoints")
 133         {
 134             good = true;
 135         }
 136 #if 0
 137         //TODO: rtl::O[U]String::getLength would be awkward to replace with
 138         // std::[u16]string_view::length/size due to the sal_Int32 vs. std::size_t return type
 139         // mismatch (C++20 ssize might make that easier, though); and while rtl::OString::getStr is
 140         // documented to be NUL-terminated (so not eligible for replacement with
 141         // std::string_view::data in general), rtl::OUString::getStr is not (so should be eligible
 142         // for replacement with std::u16string_view::data, but some call sites might nevertheless
 143         // incorrectly rely on NUL termination, so any replacement would need careful review):
 144         if (n == "getLength" || (t == StringType::RtlOustring && n == "getStr"))
 145         {
 146             good = true;
 147         }
 148 #endif
 149     }
 150     if (!good)
 151     {
 152         return nullptr;
 153     }
 154     return relevantDeclRefExpr(expr->getImplicitObjectArgument());
 155 }
 156
 157 SmallVector<DeclRefExpr const*, 2> wrap(DeclRefExpr const* expr)
 158 {
 159     if (expr == nullptr)
 160     {
 161         return {};
 162     }
 163     return { expr };
 164 }
 165
 166 SmallVector<DeclRefExpr const*, 2> relevantCXXOperatorCallExpr(CXXOperatorCallExpr const* expr)
 167 {
 168     auto const op = expr->getOperator();
 169     if (op == OO_Subscript)
 170     {
 171         auto const e = expr->getArg(0);
 172         if (relevantStringType(e->getType()) == StringType::None)
 173         {
 174             return {};
 175         }
 176         return wrap(relevantDeclRefExpr(e));
 177     }
 178     if (expr->isComparisonOp() || (op == OO_Plus && expr->getNumArgs() == 2))
 179     {
 180         SmallVector<DeclRefExpr const*, 2> v;
 181         if (auto const e = relevantDeclRefExpr(expr->getArg(0)))
 182         {
 183             v.push_back(e);
 184         }
 185         if (auto const e = relevantDeclRefExpr(expr->getArg(1)))
 186         {
 187             v.push_back(e);
 188         }
 189         return v;
 190     }
 191     if (op == OO_PlusEqual)
 192     {
 193         if (relevantStringType(expr->getArg(0)->getType()) != StringType::RtlOustring)
 194         {
 195             return {};
 196         }
 197         return wrap(relevantDeclRefExpr(expr->getArg(1)));
 198     }
 199     if (op == OO_Equal)
 200     {
 201         if (!isStringView(expr->getArg(1)->getType()))
 202         {
 203             return {};
 204         }
 205         return wrap(relevantDeclRefExpr(expr->getArg(0)));
 206     }
 207     return {};
 208 }
 209
 210 static const Expr* IgnoreImplicitAndConversionOperator(const Expr* expr)
 211 {
 212     expr = expr->IgnoreImplicit();
 213     if (auto memberCall = dyn_cast<CXXMemberCallExpr>(expr))
 214     {
 215         if (auto conversionDecl = dyn_cast_or_null<CXXConversionDecl>(memberCall->getMethodDecl()))
 216         {
 217             if (!conversionDecl->isExplicit())
 218                 expr = memberCall->getImplicitObjectArgument()->IgnoreImplicit();
 219         }
 220     }
 221     return expr;
 222 }
 223
 224 class StringViewVar final
 225     : public loplugin::FunctionAddress<loplugin::FilteringPlugin<StringViewVar>>
 226 {
 227 public:
 228     explicit StringViewVar(loplugin::InstantiationData const& data)
 229         : FunctionAddress(data)
 230     {
 231     }
 232
 233     bool VisitVarDecl(VarDecl* decl)
 234     {
 235         if (ignoreLocation(decl))
 236         {
 237             return true;
 238         }
 239         if (decl->hasGlobalStorage())
 240         {
 241             return true;
 242         }
 243         if (!decl->isThisDeclarationADefinition())
 244         {
 245             return true;
 246         }
 247         if (!relevantVarDecl(decl))
 248         {
 249             return true;
 250         }
 251         if (decl->getInit())
 252         {
 253             auto expr = IgnoreImplicitAndConversionOperator(decl->getInit());
 254             if (auto castExpr = dyn_cast<CXXFunctionalCastExpr>(expr))
 255             {
 256                 expr = IgnoreImplicitAndConversionOperator(castExpr->getSubExpr());
 257             }
 258             if (auto cxxConstruct = dyn_cast<CXXConstructExpr>(expr))
 259             {
 260                 if (cxxConstruct->getNumArgs() == 0)
 261                     currentVars_.insert(decl); // default constructor
 262                 else if (cxxConstruct->getNumArgs() == 1
 263                          && isStringView(cxxConstruct->getArg(0)->getType()))
 264                     currentVars_.insert(decl);
 265             }
 266         }
 267         return true;
 268     }
 269
 270     bool TraverseImplicitCastExpr(ImplicitCastExpr* expr)
 271     {
 272         if (ignoreLocation(expr))
 273         {
 274             return true;
 275         }
 276         auto const e = relevantImplicitCastExpr(expr);
 277         if (e == nullptr)
 278         {
 279             return FunctionAddress::TraverseImplicitCastExpr(expr);
 280         }
 281         currentGoodUses_.insert(e);
 282         auto const ret = FunctionAddress::TraverseImplicitCastExpr(expr);
 283         currentGoodUses_.erase(e);
 284         return ret;
 285     }
 286
 287     bool TraverseCStyleCastExpr(CStyleCastExpr* expr)
 288     {
 289         if (ignoreLocation(expr))
 290         {
 291             return true;
 292         }
 293         auto const e = relevantCStyleCastExpr(expr);
 294         if (e == nullptr)
 295         {
 296             return FunctionAddress::TraverseCStyleCastExpr(expr);
 297         }
 298         currentGoodUses_.insert(e);
 299         auto const ret = FunctionAddress::TraverseCStyleCastExpr(expr);
 300         currentGoodUses_.erase(e);
 301         return ret;
 302     }
 303
 304     bool TraverseCXXMemberCallExpr(CXXMemberCallExpr* expr)
 305     {
 306         if (ignoreLocation(expr))
 307         {
 308             return true;
 309         }
 310         auto const e = relevantCXXMemberCallExpr(expr);
 311         if (e == nullptr)
 312         {
 313             return FunctionAddress::TraverseCXXMemberCallExpr(expr);
 314         }
 315         currentGoodUses_.insert(e);
 316         auto const ret = FunctionAddress::TraverseCXXMemberCallExpr(expr);
 317         currentGoodUses_.erase(e);
 318         return ret;
 319     }
 320
 321     bool TraverseCXXOperatorCallExpr(CXXOperatorCallExpr* expr)
 322     {
 323         if (ignoreLocation(expr))
 324         {
 325             return true;
 326         }
 327         auto const es = relevantCXXOperatorCallExpr(expr);
 328         if (es.empty())
 329         {
 330             return FunctionAddress::TraverseCXXOperatorCallExpr(expr);
 331         }
 332         currentGoodUses_.insert(es.begin(), es.end());
 333         auto const ret = FunctionAddress::TraverseCXXOperatorCallExpr(expr);
 334         for (auto const i : es)
 335         {
 336             currentGoodUses_.erase(i);
 337         }
 338         return ret;
 339     }
 340
 341     bool VisitDeclRefExpr(DeclRefExpr* expr)
 342     {
 343         if (!FunctionAddress::VisitDeclRefExpr(expr))
 344         {
 345             return false;
 346         }
 347         if (ignoreLocation(expr))
 348         {
 349             return true;
 350         }
 351         if (currentGoodUses_.find(expr) != currentGoodUses_.end())
 352         {
 353             return true;
 354         }
 355         if (auto const d = dyn_cast<VarDecl>(expr->getDecl()))
 356         {
 357             currentVars_.erase(d);
 358         }
 359         return true;
 360     }
 361
 362 private:
 363     void run() override
 364     {
 365         if (!compiler.getLangOpts().CPlusPlus)
 366         {
 367             return;
 368         }
 369         if (compiler.getPreprocessor().getIdentifierInfo("NDEBUG")->hasMacroDefinition())
 370         {
 371             return;
 372         }
 373         StringRef fn(handler.getMainFileName());
 374         // leave the string QA tests alone
 375         if (loplugin::hasPathnamePrefix(fn, SRCDIR "/sal/qa/"))
 376         {
 377             return;
 378         }
 379         // false +
 380         if (loplugin::hasPathnamePrefix(fn, SRCDIR "/svtools/source/svrtf/parrtf.cxx"))
 381         {
 382             return;
 383         }
 384         if (!TraverseDecl(compiler.getASTContext().getTranslationUnitDecl()))
 385         {
 386             return;
 387         }
 388         for (auto const i : currentVars_)
 389         {
 390             auto const t = relevantStringType(i->getType().getNonReferenceType());
 391             report(DiagnosticsEngine::Warning,
 392                    "replace var of type %0 with "
 393                    "'%select{std::string_view|std::u16string_view}1'",
 394                    i->getLocation())
 395                 << i->getType() << (int(t) - 1) << i->getSourceRange();
 396         }
 397     }
 398
 399     std::set<VarDecl const*> currentVars_;
 400     std::set<DeclRefExpr const*> currentGoodUses_;
 401 };
 402
 403 static loplugin::Plugin::Registration<StringViewVar> reg("stringviewvar",
 404                                                          false); // might generate false+
 405 }
 406
 407 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */