clang  6.0.0svn
Replacement.cpp
Go to the documentation of this file.
1 //===--- Replacement.cpp - Framework for clang refactoring tools ----------===//
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 // Implements classes to support/store refactorings.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 
16 #include "clang/Basic/Diagnostic.h"
21 #include "clang/Lex/Lexer.h"
23 #include "llvm/ADT/SmallPtrSet.h"
24 #include "llvm/Support/FileSystem.h"
25 #include "llvm/Support/Path.h"
26 #include "llvm/Support/raw_os_ostream.h"
27 
28 namespace clang {
29 namespace tooling {
30 
31 static const char * const InvalidLocation = "";
32 
33 Replacement::Replacement() : FilePath(InvalidLocation) {}
34 
35 Replacement::Replacement(StringRef FilePath, unsigned Offset, unsigned Length,
36  StringRef ReplacementText)
37  : FilePath(FilePath), ReplacementRange(Offset, Length),
38  ReplacementText(ReplacementText) {}
39 
41  unsigned Length, StringRef ReplacementText) {
42  setFromSourceLocation(Sources, Start, Length, ReplacementText);
43 }
44 
46  const CharSourceRange &Range,
47  StringRef ReplacementText,
48  const LangOptions &LangOpts) {
49  setFromSourceRange(Sources, Range, ReplacementText, LangOpts);
50 }
51 
53  return FilePath != InvalidLocation;
54 }
55 
56 bool Replacement::apply(Rewriter &Rewrite) const {
57  SourceManager &SM = Rewrite.getSourceMgr();
58  const FileEntry *Entry = SM.getFileManager().getFile(FilePath);
59  if (!Entry)
60  return false;
61 
63  const SourceLocation Start =
64  SM.getLocForStartOfFile(ID).
65  getLocWithOffset(ReplacementRange.getOffset());
66  // ReplaceText returns false on success.
67  // ReplaceText only fails if the source location is not a file location, in
68  // which case we already returned false earlier.
69  bool RewriteSucceeded = !Rewrite.ReplaceText(
70  Start, ReplacementRange.getLength(), ReplacementText);
71  assert(RewriteSucceeded);
72  return RewriteSucceeded;
73 }
74 
75 std::string Replacement::toString() const {
76  std::string Result;
77  llvm::raw_string_ostream Stream(Result);
78  Stream << FilePath << ": " << ReplacementRange.getOffset() << ":+"
79  << ReplacementRange.getLength() << ":\"" << ReplacementText << "\"";
80  return Stream.str();
81 }
82 
83 bool operator<(const Replacement &LHS, const Replacement &RHS) {
84  if (LHS.getOffset() != RHS.getOffset())
85  return LHS.getOffset() < RHS.getOffset();
86 
87  if (LHS.getLength() != RHS.getLength())
88  return LHS.getLength() < RHS.getLength();
89 
90  if (LHS.getFilePath() != RHS.getFilePath())
91  return LHS.getFilePath() < RHS.getFilePath();
92  return LHS.getReplacementText() < RHS.getReplacementText();
93 }
94 
95 bool operator==(const Replacement &LHS, const Replacement &RHS) {
96  return LHS.getOffset() == RHS.getOffset() &&
97  LHS.getLength() == RHS.getLength() &&
98  LHS.getFilePath() == RHS.getFilePath() &&
100 }
101 
102 void Replacement::setFromSourceLocation(const SourceManager &Sources,
103  SourceLocation Start, unsigned Length,
104  StringRef ReplacementText) {
105  const std::pair<FileID, unsigned> DecomposedLocation =
106  Sources.getDecomposedLoc(Start);
107  const FileEntry *Entry = Sources.getFileEntryForID(DecomposedLocation.first);
108  this->FilePath = Entry ? Entry->getName() : InvalidLocation;
109  this->ReplacementRange = Range(DecomposedLocation.second, Length);
110  this->ReplacementText = ReplacementText;
111 }
112 
113 // FIXME: This should go into the Lexer, but we need to figure out how
114 // to handle ranges for refactoring in general first - there is no obvious
115 // good way how to integrate this into the Lexer yet.
116 static int getRangeSize(const SourceManager &Sources,
117  const CharSourceRange &Range,
118  const LangOptions &LangOpts) {
119  SourceLocation SpellingBegin = Sources.getSpellingLoc(Range.getBegin());
120  SourceLocation SpellingEnd = Sources.getSpellingLoc(Range.getEnd());
121  std::pair<FileID, unsigned> Start = Sources.getDecomposedLoc(SpellingBegin);
122  std::pair<FileID, unsigned> End = Sources.getDecomposedLoc(SpellingEnd);
123  if (Start.first != End.first) return -1;
124  if (Range.isTokenRange())
125  End.second += Lexer::MeasureTokenLength(SpellingEnd, Sources, LangOpts);
126  return End.second - Start.second;
127 }
128 
129 void Replacement::setFromSourceRange(const SourceManager &Sources,
130  const CharSourceRange &Range,
131  StringRef ReplacementText,
132  const LangOptions &LangOpts) {
133  setFromSourceLocation(Sources, Sources.getSpellingLoc(Range.getBegin()),
134  getRangeSize(Sources, Range, LangOpts),
135  ReplacementText);
136 }
137 
139 Replacements::getReplacementInChangedCode(const Replacement &R) const {
140  unsigned NewStart = getShiftedCodePosition(R.getOffset());
141  unsigned NewEnd = getShiftedCodePosition(R.getOffset() + R.getLength());
142  return Replacement(R.getFilePath(), NewStart, NewEnd - NewStart,
143  R.getReplacementText());
144 }
145 
147  switch (Err) {
149  return "Failed to apply a replacement.";
151  return "The new replacement's file path is different from the file path of "
152  "existing replacements";
154  return "The new replacement overlaps with an existing replacement.";
156  return "The new insertion has the same insert location as an existing "
157  "replacement.";
158  }
159  llvm_unreachable("A value of replacement_error has no message.");
160 }
161 
162 std::string ReplacementError::message() const {
163  std::string Message = getReplacementErrString(Err);
164  if (NewReplacement.hasValue())
165  Message += "\nNew replacement: " + NewReplacement->toString();
166  if (ExistingReplacement.hasValue())
167  Message += "\nExisting replacement: " + ExistingReplacement->toString();
168  return Message;
169 }
170 
171 char ReplacementError::ID = 0;
172 
173 Replacements Replacements::getCanonicalReplacements() const {
174  std::vector<Replacement> NewReplaces;
175  // Merge adjacent replacements.
176  for (const auto &R : Replaces) {
177  if (NewReplaces.empty()) {
178  NewReplaces.push_back(R);
179  continue;
180  }
181  auto &Prev = NewReplaces.back();
182  unsigned PrevEnd = Prev.getOffset() + Prev.getLength();
183  if (PrevEnd < R.getOffset()) {
184  NewReplaces.push_back(R);
185  } else {
186  assert(PrevEnd == R.getOffset() &&
187  "Existing replacements must not overlap.");
188  Replacement NewR(
189  R.getFilePath(), Prev.getOffset(), Prev.getLength() + R.getLength(),
190  (Prev.getReplacementText() + R.getReplacementText()).str());
191  Prev = NewR;
192  }
193  }
194  ReplacementsImpl NewReplacesImpl(NewReplaces.begin(), NewReplaces.end());
195  return Replacements(NewReplacesImpl.begin(), NewReplacesImpl.end());
196 }
197 
198 // `R` and `Replaces` are order-independent if applying them in either order
199 // has the same effect, so we need to compare replacements associated to
200 // applying them in either order.
202 Replacements::mergeIfOrderIndependent(const Replacement &R) const {
203  Replacements Rs(R);
204  // A Replacements set containg a single replacement that is `R` referring to
205  // the code after the existing replacements `Replaces` are applied.
206  Replacements RsShiftedByReplaces(getReplacementInChangedCode(R));
207  // A Replacements set that is `Replaces` referring to the code after `R` is
208  // applied.
209  Replacements ReplacesShiftedByRs;
210  for (const auto &Replace : Replaces)
211  ReplacesShiftedByRs.Replaces.insert(
212  Rs.getReplacementInChangedCode(Replace));
213  // This is equivalent to applying `Replaces` first and then `R`.
214  auto MergeShiftedRs = merge(RsShiftedByReplaces);
215  // This is equivalent to applying `R` first and then `Replaces`.
216  auto MergeShiftedReplaces = Rs.merge(ReplacesShiftedByRs);
217 
218  // Since empty or segmented replacements around existing replacements might be
219  // produced above, we need to compare replacements in canonical forms.
220  if (MergeShiftedRs.getCanonicalReplacements() ==
221  MergeShiftedReplaces.getCanonicalReplacements())
222  return MergeShiftedRs;
223  return llvm::make_error<ReplacementError>(replacement_error::overlap_conflict,
224  R, *Replaces.begin());
225 }
226 
228  // Check the file path.
229  if (!Replaces.empty() && R.getFilePath() != Replaces.begin()->getFilePath())
230  return llvm::make_error<ReplacementError>(
231  replacement_error::wrong_file_path, R, *Replaces.begin());
232 
233  // Special-case header insertions.
234  if (R.getOffset() == UINT_MAX) {
235  Replaces.insert(R);
236  return llvm::Error::success();
237  }
238 
239  // This replacement cannot conflict with replacements that end before
240  // this replacement starts or start after this replacement ends.
241  // We also know that there currently are no overlapping replacements.
242  // Thus, we know that all replacements that start after the end of the current
243  // replacement cannot overlap.
244  Replacement AtEnd(R.getFilePath(), R.getOffset() + R.getLength(), 0, "");
245 
246  // Find the first entry that starts after or at the end of R. Note that
247  // entries that start at the end can still be conflicting if R is an
248  // insertion.
249  auto I = Replaces.lower_bound(AtEnd);
250  // If `I` starts at the same offset as `R`, `R` must be an insertion.
251  if (I != Replaces.end() && R.getOffset() == I->getOffset()) {
252  assert(R.getLength() == 0);
253  // `I` is also an insertion, `R` and `I` conflict.
254  if (I->getLength() == 0) {
255  // Check if two insertions are order-indepedent: if inserting them in
256  // either order produces the same text, they are order-independent.
257  if ((R.getReplacementText() + I->getReplacementText()).str() !=
258  (I->getReplacementText() + R.getReplacementText()).str())
259  return llvm::make_error<ReplacementError>(
261  // If insertions are order-independent, we can merge them.
262  Replacement NewR(
263  R.getFilePath(), R.getOffset(), 0,
264  (R.getReplacementText() + I->getReplacementText()).str());
265  Replaces.erase(I);
266  Replaces.insert(std::move(NewR));
267  return llvm::Error::success();
268  }
269  // Insertion `R` is adjacent to a non-insertion replacement `I`, so they
270  // are order-independent. It is safe to assume that `R` will not conflict
271  // with any replacement before `I` since all replacements before `I` must
272  // either end before `R` or end at `R` but has length > 0 (if the
273  // replacement before `I` is an insertion at `R`, it would have been `I`
274  // since it is a lower bound of `AtEnd` and ordered before the current `I`
275  // in the set).
276  Replaces.insert(R);
277  return llvm::Error::success();
278  }
279 
280  // `I` is the smallest iterator (after `R`) whose entry cannot overlap.
281  // If that is begin(), there are no overlaps.
282  if (I == Replaces.begin()) {
283  Replaces.insert(R);
284  return llvm::Error::success();
285  }
286  --I;
287  auto Overlap = [](const Replacement &R1, const Replacement &R2) -> bool {
288  return Range(R1.getOffset(), R1.getLength())
289  .overlapsWith(Range(R2.getOffset(), R2.getLength()));
290  };
291  // If the previous entry does not overlap, we know that entries before it
292  // can also not overlap.
293  if (!Overlap(R, *I)) {
294  // If `R` and `I` do not have the same offset, it is safe to add `R` since
295  // it must come after `I`. Otherwise:
296  // - If `R` is an insertion, `I` must not be an insertion since it would
297  // have come after `AtEnd`.
298  // - If `R` is not an insertion, `I` must be an insertion; otherwise, `R`
299  // and `I` would have overlapped.
300  // In either case, we can safely insert `R`.
301  Replaces.insert(R);
302  } else {
303  // `I` overlaps with `R`. We need to check `R` against all overlapping
304  // replacements to see if they are order-indepedent. If they are, merge `R`
305  // with them and replace them with the merged replacements.
306  auto MergeBegin = I;
307  auto MergeEnd = std::next(I);
308  while (I != Replaces.begin()) {
309  --I;
310  // If `I` doesn't overlap with `R`, don't merge it.
311  if (!Overlap(R, *I))
312  break;
313  MergeBegin = I;
314  }
315  Replacements OverlapReplaces(MergeBegin, MergeEnd);
317  OverlapReplaces.mergeIfOrderIndependent(R);
318  if (!Merged)
319  return Merged.takeError();
320  Replaces.erase(MergeBegin, MergeEnd);
321  Replaces.insert(Merged->begin(), Merged->end());
322  }
323  return llvm::Error::success();
324 }
325 
326 namespace {
327 
328 // Represents a merged replacement, i.e. a replacement consisting of multiple
329 // overlapping replacements from 'First' and 'Second' in mergeReplacements.
330 //
331 // Position projection:
332 // Offsets and lengths of the replacements can generally refer to two different
333 // coordinate spaces. Replacements from 'First' refer to the original text
334 // whereas replacements from 'Second' refer to the text after applying 'First'.
335 //
336 // MergedReplacement always operates in the coordinate space of the original
337 // text, i.e. transforms elements from 'Second' to take into account what was
338 // changed based on the elements from 'First'.
339 //
340 // We can correctly calculate this projection as we look at the replacements in
341 // order of strictly increasing offsets.
342 //
343 // Invariants:
344 // * We always merge elements from 'First' into elements from 'Second' and vice
345 // versa. Within each set, the replacements are non-overlapping.
346 // * We only extend to the right, i.e. merge elements with strictly increasing
347 // offsets.
348 class MergedReplacement {
349 public:
350  MergedReplacement(const Replacement &R, bool MergeSecond, int D)
351  : MergeSecond(MergeSecond), Delta(D), FilePath(R.getFilePath()),
352  Offset(R.getOffset() + (MergeSecond ? 0 : Delta)), Length(R.getLength()),
353  Text(R.getReplacementText()) {
354  Delta += MergeSecond ? 0 : Text.size() - Length;
355  DeltaFirst = MergeSecond ? Text.size() - Length : 0;
356  }
357 
358  // Merges the next element 'R' into this merged element. As we always merge
359  // from 'First' into 'Second' or vice versa, the MergedReplacement knows what
360  // set the next element is coming from.
361  void merge(const Replacement &R) {
362  if (MergeSecond) {
363  unsigned REnd = R.getOffset() + Delta + R.getLength();
364  unsigned End = Offset + Text.size();
365  if (REnd > End) {
366  Length += REnd - End;
367  MergeSecond = false;
368  }
369  StringRef TextRef = Text;
370  StringRef Head = TextRef.substr(0, R.getOffset() + Delta - Offset);
371  StringRef Tail = TextRef.substr(REnd - Offset);
372  Text = (Head + R.getReplacementText() + Tail).str();
373  Delta += R.getReplacementText().size() - R.getLength();
374  } else {
375  unsigned End = Offset + Length;
376  StringRef RText = R.getReplacementText();
377  StringRef Tail = RText.substr(End - R.getOffset());
378  Text = (Text + Tail).str();
379  if (R.getOffset() + RText.size() > End) {
380  Length = R.getOffset() + R.getLength() - Offset;
381  MergeSecond = true;
382  } else {
383  Length += R.getLength() - RText.size();
384  }
385  DeltaFirst += RText.size() - R.getLength();
386  }
387  }
388 
389  // Returns 'true' if 'R' starts strictly after the MergedReplacement and thus
390  // doesn't need to be merged.
391  bool endsBefore(const Replacement &R) const {
392  if (MergeSecond)
393  return Offset + Text.size() < R.getOffset() + Delta;
394  return Offset + Length < R.getOffset();
395  }
396 
397  // Returns 'true' if an element from the second set should be merged next.
398  bool mergeSecond() const { return MergeSecond; }
399  int deltaFirst() const { return DeltaFirst; }
400  Replacement asReplacement() const { return {FilePath, Offset, Length, Text}; }
401 
402 private:
403  bool MergeSecond;
404 
405  // Amount of characters that elements from 'Second' need to be shifted by in
406  // order to refer to the original text.
407  int Delta;
408 
409  // Sum of all deltas (text-length - length) of elements from 'First' merged
410  // into this element. This is used to update 'Delta' once the
411  // MergedReplacement is completed.
412  int DeltaFirst;
413 
414  // Data of the actually merged replacement. FilePath and Offset aren't changed
415  // as the element is only extended to the right.
416  const StringRef FilePath;
417  const unsigned Offset;
418  unsigned Length;
419  std::string Text;
420 };
421 
422 } // namespace
423 
424 Replacements Replacements::merge(const Replacements &ReplacesToMerge) const {
425  if (empty() || ReplacesToMerge.empty())
426  return empty() ? ReplacesToMerge : *this;
427 
428  auto &First = Replaces;
429  auto &Second = ReplacesToMerge.Replaces;
430  // Delta is the amount of characters that replacements from 'Second' need to
431  // be shifted so that their offsets refer to the original text.
432  int Delta = 0;
433  ReplacementsImpl Result;
434 
435  // Iterate over both sets and always add the next element (smallest total
436  // Offset) from either 'First' or 'Second'. Merge that element with
437  // subsequent replacements as long as they overlap. See more details in the
438  // comment on MergedReplacement.
439  for (auto FirstI = First.begin(), SecondI = Second.begin();
440  FirstI != First.end() || SecondI != Second.end();) {
441  bool NextIsFirst = SecondI == Second.end() ||
442  (FirstI != First.end() &&
443  FirstI->getOffset() < SecondI->getOffset() + Delta);
444  MergedReplacement Merged(NextIsFirst ? *FirstI : *SecondI, NextIsFirst,
445  Delta);
446  ++(NextIsFirst ? FirstI : SecondI);
447 
448  while ((Merged.mergeSecond() && SecondI != Second.end()) ||
449  (!Merged.mergeSecond() && FirstI != First.end())) {
450  auto &I = Merged.mergeSecond() ? SecondI : FirstI;
451  if (Merged.endsBefore(*I))
452  break;
453  Merged.merge(*I);
454  ++I;
455  }
456  Delta -= Merged.deltaFirst();
457  Result.insert(Merged.asReplacement());
458  }
459  return Replacements(Result.begin(), Result.end());
460 }
461 
462 // Combines overlapping ranges in \p Ranges and sorts the combined ranges.
463 // Returns a set of non-overlapping and sorted ranges that is equivalent to
464 // \p Ranges.
465 static std::vector<Range> combineAndSortRanges(std::vector<Range> Ranges) {
466  std::sort(Ranges.begin(), Ranges.end(),
467  [](const Range &LHS, const Range &RHS) {
468  if (LHS.getOffset() != RHS.getOffset())
469  return LHS.getOffset() < RHS.getOffset();
470  return LHS.getLength() < RHS.getLength();
471  });
472  std::vector<Range> Result;
473  for (const auto &R : Ranges) {
474  if (Result.empty() ||
475  Result.back().getOffset() + Result.back().getLength() < R.getOffset()) {
476  Result.push_back(R);
477  } else {
478  unsigned NewEnd =
479  std::max(Result.back().getOffset() + Result.back().getLength(),
480  R.getOffset() + R.getLength());
481  Result[Result.size() - 1] =
482  Range(Result.back().getOffset(), NewEnd - Result.back().getOffset());
483  }
484  }
485  return Result;
486 }
487 
488 std::vector<Range>
490  const std::vector<Range> &Ranges) {
491  // To calculate the new ranges,
492  // - Turn \p Ranges into Replacements at (offset, length) with an empty
493  // (unimportant) replacement text of length "length".
494  // - Merge with \p Replaces.
495  // - The new ranges will be the affected ranges of the merged replacements.
496  auto MergedRanges = combineAndSortRanges(Ranges);
497  if (Replaces.empty())
498  return MergedRanges;
499  tooling::Replacements FakeReplaces;
500  for (const auto &R : MergedRanges) {
501  auto Err = FakeReplaces.add(Replacement(Replaces.begin()->getFilePath(),
502  R.getOffset(), R.getLength(),
503  std::string(R.getLength(), ' ')));
504  assert(!Err &&
505  "Replacements must not conflict since ranges have been merged.");
506  llvm::consumeError(std::move(Err));
507  }
508  return FakeReplaces.merge(Replaces).getAffectedRanges();
509 }
510 
511 std::vector<Range> Replacements::getAffectedRanges() const {
512  std::vector<Range> ChangedRanges;
513  int Shift = 0;
514  for (const Replacement &R : Replaces) {
515  unsigned Offset = R.getOffset() + Shift;
516  unsigned Length = R.getReplacementText().size();
517  Shift += Length - R.getLength();
518  ChangedRanges.push_back(Range(Offset, Length));
519  }
520  return combineAndSortRanges(ChangedRanges);
521 }
522 
523 unsigned Replacements::getShiftedCodePosition(unsigned Position) const {
524  unsigned Offset = 0;
525  for (const auto& R : Replaces) {
526  if (R.getOffset() + R.getLength() <= Position) {
527  Offset += R.getReplacementText().size() - R.getLength();
528  continue;
529  }
530  if (R.getOffset() < Position &&
531  R.getOffset() + R.getReplacementText().size() <= Position) {
532  Position = R.getOffset() + R.getReplacementText().size();
533  if (R.getReplacementText().size() > 0)
534  Position--;
535  }
536  break;
537  }
538  return Position + Offset;
539 }
540 
541 bool applyAllReplacements(const Replacements &Replaces, Rewriter &Rewrite) {
542  bool Result = true;
543  for (auto I = Replaces.rbegin(), E = Replaces.rend(); I != E; ++I) {
544  if (I->isApplicable()) {
545  Result = I->apply(Rewrite) && Result;
546  } else {
547  Result = false;
548  }
549  }
550  return Result;
551 }
552 
554  const Replacements &Replaces) {
555  if (Replaces.empty())
556  return Code.str();
557 
560  FileManager Files(FileSystemOptions(), InMemoryFileSystem);
561  DiagnosticsEngine Diagnostics(
563  new DiagnosticOptions);
564  SourceManager SourceMgr(Diagnostics, Files);
565  Rewriter Rewrite(SourceMgr, LangOptions());
566  InMemoryFileSystem->addFile(
567  "<stdin>", 0, llvm::MemoryBuffer::getMemBuffer(Code, "<stdin>"));
568  FileID ID = SourceMgr.createFileID(Files.getFile("<stdin>"), SourceLocation(),
570  for (auto I = Replaces.rbegin(), E = Replaces.rend(); I != E; ++I) {
571  Replacement Replace("<stdin>", I->getOffset(), I->getLength(),
572  I->getReplacementText());
573  if (!Replace.apply(Rewrite))
574  return llvm::make_error<ReplacementError>(
576  }
577  std::string Result;
578  llvm::raw_string_ostream OS(Result);
579  Rewrite.getEditBuffer(ID).write(OS);
580  OS.flush();
581  return Result;
582 }
583 
584 std::map<std::string, Replacements> groupReplacementsByFile(
585  FileManager &FileMgr,
586  const std::map<std::string, Replacements> &FileToReplaces) {
587  std::map<std::string, Replacements> Result;
588  llvm::SmallPtrSet<const FileEntry *, 16> ProcessedFileEntries;
589  for (const auto &Entry : FileToReplaces) {
590  const FileEntry *FE = FileMgr.getFile(Entry.first);
591  if (!FE)
592  llvm::errs() << "File path " << Entry.first << " is invalid.\n";
593  else if (ProcessedFileEntries.insert(FE).second)
594  Result[Entry.first] = std::move(Entry.second);
595  }
596  return Result;
597 }
598 
599 } // end namespace tooling
600 } // end namespace clang
SourceLocation getLocForStartOfFile(FileID FID) const
Return the source location corresponding to the first byte of the specified file. ...
StringRef getFilePath() const
Accessors.
Definition: Replacement.h:118
Implements support for file system lookup, file system caching, and directory search management...
Definition: FileManager.h:116
Defines the clang::FileManager interface and associated types.
Defines the SourceManager interface.
bool operator==(const Replacement &LHS, const Replacement &RHS)
Equal-to operator between two Replacements.
Definition: Replacement.cpp:95
Maintains a set of replacements that are conflict-free.
Definition: Replacement.h:205
RewriteBuffer & getEditBuffer(FileID FID)
getEditBuffer - This is like getRewriteBufferFor, but always returns a buffer, and allows you to writ...
Definition: Rewriter.cpp:223
static std::string getReplacementErrString(replacement_error Err)
std::vector< Range > getAffectedRanges() const
bool applyAllReplacements(const Replacements &Replaces, Rewriter &Rewrite)
Apply all replacements in Replaces to the Rewriter Rewrite.
FileManager & getFileManager() const
const_reverse_iterator rend() const
Definition: Replacement.h:280
SourceLocation getBegin() const
static int getRangeSize(const SourceManager &Sources, const CharSourceRange &Range, const LangOptions &LangOpts)
bool ReplaceText(SourceLocation Start, unsigned OrigLength, StringRef NewStr)
ReplaceText - This method replaces a range of characters in the input buffer with a new string...
Definition: Rewriter.cpp:303
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:48
An in-memory file system.
uint32_t Offset
Definition: CacheTokens.cpp:43
SourceManager & getSourceMgr() const
Definition: Rewriter.h:64
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:147
Defines the Diagnostic-related interfaces.
SourceLocation getSpellingLoc(SourceLocation Loc) const
Given a SourceLocation object, return the spelling location referenced by the ID. ...
#define UINT_MAX
Definition: limits.h:72
Replacement()
Creates an invalid (not applicable) replacement.
Definition: Replacement.cpp:33
const FileEntry * getFile(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)
Lookup, cache, and verify the specified file (real or virtual).
FileID getOrCreateFileID(const FileEntry *SourceFile, SrcMgr::CharacteristicKind FileCharacter)
Get the FileID for SourceFile if it exists.
A text replacement.
Definition: Replacement.h:81
unsigned getLength() const
Definition: Replacement.h:50
A source range independent of the SourceManager.
Definition: Replacement.h:42
bool operator<(const Replacement &LHS, const Replacement &RHS)
Less-than operator between two Replacements.
Definition: Replacement.cpp:83
SourceLocation End
Represents a character-granular source range.
static unsigned MeasureTokenLength(SourceLocation Loc, const SourceManager &SM, const LangOptions &LangOpts)
MeasureTokenLength - Relex the token at the specified location and return its length in bytes in the ...
Definition: Lexer.cpp:435
const FileEntry * getFileEntryForID(FileID FID) const
Returns the FileEntry record for the provided FileID.
FileID createFileID(const FileEntry *SourceFile, SourceLocation IncludePos, SrcMgr::CharacteristicKind FileCharacter, int LoadedID=0, unsigned LoadedOffset=0)
Create a new FileID that represents the specified file being #included from the specified IncludePosi...
unsigned getOffset() const
Accessors.
Definition: Replacement.h:49
const SourceManager & SM
Definition: Format.cpp:1337
const_iterator begin() const
Definition: Replacement.h:274
const_reverse_iterator rbegin() const
Definition: Replacement.h:278
static const char *const InvalidLocation
Definition: Replacement.cpp:31
Encodes a location in the source.
raw_ostream & write(raw_ostream &Stream) const
Write to Stream the result of applying all changes to the original buffer.
Definition: Rewriter.cpp:25
StringRef getName() const
Definition: FileManager.h:84
std::string message() const override
Options for controlling the compiler diagnostics engine.
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:59
bool isApplicable() const
Returns whether this replacement can be applied to a file.
Definition: Replacement.cpp:52
std::string toString() const
Returns a human readable string representation.
Definition: Replacement.cpp:75
unsigned getLength() const
Definition: Replacement.h:120
bool isTokenRange() const
Return true if the end of this range specifies the start of the last token.
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Dataflow Directional Tag Classes.
unsigned getOffset() const
Definition: Replacement.h:119
Used for handling and querying diagnostic IDs.
bool apply(Rewriter &Rewrite) const
Applies the replacement on the Rewriter.
Definition: Replacement.cpp:56
unsigned getShiftedCodePosition(unsigned Position) const
SourceLocation getEnd() const
char __ovld __cnfn max(char x, char y)
Returns y if x < y, otherwise it returns x.
Keeps track of options that affect how file operations are performed.
static std::vector< Range > combineAndSortRanges(std::vector< Range > Ranges)
Rewriter - This is the main interface to the rewrite buffers.
Definition: Rewriter.h:31
llvm::Error add(const Replacement &R)
Adds a new replacement R to the current set of replacements.
std::map< std::string, Replacements > groupReplacementsByFile(FileManager &FileMgr, const std::map< std::string, Replacements > &FileToReplaces)
If there are multiple <File, Replacements> pairs with the same file entry, we only keep one pair and ...
Defines the Diagnostic IDs-related interfaces.
LLVM_NODISCARD Replacements merge(const Replacements &Replaces) const
Merges Replaces into the current replacements.
StringRef Text
Definition: Format.cpp:1346
std::vector< Range > calculateRangesAfterReplacements(const Replacements &Replaces, const std::vector< Range > &Ranges)
Calculates the new ranges after Replaces are applied.
StringRef getReplacementText() const
Definition: Replacement.h:121
This class handles loading and caching of source files into memory.
std::pair< FileID, unsigned > getDecomposedLoc(SourceLocation Loc) const
Decompose the specified location into a raw FileID + Offset pair.