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
14#include "clang/Basic/Diagnostic.h"
15#include "clang/Basic/DiagnosticIDs.h"
16#include "clang/Basic/DiagnosticOptions.h"
17#include "clang/Basic/FileManager.h"
18#include "clang/Basic/SourceManager.h"
19#include "clang/Lex/Lexer.h"
20#include "clang/Rewrite/Core/Rewriter.h"
21#include "clang/Tooling/Core/Replacement.h"
22#include "llvm/Support/FileSystem.h"
23#include "llvm/Support/Path.h"
24#include "llvm/Support/raw_os_ostream.h"
25
26namespace clang {
27namespace tooling {
28
29static const char * const InvalidLocation = "";
30
31Replacement::Replacement()
32  : FilePath(InvalidLocation) {}
33
34Replacement::Replacement(StringRef FilePath, unsigned Offset, unsigned Length,
35                         StringRef ReplacementText)
36    : FilePath(FilePath), ReplacementRange(Offset, Length),
37      ReplacementText(ReplacementText) {}
38
39Replacement::Replacement(const SourceManager &Sources, SourceLocation Start,
40                         unsigned Length, StringRef ReplacementText) {
41  setFromSourceLocation(Sources, Start, Length, ReplacementText);
42}
43
44Replacement::Replacement(const SourceManager &Sources,
45                         const CharSourceRange &Range,
46                         StringRef ReplacementText) {
47  setFromSourceRange(Sources, Range, ReplacementText);
48}
49
50bool Replacement::isApplicable() const {
51  return FilePath != InvalidLocation;
52}
53
54bool Replacement::apply(Rewriter &Rewrite) const {
55  SourceManager &SM = Rewrite.getSourceMgr();
56  const FileEntry *Entry = SM.getFileManager().getFile(FilePath);
57  if (!Entry)
58    return false;
59  FileID ID;
60  // FIXME: Use SM.translateFile directly.
61  SourceLocation Location = SM.translateFileLineCol(Entry, 1, 1);
62  ID = Location.isValid() ?
63    SM.getFileID(Location) :
64    SM.createFileID(Entry, SourceLocation(), SrcMgr::C_User);
65  // FIXME: We cannot check whether Offset + Length is in the file, as
66  // the remapping API is not public in the RewriteBuffer.
67  const SourceLocation Start =
68    SM.getLocForStartOfFile(ID).
69    getLocWithOffset(ReplacementRange.getOffset());
70  // ReplaceText returns false on success.
71  // ReplaceText only fails if the source location is not a file location, in
72  // which case we already returned false earlier.
73  bool RewriteSucceeded = !Rewrite.ReplaceText(
74      Start, ReplacementRange.getLength(), ReplacementText);
75  assert(RewriteSucceeded);
76  return RewriteSucceeded;
77}
78
79std::string Replacement::toString() const {
80  std::string result;
81  llvm::raw_string_ostream stream(result);
82  stream << FilePath << ": " << ReplacementRange.getOffset() << ":+"
83         << ReplacementRange.getLength() << ":\"" << ReplacementText << "\"";
84  return result;
85}
86
87bool operator<(const Replacement &LHS, const Replacement &RHS) {
88  if (LHS.getOffset() != RHS.getOffset())
89    return LHS.getOffset() < RHS.getOffset();
90  if (LHS.getLength() != RHS.getLength())
91    return LHS.getLength() < RHS.getLength();
92  if (LHS.getFilePath() != RHS.getFilePath())
93    return LHS.getFilePath() < RHS.getFilePath();
94  return LHS.getReplacementText() < RHS.getReplacementText();
95}
96
97bool operator==(const Replacement &LHS, const Replacement &RHS) {
98  return LHS.getOffset() == RHS.getOffset() &&
99         LHS.getLength() == RHS.getLength() &&
100         LHS.getFilePath() == RHS.getFilePath() &&
101         LHS.getReplacementText() == RHS.getReplacementText();
102}
103
104void Replacement::setFromSourceLocation(const SourceManager &Sources,
105                                        SourceLocation Start, unsigned Length,
106                                        StringRef ReplacementText) {
107  const std::pair<FileID, unsigned> DecomposedLocation =
108      Sources.getDecomposedLoc(Start);
109  const FileEntry *Entry = Sources.getFileEntryForID(DecomposedLocation.first);
110  if (Entry) {
111    // Make FilePath absolute so replacements can be applied correctly when
112    // relative paths for files are used.
113    llvm::SmallString<256> FilePath(Entry->getName());
114    std::error_code EC = llvm::sys::fs::make_absolute(FilePath);
115    this->FilePath = EC ? FilePath.c_str() : Entry->getName();
116  } else {
117    this->FilePath = InvalidLocation;
118  }
119  this->ReplacementRange = Range(DecomposedLocation.second, Length);
120  this->ReplacementText = ReplacementText;
121}
122
123// FIXME: This should go into the Lexer, but we need to figure out how
124// to handle ranges for refactoring in general first - there is no obvious
125// good way how to integrate this into the Lexer yet.
126static int getRangeSize(const SourceManager &Sources,
127                        const CharSourceRange &Range) {
128  SourceLocation SpellingBegin = Sources.getSpellingLoc(Range.getBegin());
129  SourceLocation SpellingEnd = Sources.getSpellingLoc(Range.getEnd());
130  std::pair<FileID, unsigned> Start = Sources.getDecomposedLoc(SpellingBegin);
131  std::pair<FileID, unsigned> End = Sources.getDecomposedLoc(SpellingEnd);
132  if (Start.first != End.first) return -1;
133  if (Range.isTokenRange())
134    End.second += Lexer::MeasureTokenLength(SpellingEnd, Sources,
135                                            LangOptions());
136  return End.second - Start.second;
137}
138
139void Replacement::setFromSourceRange(const SourceManager &Sources,
140                                     const CharSourceRange &Range,
141                                     StringRef ReplacementText) {
142  setFromSourceLocation(Sources, Sources.getSpellingLoc(Range.getBegin()),
143                        getRangeSize(Sources, Range), ReplacementText);
144}
145
146unsigned shiftedCodePosition(const Replacements &Replaces, unsigned Position) {
147  unsigned NewPosition = Position;
148  for (Replacements::iterator I = Replaces.begin(), E = Replaces.end(); I != E;
149       ++I) {
150    if (I->getOffset() >= Position)
151      break;
152    if (I->getOffset() + I->getLength() > Position)
153      NewPosition += I->getOffset() + I->getLength() - Position;
154    NewPosition += I->getReplacementText().size() - I->getLength();
155  }
156  return NewPosition;
157}
158
159// FIXME: Remove this function when Replacements is implemented as std::vector
160// instead of std::set.
161unsigned shiftedCodePosition(const std::vector<Replacement> &Replaces,
162                             unsigned Position) {
163  unsigned NewPosition = Position;
164  for (std::vector<Replacement>::const_iterator I = Replaces.begin(),
165                                                E = Replaces.end();
166       I != E; ++I) {
167    if (I->getOffset() >= Position)
168      break;
169    if (I->getOffset() + I->getLength() > Position)
170      NewPosition += I->getOffset() + I->getLength() - Position;
171    NewPosition += I->getReplacementText().size() - I->getLength();
172  }
173  return NewPosition;
174}
175
176void deduplicate(std::vector<Replacement> &Replaces,
177                 std::vector<Range> &Conflicts) {
178  if (Replaces.empty())
179    return;
180
181  auto LessNoPath = [](const Replacement &LHS, const Replacement &RHS) {
182    if (LHS.getOffset() != RHS.getOffset())
183      return LHS.getOffset() < RHS.getOffset();
184    if (LHS.getLength() != RHS.getLength())
185      return LHS.getLength() < RHS.getLength();
186    return LHS.getReplacementText() < RHS.getReplacementText();
187  };
188
189  auto EqualNoPath = [](const Replacement &LHS, const Replacement &RHS) {
190    return LHS.getOffset() == RHS.getOffset() &&
191           LHS.getLength() == RHS.getLength() &&
192           LHS.getReplacementText() == RHS.getReplacementText();
193  };
194
195  // Deduplicate. We don't want to deduplicate based on the path as we assume
196  // that all replacements refer to the same file (or are symlinks).
197  std::sort(Replaces.begin(), Replaces.end(), LessNoPath);
198  Replaces.erase(std::unique(Replaces.begin(), Replaces.end(), EqualNoPath),
199                 Replaces.end());
200
201  // Detect conflicts
202  Range ConflictRange(Replaces.front().getOffset(),
203                      Replaces.front().getLength());
204  unsigned ConflictStart = 0;
205  unsigned ConflictLength = 1;
206  for (unsigned i = 1; i < Replaces.size(); ++i) {
207    Range Current(Replaces[i].getOffset(), Replaces[i].getLength());
208    if (ConflictRange.overlapsWith(Current)) {
209      // Extend conflicted range
210      ConflictRange = Range(ConflictRange.getOffset(),
211                            std::max(ConflictRange.getLength(),
212                                     Current.getOffset() + Current.getLength() -
213                                         ConflictRange.getOffset()));
214      ++ConflictLength;
215    } else {
216      if (ConflictLength > 1)
217        Conflicts.push_back(Range(ConflictStart, ConflictLength));
218      ConflictRange = Current;
219      ConflictStart = i;
220      ConflictLength = 1;
221    }
222  }
223
224  if (ConflictLength > 1)
225    Conflicts.push_back(Range(ConflictStart, ConflictLength));
226}
227
228bool applyAllReplacements(const Replacements &Replaces, Rewriter &Rewrite) {
229  bool Result = true;
230  for (Replacements::const_iterator I = Replaces.begin(),
231                                    E = Replaces.end();
232       I != E; ++I) {
233    if (I->isApplicable()) {
234      Result = I->apply(Rewrite) && Result;
235    } else {
236      Result = false;
237    }
238  }
239  return Result;
240}
241
242// FIXME: Remove this function when Replacements is implemented as std::vector
243// instead of std::set.
244bool applyAllReplacements(const std::vector<Replacement> &Replaces,
245                          Rewriter &Rewrite) {
246  bool Result = true;
247  for (std::vector<Replacement>::const_iterator I = Replaces.begin(),
248                                                E = Replaces.end();
249       I != E; ++I) {
250    if (I->isApplicable()) {
251      Result = I->apply(Rewrite) && Result;
252    } else {
253      Result = false;
254    }
255  }
256  return Result;
257}
258
259std::string applyAllReplacements(StringRef Code, const Replacements &Replaces) {
260  FileManager Files((FileSystemOptions()));
261  DiagnosticsEngine Diagnostics(
262      IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs),
263      new DiagnosticOptions);
264  SourceManager SourceMgr(Diagnostics, Files);
265  Rewriter Rewrite(SourceMgr, LangOptions());
266  std::unique_ptr<llvm::MemoryBuffer> Buf =
267      llvm::MemoryBuffer::getMemBuffer(Code, "<stdin>");
268  const clang::FileEntry *Entry =
269      Files.getVirtualFile("<stdin>", Buf->getBufferSize(), 0);
270  SourceMgr.overrideFileContents(Entry, std::move(Buf));
271  FileID ID =
272      SourceMgr.createFileID(Entry, SourceLocation(), clang::SrcMgr::C_User);
273  for (Replacements::const_iterator I = Replaces.begin(), E = Replaces.end();
274       I != E; ++I) {
275    Replacement Replace("<stdin>", I->getOffset(), I->getLength(),
276                        I->getReplacementText());
277    if (!Replace.apply(Rewrite))
278      return "";
279  }
280  std::string Result;
281  llvm::raw_string_ostream OS(Result);
282  Rewrite.getEditBuffer(ID).write(OS);
283  OS.flush();
284  return Result;
285}
286
287} // end namespace tooling
288} // end namespace clang
289
290