compilerplugins/clang/flatten.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
  10 #include "compat.hxx"
  11 #include "plugin.hxx"
  12 #include <cassert>
  13 #include <string>
  14 #include <iostream>
  15 #include <fstream>
  16 #include <set>
  17 #include <stack>
  18
  19 /**
  20   Look for places where we can flatten the control flow in a method by returning early.
  21  */
  22 namespace {
  23
  24 class Flatten:
  25     public loplugin::FilteringRewritePlugin<Flatten>
  26 {
  27 public:
  28     explicit Flatten(loplugin::InstantiationData const & data):
  29         FilteringRewritePlugin(data) {}
  30
  31     virtual void run() override
  32     {
  33         TraverseDecl(compiler.getASTContext().getTranslationUnitDecl());
  34     }
  35
  36     bool TraverseIfStmt(IfStmt *);
  37     bool TraverseCXXCatchStmt(CXXCatchStmt * );
  38     bool TraverseCompoundStmt(CompoundStmt *);
  39     bool TraverseFunctionDecl(FunctionDecl *);
  40     bool TraverseCXXMethodDecl(CXXMethodDecl *);
  41     bool TraverseCXXConstructorDecl(CXXConstructorDecl *);
  42     bool TraverseCXXConversionDecl(CXXConversionDecl *);
  43     bool TraverseCXXDestructorDecl(CXXDestructorDecl *);
  44     bool VisitIfStmt(IfStmt const * );
  45 private:
  46     bool rewrite1(IfStmt const * );
  47     bool rewrite2(IfStmt const * );
  48     bool rewriteLargeIf(IfStmt const * );
  49     SourceRange ignoreMacroExpansions(SourceRange range);
  50     SourceRange extendOverComments(SourceRange range);
  51     std::string getSourceAsString(SourceRange range);
  52     compat::optional<std::string> invertCondition(
  53         Expr const * condExpr, SourceRange conditionRange);
  54     bool isLargeCompoundStmt(Stmt const *);
  55
  56     Stmt const * lastStmtInCompoundStmt = nullptr;
  57     FunctionDecl const * functionDecl = nullptr;
  58     CompoundStmt const * functionDeclBody = nullptr;
  59     Stmt const * mElseBranch = nullptr;
  60 };
  61
  62 static Stmt const * containsSingleThrowExpr(Stmt const * stmt)
  63 {
  64     if (auto compoundStmt = dyn_cast<CompoundStmt>(stmt)) {
  65         if (compoundStmt->size() != 1)
  66             return nullptr;
  67         stmt = *compoundStmt->body_begin();
  68     }
  69     if (auto exprWithCleanups = dyn_cast<ExprWithCleanups>(stmt)) {
  70         stmt = exprWithCleanups->getSubExpr();
  71     }
  72     return dyn_cast<CXXThrowExpr>(stmt);
  73 }
  74
  75 static bool containsVarDecl(Stmt const * stmt)
  76 {
  77     if (auto compoundStmt = dyn_cast<CompoundStmt>(stmt)) {
  78         for (auto i = compoundStmt->body_begin(); i != compoundStmt->body_end(); ++i) {
  79             auto declStmt = dyn_cast<DeclStmt>(*i);
  80             if (declStmt && isa<VarDecl>(*declStmt->decl_begin()))
  81                 return true;
  82         }
  83         return false;
  84     }
  85     auto declStmt = dyn_cast<DeclStmt>(stmt);
  86     return declStmt && isa<VarDecl>(*declStmt->decl_begin());
  87 }
  88
  89 bool Flatten::TraverseCXXCatchStmt(CXXCatchStmt* )
  90 {
  91     // ignore stuff inside catch statements, where doing a "if...else..throw" is more natural
  92     return true;
  93 }
  94
  95 bool Flatten::TraverseIfStmt(IfStmt * ifStmt)
  96 {
  97     if (!WalkUpFromIfStmt(ifStmt)) {
  98         return false;
  99     }
 100     auto const saved = mElseBranch;
 101     mElseBranch = ifStmt->getElse();
 102     auto ret = true;
 103     for (auto const sub: ifStmt->children()) {
 104         if (!TraverseStmt(sub)) {
 105             ret = false;
 106             break;
 107         }
 108     }
 109     mElseBranch = saved;
 110     return ret;
 111 }
 112
 113 bool Flatten::TraverseCompoundStmt(CompoundStmt * compoundStmt)
 114 {
 115     auto copy = lastStmtInCompoundStmt;
 116     if (compoundStmt->size() > 0)
 117         lastStmtInCompoundStmt = compoundStmt->body_back();
 118     else
 119         lastStmtInCompoundStmt = nullptr;
 120
 121     bool rv = RecursiveASTVisitor<Flatten>::TraverseCompoundStmt(compoundStmt);
 122
 123     lastStmtInCompoundStmt = copy;
 124     return rv;
 125 }
 126
 127 bool Flatten::TraverseFunctionDecl(FunctionDecl * fd)
 128 {
 129     auto copy1 = functionDeclBody;
 130     auto copy2 = fd;
 131     functionDeclBody = dyn_cast_or_null<CompoundStmt>(fd->getBody());
 132     functionDecl = fd;
 133     bool rv = RecursiveASTVisitor<Flatten>::TraverseFunctionDecl(fd);
 134     functionDeclBody = copy1;
 135     functionDecl = copy2;
 136     return rv;
 137 }
 138
 139 bool Flatten::TraverseCXXMethodDecl(CXXMethodDecl * fd)
 140 {
 141     auto copy1 = functionDeclBody;
 142     auto copy2 = fd;
 143     functionDeclBody = dyn_cast_or_null<CompoundStmt>(fd->getBody());
 144     functionDecl = fd;
 145     bool rv = RecursiveASTVisitor<Flatten>::TraverseCXXMethodDecl(fd);
 146     functionDeclBody = copy1;
 147     functionDecl = copy2;
 148     return rv;
 149 }
 150
 151 bool Flatten::TraverseCXXConstructorDecl(CXXConstructorDecl * fd)
 152 {
 153     auto copy1 = functionDeclBody;
 154     auto copy2 = fd;
 155     functionDeclBody = dyn_cast_or_null<CompoundStmt>(fd->getBody());
 156     functionDecl = fd;
 157     bool rv = RecursiveASTVisitor<Flatten>::TraverseCXXConstructorDecl(fd);
 158     functionDeclBody = copy1;
 159     functionDecl = copy2;
 160     return rv;
 161 }
 162
 163 bool Flatten::TraverseCXXConversionDecl(CXXConversionDecl * fd)
 164 {
 165     auto copy1 = functionDeclBody;
 166     auto copy2 = fd;
 167     functionDeclBody = dyn_cast_or_null<CompoundStmt>(fd->getBody());
 168     functionDecl = fd;
 169     bool rv = RecursiveASTVisitor<Flatten>::TraverseCXXConversionDecl(fd);
 170     functionDeclBody = copy1;
 171     functionDecl = copy2;
 172     return rv;
 173 }
 174
 175 bool Flatten::TraverseCXXDestructorDecl(CXXDestructorDecl * fd)
 176 {
 177     auto copy1 = functionDeclBody;
 178     auto copy2 = fd;
 179     functionDeclBody = dyn_cast_or_null<CompoundStmt>(fd->getBody());
 180     functionDecl = fd;
 181     bool rv = RecursiveASTVisitor<Flatten>::TraverseCXXDestructorDecl(fd);
 182     functionDeclBody = copy1;
 183     functionDecl = copy2;
 184     return rv;
 185 }
 186
 187
 188 bool Flatten::VisitIfStmt(IfStmt const * ifStmt)
 189 {
 190     if (ignoreLocation(ifStmt))
 191         return true;
 192
 193     // ignore if we are part of an if/then/else/if chain
 194     if (ifStmt == mElseBranch || (ifStmt->getElse() && isa<IfStmt>(ifStmt->getElse())))
 195         return true;
 196
 197     // look for a large if(){} block at the end of a function
 198     if (!ifStmt->getElse()
 199         && (functionDecl->getReturnType().isNull() || functionDecl->getReturnType()->isVoidType())
 200         && functionDeclBody && functionDeclBody->size()
 201         && functionDeclBody->body_back() == ifStmt
 202         && isLargeCompoundStmt(ifStmt->getThen()))
 203     {
 204         if (!rewriteLargeIf(ifStmt))
 205         {
 206             report(
 207                 DiagnosticsEngine::Warning,
 208                 "large if statement at end of function, rather invert the condition and exit early, and flatten the function",
 209                 ifStmt->getBeginLoc())
 210               << ifStmt->getSourceRange();
 211         }
 212         return true;
 213     }
 214
 215     if (!ifStmt->getElse())
 216         return true;
 217
 218     auto const thenThrowExpr = containsSingleThrowExpr(ifStmt->getThen());
 219     auto const elseThrowExpr = containsSingleThrowExpr(ifStmt->getElse());
 220     // If neither contains a throw, nothing to do; if both contain throws, no
 221     // improvement:
 222     if ((thenThrowExpr == nullptr) == (elseThrowExpr == nullptr)) {
 223         return true;
 224     }
 225
 226     if (containsPreprocessingConditionalInclusion(ifStmt->getSourceRange())) {
 227         return true;
 228     }
 229
 230     if (elseThrowExpr)
 231     {
 232         // if the "if" statement is not the last statement in its block, and it contains
 233         // var decls in its then block, we cannot de-indent the then block without
 234         // extending the lifetime of some variables, which may be problematic
 235         if (ifStmt != lastStmtInCompoundStmt && containsVarDecl(ifStmt->getThen()))
 236             return true;
 237
 238         if (!rewrite1(ifStmt))
 239         {
 240             report(
 241                 DiagnosticsEngine::Warning,
 242                 "unconditional throw in else branch, rather invert the condition, throw early, and flatten the normal case",
 243                 elseThrowExpr->getBeginLoc())
 244                 << elseThrowExpr->getSourceRange();
 245             report(
 246                 DiagnosticsEngine::Note,
 247                 "if condition here",
 248                 ifStmt->getBeginLoc())
 249                 << ifStmt->getSourceRange();
 250         }
 251     }
 252     if (thenThrowExpr)
 253     {
 254         // if the "if" statement is not the last statement in its block, and it contains
 255         // var decls in its else block, we cannot de-indent the else block without
 256         // extending the lifetime of some variables, which may be problematic
 257         if (ifStmt != lastStmtInCompoundStmt && containsVarDecl(ifStmt->getElse()))
 258             return true;
 259
 260         if (!rewrite2(ifStmt))
 261         {
 262             report(
 263                 DiagnosticsEngine::Warning,
 264                 "unconditional throw in then branch, just flatten the else",
 265                 thenThrowExpr->getBeginLoc())
 266                 << thenThrowExpr->getSourceRange();
 267         }
 268     }
 269     return true;
 270 }
 271
 272 static std::string stripOpenAndCloseBrace(std::string s);
 273 static std::string stripTrailingEmptyLines(std::string s);
 274 static std::string deindent(std::string const & s);
 275 static std::vector<std::string> split(std::string s);
 276 static bool startswith(std::string const & rStr, char const * pSubStr);
 277 static int countLeadingSpaces(std::string const &);
 278 static std::string padSpace(int iNoSpaces);
 279 static bool replace(std::string & s, std::string const & from, std::string const & to);
 280
 281 bool Flatten::rewrite1(IfStmt const * ifStmt)
 282 {
 283     if (!rewriter)
 284         return false;
 285
 286     auto conditionRange = ignoreMacroExpansions(ifStmt->getCond()->getSourceRange());
 287     if (!conditionRange.isValid()) {
 288         return false;
 289     }
 290     auto thenRange = ignoreMacroExpansions(ifStmt->getThen()->getSourceRange());
 291     if (!thenRange.isValid()) {
 292         return false;
 293     }
 294     auto elseRange = ignoreMacroExpansions(ifStmt->getElse()->getSourceRange());
 295     if (!elseRange.isValid()) {
 296         return false;
 297     }
 298     SourceRange elseKeywordRange = ifStmt->getElseLoc();
 299
 300     thenRange = extendOverComments(thenRange);
 301     elseRange = extendOverComments(elseRange);
 302     elseKeywordRange = extendOverComments(elseKeywordRange);
 303
 304     // in adjusting the formatting I assume that "{" starts on a new line
 305
 306     compat::optional<std::string> conditionString = invertCondition(ifStmt->getCond(), conditionRange);
 307     if (!conditionString)
 308         return false;
 309
 310     std::string thenString = getSourceAsString(thenRange);
 311     if (auto compoundStmt = dyn_cast<CompoundStmt>(ifStmt->getThen())) {
 312         if (compoundStmt->getLBracLoc().isValid()) {
 313             thenString = stripOpenAndCloseBrace(thenString);
 314         }
 315     }
 316     thenString = deindent(thenString);
 317
 318     std::string elseString = getSourceAsString(elseRange);
 319
 320     if (!replaceText(elseRange, thenString)) {
 321         return false;
 322     }
 323     if (!removeText(elseKeywordRange)) {
 324         return false;
 325     }
 326     if (!replaceText(thenRange, elseString)) {
 327         return false;
 328     }
 329     if (!replaceText(conditionRange, *conditionString)) {
 330         return false;
 331     }
 332
 333     return true;
 334 }
 335
 336 bool Flatten::rewrite2(IfStmt const * ifStmt)
 337 {
 338     if (!rewriter)
 339         return false;
 340
 341     auto conditionRange = ignoreMacroExpansions(ifStmt->getCond()->getSourceRange());
 342     if (!conditionRange.isValid()) {
 343         return false;
 344     }
 345     auto thenRange = ignoreMacroExpansions(ifStmt->getThen()->getSourceRange());
 346     if (!thenRange.isValid()) {
 347         return false;
 348     }
 349     auto elseRange = ignoreMacroExpansions(ifStmt->getElse()->getSourceRange());
 350     if (!elseRange.isValid()) {
 351         return false;
 352     }
 353     SourceRange elseKeywordRange = ifStmt->getElseLoc();
 354
 355     elseRange = extendOverComments(elseRange);
 356     elseKeywordRange = extendOverComments(elseKeywordRange);
 357
 358     // in adjusting the formatting I assume that "{" starts on a new line
 359
 360     std::string elseString = getSourceAsString(elseRange);
 361     if (auto compoundStmt = dyn_cast<CompoundStmt>(ifStmt->getElse())) {
 362         if (compoundStmt->getLBracLoc().isValid()) {
 363             elseString = stripOpenAndCloseBrace(elseString);
 364         }
 365     }
 366     elseString = deindent(elseString);
 367
 368     if (!replaceText(elseRange, elseString)) {
 369         return false;
 370     }
 371     if (!removeText(elseKeywordRange)) {
 372         return false;
 373     }
 374
 375     return true;
 376 }
 377
 378 bool Flatten::rewriteLargeIf(IfStmt const * ifStmt)
 379 {
 380     if (!rewriter)
 381         return false;
 382
 383     auto conditionRange = ignoreMacroExpansions(ifStmt->getCond()->getSourceRange());
 384     if (!conditionRange.isValid()) {
 385         return false;
 386     }
 387     auto thenRange = ignoreMacroExpansions(ifStmt->getThen()->getSourceRange());
 388     if (!thenRange.isValid()) {
 389         return false;
 390     }
 391
 392     thenRange = extendOverComments(thenRange);
 393
 394     // in adjusting the formatting I assume that "{" starts on a new line
 395
 396     compat::optional<std::string> conditionString = invertCondition(ifStmt->getCond(), conditionRange);
 397     if (!conditionString)
 398         return false;
 399
 400     std::string thenString = getSourceAsString(thenRange);
 401     if (auto compoundStmt = dyn_cast<CompoundStmt>(ifStmt->getThen())) {
 402         if (compoundStmt->getLBracLoc().isValid()) {
 403             thenString = stripOpenAndCloseBrace(thenString);
 404         }
 405     }
 406     int iNoSpaces = countLeadingSpaces(thenString);
 407     thenString = padSpace(iNoSpaces) + "return;\n\n" + deindent(thenString);
 408     thenString = stripTrailingEmptyLines(thenString);
 409
 410     if (!replaceText(thenRange, thenString)) {
 411         return false;
 412     }
 413     if (!replaceText(conditionRange, *conditionString)) {
 414         return false;
 415     }
 416
 417     return true;
 418 }
 419
 420 compat::optional<std::string> Flatten::invertCondition(Expr const * condExpr, SourceRange conditionRange)
 421 {
 422     std::string s = getSourceAsString(conditionRange);
 423
 424     condExpr = condExpr->IgnoreImpCasts();
 425
 426     if (auto exprWithCleanups = dyn_cast<ExprWithCleanups>(condExpr))
 427         condExpr = exprWithCleanups->getSubExpr()->IgnoreImpCasts();
 428
 429     // an if statement will automatically invoke a bool-conversion method
 430     if (auto memberCallExpr = dyn_cast<CXXMemberCallExpr>(condExpr))
 431     {
 432         if (memberCallExpr->getMethodDecl() && isa<CXXConversionDecl>(memberCallExpr->getMethodDecl()))
 433             condExpr = memberCallExpr->getImplicitObjectArgument()->IgnoreImpCasts();
 434     }
 435
 436     if (auto unaryOp = dyn_cast<UnaryOperator>(condExpr))
 437     {
 438         if (unaryOp->getOpcode() != UO_LNot)
 439             return "!(" + s + ")";
 440         auto i = s.find("!");
 441         assert (i != std::string::npos);
 442         s = s.substr(i+1);
 443     }
 444     else if (auto binaryOp = dyn_cast<BinaryOperator>(condExpr))
 445     {
 446         bool ok = true;
 447         switch (binaryOp->getOpcode())
 448         {
 449             case BO_LT: ok = replace(s, "<", ">="); break;
 450             case BO_GT: ok = replace(s, ">", "<="); break;
 451             case BO_LE: ok = replace(s, "<=", ">"); break;
 452             case BO_GE: ok = replace(s, ">=", "<"); break;
 453             case BO_EQ: ok = replace(s, "==", "!="); break;
 454             case BO_NE: ok = replace(s, "!=", "=="); break;
 455             default:
 456                 s = "!(" + s + ")";
 457         }
 458         if (!ok)
 459            return compat::optional<std::string>();
 460     }
 461     else if (auto opCallExpr = dyn_cast<CXXOperatorCallExpr>(condExpr))
 462     {
 463         bool ok = true;
 464         switch (opCallExpr->getOperator())
 465         {
 466             case OO_Less: ok = replace(s, "<", ">="); break;
 467             case OO_Greater: ok = replace(s, ">", "<="); break;
 468             case OO_LessEqual: ok = replace(s, "<=", ">"); break;
 469             case OO_GreaterEqual: ok = replace(s, ">=", "<"); break;
 470             case OO_EqualEqual: ok = replace(s, "==", "!="); break;
 471             case OO_ExclaimEqual: ok = replace(s, "!=", "=="); break;
 472             default:
 473                 s = "!(" + s + ")";
 474         }
 475         if (!ok)
 476             return compat::optional<std::string>();
 477     }
 478     else if (isa<DeclRefExpr>(condExpr) || isa<CallExpr>(condExpr) || isa<MemberExpr>(condExpr))
 479         s = "!" + s;
 480     else
 481         s = "!(" + s + ")";
 482     return s;
 483 }
 484
 485 std::string stripOpenAndCloseBrace(std::string s)
 486 {
 487     size_t i = s.find("{");
 488     if (i == std::string::npos)
 489     {
 490         assert( !"did not find {" );
 491         abort();
 492     }
 493
 494     ++i;
 495     // strip to line end
 496     while (s[i] == ' ')
 497         ++i;
 498     if (s[i] == '\n')
 499          ++i;
 500     s = s.substr(i);
 501
 502     i = s.rfind("}");
 503     if (i == std::string::npos)
 504     {
 505         assert( !"did not find }" );
 506         abort();
 507     }
 508     --i;
 509     while (s[i] == ' ')
 510         --i;
 511     s = s.substr(0,i);
 512     return s;
 513 }
 514
 515 std::string deindent(std::string const & s)
 516 {
 517     std::vector<std::string> lines = split(s);
 518     std::string rv;
 519     for (auto s : lines) {
 520         if (startswith(s, "    "))
 521             rv += s.substr(4);
 522         else
 523             rv += s;
 524         rv += "\n";
 525     }
 526     return rv;
 527 }
 528
 529 std::vector<std::string> split(std::string s)
 530 {
 531     if (s.back() == '\n')
 532         s = s.substr(0, s.size()-1);
 533     size_t next = -1;
 534     std::vector<std::string> rv;
 535     do
 536     {
 537         size_t current = next + 1;
 538         next = s.find_first_of( "\n", current );
 539         rv.push_back(s.substr( current, next - current ));
 540     }
 541     while (next != std::string::npos);
 542     return rv;
 543 }
 544
 545 bool startswith(std::string const & rStr, char const * pSubStr)
 546 {
 547     return rStr.compare(0, strlen(pSubStr), pSubStr) == 0;
 548 }
 549
 550 int countLeadingSpaces(std::string const & s)
 551 {
 552     int i = 0;
 553     while (i < (int)s.length() && s[i] == ' ')
 554         i++;
 555     return i;
 556 }
 557
 558 std::string padSpace(int iNoSpaces)
 559 {
 560     std::string s;
 561     for (int i = 0; i < iNoSpaces; ++i)
 562         s += " ";
 563     return s;
 564 }
 565
 566 std::string stripTrailingEmptyLines(std::string s)
 567 {
 568     while (s.back() == '\n')
 569         s.resize(s.length() - 1);
 570     return s;
 571 }
 572
 573 bool replace(std::string & s, std::string const & from, std::string const & to)
 574 {
 575     auto i = s.find(from);
 576     assert (i != std::string::npos);
 577     s.replace(i, from.length(), to);
 578     // just in case we have something really weird, like the operator token is also present in the rest of the condition somehow
 579    return s.find(from) == std::string::npos;
 580 }
 581
 582 SourceRange Flatten::ignoreMacroExpansions(SourceRange range) {
 583     while (compiler.getSourceManager().isMacroArgExpansion(range.getBegin())) {
 584         range.setBegin(
 585             compiler.getSourceManager().getImmediateMacroCallerLoc(
 586                 range.getBegin()));
 587     }
 588     if (range.getBegin().isMacroID()) {
 589         SourceLocation loc;
 590         if (Lexer::isAtStartOfMacroExpansion(
 591                 range.getBegin(), compiler.getSourceManager(),
 592                 compiler.getLangOpts(), &loc))
 593         {
 594             range.setBegin(loc);
 595         }
 596     }
 597     while (compiler.getSourceManager().isMacroArgExpansion(range.getEnd())) {
 598         range.setEnd(
 599             compiler.getSourceManager().getImmediateMacroCallerLoc(
 600                 range.getEnd()));
 601     }
 602     if (range.getEnd().isMacroID()) {
 603         SourceLocation loc;
 604         if (Lexer::isAtEndOfMacroExpansion(
 605                 range.getEnd(), compiler.getSourceManager(),
 606                 compiler.getLangOpts(), &loc))
 607         {
 608             range.setEnd(loc);
 609         }
 610     }
 611     return range.getBegin().isMacroID() || range.getEnd().isMacroID()
 612         ? SourceRange() : range;
 613 }
 614
 615 /**
 616  * Extend the SourceRange to include any leading and trailing whitespace, and any comments.
 617  */
 618 SourceRange Flatten::extendOverComments(SourceRange range)
 619 {
 620     SourceManager& SM = compiler.getSourceManager();
 621     SourceLocation startLoc = range.getBegin();
 622     SourceLocation endLoc = range.getEnd();
 623     char const *p1 = SM.getCharacterData( startLoc );
 624     char const *p2 = SM.getCharacterData( endLoc );
 625
 626     // scan backwards from the beginning to include any spaces on that line
 627     while (*(p1-1) == ' ')
 628         --p1;
 629     startLoc = startLoc.getLocWithOffset(p1 - SM.getCharacterData( startLoc ));
 630
 631     // look for trailing ";"
 632     while (*(p2+1) == ';')
 633         ++p2;
 634     // look for trailing " "
 635     while (*(p2+1) == ' ')
 636         ++p2;
 637     // look for single line comments attached to the end of the statement
 638     if (*(p2+1) == '/' && *(p2+2) == '/')
 639     {
 640         p2 += 2;
 641         while (*(p2+1) && *(p2+1) != '\n')
 642             ++p2;
 643         if (*(p2+1) == '\n')
 644             ++p2;
 645     }
 646     else
 647     {
 648         // make the source code we extract include any trailing "\n"
 649         if (*(p2+1) == '\n')
 650             ++p2;
 651     }
 652     endLoc = endLoc.getLocWithOffset(p2 - SM.getCharacterData( endLoc ));
 653
 654     return SourceRange(startLoc, endLoc);
 655 }
 656
 657 std::string Flatten::getSourceAsString(SourceRange range)
 658 {
 659     SourceManager& SM = compiler.getSourceManager();
 660     SourceLocation startLoc = range.getBegin();
 661     SourceLocation endLoc = range.getEnd();
 662     char const *p1 = SM.getCharacterData( startLoc );
 663     char const *p2 = SM.getCharacterData( endLoc );
 664     p2 += Lexer::MeasureTokenLength( endLoc, SM, compiler.getLangOpts());
 665     if (p2 < p1) {
 666         // workaround clang weirdness, but don't return empty string
 667         // in case it happens during code replacement
 668         return "clang returned bad pointers";
 669     }
 670     if (p2 - p1 > 64 * 1024) {
 671         // workaround clang weirdness, but don't return empty string
 672         // in case it happens during code replacement
 673         return "clang returned overlay large source range";
 674     }
 675     return std::string( p1, p2 - p1);
 676 }
 677
 678 bool Flatten::isLargeCompoundStmt(Stmt const * stmt)
 679 {
 680     auto stmtRange = stmt->getSourceRange();
 681     std::string s = getSourceAsString(stmtRange);
 682     return std::count(s.begin(), s.end(), '\n') > 10;
 683 }
 684
 685 loplugin::Plugin::Registration< Flatten > X("flatten", false);
 686
 687 }
 688
 689 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */