1 //===-- TransformActions.cpp - Migration to ARC mode ----------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "Internals.h"
10 #include "clang/AST/ASTContext.h"
11 #include "clang/AST/Expr.h"
12 #include "clang/Basic/SourceManager.h"
13 #include "clang/Lex/Preprocessor.h"
14 #include "llvm/ADT/DenseSet.h"
15 #include <map>
16 using namespace clang;
17 using namespace arcmt;
18 
19 namespace {
20 
21 /// 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   /// 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   /// 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   /// 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   ASTContext &getASTContext() { return Ctx; }
126 
127   void startTransaction();
128   bool commitTransaction();
129   void abortTransaction();
130 
131   bool isInTransaction() const { return IsInTransaction; }
132 
133   void insert(SourceLocation loc, StringRef text);
134   void insertAfterToken(SourceLocation loc, StringRef text);
135   void remove(SourceRange range);
136   void removeStmt(Stmt *S);
137   void replace(SourceRange range, StringRef text);
138   void replace(SourceRange range, SourceRange replacementRange);
139   void replaceStmt(Stmt *S, StringRef text);
140   void replaceText(SourceLocation loc, StringRef text,
141                    StringRef replacementText);
142   void increaseIndentation(SourceRange range,
143                            SourceLocation parentIndent);
144 
145   bool clearDiagnostic(ArrayRef<unsigned> IDs, SourceRange range);
146 
147   void applyRewrites(TransformActions::RewriteReceiver &receiver);
148 
149 private:
150   bool canInsert(SourceLocation loc);
151   bool canInsertAfterToken(SourceLocation loc);
152   bool canRemoveRange(SourceRange range);
153   bool canReplaceRange(SourceRange range, SourceRange replacementRange);
154   bool canReplaceText(SourceLocation loc, StringRef text);
155 
156   void commitInsert(SourceLocation loc, StringRef text);
157   void commitInsertAfterToken(SourceLocation loc, StringRef text);
158   void commitRemove(SourceRange range);
159   void commitRemoveStmt(Stmt *S);
160   void commitReplace(SourceRange range, SourceRange replacementRange);
161   void commitReplaceText(SourceLocation loc, StringRef text,
162                          StringRef replacementText);
163   void commitIncreaseIndentation(SourceRange range,SourceLocation parentIndent);
164   void commitClearDiagnostic(ArrayRef<unsigned> IDs, SourceRange range);
165 
166   void addRemoval(CharSourceRange range);
167   void addInsertion(SourceLocation loc, StringRef text);
168 
169   /// Stores text passed to the transformation methods to keep the string
170   /// "alive". Since the vast majority of text will be the same, we also unique
171   /// the strings using a StringMap.
172   StringRef getUniqueText(StringRef text);
173 
174   /// Computes the source location just past the end of the token at
175   /// the given source location. If the location points at a macro, the whole
176   /// macro expansion is skipped.
177   static SourceLocation getLocForEndOfToken(SourceLocation loc,
178                                             SourceManager &SM,Preprocessor &PP);
179 };
180 
181 } // anonymous namespace
182 
183 void TransformActionsImpl::startTransaction() {
184   assert(!IsInTransaction &&
185          "Cannot start a transaction in the middle of another one");
186   IsInTransaction = true;
187 }
188 
189 bool TransformActionsImpl::commitTransaction() {
190   assert(IsInTransaction && "No transaction started");
191 
192   if (CachedActions.empty()) {
193     IsInTransaction = false;
194     return false;
195   }
196 
197   // Verify that all actions are possible otherwise abort the whole transaction.
198   bool AllActionsPossible = true;
199   for (unsigned i = 0, e = CachedActions.size(); i != e; ++i) {
200     ActionData &act = CachedActions[i];
201     switch (act.Kind) {
202     case Act_Insert:
203       if (!canInsert(act.Loc))
204         AllActionsPossible = false;
205       break;
206     case Act_InsertAfterToken:
207       if (!canInsertAfterToken(act.Loc))
208         AllActionsPossible = false;
209       break;
210     case Act_Remove:
211       if (!canRemoveRange(act.R1))
212         AllActionsPossible = false;
213       break;
214     case Act_RemoveStmt:
215       assert(act.S);
216       if (!canRemoveRange(act.S->getSourceRange()))
217         AllActionsPossible = false;
218       break;
219     case Act_Replace:
220       if (!canReplaceRange(act.R1, act.R2))
221         AllActionsPossible = false;
222       break;
223     case Act_ReplaceText:
224       if (!canReplaceText(act.Loc, act.Text1))
225         AllActionsPossible = false;
226       break;
227     case Act_IncreaseIndentation:
228       // This is not important, we don't care if it will fail.
229       break;
230     case Act_ClearDiagnostic:
231       // We are just checking source rewrites.
232       break;
233     }
234     if (!AllActionsPossible)
235       break;
236   }
237 
238   if (!AllActionsPossible) {
239     abortTransaction();
240     return true;
241   }
242 
243   for (unsigned i = 0, e = CachedActions.size(); i != e; ++i) {
244     ActionData &act = CachedActions[i];
245     switch (act.Kind) {
246     case Act_Insert:
247       commitInsert(act.Loc, act.Text1);
248       break;
249     case Act_InsertAfterToken:
250       commitInsertAfterToken(act.Loc, act.Text1);
251       break;
252     case Act_Remove:
253       commitRemove(act.R1);
254       break;
255     case Act_RemoveStmt:
256       commitRemoveStmt(act.S);
257       break;
258     case Act_Replace:
259       commitReplace(act.R1, act.R2);
260       break;
261     case Act_ReplaceText:
262       commitReplaceText(act.Loc, act.Text1, act.Text2);
263       break;
264     case Act_IncreaseIndentation:
265       commitIncreaseIndentation(act.R1, act.Loc);
266       break;
267     case Act_ClearDiagnostic:
268       commitClearDiagnostic(act.DiagIDs, act.R1);
269       break;
270     }
271   }
272 
273   CachedActions.clear();
274   IsInTransaction = false;
275   return false;
276 }
277 
278 void TransformActionsImpl::abortTransaction() {
279   assert(IsInTransaction && "No transaction started");
280   CachedActions.clear();
281   IsInTransaction = false;
282 }
283 
284 void TransformActionsImpl::insert(SourceLocation loc, StringRef text) {
285   assert(IsInTransaction && "Actions only allowed during a transaction");
286   text = getUniqueText(text);
287   ActionData data;
288   data.Kind = Act_Insert;
289   data.Loc = loc;
290   data.Text1 = text;
291   CachedActions.push_back(data);
292 }
293 
294 void TransformActionsImpl::insertAfterToken(SourceLocation loc, StringRef text) {
295   assert(IsInTransaction && "Actions only allowed during a transaction");
296   text = getUniqueText(text);
297   ActionData data;
298   data.Kind = Act_InsertAfterToken;
299   data.Loc = loc;
300   data.Text1 = text;
301   CachedActions.push_back(data);
302 }
303 
304 void TransformActionsImpl::remove(SourceRange range) {
305   assert(IsInTransaction && "Actions only allowed during a transaction");
306   ActionData data;
307   data.Kind = Act_Remove;
308   data.R1 = range;
309   CachedActions.push_back(data);
310 }
311 
312 void TransformActionsImpl::removeStmt(Stmt *S) {
313   assert(IsInTransaction && "Actions only allowed during a transaction");
314   ActionData data;
315   data.Kind = Act_RemoveStmt;
316   if (auto *E = dyn_cast<Expr>(S))
317     S = E->IgnoreImplicit(); // important for uniquing
318   data.S = S;
319   CachedActions.push_back(data);
320 }
321 
322 void TransformActionsImpl::replace(SourceRange range, StringRef text) {
323   assert(IsInTransaction && "Actions only allowed during a transaction");
324   text = getUniqueText(text);
325   remove(range);
326   insert(range.getBegin(), text);
327 }
328 
329 void TransformActionsImpl::replace(SourceRange range,
330                                    SourceRange replacementRange) {
331   assert(IsInTransaction && "Actions only allowed during a transaction");
332   ActionData data;
333   data.Kind = Act_Replace;
334   data.R1 = range;
335   data.R2 = replacementRange;
336   CachedActions.push_back(data);
337 }
338 
339 void TransformActionsImpl::replaceText(SourceLocation loc, StringRef text,
340                                        StringRef replacementText) {
341   text = getUniqueText(text);
342   replacementText = getUniqueText(replacementText);
343   ActionData data;
344   data.Kind = Act_ReplaceText;
345   data.Loc = loc;
346   data.Text1 = text;
347   data.Text2 = replacementText;
348   CachedActions.push_back(data);
349 }
350 
351 void TransformActionsImpl::replaceStmt(Stmt *S, StringRef text) {
352   assert(IsInTransaction && "Actions only allowed during a transaction");
353   text = getUniqueText(text);
354   insert(S->getBeginLoc(), text);
355   removeStmt(S);
356 }
357 
358 void TransformActionsImpl::increaseIndentation(SourceRange range,
359                                                SourceLocation parentIndent) {
360   if (range.isInvalid()) return;
361   assert(IsInTransaction && "Actions only allowed during a transaction");
362   ActionData data;
363   data.Kind = Act_IncreaseIndentation;
364   data.R1 = range;
365   data.Loc = parentIndent;
366   CachedActions.push_back(data);
367 }
368 
369 bool TransformActionsImpl::clearDiagnostic(ArrayRef<unsigned> IDs,
370                                            SourceRange range) {
371   assert(IsInTransaction && "Actions only allowed during a transaction");
372   if (!CapturedDiags.hasDiagnostic(IDs, range))
373     return false;
374 
375   ActionData data;
376   data.Kind = Act_ClearDiagnostic;
377   data.R1 = range;
378   data.DiagIDs.append(IDs.begin(), IDs.end());
379   CachedActions.push_back(data);
380   return true;
381 }
382 
383 bool TransformActionsImpl::canInsert(SourceLocation loc) {
384   if (loc.isInvalid())
385     return false;
386 
387   SourceManager &SM = Ctx.getSourceManager();
388   if (SM.isInSystemHeader(SM.getExpansionLoc(loc)))
389     return false;
390 
391   if (loc.isFileID())
392     return true;
393   return PP.isAtStartOfMacroExpansion(loc);
394 }
395 
396 bool TransformActionsImpl::canInsertAfterToken(SourceLocation loc) {
397   if (loc.isInvalid())
398     return false;
399 
400   SourceManager &SM = Ctx.getSourceManager();
401   if (SM.isInSystemHeader(SM.getExpansionLoc(loc)))
402     return false;
403 
404   if (loc.isFileID())
405     return true;
406   return PP.isAtEndOfMacroExpansion(loc);
407 }
408 
409 bool TransformActionsImpl::canRemoveRange(SourceRange range) {
410   return canInsert(range.getBegin()) && canInsertAfterToken(range.getEnd());
411 }
412 
413 bool TransformActionsImpl::canReplaceRange(SourceRange range,
414                                            SourceRange replacementRange) {
415   return canRemoveRange(range) && canRemoveRange(replacementRange);
416 }
417 
418 bool TransformActionsImpl::canReplaceText(SourceLocation loc, StringRef text) {
419   if (!canInsert(loc))
420     return false;
421 
422   SourceManager &SM = Ctx.getSourceManager();
423   loc = SM.getExpansionLoc(loc);
424 
425   // Break down the source location.
426   std::pair<FileID, unsigned> locInfo = SM.getDecomposedLoc(loc);
427 
428   // Try to load the file buffer.
429   bool invalidTemp = false;
430   StringRef file = SM.getBufferData(locInfo.first, &invalidTemp);
431   if (invalidTemp)
432     return false;
433 
434   return file.substr(locInfo.second).startswith(text);
435 }
436 
437 void TransformActionsImpl::commitInsert(SourceLocation loc, StringRef text) {
438   addInsertion(loc, text);
439 }
440 
441 void TransformActionsImpl::commitInsertAfterToken(SourceLocation loc,
442                                                   StringRef text) {
443   addInsertion(getLocForEndOfToken(loc, Ctx.getSourceManager(), PP), text);
444 }
445 
446 void TransformActionsImpl::commitRemove(SourceRange range) {
447   addRemoval(CharSourceRange::getTokenRange(range));
448 }
449 
450 void TransformActionsImpl::commitRemoveStmt(Stmt *S) {
451   assert(S);
452   if (StmtRemovals.count(S))
453     return; // already removed.
454 
455   if (Expr *E = dyn_cast<Expr>(S)) {
456     commitRemove(E->getSourceRange());
457     commitInsert(E->getSourceRange().getBegin(), getARCMTMacroName());
458   } else
459     commitRemove(S->getSourceRange());
460 
461   StmtRemovals.insert(S);
462 }
463 
464 void TransformActionsImpl::commitReplace(SourceRange range,
465                                          SourceRange replacementRange) {
466   RangeComparison comp = CharRange::compare(replacementRange, range,
467                                                Ctx.getSourceManager(), PP);
468   assert(comp == Range_Contained);
469   if (comp != Range_Contained)
470     return; // Although we asserted, be extra safe for release build.
471   if (range.getBegin() != replacementRange.getBegin())
472     addRemoval(CharSourceRange::getCharRange(range.getBegin(),
473                                              replacementRange.getBegin()));
474   if (replacementRange.getEnd() != range.getEnd())
475     addRemoval(CharSourceRange::getTokenRange(
476                                   getLocForEndOfToken(replacementRange.getEnd(),
477                                                       Ctx.getSourceManager(), PP),
478                                   range.getEnd()));
479 }
480 void TransformActionsImpl::commitReplaceText(SourceLocation loc,
481                                              StringRef text,
482                                              StringRef replacementText) {
483   SourceManager &SM = Ctx.getSourceManager();
484   loc = SM.getExpansionLoc(loc);
485   // canReplaceText already checked if loc points at text.
486   SourceLocation afterText = loc.getLocWithOffset(text.size());
487 
488   addRemoval(CharSourceRange::getCharRange(loc, afterText));
489   commitInsert(loc, replacementText);
490 }
491 
492 void TransformActionsImpl::commitIncreaseIndentation(SourceRange range,
493                                                   SourceLocation parentIndent) {
494   SourceManager &SM = Ctx.getSourceManager();
495   IndentationRanges.push_back(
496                  std::make_pair(CharRange(CharSourceRange::getTokenRange(range),
497                                           SM, PP),
498                                 SM.getExpansionLoc(parentIndent)));
499 }
500 
501 void TransformActionsImpl::commitClearDiagnostic(ArrayRef<unsigned> IDs,
502                                                  SourceRange range) {
503   CapturedDiags.clearDiagnostic(IDs, range);
504 }
505 
506 void TransformActionsImpl::addInsertion(SourceLocation loc, StringRef text) {
507   SourceManager &SM = Ctx.getSourceManager();
508   loc = SM.getExpansionLoc(loc);
509   for (const CharRange &I : llvm::reverse(Removals)) {
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       [[fallthrough]];
544     case Range_ExtendsBegin:
545       newRange.End = RI->End;
546       Removals.erase(RI);
547       break;
548     case Range_ExtendsEnd:
549       RI->End = newRange.End;
550       return;
551     }
552   }
553 
554   Removals.insert(Removals.begin(), newRange);
555 }
556 
557 void TransformActionsImpl::applyRewrites(
558                                   TransformActions::RewriteReceiver &receiver) {
559   for (InsertsMap::iterator I = Inserts.begin(), E = Inserts.end(); I!=E; ++I) {
560     SourceLocation loc = I->first;
561     for (TextsVec::iterator
562            TI = I->second.begin(), TE = I->second.end(); TI != TE; ++TI) {
563       receiver.insert(loc, *TI);
564     }
565   }
566 
567   for (std::vector<std::pair<CharRange, SourceLocation> >::iterator
568        I = IndentationRanges.begin(), E = IndentationRanges.end(); I!=E; ++I) {
569     CharSourceRange range = CharSourceRange::getCharRange(I->first.Begin,
570                                                           I->first.End);
571     receiver.increaseIndentation(range, I->second);
572   }
573 
574   for (std::list<CharRange>::iterator
575          I = Removals.begin(), E = Removals.end(); I != E; ++I) {
576     CharSourceRange range = CharSourceRange::getCharRange(I->Begin, I->End);
577     receiver.remove(range);
578   }
579 }
580 
581 /// Stores text passed to the transformation methods to keep the string
582 /// "alive". Since the vast majority of text will be the same, we also unique
583 /// the strings using a StringMap.
584 StringRef TransformActionsImpl::getUniqueText(StringRef text) {
585   return UniqueText.insert(std::make_pair(text, false)).first->first();
586 }
587 
588 /// 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     CharSourceRange Exp = SM.getExpansionRange(loc);
596     if (Exp.isCharRange())
597       return Exp.getEnd();
598     loc = Exp.getEnd();
599   }
600   return PP.getLocForEndOfToken(loc);
601 }
602 
603 TransformActions::RewriteReceiver::~RewriteReceiver() { }
604 
605 TransformActions::TransformActions(DiagnosticsEngine &diag,
606                                    CapturedDiagList &capturedDiags,
607                                    ASTContext &ctx, Preprocessor &PP)
608     : Diags(diag), CapturedDiags(capturedDiags) {
609   Impl = new TransformActionsImpl(capturedDiags, ctx, PP);
610 }
611 
612 TransformActions::~TransformActions() {
613   delete static_cast<TransformActionsImpl*>(Impl);
614 }
615 
616 void TransformActions::startTransaction() {
617   static_cast<TransformActionsImpl*>(Impl)->startTransaction();
618 }
619 
620 bool TransformActions::commitTransaction() {
621   return static_cast<TransformActionsImpl*>(Impl)->commitTransaction();
622 }
623 
624 void TransformActions::abortTransaction() {
625   static_cast<TransformActionsImpl*>(Impl)->abortTransaction();
626 }
627 
628 
629 void TransformActions::insert(SourceLocation loc, StringRef text) {
630   static_cast<TransformActionsImpl*>(Impl)->insert(loc, text);
631 }
632 
633 void TransformActions::insertAfterToken(SourceLocation loc,
634                                         StringRef text) {
635   static_cast<TransformActionsImpl*>(Impl)->insertAfterToken(loc, text);
636 }
637 
638 void TransformActions::remove(SourceRange range) {
639   static_cast<TransformActionsImpl*>(Impl)->remove(range);
640 }
641 
642 void TransformActions::removeStmt(Stmt *S) {
643   static_cast<TransformActionsImpl*>(Impl)->removeStmt(S);
644 }
645 
646 void TransformActions::replace(SourceRange range, StringRef text) {
647   static_cast<TransformActionsImpl*>(Impl)->replace(range, text);
648 }
649 
650 void TransformActions::replace(SourceRange range,
651                                SourceRange replacementRange) {
652   static_cast<TransformActionsImpl*>(Impl)->replace(range, replacementRange);
653 }
654 
655 void TransformActions::replaceStmt(Stmt *S, StringRef text) {
656   static_cast<TransformActionsImpl*>(Impl)->replaceStmt(S, text);
657 }
658 
659 void TransformActions::replaceText(SourceLocation loc, StringRef text,
660                                    StringRef replacementText) {
661   static_cast<TransformActionsImpl*>(Impl)->replaceText(loc, text,
662                                                         replacementText);
663 }
664 
665 void TransformActions::increaseIndentation(SourceRange range,
666                                            SourceLocation parentIndent) {
667   static_cast<TransformActionsImpl*>(Impl)->increaseIndentation(range,
668                                                                 parentIndent);
669 }
670 
671 bool TransformActions::clearDiagnostic(ArrayRef<unsigned> IDs,
672                                        SourceRange range) {
673   return static_cast<TransformActionsImpl*>(Impl)->clearDiagnostic(IDs, range);
674 }
675 
676 void TransformActions::applyRewrites(RewriteReceiver &receiver) {
677   static_cast<TransformActionsImpl*>(Impl)->applyRewrites(receiver);
678 }
679 
680 DiagnosticBuilder TransformActions::report(SourceLocation loc, unsigned diagId,
681                                            SourceRange range) {
682   assert(!static_cast<TransformActionsImpl *>(Impl)->isInTransaction() &&
683          "Errors should be emitted out of a transaction");
684   return Diags.Report(loc, diagId) << range;
685 }
686 
687 void TransformActions::reportError(StringRef message, SourceLocation loc,
688                                    SourceRange range) {
689   report(loc, diag::err_mt_message, range) << message;
690 }
691 
692 void TransformActions::reportWarning(StringRef message, SourceLocation loc,
693                                      SourceRange range) {
694   report(loc, diag::warn_mt_message, range) << message;
695 }
696 
697 void TransformActions::reportNote(StringRef message, SourceLocation loc,
698                                   SourceRange range) {
699   report(loc, diag::note_mt_message, range) << message;
700 }
701