clang 10.0.0git

TransformActions.cpp
Go to the documentation of this file.
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 LLVM_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 }
ASTContext.h
Defines the clang::ASTContext interface.
clang::arcmt::TransformActions::reportNote
void reportNote(StringRef note, SourceLocation loc, SourceRange range=SourceRange())
Definition: TransformActions.cpp:697
clang::SourceLocation::getLocWithOffset
SourceLocation getLocWithOffset(int Offset) const
Return a source location with the specified offset from this SourceLocation.
Definition: SourceLocation.h:132
clang::Stmt
Stmt - This represents one statement.
Definition: Stmt.h:66
SourceManager.h
Defines the SourceManager interface.
clang::arcmt::getARCMTMacroName
static StringRef getARCMTMacroName()
Definition: Internals.h:172
clang::CharSourceRange::getTokenRange
static CharSourceRange getTokenRange(SourceRange R)
Definition: SourceLocation.h:258
clang::arcmt::CapturedDiagList
Definition: Internals.h:24
llvm::DenseSet
Definition: Sema.h:71
clang::SourceManager::isBeforeInTranslationUnit
bool isBeforeInTranslationUnit(SourceLocation LHS, SourceLocation RHS) const
Determines the order of 2 source locations in the translation unit.
Definition: SourceManager.cpp:1936
clang::CharSourceRange::isCharRange
bool isCharRange() const
Definition: SourceLocation.h:278
clang::DiagnosticsEngine::Report
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1300
clang::arcmt::TransformActions::abortTransaction
void abortTransaction()
Definition: TransformActions.cpp:624
Internals.h
clang::arcmt::CapturedDiagList::hasDiagnostic
bool hasDiagnostic(ArrayRef< unsigned > IDs, SourceRange range) const
Definition: ARCMT.cpp:58
clang::SourceManager::getBufferData
StringRef getBufferData(FileID FID, bool *Invalid=nullptr) const
Return a StringRef to the source buffer data for the specified FileID.
Definition: SourceManager.cpp:702
clang::transformer::range
RangeSelector range(RangeSelector Begin, RangeSelector End)
Selects from the start of Begin and to the end of End.
Definition: RangeSelector.cpp:151
clang::arcmt::TransformActions::startTransaction
void startTransaction()
Definition: TransformActions.cpp:616
clang::Preprocessor::getLocForEndOfToken
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Computes the source location just past the end of the token at this source location.
Definition: Preprocessor.h:1784
clang::CharSourceRange::getBegin
SourceLocation getBegin() const
Definition: SourceLocation.h:280
clang::ASTContext
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:168
clang::Stmt::getBeginLoc
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:275
clang::arcmt::TransformActions::applyRewrites
void applyRewrites(RewriteReceiver &receiver)
Definition: TransformActions.cpp:676
clang::arcmt::TransformActions::report
DiagnosticBuilder report(SourceLocation loc, unsigned diagId, SourceRange range=SourceRange())
Definition: TransformActions.cpp:680
clang::arcmt::TransformActions::reportError
void reportError(StringRef error, SourceLocation loc, SourceRange range=SourceRange())
Definition: TransformActions.cpp:687
clang::arcmt::TransformActions::reportWarning
void reportWarning(StringRef warning, SourceLocation loc, SourceRange range=SourceRange())
Definition: TransformActions.cpp:692
clang::arcmt::CapturedDiagList::clearDiagnostic
bool clearDiagnostic(ArrayRef< unsigned > IDs, SourceRange range)
Definition: ARCMT.cpp:28
clang::arcmt::TransformActions::commitTransaction
bool commitTransaction()
Definition: TransformActions.cpp:620
clang::SourceManager::getExpansionLoc
SourceLocation getExpansionLoc(SourceLocation Loc) const
Given a SourceLocation object Loc, return the expansion location referenced by the ID...
Definition: SourceManager.h:1159
clang::DiagnosticsEngine
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:149
clang::arcmt::TransformActions::~TransformActions
~TransformActions()
Definition: TransformActions.cpp:612
clang::SourceLocation::isFileID
bool isFileID() const
Definition: SourceLocation.h:98
llvm::ArrayRef< unsigned >
clang::DiagnosticBuilder
A little helper class used to produce diagnostics.
Definition: Diagnostic.h:1053
clang::arcmt::TransformActions::clearDiagnostic
bool clearDiagnostic(ArrayRef< unsigned > IDs, SourceRange range)
Definition: TransformActions.cpp:671
clang::Expr
This represents one expression.
Definition: Expr.h:108
End
SourceLocation End
Definition: USRLocFinder.cpp:166
clang::CharSourceRange
Represents a character-granular source range.
Definition: SourceLocation.h:250
compare
static bool compare(const PathDiagnostic &X, const PathDiagnostic &Y)
Definition: PathDiagnostic.cpp:346
clang::SourceManager::isInSystemHeader
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
Definition: SourceManager.h:1493
clang::arcmt::TransformActions::insertAfterToken
void insertAfterToken(SourceLocation loc, StringRef text)
Definition: TransformActions.cpp:633
Preprocessor.h
Defines the clang::Preprocessor interface.
Begin
SourceLocation Begin
Definition: USRLocFinder.cpp:164
clang::SourceRange::isInvalid
bool isInvalid() const
Definition: SourceLocation.h:223
clang::arcmt::TransformActions::RewriteReceiver::insert
virtual void insert(SourceLocation loc, StringRef text)=0
clang::transformer::remove
ASTEdit remove(RangeSelector S)
Removes the source selected by S.
Definition: RewriteRule.cpp:82
clang::SourceRange::getEnd
SourceLocation getEnd() const
Definition: SourceLocation.h:217
clang::frontend::ActionKind
ActionKind
Definition: FrontendOptions.h:34
SM
const SourceManager & SM
Definition: Format.cpp:1685
clang::CharSourceRange::getCharRange
static CharSourceRange getCharRange(SourceRange R)
Definition: SourceLocation.h:262
clang::arcmt::TransformActions::TransformActions
TransformActions(DiagnosticsEngine &diag, CapturedDiagList &capturedDiags, ASTContext &ctx, Preprocessor &PP)
Definition: TransformActions.cpp:605
false
#define false
Definition: stdbool.h:17
Kind
Kind
Definition: ChrootChecker.cpp:29
clang::FullSourceLoc::isBeforeInTranslationUnitThan
bool isBeforeInTranslationUnitThan(SourceLocation Loc) const
Determines the order of 2 source locations in the translation unit.
Definition: SourceLocation.cpp:232
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:86
clang::arcmt::TransformActions::RewriteReceiver::~RewriteReceiver
virtual ~RewriteReceiver()
Definition: TransformActions.cpp:603
clang::arcmt::TransformActions::replaceStmt
void replaceStmt(Stmt *S, StringRef text)
Definition: TransformActions.cpp:655
clang::arcmt::TransformActions::increaseIndentation
void increaseIndentation(SourceRange range, SourceLocation parentIndent)
Definition: TransformActions.cpp:665
clang::Preprocessor::isAtStartOfMacroExpansion
bool isAtStartOfMacroExpansion(SourceLocation loc, SourceLocation *MacroBegin=nullptr) const
Returns true if the given MacroID location points at the first token of the macro expansion...
Definition: Preprocessor.h:1793
llvm::SmallVector
Definition: LLVM.h:35
clang::Preprocessor::isAtEndOfMacroExpansion
bool isAtEndOfMacroExpansion(SourceLocation loc, SourceLocation *MacroEnd=nullptr) const
Returns true if the given MacroID location points at the last token of the macro expansion.
Definition: Preprocessor.h:1804
clang::arcmt::TransformActions::RewriteReceiver::remove
virtual void remove(CharSourceRange range)=0
clang::CharSourceRange::isTokenRange
bool isTokenRange() const
Return true if the end of this range specifies the start of the last token.
Definition: SourceLocation.h:277
clang
Dataflow Directional Tag Classes.
Definition: CFGReachabilityAnalysis.h:21
clang::SourceLocation::isValid
bool isValid() const
Return true if this is a valid SourceLocation object.
Definition: SourceLocation.h:106
clang::comments::tok::text
Definition: CommentLexer.h:35
clang::arcmt::TransformActions::replaceText
void replaceText(SourceLocation loc, StringRef text, StringRef replacementText)
Definition: TransformActions.cpp:659
clang::SourceLocation::isMacroID
bool isMacroID() const
Definition: SourceLocation.h:99
clang::CharSourceRange::getEnd
SourceLocation getEnd() const
Definition: SourceLocation.h:281
clang::SourceManager::getExpansionRange
CharSourceRange getExpansionRange(SourceLocation Loc) const
Given a SourceLocation object, return the range of tokens covered by the expansion in the ultimate fi...
Definition: SourceManager.cpp:1010
clang::arcmt::TransformActions::removeStmt
void removeStmt(Stmt *S)
Definition: TransformActions.cpp:642
clang::ASTContext::getSourceManager
SourceManager & getSourceManager()
Definition: ASTContext.h:679
clang::arcmt::TransformActions::replace
void replace(SourceRange range, StringRef text)
Definition: TransformActions.cpp:646
clang::arcmt::TransformActions::remove
void remove(SourceRange range)
Definition: TransformActions.cpp:638
clang::SourceLocation::isInvalid
bool isInvalid() const
Definition: SourceLocation.h:107
Expr.h
iterator
clang::Stmt::getSourceRange
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:263
clang::arcmt::TransformActions::insert
void insert(SourceLocation loc, StringRef text)
Definition: TransformActions.cpp:629
clang::FullSourceLoc
A SourceLocation and its associated SourceManager.
Definition: SourceLocation.h:361
clang::arcmt::TransformActions::RewriteReceiver::increaseIndentation
virtual void increaseIndentation(CharSourceRange range, SourceLocation parentIndent)=0
clang::SourceRange
A trivial tuple used to represent a source range.
Definition: SourceLocation.h:207
clang::arcmt::TransformActions::RewriteReceiver
Definition: Internals.h:109
clang::SourceRange::getBegin
SourceLocation getBegin() const
Definition: SourceLocation.h:216
clang::SourceManager
This class handles loading and caching of source files into memory.
Definition: SourceManager.h:596
clang::SourceManager::getDecomposedLoc
std::pair< FileID, unsigned > getDecomposedLoc(SourceLocation Loc) const
Decompose the specified location into a raw FileID + Offset pair.
Definition: SourceManager.h:1238
clang::Preprocessor
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:128