EditedSource.cpp revision ecc271fefd51d825df81d78549b60037f67f0224 
1//===----- EditedSource.cpp - Collection of source edits ------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "clang/Edit/EditedSource.h"
11#include "clang/Basic/CharInfo.h"
12#include "clang/Basic/SourceManager.h"
13#include "clang/Edit/Commit.h"
14#include "clang/Edit/EditsReceiver.h"
15#include "clang/Lex/Lexer.h"
16#include "llvm/ADT/SmallString.h"
17#include "llvm/ADT/Twine.h"
18
19using namespace clang;
20using namespace edit;
21
22void EditsReceiver::remove(CharSourceRange range) {
23  replace(range, StringRef());
24}
25
26StringRef EditedSource::copyString(const Twine &twine) {
27  SmallString<128> Data;
28  return copyString(twine.toStringRef(Data));
29}
30
31bool EditedSource::canInsertInOffset(SourceLocation OrigLoc, FileOffset Offs) {
32  FileEditsTy::iterator FA = getActionForOffset(Offs);
33  if (FA != FileEdits.end()) {
34    if (FA->first != Offs)
35      return false; // position has been removed.
36  }
37
38  if (SourceMgr.isMacroArgExpansion(OrigLoc)) {
39    SourceLocation
40      DefArgLoc = SourceMgr.getImmediateExpansionRange(OrigLoc).first;
41    SourceLocation
42      ExpLoc = SourceMgr.getImmediateExpansionRange(DefArgLoc).first;
43    llvm::DenseMap<unsigned, SourceLocation>::iterator
44      I = ExpansionToArgMap.find(ExpLoc.getRawEncoding());
45    if (I != ExpansionToArgMap.end() && I->second != DefArgLoc)
46      return false; // Trying to write in a macro argument input that has
47                 // already been written for another argument of the same macro.
48  }
49
50  return true;
51}
52
53bool EditedSource::commitInsert(SourceLocation OrigLoc,
54                                FileOffset Offs, StringRef text,
55                                bool beforePreviousInsertions) {
56  if (!canInsertInOffset(OrigLoc, Offs))
57    return false;
58  if (text.empty())
59    return true;
60
61  if (SourceMgr.isMacroArgExpansion(OrigLoc)) {
62    SourceLocation
63      DefArgLoc = SourceMgr.getImmediateExpansionRange(OrigLoc).first;
64    SourceLocation
65      ExpLoc = SourceMgr.getImmediateExpansionRange(DefArgLoc).first;
66    ExpansionToArgMap[ExpLoc.getRawEncoding()] = DefArgLoc;
67  }
68
69  FileEdit &FA = FileEdits[Offs];
70  if (FA.Text.empty()) {
71    FA.Text = copyString(text);
72    return true;
73  }
74
75  Twine concat;
76  if (beforePreviousInsertions)
77    concat = Twine(text) + FA.Text;
78  else
79    concat = Twine(FA.Text) +  text;
80
81  FA.Text = copyString(concat);
82  return true;
83}
84
85bool EditedSource::commitInsertFromRange(SourceLocation OrigLoc,
86                                   FileOffset Offs,
87                                   FileOffset InsertFromRangeOffs, unsigned Len,
88                                   bool beforePreviousInsertions) {
89  if (Len == 0)
90    return true;
91
92  SmallString<128> StrVec;
93  FileOffset BeginOffs = InsertFromRangeOffs;
94  FileOffset EndOffs = BeginOffs.getWithOffset(Len);
95  FileEditsTy::iterator I = FileEdits.upper_bound(BeginOffs);
96  if (I != FileEdits.begin())
97    --I;
98
99  for (; I != FileEdits.end(); ++I) {
100    FileEdit &FA = I->second;
101    FileOffset B = I->first;
102    FileOffset E = B.getWithOffset(FA.RemoveLen);
103
104    if (BeginOffs == B)
105      break;
106
107    if (BeginOffs < E) {
108      if (BeginOffs > B) {
109        BeginOffs = E;
110        ++I;
111      }
112      break;
113    }
114  }
115
116  for (; I != FileEdits.end() && EndOffs > I->first; ++I) {
117    FileEdit &FA = I->second;
118    FileOffset B = I->first;
119    FileOffset E = B.getWithOffset(FA.RemoveLen);
120
121    if (BeginOffs < B) {
122      bool Invalid = false;
123      StringRef text = getSourceText(BeginOffs, B, Invalid);
124      if (Invalid)
125        return false;
126      StrVec += text;
127    }
128    StrVec += FA.Text;
129    BeginOffs = E;
130  }
131
132  if (BeginOffs < EndOffs) {
133    bool Invalid = false;
134    StringRef text = getSourceText(BeginOffs, EndOffs, Invalid);
135    if (Invalid)
136      return false;
137    StrVec += text;
138  }
139
140  return commitInsert(OrigLoc, Offs, StrVec.str(), beforePreviousInsertions);
141}
142
143void EditedSource::commitRemove(SourceLocation OrigLoc,
144                                FileOffset BeginOffs, unsigned Len) {
145  if (Len == 0)
146    return;
147
148  FileOffset EndOffs = BeginOffs.getWithOffset(Len);
149  FileEditsTy::iterator I = FileEdits.upper_bound(BeginOffs);
150  if (I != FileEdits.begin())
151    --I;
152
153  for (; I != FileEdits.end(); ++I) {
154    FileEdit &FA = I->second;
155    FileOffset B = I->first;
156    FileOffset E = B.getWithOffset(FA.RemoveLen);
157
158    if (BeginOffs < E)
159      break;
160  }
161
162  FileOffset TopBegin, TopEnd;
163  FileEdit *TopFA = 0;
164
165  if (I == FileEdits.end()) {
166    FileEditsTy::iterator
167      NewI = FileEdits.insert(I, std::make_pair(BeginOffs, FileEdit()));
168    NewI->second.RemoveLen = Len;
169    return;
170  }
171
172  FileEdit &FA = I->second;
173  FileOffset B = I->first;
174  FileOffset E = B.getWithOffset(FA.RemoveLen);
175  if (BeginOffs < B) {
176    FileEditsTy::iterator
177      NewI = FileEdits.insert(I, std::make_pair(BeginOffs, FileEdit()));
178    TopBegin = BeginOffs;
179    TopEnd = EndOffs;
180    TopFA = &NewI->second;
181    TopFA->RemoveLen = Len;
182  } else {
183    TopBegin = B;
184    TopEnd = E;
185    TopFA = &I->second;
186    if (TopEnd >= EndOffs)
187      return;
188    unsigned diff = EndOffs.getOffset() - TopEnd.getOffset();
189    TopEnd = EndOffs;
190    TopFA->RemoveLen += diff;
191    if (B == BeginOffs)
192      TopFA->Text = StringRef();
193    ++I;
194  }
195
196  while (I != FileEdits.end()) {
197    FileEdit &FA = I->second;
198    FileOffset B = I->first;
199    FileOffset E = B.getWithOffset(FA.RemoveLen);
200
201    if (B >= TopEnd)
202      break;
203
204    if (E <= TopEnd) {
205      FileEdits.erase(I++);
206      continue;
207    }
208
209    if (B < TopEnd) {
210      unsigned diff = E.getOffset() - TopEnd.getOffset();
211      TopEnd = E;
212      TopFA->RemoveLen += diff;
213      FileEdits.erase(I);
214    }
215
216    break;
217  }
218}
219
220bool EditedSource::commit(const Commit &commit) {
221  if (!commit.isCommitable())
222    return false;
223
224  for (edit::Commit::edit_iterator
225         I = commit.edit_begin(), E = commit.edit_end(); I != E; ++I) {
226    const edit::Commit::Edit &edit = *I;
227    switch (edit.Kind) {
228    case edit::Commit::Act_Insert:
229      commitInsert(edit.OrigLoc, edit.Offset, edit.Text, edit.BeforePrev);
230      break;
231    case edit::Commit::Act_InsertFromRange:
232      commitInsertFromRange(edit.OrigLoc, edit.Offset,
233                            edit.InsertFromRangeOffs, edit.Length,
234                            edit.BeforePrev);
235      break;
236    case edit::Commit::Act_Remove:
237      commitRemove(edit.OrigLoc, edit.Offset, edit.Length);
238      break;
239    }
240  }
241
242  return true;
243}
244
245// \brief Returns true if it is ok to make the two given characters adjacent.
246static bool canBeJoined(char left, char right, const LangOptions &LangOpts) {
247  // FIXME: Should use TokenConcatenation to make sure we don't allow stuff like
248  // making two '<' adjacent.
249  return !(Lexer::isIdentifierBodyChar(left, LangOpts) &&
250           Lexer::isIdentifierBodyChar(right, LangOpts));
251}
252
253/// \brief Returns true if it is ok to eliminate the trailing whitespace between
254/// the given characters.
255static bool canRemoveWhitespace(char left, char beforeWSpace, char right,
256                                const LangOptions &LangOpts) {
257  if (!canBeJoined(left, right, LangOpts))
258    return false;
259  if (isWhitespace(left) || isWhitespace(right))
260    return true;
261  if (canBeJoined(beforeWSpace, right, LangOpts))
262    return false; // the whitespace was intentional, keep it.
263  return true;
264}
265
266/// \brief Check the range that we are going to remove and:
267/// -Remove any trailing whitespace if possible.
268/// -Insert a space if removing the range is going to mess up the source tokens.
269static void adjustRemoval(const SourceManager &SM, const LangOptions &LangOpts,
270                          SourceLocation Loc, FileOffset offs,
271                          unsigned &len, StringRef &text) {
272  assert(len && text.empty());
273  SourceLocation BeginTokLoc = Lexer::GetBeginningOfToken(Loc, SM, LangOpts);
274  if (BeginTokLoc != Loc)
275    return; // the range is not at the beginning of a token, keep the range.
276
277  bool Invalid = false;
278  StringRef buffer = SM.getBufferData(offs.getFID(), &Invalid);
279  if (Invalid)
280    return;
281
282  unsigned begin = offs.getOffset();
283  unsigned end = begin + len;
284
285  // FIXME: Remove newline.
286
287  if (begin == 0) {
288    if (buffer[end] == ' ')
289      ++len;
290    return;
291  }
292
293  if (buffer[end] == ' ') {
294    if (canRemoveWhitespace(/*left=*/buffer[begin-1],
295                            /*beforeWSpace=*/buffer[end-1],
296                            /*right=*/buffer[end+1],
297                            LangOpts))
298      ++len;
299    return;
300  }
301
302  if (!canBeJoined(buffer[begin-1], buffer[end], LangOpts))
303    text = " ";
304}
305
306static void applyRewrite(EditsReceiver &receiver,
307                         StringRef text, FileOffset offs, unsigned len,
308                         const SourceManager &SM, const LangOptions &LangOpts) {
309  assert(!offs.getFID().isInvalid());
310  SourceLocation Loc = SM.getLocForStartOfFile(offs.getFID());
311  Loc = Loc.getLocWithOffset(offs.getOffset());
312  assert(Loc.isFileID());
313
314  if (text.empty())
315    adjustRemoval(SM, LangOpts, Loc, offs, len, text);
316
317  CharSourceRange range = CharSourceRange::getCharRange(Loc,
318                                                     Loc.getLocWithOffset(len));
319
320  if (text.empty()) {
321    assert(len);
322    receiver.remove(range);
323    return;
324  }
325
326  if (len)
327    receiver.replace(range, text);
328  else
329    receiver.insert(Loc, text);
330}
331
332void EditedSource::applyRewrites(EditsReceiver &receiver) {
333  SmallString<128> StrVec;
334  FileOffset CurOffs, CurEnd;
335  unsigned CurLen;
336
337  if (FileEdits.empty())
338    return;
339
340  FileEditsTy::iterator I = FileEdits.begin();
341  CurOffs = I->first;
342  StrVec = I->second.Text;
343  CurLen = I->second.RemoveLen;
344  CurEnd = CurOffs.getWithOffset(CurLen);
345  ++I;
346
347  for (FileEditsTy::iterator E = FileEdits.end(); I != E; ++I) {
348    FileOffset offs = I->first;
349    FileEdit act = I->second;
350    assert(offs >= CurEnd);
351
352    if (offs == CurEnd) {
353      StrVec += act.Text;
354      CurLen += act.RemoveLen;
355      CurEnd.getWithOffset(act.RemoveLen);
356      continue;
357    }
358
359    applyRewrite(receiver, StrVec.str(), CurOffs, CurLen, SourceMgr, LangOpts);
360    CurOffs = offs;
361    StrVec = act.Text;
362    CurLen = act.RemoveLen;
363    CurEnd = CurOffs.getWithOffset(CurLen);
364  }
365
366  applyRewrite(receiver, StrVec.str(), CurOffs, CurLen, SourceMgr, LangOpts);
367}
368
369void EditedSource::clearRewrites() {
370  FileEdits.clear();
371  StrAlloc.Reset();
372}
373
374StringRef EditedSource::getSourceText(FileOffset BeginOffs, FileOffset EndOffs,
375                                      bool &Invalid) {
376  assert(BeginOffs.getFID() == EndOffs.getFID());
377  assert(BeginOffs <= EndOffs);
378  SourceLocation BLoc = SourceMgr.getLocForStartOfFile(BeginOffs.getFID());
379  BLoc = BLoc.getLocWithOffset(BeginOffs.getOffset());
380  assert(BLoc.isFileID());
381  SourceLocation
382    ELoc = BLoc.getLocWithOffset(EndOffs.getOffset() - BeginOffs.getOffset());
383  return Lexer::getSourceText(CharSourceRange::getCharRange(BLoc, ELoc),
384                              SourceMgr, LangOpts, &Invalid);
385}
386
387EditedSource::FileEditsTy::iterator
388EditedSource::getActionForOffset(FileOffset Offs) {
389  FileEditsTy::iterator I = FileEdits.upper_bound(Offs);
390  if (I == FileEdits.begin())
391    return FileEdits.end();
392  --I;
393  FileEdit &FA = I->second;
394  FileOffset B = I->first;
395  FileOffset E = B.getWithOffset(FA.RemoveLen);
396  if (Offs >= B && Offs < E)
397    return I;
398
399  return FileEdits.end();
400}
401