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