contrib/llvm/tools/clang/lib/ARCMigrate/TransformActions.cpp

   1 //===--- ARCMT.cpp - Migration to ARC mode --------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "Internals.h"
  11 #include "clang/AST/ASTContext.h"
  12 #include "clang/AST/Expr.h"
  13 #include "clang/Basic/SourceManager.h"
  14 #include "clang/Lex/Preprocessor.h"
  15 #include "llvm/ADT/DenseSet.h"
  16 #include <map>
  17 using namespace clang;
  18 using namespace arcmt;
  19
  20 namespace {
  21
  22 /// \brief Collects transformations and merges them before applying them with
  23 /// with applyRewrites(). E.g. if the same source range
  24 /// is requested to be removed twice, only one rewriter remove will be invoked.
  25 /// Rewrites happen in "transactions"; if one rewrite in the transaction cannot
  26 /// be done (e.g. it resides in a macro) all rewrites in the transaction are
  27 /// aborted.
  28 /// FIXME: "Transactional" rewrites support should be baked in the Rewriter.
  29 class TransformActionsImpl {
  30   CapturedDiagList &CapturedDiags;
  31   ASTContext &Ctx;
  32   Preprocessor &PP;
  33
  34   bool IsInTransaction;
  35
  36   enum ActionKind {
  37     Act_Insert, Act_InsertAfterToken,
  38     Act_Remove, Act_RemoveStmt,
  39     Act_Replace, Act_ReplaceText,
  40     Act_IncreaseIndentation,
  41     Act_ClearDiagnostic
  42   };
  43
  44   struct ActionData {
  45     ActionKind Kind;
  46     SourceLocation Loc;
  47     SourceRange R1, R2;
  48     StringRef Text1, Text2;
  49     Stmt *S;
  50     SmallVector<unsigned, 2> DiagIDs;
  51   };
  52
  53   std::vector<ActionData> CachedActions;
  54
  55   enum RangeComparison {
  56     Range_Before,
  57     Range_After,
  58     Range_Contains,
  59     Range_Contained,
  60     Range_ExtendsBegin,
  61     Range_ExtendsEnd
  62   };
  63
  64   /// \brief A range to remove. It is a character range.
  65   struct CharRange {
  66     FullSourceLoc Begin, End;
  67
  68     CharRange(CharSourceRange range, SourceManager &srcMgr, Preprocessor &PP) {
  69       SourceLocation beginLoc = range.getBegin(), endLoc = range.getEnd();
  70       assert(beginLoc.isValid() && endLoc.isValid());
  71       if (range.isTokenRange()) {
  72         Begin = FullSourceLoc(srcMgr.getExpansionLoc(beginLoc), srcMgr);
  73         End = FullSourceLoc(getLocForEndOfToken(endLoc, srcMgr, PP), srcMgr);
  74       } else {
  75         Begin = FullSourceLoc(srcMgr.getExpansionLoc(beginLoc), srcMgr);
  76         End = FullSourceLoc(srcMgr.getExpansionLoc(endLoc), srcMgr);
  77       }
  78       assert(Begin.isValid() && End.isValid());
  79     }
  80
  81     RangeComparison compareWith(const CharRange &RHS) const {
  82       if (End.isBeforeInTranslationUnitThan(RHS.Begin))
  83         return Range_Before;
  84       if (RHS.End.isBeforeInTranslationUnitThan(Begin))
  85         return Range_After;
  86       if (!Begin.isBeforeInTranslationUnitThan(RHS.Begin) &&
  87           !RHS.End.isBeforeInTranslationUnitThan(End))
  88         return Range_Contained;
  89       if (Begin.isBeforeInTranslationUnitThan(RHS.Begin) &&
  90           RHS.End.isBeforeInTranslationUnitThan(End))
  91         return Range_Contains;
  92       if (Begin.isBeforeInTranslationUnitThan(RHS.Begin))
  93         return Range_ExtendsBegin;
  94       else
  95         return Range_ExtendsEnd;
  96     }
  97
  98     static RangeComparison compare(SourceRange LHS, SourceRange RHS,
  99                                    SourceManager &SrcMgr, Preprocessor &PP) {
 100       return CharRange(CharSourceRange::getTokenRange(LHS), SrcMgr, PP)
 101                   .compareWith(CharRange(CharSourceRange::getTokenRange(RHS),
 102                                             SrcMgr, PP));
 103     }
 104   };
 105
 106   typedef SmallVector<StringRef, 2> TextsVec;
 107   typedef std::map<FullSourceLoc, TextsVec, FullSourceLoc::BeforeThanCompare>
 108       InsertsMap;
 109   InsertsMap Inserts;
 110   /// \brief A list of ranges to remove. They are always sorted and they never
 111   /// intersect with each other.
 112   std::list<CharRange> Removals;
 113
 114   llvm::DenseSet<Stmt *> StmtRemovals;
 115
 116   std::vector<std::pair<CharRange, SourceLocation> > IndentationRanges;
 117
 118   /// \brief Keeps text passed to transformation methods.
 119   llvm::StringMap<bool> UniqueText;
 120
 121 public:
 122   TransformActionsImpl(CapturedDiagList &capturedDiags,
 123                        ASTContext &ctx, Preprocessor &PP)
 124     : CapturedDiags(capturedDiags), Ctx(ctx), PP(PP), IsInTransaction(false) { }
 125
 126   ASTContext &getASTContext() { return Ctx; }
 127
 128   void startTransaction();
 129   bool commitTransaction();
 130   void abortTransaction();
 131
 132   bool isInTransaction() const { return IsInTransaction; }
 133
 134   void insert(SourceLocation loc, StringRef text);
 135   void insertAfterToken(SourceLocation loc, StringRef text);
 136   void remove(SourceRange range);
 137   void removeStmt(Stmt *S);
 138   void replace(SourceRange range, StringRef text);
 139   void replace(SourceRange range, SourceRange replacementRange);
 140   void replaceStmt(Stmt *S, StringRef text);
 141   void replaceText(SourceLocation loc, StringRef text,
 142                    StringRef replacementText);
 143   void increaseIndentation(SourceRange range,
 144                            SourceLocation parentIndent);
 145
 146   bool clearDiagnostic(ArrayRef<unsigned> IDs, SourceRange range);
 147
 148   void applyRewrites(TransformActions::RewriteReceiver &receiver);
 149
 150 private:
 151   bool canInsert(SourceLocation loc);
 152   bool canInsertAfterToken(SourceLocation loc);
 153   bool canRemoveRange(SourceRange range);
 154   bool canReplaceRange(SourceRange range, SourceRange replacementRange);
 155   bool canReplaceText(SourceLocation loc, StringRef text);
 156
 157   void commitInsert(SourceLocation loc, StringRef text);
 158   void commitInsertAfterToken(SourceLocation loc, StringRef text);
 159   void commitRemove(SourceRange range);
 160   void commitRemoveStmt(Stmt *S);
 161   void commitReplace(SourceRange range, SourceRange replacementRange);
 162   void commitReplaceText(SourceLocation loc, StringRef text,
 163                          StringRef replacementText);
 164   void commitIncreaseIndentation(SourceRange range,SourceLocation parentIndent);
 165   void commitClearDiagnostic(ArrayRef<unsigned> IDs, SourceRange range);
 166
 167   void addRemoval(CharSourceRange range);
 168   void addInsertion(SourceLocation loc, StringRef text);
 169
 170   /// \brief Stores text passed to the transformation methods to keep the string
 171   /// "alive". Since the vast majority of text will be the same, we also unique
 172   /// the strings using a StringMap.
 173   StringRef getUniqueText(StringRef text);
 174
 175   /// \brief Computes the source location just past the end of the token at
 176   /// the given source location. If the location points at a macro, the whole
 177   /// macro expansion is skipped.
 178   static SourceLocation getLocForEndOfToken(SourceLocation loc,
 179                                             SourceManager &SM,Preprocessor &PP);
 180 };
 181
 182 } // anonymous namespace
 183
 184 void TransformActionsImpl::startTransaction() {
 185   assert(!IsInTransaction &&
 186          "Cannot start a transaction in the middle of another one");
 187   IsInTransaction = true;
 188 }
 189
 190 bool TransformActionsImpl::commitTransaction() {
 191   assert(IsInTransaction && "No transaction started");
 192
 193   if (CachedActions.empty()) {
 194     IsInTransaction = false;
 195     return false;
 196   }
 197
 198   // Verify that all actions are possible otherwise abort the whole transaction.
 199   bool AllActionsPossible = true;
 200   for (unsigned i = 0, e = CachedActions.size(); i != e; ++i) {
 201     ActionData &act = CachedActions[i];
 202     switch (act.Kind) {
 203     case Act_Insert:
 204       if (!canInsert(act.Loc))
 205         AllActionsPossible = false;
 206       break;
 207     case Act_InsertAfterToken:
 208       if (!canInsertAfterToken(act.Loc))
 209         AllActionsPossible = false;
 210       break;
 211     case Act_Remove:
 212       if (!canRemoveRange(act.R1))
 213         AllActionsPossible = false;
 214       break;
 215     case Act_RemoveStmt:
 216       assert(act.S);
 217       if (!canRemoveRange(act.S->getSourceRange()))
 218         AllActionsPossible = false;
 219       break;
 220     case Act_Replace:
 221       if (!canReplaceRange(act.R1, act.R2))
 222         AllActionsPossible = false;
 223       break;
 224     case Act_ReplaceText:
 225       if (!canReplaceText(act.Loc, act.Text1))
 226         AllActionsPossible = false;
 227       break;
 228     case Act_IncreaseIndentation:
 229       // This is not important, we don't care if it will fail.
 230       break;
 231     case Act_ClearDiagnostic:
 232       // We are just checking source rewrites.
 233       break;
 234     }
 235     if (!AllActionsPossible)
 236       break;
 237   }
 238
 239   if (!AllActionsPossible) {
 240     abortTransaction();
 241     return true;
 242   }
 243
 244   for (unsigned i = 0, e = CachedActions.size(); i != e; ++i) {
 245     ActionData &act = CachedActions[i];
 246     switch (act.Kind) {
 247     case Act_Insert:
 248       commitInsert(act.Loc, act.Text1);
 249       break;
 250     case Act_InsertAfterToken:
 251       commitInsertAfterToken(act.Loc, act.Text1);
 252       break;
 253     case Act_Remove:
 254       commitRemove(act.R1);
 255       break;
 256     case Act_RemoveStmt:
 257       commitRemoveStmt(act.S);
 258       break;
 259     case Act_Replace:
 260       commitReplace(act.R1, act.R2);
 261       break;
 262     case Act_ReplaceText:
 263       commitReplaceText(act.Loc, act.Text1, act.Text2);
 264       break;
 265     case Act_IncreaseIndentation:
 266       commitIncreaseIndentation(act.R1, act.Loc);
 267       break;
 268     case Act_ClearDiagnostic:
 269       commitClearDiagnostic(act.DiagIDs, act.R1);
 270       break;
 271     }
 272   }
 273
 274   CachedActions.clear();
 275   IsInTransaction = false;
 276   return false;
 277 }
 278
 279 void TransformActionsImpl::abortTransaction() {
 280   assert(IsInTransaction && "No transaction started");
 281   CachedActions.clear();
 282   IsInTransaction = false;
 283 }
 284
 285 void TransformActionsImpl::insert(SourceLocation loc, StringRef text) {
 286   assert(IsInTransaction && "Actions only allowed during a transaction");
 287   text = getUniqueText(text);
 288   ActionData data;
 289   data.Kind = Act_Insert;
 290   data.Loc = loc;
 291   data.Text1 = text;
 292   CachedActions.push_back(data);
 293 }
 294
 295 void TransformActionsImpl::insertAfterToken(SourceLocation loc, StringRef text) {
 296   assert(IsInTransaction && "Actions only allowed during a transaction");
 297   text = getUniqueText(text);
 298   ActionData data;
 299   data.Kind = Act_InsertAfterToken;
 300   data.Loc = loc;
 301   data.Text1 = text;
 302   CachedActions.push_back(data);
 303 }
 304
 305 void TransformActionsImpl::remove(SourceRange range) {
 306   assert(IsInTransaction && "Actions only allowed during a transaction");
 307   ActionData data;
 308   data.Kind = Act_Remove;
 309   data.R1 = range;
 310   CachedActions.push_back(data);
 311 }
 312
 313 void TransformActionsImpl::removeStmt(Stmt *S) {
 314   assert(IsInTransaction && "Actions only allowed during a transaction");
 315   ActionData data;
 316   data.Kind = Act_RemoveStmt;
 317   data.S = S->IgnoreImplicit(); // important for uniquing
 318   CachedActions.push_back(data);
 319 }
 320
 321 void TransformActionsImpl::replace(SourceRange range, StringRef text) {
 322   assert(IsInTransaction && "Actions only allowed during a transaction");
 323   text = getUniqueText(text);
 324   remove(range);
 325   insert(range.getBegin(), text);
 326 }
 327
 328 void TransformActionsImpl::replace(SourceRange range,
 329                                    SourceRange replacementRange) {
 330   assert(IsInTransaction && "Actions only allowed during a transaction");
 331   ActionData data;
 332   data.Kind = Act_Replace;
 333   data.R1 = range;
 334   data.R2 = replacementRange;
 335   CachedActions.push_back(data);
 336 }
 337
 338 void TransformActionsImpl::replaceText(SourceLocation loc, StringRef text,
 339                                        StringRef replacementText) {
 340   text = getUniqueText(text);
 341   replacementText = getUniqueText(replacementText);
 342   ActionData data;
 343   data.Kind = Act_ReplaceText;
 344   data.Loc = loc;
 345   data.Text1 = text;
 346   data.Text2 = replacementText;
 347   CachedActions.push_back(data);
 348 }
 349
 350 void TransformActionsImpl::replaceStmt(Stmt *S, StringRef text) {
 351   assert(IsInTransaction && "Actions only allowed during a transaction");
 352   text = getUniqueText(text);
 353   insert(S->getLocStart(), text);
 354   removeStmt(S);
 355 }
 356
 357 void TransformActionsImpl::increaseIndentation(SourceRange range,
 358                                                SourceLocation parentIndent) {
 359   if (range.isInvalid()) return;
 360   assert(IsInTransaction && "Actions only allowed during a transaction");
 361   ActionData data;
 362   data.Kind = Act_IncreaseIndentation;
 363   data.R1 = range;
 364   data.Loc = parentIndent;
 365   CachedActions.push_back(data);
 366 }
 367
 368 bool TransformActionsImpl::clearDiagnostic(ArrayRef<unsigned> IDs,
 369                                            SourceRange range) {
 370   assert(IsInTransaction && "Actions only allowed during a transaction");
 371   if (!CapturedDiags.hasDiagnostic(IDs, range))
 372     return false;
 373
 374   ActionData data;
 375   data.Kind = Act_ClearDiagnostic;
 376   data.R1 = range;
 377   data.DiagIDs.append(IDs.begin(), IDs.end());
 378   CachedActions.push_back(data);
 379   return true;
 380 }
 381
 382 bool TransformActionsImpl::canInsert(SourceLocation loc) {
 383   if (loc.isInvalid())
 384     return false;
 385
 386   SourceManager &SM = Ctx.getSourceManager();
 387   if (SM.isInSystemHeader(SM.getExpansionLoc(loc)))
 388     return false;
 389
 390   if (loc.isFileID())
 391     return true;
 392   return PP.isAtStartOfMacroExpansion(loc);
 393 }
 394
 395 bool TransformActionsImpl::canInsertAfterToken(SourceLocation loc) {
 396   if (loc.isInvalid())
 397     return false;
 398
 399   SourceManager &SM = Ctx.getSourceManager();
 400   if (SM.isInSystemHeader(SM.getExpansionLoc(loc)))
 401     return false;
 402
 403   if (loc.isFileID())
 404     return true;
 405   return PP.isAtEndOfMacroExpansion(loc);
 406 }
 407
 408 bool TransformActionsImpl::canRemoveRange(SourceRange range) {
 409   return canInsert(range.getBegin()) && canInsertAfterToken(range.getEnd());
 410 }
 411
 412 bool TransformActionsImpl::canReplaceRange(SourceRange range,
 413                                            SourceRange replacementRange) {
 414   return canRemoveRange(range) && canRemoveRange(replacementRange);
 415 }
 416
 417 bool TransformActionsImpl::canReplaceText(SourceLocation loc, StringRef text) {
 418   if (!canInsert(loc))
 419     return false;
 420
 421   SourceManager &SM = Ctx.getSourceManager();
 422   loc = SM.getExpansionLoc(loc);
 423
 424   // Break down the source location.
 425   std::pair<FileID, unsigned> locInfo = SM.getDecomposedLoc(loc);
 426
 427   // Try to load the file buffer.
 428   bool invalidTemp = false;
 429   StringRef file = SM.getBufferData(locInfo.first, &invalidTemp);
 430   if (invalidTemp)
 431     return false;
 432
 433   return file.substr(locInfo.second).startswith(text);
 434 }
 435
 436 void TransformActionsImpl::commitInsert(SourceLocation loc, StringRef text) {
 437   addInsertion(loc, text);
 438 }
 439
 440 void TransformActionsImpl::commitInsertAfterToken(SourceLocation loc,
 441                                                   StringRef text) {
 442   addInsertion(getLocForEndOfToken(loc, Ctx.getSourceManager(), PP), text);
 443 }
 444
 445 void TransformActionsImpl::commitRemove(SourceRange range) {
 446   addRemoval(CharSourceRange::getTokenRange(range));
 447 }
 448
 449 void TransformActionsImpl::commitRemoveStmt(Stmt *S) {
 450   assert(S);
 451   if (StmtRemovals.count(S))
 452     return; // already removed.
 453
 454   if (Expr *E = dyn_cast<Expr>(S)) {
 455     commitRemove(E->getSourceRange());
 456     commitInsert(E->getSourceRange().getBegin(), getARCMTMacroName());
 457   } else
 458     commitRemove(S->getSourceRange());
 459
 460   StmtRemovals.insert(S);
 461 }
 462
 463 void TransformActionsImpl::commitReplace(SourceRange range,
 464                                          SourceRange replacementRange) {
 465   RangeComparison comp = CharRange::compare(replacementRange, range,
 466                                                Ctx.getSourceManager(), PP);
 467   assert(comp == Range_Contained);
 468   if (comp != Range_Contained)
 469     return; // Although we asserted, be extra safe for release build.
 470   if (range.getBegin() != replacementRange.getBegin())
 471     addRemoval(CharSourceRange::getCharRange(range.getBegin(),
 472                                              replacementRange.getBegin()));
 473   if (replacementRange.getEnd() != range.getEnd())
 474     addRemoval(CharSourceRange::getTokenRange(
 475                                   getLocForEndOfToken(replacementRange.getEnd(),
 476                                                       Ctx.getSourceManager(), PP),
 477                                   range.getEnd()));
 478 }
 479 void TransformActionsImpl::commitReplaceText(SourceLocation loc,
 480                                              StringRef text,
 481                                              StringRef replacementText) {
 482   SourceManager &SM = Ctx.getSourceManager();
 483   loc = SM.getExpansionLoc(loc);
 484   // canReplaceText already checked if loc points at text.
 485   SourceLocation afterText = loc.getLocWithOffset(text.size());
 486
 487   addRemoval(CharSourceRange::getCharRange(loc, afterText));
 488   commitInsert(loc, replacementText);
 489 }
 490
 491 void TransformActionsImpl::commitIncreaseIndentation(SourceRange range,
 492                                                   SourceLocation parentIndent) {
 493   SourceManager &SM = Ctx.getSourceManager();
 494   IndentationRanges.push_back(
 495                  std::make_pair(CharRange(CharSourceRange::getTokenRange(range),
 496                                           SM, PP),
 497                                 SM.getExpansionLoc(parentIndent)));
 498 }
 499
 500 void TransformActionsImpl::commitClearDiagnostic(ArrayRef<unsigned> IDs,
 501                                                  SourceRange range) {
 502   CapturedDiags.clearDiagnostic(IDs, range);
 503 }
 504
 505 void TransformActionsImpl::addInsertion(SourceLocation loc, StringRef text) {
 506   SourceManager &SM = Ctx.getSourceManager();
 507   loc = SM.getExpansionLoc(loc);
 508   for (std::list<CharRange>::reverse_iterator
 509          I = Removals.rbegin(), E = Removals.rend(); I != E; ++I) {
 510     if (!SM.isBeforeInTranslationUnit(loc, I->End))
 511       break;
 512     if (I->Begin.isBeforeInTranslationUnitThan(loc))
 513       return;
 514   }
 515
 516   Inserts[FullSourceLoc(loc, SM)].push_back(text);
 517 }
 518
 519 void TransformActionsImpl::addRemoval(CharSourceRange range) {
 520   CharRange newRange(range, Ctx.getSourceManager(), PP);
 521   if (newRange.Begin == newRange.End)
 522     return;
 523
 524   Inserts.erase(Inserts.upper_bound(newRange.Begin),
 525                 Inserts.lower_bound(newRange.End));
 526
 527   std::list<CharRange>::iterator I = Removals.end();
 528   while (I != Removals.begin()) {
 529     std::list<CharRange>::iterator RI = I;
 530     --RI;
 531     RangeComparison comp = newRange.compareWith(*RI);
 532     switch (comp) {
 533     case Range_Before:
 534       --I;
 535       break;
 536     case Range_After:
 537       Removals.insert(I, newRange);
 538       return;
 539     case Range_Contained:
 540       return;
 541     case Range_Contains:
 542       RI->End = newRange.End;
 543     case Range_ExtendsBegin:
 544       newRange.End = RI->End;
 545       Removals.erase(RI);
 546       break;
 547     case Range_ExtendsEnd:
 548       RI->End = newRange.End;
 549       return;
 550     }
 551   }
 552
 553   Removals.insert(Removals.begin(), newRange);
 554 }
 555
 556 void TransformActionsImpl::applyRewrites(
 557                                   TransformActions::RewriteReceiver &receiver) {
 558   for (InsertsMap::iterator I = Inserts.begin(), E = Inserts.end(); I!=E; ++I) {
 559     SourceLocation loc = I->first;
 560     for (TextsVec::iterator
 561            TI = I->second.begin(), TE = I->second.end(); TI != TE; ++TI) {
 562       receiver.insert(loc, *TI);
 563     }
 564   }
 565
 566   for (std::vector<std::pair<CharRange, SourceLocation> >::iterator
 567        I = IndentationRanges.begin(), E = IndentationRanges.end(); I!=E; ++I) {
 568     CharSourceRange range = CharSourceRange::getCharRange(I->first.Begin,
 569                                                           I->first.End);
 570     receiver.increaseIndentation(range, I->second);
 571   }
 572
 573   for (std::list<CharRange>::iterator
 574          I = Removals.begin(), E = Removals.end(); I != E; ++I) {
 575     CharSourceRange range = CharSourceRange::getCharRange(I->Begin, I->End);
 576     receiver.remove(range);
 577   }
 578 }
 579
 580 /// \brief Stores text passed to the transformation methods to keep the string
 581 /// "alive". Since the vast majority of text will be the same, we also unique
 582 /// the strings using a StringMap.
 583 StringRef TransformActionsImpl::getUniqueText(StringRef text) {
 584   llvm::StringMapEntry<bool> &entry = UniqueText.GetOrCreateValue(text);
 585   return entry.getKey();
 586 }
 587
 588 /// \brief Computes the source location just past the end of the token at
 589 /// the given source location. If the location points at a macro, the whole
 590 /// macro expansion is skipped.
 591 SourceLocation TransformActionsImpl::getLocForEndOfToken(SourceLocation loc,
 592                                                          SourceManager &SM,
 593                                                          Preprocessor &PP) {
 594   if (loc.isMacroID())
 595     loc = SM.getExpansionRange(loc).second;
 596   return PP.getLocForEndOfToken(loc);
 597 }
 598
 599 TransformActions::RewriteReceiver::~RewriteReceiver() { }
 600
 601 TransformActions::TransformActions(DiagnosticsEngine &diag,
 602                                    CapturedDiagList &capturedDiags,
 603                                    ASTContext &ctx, Preprocessor &PP)
 604   : Diags(diag), CapturedDiags(capturedDiags), ReportedErrors(false) {
 605   Impl = new TransformActionsImpl(capturedDiags, ctx, PP);
 606 }
 607
 608 TransformActions::~TransformActions() {
 609   delete static_cast<TransformActionsImpl*>(Impl);
 610 }
 611
 612 void TransformActions::startTransaction() {
 613   static_cast<TransformActionsImpl*>(Impl)->startTransaction();
 614 }
 615
 616 bool TransformActions::commitTransaction() {
 617   return static_cast<TransformActionsImpl*>(Impl)->commitTransaction();
 618 }
 619
 620 void TransformActions::abortTransaction() {
 621   static_cast<TransformActionsImpl*>(Impl)->abortTransaction();
 622 }
 623
 624
 625 void TransformActions::insert(SourceLocation loc, StringRef text) {
 626   static_cast<TransformActionsImpl*>(Impl)->insert(loc, text);
 627 }
 628
 629 void TransformActions::insertAfterToken(SourceLocation loc,
 630                                         StringRef text) {
 631   static_cast<TransformActionsImpl*>(Impl)->insertAfterToken(loc, text);
 632 }
 633
 634 void TransformActions::remove(SourceRange range) {
 635   static_cast<TransformActionsImpl*>(Impl)->remove(range);
 636 }
 637
 638 void TransformActions::removeStmt(Stmt *S) {
 639   static_cast<TransformActionsImpl*>(Impl)->removeStmt(S);
 640 }
 641
 642 void TransformActions::replace(SourceRange range, StringRef text) {
 643   static_cast<TransformActionsImpl*>(Impl)->replace(range, text);
 644 }
 645
 646 void TransformActions::replace(SourceRange range,
 647                                SourceRange replacementRange) {
 648   static_cast<TransformActionsImpl*>(Impl)->replace(range, replacementRange);
 649 }
 650
 651 void TransformActions::replaceStmt(Stmt *S, StringRef text) {
 652   static_cast<TransformActionsImpl*>(Impl)->replaceStmt(S, text);
 653 }
 654
 655 void TransformActions::replaceText(SourceLocation loc, StringRef text,
 656                                    StringRef replacementText) {
 657   static_cast<TransformActionsImpl*>(Impl)->replaceText(loc, text,
 658                                                         replacementText);
 659 }
 660
 661 void TransformActions::increaseIndentation(SourceRange range,
 662                                            SourceLocation parentIndent) {
 663   static_cast<TransformActionsImpl*>(Impl)->increaseIndentation(range,
 664                                                                 parentIndent);
 665 }
 666
 667 bool TransformActions::clearDiagnostic(ArrayRef<unsigned> IDs,
 668                                        SourceRange range) {
 669   return static_cast<TransformActionsImpl*>(Impl)->clearDiagnostic(IDs, range);
 670 }
 671
 672 void TransformActions::applyRewrites(RewriteReceiver &receiver) {
 673   static_cast<TransformActionsImpl*>(Impl)->applyRewrites(receiver);
 674 }
 675
 676 void TransformActions::reportError(StringRef error, SourceLocation loc,
 677                                    SourceRange range) {
 678   assert(!static_cast<TransformActionsImpl*>(Impl)->isInTransaction() &&
 679          "Errors should be emitted out of a transaction");
 680
 681   SourceManager &SM = static_cast<TransformActionsImpl*>(Impl)->
 682                                              getASTContext().getSourceManager();
 683   if (SM.isInSystemHeader(SM.getExpansionLoc(loc)))
 684     return;
 685
 686   // FIXME: Use a custom category name to distinguish rewriter errors.
 687   std::string rewriteErr = "[rewriter] ";
 688   rewriteErr += error;
 689   unsigned diagID
 690      = Diags.getDiagnosticIDs()->getCustomDiagID(DiagnosticIDs::Error,
 691                                                  rewriteErr);
 692   Diags.Report(loc, diagID) << range;
 693   ReportedErrors = true;
 694 }
 695
 696 void TransformActions::reportWarning(StringRef warning, SourceLocation loc,
 697                                    SourceRange range) {
 698   assert(!static_cast<TransformActionsImpl*>(Impl)->isInTransaction() &&
 699          "Warning should be emitted out of a transaction");
 700
 701   SourceManager &SM = static_cast<TransformActionsImpl*>(Impl)->
 702     getASTContext().getSourceManager();
 703   if (SM.isInSystemHeader(SM.getExpansionLoc(loc)))
 704     return;
 705
 706   // FIXME: Use a custom category name to distinguish rewriter errors.
 707   std::string rewriterWarn = "[rewriter] ";
 708   rewriterWarn += warning;
 709   unsigned diagID
 710   = Diags.getDiagnosticIDs()->getCustomDiagID(DiagnosticIDs::Warning,
 711                                               rewriterWarn);
 712   Diags.Report(loc, diagID) << range;
 713 }
 714
 715 void TransformActions::reportNote(StringRef note, SourceLocation loc,
 716                                   SourceRange range) {
 717   assert(!static_cast<TransformActionsImpl*>(Impl)->isInTransaction() &&
 718          "Errors should be emitted out of a transaction");
 719
 720   SourceManager &SM = static_cast<TransformActionsImpl*>(Impl)->
 721                                              getASTContext().getSourceManager();
 722   if (SM.isInSystemHeader(SM.getExpansionLoc(loc)))
 723     return;
 724
 725   // FIXME: Use a custom category name to distinguish rewriter errors.
 726   std::string rewriteNote = "[rewriter] ";
 727   rewriteNote += note;
 728   unsigned diagID
 729      = Diags.getDiagnosticIDs()->getCustomDiagID(DiagnosticIDs::Note,
 730                                                  rewriteNote);
 731   Diags.Report(loc, diagID) << range;
 732 }