compilerplugins/clang/ostr.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 <stack>
  13
  14 #include "check.hxx"
  15 #include "compat.hxx"
  16 #include "plugin.hxx"
  17
  18 // Rewrite some uses of O[U]String to use ""_ostr/u""_ustr literals.
  19
  20 namespace
  21 {
  22 class Ostr : public loplugin::FilteringRewritePlugin<Ostr>
  23 {
  24 public:
  25     explicit Ostr(loplugin::InstantiationData const& data)
  26         : FilteringRewritePlugin(data)
  27     {
  28     }
  29
  30     // Needed so that e.g.
  31     //
  32     //   struct S { OUString s; };
  33     //   S s = {u"foo"};
  34     //
  35     // is caught:
  36     bool shouldVisitImplicitCode() const { return true; }
  37
  38     void run() override
  39     {
  40         if (compiler.getLangOpts().CPlusPlus
  41             && TraverseDecl(compiler.getASTContext().getTranslationUnitDecl()))
  42         {
  43             for (auto const& i : vars_)
  44             {
  45                 auto const utf16
  46                     = bool(loplugin::TypeCheck(i.first->getType()).Class("OUStringLiteral"));
  47                 if (i.second.singleUse == nullptr)
  48                 {
  49                     if (rewriter != nullptr)
  50                     {
  51                         auto e = i.first->getInit()->IgnoreParenImpCasts();
  52                         if (auto const e2 = dyn_cast<ConstantExpr>(e))
  53                         {
  54                             e = e2->getSubExpr()->IgnoreParenImpCasts();
  55                         }
  56                         if (auto const e2 = dyn_cast<CXXConstructExpr>(e))
  57                         {
  58                             assert(e2->getNumArgs() == 1);
  59                             e = e2->getArg(0)->IgnoreParenImpCasts();
  60                         }
  61                         e = dyn_cast<clang::StringLiteral>(e);
  62                         // e is null when this OUStringLiteral is initialized with another
  63                         // OUStringLiteral:
  64                         if (e == nullptr
  65                             || insertTextAfterToken(e->getEndLoc(), utf16 ? "_ustr" : "_ostr"))
  66                         {
  67                             auto ok = true;
  68                             for (auto d = i.first->getMostRecentDecl(); d != nullptr;
  69                                  d = d->getPreviousDecl())
  70                             {
  71                                 auto const l1 = d->getTypeSpecStartLoc();
  72                                 auto l2 = d->getTypeSpecEndLoc();
  73                                 l2 = l2.getLocWithOffset(Lexer::MeasureTokenLength(
  74                                     l2, compiler.getSourceManager(), compiler.getLangOpts()));
  75                                 if (!replaceText(l1, delta(l1, l2), utf16 ? "OUString" : "OString"))
  76                                 {
  77                                     ok = false;
  78                                 }
  79                             }
  80                             for (auto const i : i.second.explicitConversions)
  81                             {
  82                                 auto const e2 = i->getArg(0);
  83                                 auto l1 = i->getBeginLoc();
  84                                 auto l2 = e2->getBeginLoc();
  85                                 auto l3 = e2->getEndLoc();
  86                                 auto l4 = i->getEndLoc();
  87                                 while (compiler.getSourceManager().isMacroArgExpansion(l1)
  88                                        && compiler.getSourceManager().isMacroArgExpansion(l2)
  89                                        && compiler.getSourceManager().isMacroArgExpansion(l3)
  90                                        && compiler.getSourceManager().isMacroArgExpansion(l4))
  91                                 //TODO: check all four locations are part of the same macro argument
  92                                 // expansion
  93                                 {
  94                                     l1 = compiler.getSourceManager().getImmediateMacroCallerLoc(l1);
  95                                     l2 = compiler.getSourceManager().getImmediateMacroCallerLoc(l2);
  96                                     l3 = compiler.getSourceManager().getImmediateMacroCallerLoc(l3);
  97                                     l4 = compiler.getSourceManager().getImmediateMacroCallerLoc(l4);
  98                                 }
  99                                 l3 = l3.getLocWithOffset(Lexer::MeasureTokenLength(
 100                                     l3, compiler.getSourceManager(), compiler.getLangOpts()));
 101                                 l4 = l4.getLocWithOffset(Lexer::MeasureTokenLength(
 102                                     l4, compiler.getSourceManager(), compiler.getLangOpts()));
 103                                 removeText(l1, delta(l1, l2));
 104                                 removeText(l3, delta(l3, l4));
 105                             }
 106                             if (ok)
 107                             {
 108                                 continue;
 109                             }
 110                         }
 111                     }
 112                     report(DiagnosticsEngine::Warning,
 113                            "use '%select{OString|OUString}0', created from a %select{_ostr|_ustr}0 "
 114                            "user-defined string literal, instead of "
 115                            "'%select{OStringLiteral|OUStringLiteral}0' for the variable %1",
 116                            i.first->getLocation())
 117                         << utf16 << i.first->getName() << i.first->getSourceRange();
 118                     for (auto d = i.first->getMostRecentDecl(); d != nullptr;
 119                          d = d->getPreviousDecl())
 120                     {
 121                         if (d != i.first)
 122                         {
 123                             report(DiagnosticsEngine::Note, "variable %0 declared here",
 124                                    d->getLocation())
 125                                 << d->getName() << d->getSourceRange();
 126                         }
 127                     }
 128                 }
 129                 else
 130                 {
 131                     if (!compiler.getDiagnosticOpts().VerifyDiagnostics)
 132                     {
 133                         //TODO, left for later:
 134                         continue;
 135                     }
 136                     report(DiagnosticsEngine::Warning,
 137                            "directly use a %select{_ostr|_ustr}0 user-defined string literal "
 138                            "instead of introducing the intermediary "
 139                            "'%select{OStringLiteral|OUStringLiteral}0' variable %1",
 140                            i.second.singleUse->getExprLoc())
 141                         << utf16 << i.first->getName() << i.second.singleUse->getSourceRange();
 142                     for (auto d = i.first->getMostRecentDecl(); d != nullptr;
 143                          d = d->getPreviousDecl())
 144                     {
 145                         report(DiagnosticsEngine::Note, "intermediary variable %0 declared here",
 146                                d->getLocation())
 147                             << d->getName() << d->getSourceRange();
 148                     }
 149                 }
 150             }
 151         }
 152     }
 153
 154     bool TraverseParmVarDecl(ParmVarDecl* decl)
 155     {
 156         // Otherwise,
 157         //
 158         //   struct S { void f(int = 0); };
 159         //   void S::f(int) {}
 160         //
 161         // would visit the default argument twice:
 162         if (decl->hasDefaultArg() && !decl->hasUninstantiatedDefaultArg()
 163             && !decl->hasUnparsedDefaultArg() && !defaultArgs_.insert(decl->getDefaultArg()).second)
 164         {
 165             return true;
 166         }
 167         return RecursiveASTVisitor::TraverseParmVarDecl(decl);
 168     }
 169
 170     bool TraverseCXXFunctionalCastExpr(CXXFunctionalCastExpr* expr)
 171     {
 172         functionalCasts_.push(expr);
 173         auto const ret = RecursiveASTVisitor::TraverseCXXFunctionalCastExpr(expr);
 174         functionalCasts_.pop();
 175         return ret;
 176     }
 177
 178     bool VisitVarDecl(VarDecl const* decl)
 179     {
 180         if (ignoreLocation(decl))
 181         {
 182             return true;
 183         }
 184         if (!decl->isThisDeclarationADefinition())
 185         {
 186             return true;
 187         }
 188         loplugin::TypeCheck const tc(decl->getType());
 189         if (!(tc.Class("OStringLiteral").Namespace("rtl").GlobalNamespace()
 190               || tc.Class("OUStringLiteral").Namespace("rtl").GlobalNamespace()))
 191         {
 192             return true;
 193         }
 194         if (suppressWarningAt(decl->getLocation()))
 195         {
 196             return true;
 197         }
 198         vars_[decl].multipleUses
 199             = decl->getDeclContext()->isFileContext()
 200                   ? !compiler.getSourceManager().isInMainFile(decl->getLocation())
 201                   : decl->isExternallyVisible();
 202         return true;
 203     }
 204
 205     bool VisitDeclRefExpr(DeclRefExpr const* expr)
 206     {
 207         if (ignoreLocation(expr))
 208         {
 209             return true;
 210         }
 211         auto const d1 = dyn_cast<VarDecl>(expr->getDecl());
 212         if (d1 == nullptr)
 213         {
 214             return true;
 215         }
 216         auto const d2 = d1->getDefinition();
 217         if (d2 == nullptr)
 218         {
 219             return true;
 220         }
 221         auto const i = vars_.find(d2);
 222         if (i == vars_.end())
 223         {
 224             return true;
 225         }
 226         if (!i->second.multipleUses)
 227         {
 228             if (i->second.singleUse == nullptr)
 229             {
 230                 i->second.singleUse = expr;
 231             }
 232             else
 233             {
 234                 i->second.multipleUses = true;
 235                 i->second.singleUse = nullptr;
 236             }
 237         }
 238         return true;
 239     }
 240
 241     bool VisitCXXConstructExpr(CXXConstructExpr const* expr)
 242     {
 243         if (ignoreLocation(expr))
 244         {
 245             return true;
 246         }
 247         auto const dc = expr->getConstructor()->getParent();
 248         auto const utf16
 249             = bool(loplugin::DeclCheck(dc).Class("OUString").Namespace("rtl").GlobalNamespace());
 250         if (!(utf16 || loplugin::DeclCheck(dc).Class("OString").Namespace("rtl").GlobalNamespace()))
 251         {
 252             return true;
 253         }
 254         if (expr->getNumArgs() == 1
 255             && loplugin::TypeCheck(expr->getArg(0)->getType())
 256                    .Class(utf16 ? "OUStringLiteral" : "OStringLiteral")
 257                    .Namespace("rtl")
 258                    .GlobalNamespace())
 259         {
 260             if (functionalCasts_.empty()
 261                 || functionalCasts_.top()->getSubExpr()->IgnoreImplicit() != expr)
 262             {
 263                 return true;
 264             }
 265             auto const e = dyn_cast<DeclRefExpr>(expr->getArg(0)->IgnoreParenImpCasts());
 266             if (e == nullptr)
 267             {
 268                 return true;
 269             }
 270             auto const d1 = dyn_cast<VarDecl>(e->getDecl());
 271             if (d1 == nullptr)
 272             {
 273                 return true;
 274             }
 275             auto const d2 = d1->getDefinition();
 276             if (d2 == nullptr)
 277             {
 278                 return true;
 279             }
 280             auto const i = vars_.find(d2);
 281             if (i == vars_.end())
 282             {
 283                 return true;
 284             }
 285             i->second.explicitConversions.insert(expr);
 286             return true;
 287         }
 288         if (expr->getNumArgs() != 2)
 289         {
 290             return true;
 291         }
 292         if (!loplugin::TypeCheck(expr->getArg(1)->getType())
 293                  .Struct("Dummy")
 294                  .Namespace("libreoffice_internal")
 295                  .Namespace("rtl")
 296                  .GlobalNamespace())
 297         {
 298             return true;
 299         }
 300         auto const e2 = dyn_cast<clang::StringLiteral>(expr->getArg(0)->IgnoreParenImpCasts());
 301         if (e2 == nullptr)
 302         {
 303             return true;
 304         }
 305         if (!(compat::isOrdinary(e2) || e2->isUTF8()))
 306         {
 307             return true;
 308         }
 309         auto const temp = isa<CXXTemporaryObjectExpr>(expr)
 310                           || (!functionalCasts_.empty()
 311                               && functionalCasts_.top()->getSubExpr()->IgnoreImplicit() == expr);
 312         auto const e1 = temp ? static_cast<Expr const*>(expr) : static_cast<Expr const*>(e2);
 313         auto l1 = e1->getBeginLoc();
 314         auto l2 = e2->getBeginLoc();
 315         auto l3 = e2->getEndLoc();
 316         auto l4 = e1->getEndLoc();
 317         while (compiler.getSourceManager().isMacroArgExpansion(l1)
 318                && compiler.getSourceManager().isMacroArgExpansion(l2)
 319                && compiler.getSourceManager().isMacroArgExpansion(l3)
 320                && compiler.getSourceManager().isMacroArgExpansion(l4))
 321         //TODO: check all four locations are part of the same macro argument expansion
 322         {
 323             l1 = compiler.getSourceManager().getImmediateMacroCallerLoc(l1);
 324             l2 = compiler.getSourceManager().getImmediateMacroCallerLoc(l2);
 325             l3 = compiler.getSourceManager().getImmediateMacroCallerLoc(l3);
 326             l4 = compiler.getSourceManager().getImmediateMacroCallerLoc(l4);
 327         }
 328         if (!locs_.insert(l1).second)
 329         {
 330             return true;
 331         }
 332         auto const macroBegin = l2.isMacroID()
 333                                 && Lexer::isAtStartOfMacroExpansion(l2, compiler.getSourceManager(),
 334                                                                     compiler.getLangOpts());
 335         if (macroBegin)
 336         {
 337             l2 = compiler.getSourceManager().getImmediateMacroCallerLoc(l2);
 338         }
 339         auto const macroEnd = l3.isMacroID()
 340                               && Lexer::isAtEndOfMacroExpansion(l3, compiler.getSourceManager(),
 341                                                                 compiler.getLangOpts());
 342         if (macroEnd)
 343         {
 344             l3 = compiler.getSourceManager().getImmediateMacroCallerLoc(l3);
 345         }
 346         if (!temp)
 347         {
 348             l1 = l2;
 349             l4 = l3;
 350         }
 351         if (isInUnoIncludeFile(compiler.getSourceManager().getSpellingLoc(l1)))
 352         {
 353             return true;
 354         }
 355         if (!compiler.getDiagnosticOpts().VerifyDiagnostics && utf16)
 356         {
 357             //TODO: Leave rewriting these uses of ordinary string literals for later (but already
 358             // cover them when verifying CompilerTest_compilerplugins_clang):
 359             return true;
 360         }
 361         if (rewriter != nullptr && isSpellingRange(l1, l2) && isSpellingRange(l3, l4))
 362         {
 363             l3 = l3.getLocWithOffset(
 364                 Lexer::MeasureTokenLength(l3, compiler.getSourceManager(), compiler.getLangOpts()));
 365             l4 = l4.getLocWithOffset(
 366                 Lexer::MeasureTokenLength(l4, compiler.getSourceManager(), compiler.getLangOpts()));
 367             if (replaceText(l1, delta(l1, l2), utf16 ? (macroBegin ? "u\"\" " : "u") : "")
 368                 && replaceText(l3, delta(l3, l4),
 369                                utf16 ? (macroEnd ? " \"\"_ustr" : "_ustr")
 370                                      : (macroEnd ? " \"\"_ostr" : "_ostr")))
 371             {
 372                 return true;
 373             }
 374         }
 375         report(DiagnosticsEngine::Warning,
 376                "use a %select{_ostr|_ustr}0 user-defined string literal instead of constructing an"
 377                " instance of %1 from an ordinary string literal",
 378                expr->getExprLoc())
 379             << utf16 << expr->getType().getLocalUnqualifiedType() << expr->getSourceRange();
 380         return true;
 381     }
 382
 383     bool VisitCXXOperatorCallExpr(CXXOperatorCallExpr const* expr)
 384     {
 385         if (ignoreLocation(expr))
 386         {
 387             return true;
 388         }
 389         if (expr->getOperator() != OO_Equal)
 390         {
 391             return true;
 392         }
 393         if (!loplugin::TypeCheck(expr->getArg(0)->getType())
 394                  .Class("OString")
 395                  .Namespace("rtl")
 396                  .GlobalNamespace())
 397         {
 398             return true;
 399         }
 400         auto const e2 = dyn_cast<clang::StringLiteral>(expr->getArg(1)->IgnoreParenImpCasts());
 401         if (e2 == nullptr)
 402         {
 403             return true;
 404         }
 405         if (rewriter != nullptr)
 406         {
 407             auto loc = e2->getEndLoc();
 408             auto const macroEnd = loc.isMacroID()
 409                                   && Lexer::isAtEndOfMacroExpansion(
 410                                          loc, compiler.getSourceManager(), compiler.getLangOpts());
 411             if (macroEnd)
 412             {
 413                 loc = compiler.getSourceManager().getImmediateMacroCallerLoc(loc);
 414             }
 415             if (insertTextAfterToken(loc, macroEnd ? " \"\"_ostr" : "_ostr"))
 416             {
 417                 return true;
 418             }
 419         }
 420         report(DiagnosticsEngine::Warning,
 421                "use a _ostr user-defined string literal instead of assigning from an ordinary"
 422                " string literal",
 423                expr->getExprLoc())
 424             << expr->getSourceRange();
 425         return true;
 426     }
 427
 428     bool VisitCXXMemberCallExpr(CXXMemberCallExpr const* expr)
 429     {
 430         if (ignoreLocation(expr))
 431         {
 432             return true;
 433         }
 434         if (!loplugin::DeclCheck(expr->getMethodDecl()).Operator(OO_Equal))
 435         {
 436             return true;
 437         }
 438         if (!loplugin::TypeCheck(expr->getObjectType())
 439                  .Class("OString")
 440                  .Namespace("rtl")
 441                  .GlobalNamespace())
 442         {
 443             return true;
 444         }
 445         auto const e2 = dyn_cast<clang::StringLiteral>(expr->getArg(0)->IgnoreParenImpCasts());
 446         if (e2 == nullptr)
 447         {
 448             return true;
 449         }
 450         if (rewriter != nullptr)
 451         {
 452             //TODO
 453         }
 454         report(DiagnosticsEngine::Warning,
 455                "use a _ostr user-defined string literal instead of assigning from an ordinary"
 456                " string literal",
 457                expr->getExprLoc())
 458             << expr->getSourceRange();
 459         return true;
 460     }
 461
 462     bool VisitCastExpr(CastExpr const* expr)
 463     {
 464         if (ignoreLocation(expr))
 465         {
 466             return true;
 467         }
 468         auto const t1 = expr->getType().getNonReferenceType();
 469         auto const tc1 = loplugin::TypeCheck(t1);
 470         if (!(tc1.ClassOrStruct("basic_string").StdNamespace()
 471               || tc1.ClassOrStruct("basic_string_view").StdNamespace()))
 472         {
 473             return true;
 474         }
 475         auto const e2 = dyn_cast<UserDefinedLiteral>(expr->getSubExprAsWritten());
 476         if (e2 == nullptr)
 477         {
 478             return true;
 479         }
 480         auto const tc2 = loplugin::TypeCheck(e2->getType());
 481         if (!(tc2.Class("OString").Namespace("rtl").GlobalNamespace()
 482               || tc2.Class("OUString").Namespace("rtl").GlobalNamespace()))
 483         {
 484             return true;
 485         }
 486         report(DiagnosticsEngine::Warning,
 487                "directly use a %0 value instead of a %select{_ostr|_ustr}1 user-defined string"
 488                " literal",
 489                expr->getExprLoc())
 490             << t1.getUnqualifiedType() << bool(tc2.Class("OUString")) << expr->getSourceRange();
 491         return true;
 492     }
 493
 494 private:
 495     bool isSpellingRange(SourceLocation loc1, SourceLocation loc2)
 496     {
 497         if (!SourceLocation::isPairOfFileLocations(loc1, loc2))
 498         {
 499             return false;
 500         }
 501         if (compiler.getSourceManager().getFileID(loc1)
 502             != compiler.getSourceManager().getFileID(loc2))
 503         {
 504             return false;
 505         }
 506         return loc1 <= loc2;
 507     }
 508
 509     unsigned delta(SourceLocation loc1, SourceLocation loc2)
 510     {
 511         return compiler.getSourceManager().getDecomposedLoc(loc2).second
 512                - compiler.getSourceManager().getDecomposedLoc(loc1).second;
 513     }
 514
 515     struct Var
 516     {
 517         bool multipleUses = false;
 518         DeclRefExpr const* singleUse = nullptr;
 519         std::set<CXXConstructExpr const*> explicitConversions;
 520     };
 521
 522     std::set<Expr const*> defaultArgs_;
 523     std::stack<CXXFunctionalCastExpr const*> functionalCasts_;
 524     std::set<SourceLocation> locs_;
 525     std::map<VarDecl const*, Var> vars_;
 526 };
 527
 528 loplugin::Plugin::Registration<Ostr> X("ostr", true);
 529 }
 530
 531 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */