compilerplugins/clang/stringview.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   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 #ifndef LO_CLANG_SHARED_PLUGINS
  10
  11 #include <cassert>
  12 #include <string>
  13 #include <iostream>
  14 #include <unordered_map>
  15 #include <unordered_set>
  16
  17 #include "plugin.hxx"
  18 #include "check.hxx"
  19 #include "config_clang.h"
  20 #include "clang/AST/CXXInheritance.h"
  21 #include "clang/AST/StmtVisitor.h"
  22
  23 /**
  24     Look for places where we are making a substring copy of an OUString, and then passing it to a
  25     function that takes a u16string_view, in which case it is more efficient to pass a view
  26     of the OUString, rather than making a copy.
  27
  28     TODO currently does not check if there is some other visible overload of the callee, that can take
  29     a string_view.
  30     TODO handle OUStringBuffer/OStringBuffer similarly
  31 */
  32
  33 namespace
  34 {
  35 class StringView : public loplugin::FilteringPlugin<StringView>
  36 {
  37 public:
  38     explicit StringView(loplugin::InstantiationData const& data)
  39         : FilteringPlugin(data)
  40     {
  41     }
  42
  43     bool preRun() override
  44     {
  45         auto const fn = handler.getMainFileName();
  46         return !(loplugin::isSamePathname(fn, SRCDIR "/sal/qa/OStringBuffer/rtl_OStringBuffer.cxx")
  47                  || loplugin::hasPathnamePrefix(fn, SRCDIR "/sal/qa/rtl/strings/")
  48                  || loplugin::hasPathnamePrefix(fn, SRCDIR "/sal/qa/rtl/oustring/"));
  49     }
  50
  51     virtual void run() override
  52     {
  53         if (!preRun())
  54             return;
  55         TraverseDecl(compiler.getASTContext().getTranslationUnitDecl());
  56     }
  57
  58     bool VisitFunctionDecl(FunctionDecl const*);
  59     bool VisitCXXOperatorCallExpr(CXXOperatorCallExpr const*);
  60     bool VisitImplicitCastExpr(ImplicitCastExpr const*);
  61     bool VisitCXXMemberCallExpr(CXXMemberCallExpr const*);
  62     bool VisitCXXConstructExpr(CXXConstructExpr const*);
  63
  64 private:
  65     void handleSubExprThatCouldBeView(Expr const* expr);
  66     void handleCXXConstructExpr(CXXConstructExpr const* expr);
  67     void handleCXXMemberCallExpr(CXXMemberCallExpr const* expr);
  68 };
  69
  70 bool StringView::VisitCXXOperatorCallExpr(CXXOperatorCallExpr const* cxxOperatorCallExpr)
  71 {
  72     if (ignoreLocation(cxxOperatorCallExpr))
  73         return true;
  74
  75     auto op = cxxOperatorCallExpr->getOperator();
  76     if (op == OO_Plus && cxxOperatorCallExpr->getNumArgs() == 2)
  77     {
  78         handleSubExprThatCouldBeView(cxxOperatorCallExpr->getArg(0));
  79         handleSubExprThatCouldBeView(cxxOperatorCallExpr->getArg(1));
  80     }
  81     if (cxxOperatorCallExpr->isComparisonOp())
  82     {
  83         handleSubExprThatCouldBeView(cxxOperatorCallExpr->getArg(0));
  84         handleSubExprThatCouldBeView(cxxOperatorCallExpr->getArg(1));
  85     }
  86     else if (op == OO_PlusEqual)
  87         handleSubExprThatCouldBeView(cxxOperatorCallExpr->getArg(1));
  88     else if (op == OO_Subscript)
  89         handleSubExprThatCouldBeView(cxxOperatorCallExpr->getArg(0));
  90     else if (op == OO_Equal)
  91     {
  92         if (loplugin::TypeCheck(cxxOperatorCallExpr->getType())
  93                 .Class("OUStringBuffer")
  94                 .Namespace("rtl")
  95                 .GlobalNamespace()
  96             || loplugin::TypeCheck(cxxOperatorCallExpr->getType())
  97                    .Class("OStringBuffer")
  98                    .Namespace("rtl")
  99                    .GlobalNamespace())
 100         {
 101             handleSubExprThatCouldBeView(cxxOperatorCallExpr->getArg(1));
 102         }
 103     }
 104     return true;
 105 }
 106
 107 bool StringView::VisitFunctionDecl(FunctionDecl const* functionDecl)
 108 {
 109     if (ignoreLocation(functionDecl))
 110         return true;
 111     // debugging
 112     // if (functionDecl->getIdentifier() && functionDecl->getName() == "f1")
 113     //     functionDecl->dump();
 114     return true;
 115 }
 116
 117 bool StringView::VisitImplicitCastExpr(ImplicitCastExpr const* expr)
 118 {
 119     if (ignoreLocation(expr))
 120     {
 121         return true;
 122     }
 123     if (!loplugin::TypeCheck(expr->getType()).ClassOrStruct("basic_string_view").StdNamespace())
 124     {
 125         return true;
 126     }
 127     handleSubExprThatCouldBeView(expr->getSubExprAsWritten());
 128     return true;
 129 }
 130
 131 void StringView::handleSubExprThatCouldBeView(Expr const* subExpr)
 132 {
 133     auto const e0 = subExpr->IgnoreImplicit();
 134     auto const e = e0->IgnoreParens();
 135     auto const tc = loplugin::TypeCheck(e->getType());
 136     if (!(tc.Class("OString").Namespace("rtl").GlobalNamespace()
 137           || tc.Class("OUString").Namespace("rtl").GlobalNamespace()
 138           || tc.Class("OUStringBuffer").Namespace("rtl").GlobalNamespace()))
 139     {
 140         return;
 141     }
 142     if (auto const e1 = dyn_cast<CXXConstructExpr>(e))
 143     {
 144         if (e0 == subExpr)
 145         {
 146             handleCXXConstructExpr(e1);
 147         }
 148     }
 149     else if (auto const e2 = dyn_cast<CXXFunctionalCastExpr>(e))
 150     {
 151         auto e3 = e2->getSubExpr();
 152         if (auto const e4 = dyn_cast<CXXBindTemporaryExpr>(e3))
 153         {
 154             e3 = e4->getSubExpr();
 155         }
 156         if (auto const e4 = dyn_cast<CXXConstructExpr>(e3))
 157         {
 158             handleCXXConstructExpr(e4);
 159         }
 160     }
 161     else if (auto const e3 = dyn_cast<CXXMemberCallExpr>(e))
 162     {
 163         handleCXXMemberCallExpr(e3);
 164     }
 165 }
 166
 167 void StringView::handleCXXConstructExpr(CXXConstructExpr const* expr)
 168 {
 169     QualType argType;
 170     enum
 171     {
 172         None,
 173         OrChar,
 174         ViaConcatenation
 175     } extra
 176         = None;
 177     auto const d = expr->getConstructor();
 178     switch (d->getNumParams())
 179     {
 180         case 0:
 181             break;
 182         case 1:
 183         {
 184             auto const t = d->getParamDecl(0)->getType();
 185             if (t->isAnyCharacterType())
 186             {
 187                 argType = expr->getArg(0)->IgnoreImplicit()->getType();
 188                 extra = OrChar;
 189                 break;
 190             }
 191             loplugin::TypeCheck tc(t);
 192             if (tc.RvalueReference().Struct("StringNumber").Namespace("rtl").GlobalNamespace()
 193                 || tc.ClassOrStruct("basic_string_view").StdNamespace())
 194             {
 195                 argType = expr->getArg(0)->IgnoreImplicit()->getType();
 196                 break;
 197             }
 198             if (tc.RvalueReference().Struct("StringConcat").Namespace("rtl").GlobalNamespace())
 199             {
 200                 argType = expr->getArg(0)->IgnoreImplicit()->getType();
 201                 extra = ViaConcatenation;
 202                 break;
 203             }
 204             return;
 205         }
 206         case 2:
 207         {
 208             auto const t0 = d->getParamDecl(0)->getType();
 209             if (t0->isPointerType() && t0->getPointeeType()->isAnyCharacterType())
 210             {
 211                 auto const t = d->getParamDecl(1)->getType();
 212                 if (t->isIntegralType(compiler.getASTContext())
 213                     && !(t->isBooleanType() || t->isAnyCharacterType()))
 214                 {
 215                     auto const arg = expr->getArg(1);
 216                     if (!arg->isValueDependent())
 217                     {
 218                         if (auto const val = arg->getIntegerConstantExpr(compiler.getASTContext()))
 219                         {
 220                             if (val->getExtValue() == 1)
 221                             {
 222                                 extra = OrChar;
 223                             }
 224                         }
 225                     }
 226                     argType = expr->getArg(0)->IgnoreImplicit()->getType();
 227                     break;
 228                 }
 229             }
 230             if (loplugin::TypeCheck(d->getParamDecl(1)->getType())
 231                     .Struct("Dummy")
 232                     .Namespace("libreoffice_internal")
 233                     .Namespace("rtl")
 234                     .GlobalNamespace())
 235             {
 236                 argType = expr->getArg(0)->IgnoreImplicit()->getType();
 237                 break;
 238             }
 239             return;
 240         }
 241         default:
 242             return;
 243     }
 244     report(DiagnosticsEngine::Warning,
 245            "instead of an %0%select{| constructed from a %2}1, pass a"
 246            " '%select{std::string_view|std::u16string_view}3'"
 247            "%select{| (or an '%select{rtl::OStringChar|rtl::OUStringChar}3')|"
 248            " via 'rtl::Concat2View'}4",
 249            expr->getExprLoc())
 250         << expr->getType() << (argType.isNull() ? 0 : 1) << argType
 251         << (loplugin::TypeCheck(expr->getType()).Class("OString").Namespace("rtl").GlobalNamespace()
 252                 ? 0
 253                 : 1)
 254         << extra << expr->getSourceRange();
 255 }
 256
 257 void StringView::handleCXXMemberCallExpr(CXXMemberCallExpr const* expr)
 258 {
 259     auto const dc1 = loplugin::DeclCheck(expr->getMethodDecl());
 260     if (auto const dc2 = dc1.Function("copy"))
 261     {
 262         if (dc2.Class("OString").Namespace("rtl").GlobalNamespace()
 263             || dc2.Class("OUString").Namespace("rtl").GlobalNamespace()
 264             || dc2.Class("OUStringBuffer").Namespace("rtl").GlobalNamespace())
 265         {
 266             report(DiagnosticsEngine::Warning, "rather than copy, pass with a view using subView()",
 267                    expr->getExprLoc())
 268                 << expr->getSourceRange();
 269         }
 270         return;
 271     }
 272     if (auto const dc2 = dc1.Function("getToken"))
 273     {
 274         if (dc2.Class("OString").Namespace("rtl").GlobalNamespace()
 275             || dc2.Class("OUString").Namespace("rtl").GlobalNamespace()
 276             || dc2.Class("OUStringBuffer").Namespace("rtl").GlobalNamespace())
 277         {
 278             report(DiagnosticsEngine::Warning,
 279                    "rather than getToken, pass with a view using o3tl::getToken()",
 280                    expr->getExprLoc())
 281                 << expr->getSourceRange();
 282         }
 283         return;
 284     }
 285     if (auto const dc2 = dc1.Function("trim"))
 286     {
 287         if (dc2.Class("OString").Namespace("rtl").GlobalNamespace()
 288             || dc2.Class("OUString").Namespace("rtl").GlobalNamespace()
 289             || dc2.Class("OUStringBuffer").Namespace("rtl").GlobalNamespace())
 290         {
 291             report(DiagnosticsEngine::Warning,
 292                    "rather than trim, pass with a view using o3tl::trim()", expr->getExprLoc())
 293                 << expr->getSourceRange();
 294         }
 295         return;
 296     }
 297     if (auto const dc2 = dc1.Function("makeStringAndClear"))
 298     {
 299         if (dc2.Class("OStringBuffer").Namespace("rtl").GlobalNamespace()
 300             || dc2.Class("OUStringBuffer").Namespace("rtl").GlobalNamespace())
 301         {
 302             auto const obj = expr->getImplicitObjectArgument();
 303             if (!(obj->isLValue() || obj->getType()->isPointerType()))
 304             {
 305                 report(DiagnosticsEngine::Warning,
 306                        "rather than call makeStringAndClear on an rvalue, pass with a view",
 307                        expr->getExprLoc())
 308                     << expr->getSourceRange();
 309             }
 310         }
 311         return;
 312     }
 313     if (auto const dc2 = dc1.Function("toString"))
 314     {
 315         if (dc2.Class("OStringBuffer").Namespace("rtl").GlobalNamespace()
 316             || dc2.Class("OUStringBuffer").Namespace("rtl").GlobalNamespace())
 317         {
 318             report(DiagnosticsEngine::Warning, "rather than call toString, pass with a view",
 319                    expr->getExprLoc())
 320                 << expr->getSourceRange();
 321         }
 322         return;
 323     }
 324 }
 325
 326 bool StringView::VisitCXXMemberCallExpr(CXXMemberCallExpr const* expr)
 327 {
 328     if (ignoreLocation(expr))
 329     {
 330         return true;
 331     }
 332     /** check for calls to O[U]StringBuffer::append that could be passed as a
 333         std::u16string_view */
 334     if (loplugin::TypeCheck(expr->getType())
 335             .Class("OUStringBuffer")
 336             .Namespace("rtl")
 337             .GlobalNamespace()
 338         || loplugin::TypeCheck(expr->getType())
 339                .Class("OStringBuffer")
 340                .Namespace("rtl")
 341                .GlobalNamespace())
 342     {
 343         auto const dc = loplugin::DeclCheck(expr->getMethodDecl());
 344         if (dc.Function("append") || dc.Function("indexOf") || dc.Function("lastIndexOf"))
 345         {
 346             handleSubExprThatCouldBeView(expr->getArg(0));
 347         }
 348         else if (dc.Function("insert"))
 349         {
 350             handleSubExprThatCouldBeView(expr->getArg(1));
 351         }
 352     }
 353
 354     // rather than getToken...toInt32, use o3tl::toInt(o3tl::getToken(...)
 355     auto tc = loplugin::TypeCheck(expr->getImplicitObjectArgument()->getType());
 356     if (tc.Class("OUString").Namespace("rtl").GlobalNamespace()
 357         || tc.Class("OString").Namespace("rtl").GlobalNamespace())
 358     {
 359         auto const dc = loplugin::DeclCheck(expr->getMethodDecl());
 360         if (dc.Function("toInt32") || dc.Function("toUInt32") || dc.Function("toInt64")
 361             || dc.Function("toDouble") || dc.Function("equalsAscii") || dc.Function("equalsAsciiL")
 362             || dc.Function("equalsIgnoreAsciiCase") || dc.Function("compareToIgnoreAsciiCase")
 363             || dc.Function("matchIgnoreAsciiCase") || dc.Function("trim")
 364             || dc.Function("startsWith") || dc.Function("endsWith") || dc.Function("match")
 365             || dc.Function("isEmpty") || dc.Function("getLength")
 366             || dc.Function("iterateCodePoints"))
 367         {
 368             handleSubExprThatCouldBeView(expr->getImplicitObjectArgument());
 369         }
 370     }
 371     return true;
 372 }
 373
 374 /** check for calls to O[U]StringBuffer constructor that could be passed as a
 375     std::u16string_view */
 376 bool StringView::VisitCXXConstructExpr(CXXConstructExpr const* expr)
 377 {
 378     if (ignoreLocation(expr))
 379     {
 380         return true;
 381     }
 382     if (!loplugin::TypeCheck(expr->getType())
 383              .Class("OUStringBuffer")
 384              .Namespace("rtl")
 385              .GlobalNamespace()
 386         && !loplugin::TypeCheck(expr->getType())
 387                 .Class("OStringBuffer")
 388                 .Namespace("rtl")
 389                 .GlobalNamespace())
 390     {
 391         return true;
 392     }
 393     if (!compiler.getLangOpts().CPlusPlus17 && expr->isElidable()) // external C++03 code
 394     {
 395         return true;
 396     }
 397     if (expr->getNumArgs() > 0)
 398         handleSubExprThatCouldBeView(expr->getArg(0));
 399     return true;
 400 }
 401
 402 loplugin::Plugin::Registration<StringView> stringview("stringview");
 403 }
 404
 405 #endif // LO_CLANG_SHARED_PLUGINS
 406
 407 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */