• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===----- Commit.cpp - A unit of 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/Commit.h"
11 #include "clang/Basic/SourceManager.h"
12 #include "clang/Edit/EditedSource.h"
13 #include "clang/Lex/Lexer.h"
14 #include "clang/Lex/PPConditionalDirectiveRecord.h"
15 
16 using namespace clang;
17 using namespace edit;
18 
getFileLocation(SourceManager & SM) const19 SourceLocation Commit::Edit::getFileLocation(SourceManager &SM) const {
20   SourceLocation Loc = SM.getLocForStartOfFile(Offset.getFID());
21   Loc = Loc.getLocWithOffset(Offset.getOffset());
22   assert(Loc.isFileID());
23   return Loc;
24 }
25 
getFileRange(SourceManager & SM) const26 CharSourceRange Commit::Edit::getFileRange(SourceManager &SM) const {
27   SourceLocation Loc = getFileLocation(SM);
28   return CharSourceRange::getCharRange(Loc, Loc.getLocWithOffset(Length));
29 }
30 
getInsertFromRange(SourceManager & SM) const31 CharSourceRange Commit::Edit::getInsertFromRange(SourceManager &SM) const {
32   SourceLocation Loc = SM.getLocForStartOfFile(InsertFromRangeOffs.getFID());
33   Loc = Loc.getLocWithOffset(InsertFromRangeOffs.getOffset());
34   assert(Loc.isFileID());
35   return CharSourceRange::getCharRange(Loc, Loc.getLocWithOffset(Length));
36 }
37 
Commit(EditedSource & Editor)38 Commit::Commit(EditedSource &Editor)
39   : SourceMgr(Editor.getSourceManager()), LangOpts(Editor.getLangOpts()),
40     PPRec(Editor.getPPCondDirectiveRecord()),
41     Editor(&Editor), IsCommitable(true) { }
42 
insert(SourceLocation loc,StringRef text,bool afterToken,bool beforePreviousInsertions)43 bool Commit::insert(SourceLocation loc, StringRef text,
44                     bool afterToken, bool beforePreviousInsertions) {
45   if (text.empty())
46     return true;
47 
48   FileOffset Offs;
49   if ((!afterToken && !canInsert(loc, Offs)) ||
50       ( afterToken && !canInsertAfterToken(loc, Offs, loc))) {
51     IsCommitable = false;
52     return false;
53   }
54 
55   addInsert(loc, Offs, text, beforePreviousInsertions);
56   return true;
57 }
58 
insertFromRange(SourceLocation loc,CharSourceRange range,bool afterToken,bool beforePreviousInsertions)59 bool Commit::insertFromRange(SourceLocation loc,
60                              CharSourceRange range,
61                              bool afterToken, bool beforePreviousInsertions) {
62   FileOffset RangeOffs;
63   unsigned RangeLen;
64   if (!canRemoveRange(range, RangeOffs, RangeLen)) {
65     IsCommitable = false;
66     return false;
67   }
68 
69   FileOffset Offs;
70   if ((!afterToken && !canInsert(loc, Offs)) ||
71       ( afterToken && !canInsertAfterToken(loc, Offs, loc))) {
72     IsCommitable = false;
73     return false;
74   }
75 
76   if (PPRec &&
77       PPRec->areInDifferentConditionalDirectiveRegion(loc, range.getBegin())) {
78     IsCommitable = false;
79     return false;
80   }
81 
82   addInsertFromRange(loc, Offs, RangeOffs, RangeLen, beforePreviousInsertions);
83   return true;
84 }
85 
remove(CharSourceRange range)86 bool Commit::remove(CharSourceRange range) {
87   FileOffset Offs;
88   unsigned Len;
89   if (!canRemoveRange(range, Offs, Len)) {
90     IsCommitable = false;
91     return false;
92   }
93 
94   addRemove(range.getBegin(), Offs, Len);
95   return true;
96 }
97 
insertWrap(StringRef before,CharSourceRange range,StringRef after)98 bool Commit::insertWrap(StringRef before, CharSourceRange range,
99                         StringRef after) {
100   bool commitableBefore = insert(range.getBegin(), before, /*afterToken=*/false,
101                                  /*beforePreviousInsertions=*/true);
102   bool commitableAfter;
103   if (range.isTokenRange())
104     commitableAfter = insertAfterToken(range.getEnd(), after);
105   else
106     commitableAfter = insert(range.getEnd(), after);
107 
108   return commitableBefore && commitableAfter;
109 }
110 
replace(CharSourceRange range,StringRef text)111 bool Commit::replace(CharSourceRange range, StringRef text) {
112   if (text.empty())
113     return remove(range);
114 
115   FileOffset Offs;
116   unsigned Len;
117   if (!canInsert(range.getBegin(), Offs) || !canRemoveRange(range, Offs, Len)) {
118     IsCommitable = false;
119     return false;
120   }
121 
122   addRemove(range.getBegin(), Offs, Len);
123   addInsert(range.getBegin(), Offs, text, false);
124   return true;
125 }
126 
replaceWithInner(CharSourceRange range,CharSourceRange replacementRange)127 bool Commit::replaceWithInner(CharSourceRange range,
128                               CharSourceRange replacementRange) {
129   FileOffset OuterBegin;
130   unsigned OuterLen;
131   if (!canRemoveRange(range, OuterBegin, OuterLen)) {
132     IsCommitable = false;
133     return false;
134   }
135 
136   FileOffset InnerBegin;
137   unsigned InnerLen;
138   if (!canRemoveRange(replacementRange, InnerBegin, InnerLen)) {
139     IsCommitable = false;
140     return false;
141   }
142 
143   FileOffset OuterEnd = OuterBegin.getWithOffset(OuterLen);
144   FileOffset InnerEnd = InnerBegin.getWithOffset(InnerLen);
145   if (OuterBegin.getFID() != InnerBegin.getFID() ||
146       InnerBegin < OuterBegin ||
147       InnerBegin > OuterEnd ||
148       InnerEnd > OuterEnd) {
149     IsCommitable = false;
150     return false;
151   }
152 
153   addRemove(range.getBegin(),
154             OuterBegin, InnerBegin.getOffset() - OuterBegin.getOffset());
155   addRemove(replacementRange.getEnd(),
156             InnerEnd, OuterEnd.getOffset() - InnerEnd.getOffset());
157   return true;
158 }
159 
replaceText(SourceLocation loc,StringRef text,StringRef replacementText)160 bool Commit::replaceText(SourceLocation loc, StringRef text,
161                          StringRef replacementText) {
162   if (text.empty() || replacementText.empty())
163     return true;
164 
165   FileOffset Offs;
166   unsigned Len;
167   if (!canReplaceText(loc, replacementText, Offs, Len)) {
168     IsCommitable = false;
169     return false;
170   }
171 
172   addRemove(loc, Offs, Len);
173   addInsert(loc, Offs, text, false);
174   return true;
175 }
176 
addInsert(SourceLocation OrigLoc,FileOffset Offs,StringRef text,bool beforePreviousInsertions)177 void Commit::addInsert(SourceLocation OrigLoc, FileOffset Offs, StringRef text,
178                        bool beforePreviousInsertions) {
179   if (text.empty())
180     return;
181 
182   Edit data;
183   data.Kind = Act_Insert;
184   data.OrigLoc = OrigLoc;
185   data.Offset = Offs;
186   data.Text = text.copy(StrAlloc);
187   data.BeforePrev = beforePreviousInsertions;
188   CachedEdits.push_back(data);
189 }
190 
addInsertFromRange(SourceLocation OrigLoc,FileOffset Offs,FileOffset RangeOffs,unsigned RangeLen,bool beforePreviousInsertions)191 void Commit::addInsertFromRange(SourceLocation OrigLoc, FileOffset Offs,
192                                 FileOffset RangeOffs, unsigned RangeLen,
193                                 bool beforePreviousInsertions) {
194   if (RangeLen == 0)
195     return;
196 
197   Edit data;
198   data.Kind = Act_InsertFromRange;
199   data.OrigLoc = OrigLoc;
200   data.Offset = Offs;
201   data.InsertFromRangeOffs = RangeOffs;
202   data.Length = RangeLen;
203   data.BeforePrev = beforePreviousInsertions;
204   CachedEdits.push_back(data);
205 }
206 
addRemove(SourceLocation OrigLoc,FileOffset Offs,unsigned Len)207 void Commit::addRemove(SourceLocation OrigLoc,
208                        FileOffset Offs, unsigned Len) {
209   if (Len == 0)
210     return;
211 
212   Edit data;
213   data.Kind = Act_Remove;
214   data.OrigLoc = OrigLoc;
215   data.Offset = Offs;
216   data.Length = Len;
217   CachedEdits.push_back(data);
218 }
219 
canInsert(SourceLocation loc,FileOffset & offs)220 bool Commit::canInsert(SourceLocation loc, FileOffset &offs) {
221   if (loc.isInvalid())
222     return false;
223 
224   if (loc.isMacroID())
225     isAtStartOfMacroExpansion(loc, &loc);
226 
227   const SourceManager &SM = SourceMgr;
228   while (SM.isMacroArgExpansion(loc))
229     loc = SM.getImmediateSpellingLoc(loc);
230 
231   if (loc.isMacroID())
232     if (!isAtStartOfMacroExpansion(loc, &loc))
233       return false;
234 
235   if (SM.isInSystemHeader(loc))
236     return false;
237 
238   std::pair<FileID, unsigned> locInfo = SM.getDecomposedLoc(loc);
239   if (locInfo.first.isInvalid())
240     return false;
241   offs = FileOffset(locInfo.first, locInfo.second);
242   return canInsertInOffset(loc, offs);
243 }
244 
canInsertAfterToken(SourceLocation loc,FileOffset & offs,SourceLocation & AfterLoc)245 bool Commit::canInsertAfterToken(SourceLocation loc, FileOffset &offs,
246                                  SourceLocation &AfterLoc) {
247   if (loc.isInvalid())
248 
249     return false;
250 
251   SourceLocation spellLoc = SourceMgr.getSpellingLoc(loc);
252   unsigned tokLen = Lexer::MeasureTokenLength(spellLoc, SourceMgr, LangOpts);
253   AfterLoc = loc.getLocWithOffset(tokLen);
254 
255   if (loc.isMacroID())
256     isAtEndOfMacroExpansion(loc, &loc);
257 
258   const SourceManager &SM = SourceMgr;
259   while (SM.isMacroArgExpansion(loc))
260     loc = SM.getImmediateSpellingLoc(loc);
261 
262   if (loc.isMacroID())
263     if (!isAtEndOfMacroExpansion(loc, &loc))
264       return false;
265 
266   if (SM.isInSystemHeader(loc))
267     return false;
268 
269   loc = Lexer::getLocForEndOfToken(loc, 0, SourceMgr, LangOpts);
270   if (loc.isInvalid())
271     return false;
272 
273   std::pair<FileID, unsigned> locInfo = SM.getDecomposedLoc(loc);
274   if (locInfo.first.isInvalid())
275     return false;
276   offs = FileOffset(locInfo.first, locInfo.second);
277   return canInsertInOffset(loc, offs);
278 }
279 
canInsertInOffset(SourceLocation OrigLoc,FileOffset Offs)280 bool Commit::canInsertInOffset(SourceLocation OrigLoc, FileOffset Offs) {
281   for (unsigned i = 0, e = CachedEdits.size(); i != e; ++i) {
282     Edit &act = CachedEdits[i];
283     if (act.Kind == Act_Remove) {
284       if (act.Offset.getFID() == Offs.getFID() &&
285           Offs > act.Offset && Offs < act.Offset.getWithOffset(act.Length))
286         return false; // position has been removed.
287     }
288   }
289 
290   if (!Editor)
291     return true;
292   return Editor->canInsertInOffset(OrigLoc, Offs);
293 }
294 
canRemoveRange(CharSourceRange range,FileOffset & Offs,unsigned & Len)295 bool Commit::canRemoveRange(CharSourceRange range,
296                             FileOffset &Offs, unsigned &Len) {
297   const SourceManager &SM = SourceMgr;
298   range = Lexer::makeFileCharRange(range, SM, LangOpts);
299   if (range.isInvalid())
300     return false;
301 
302   if (range.getBegin().isMacroID() || range.getEnd().isMacroID())
303     return false;
304   if (SM.isInSystemHeader(range.getBegin()) ||
305       SM.isInSystemHeader(range.getEnd()))
306     return false;
307 
308   if (PPRec && PPRec->rangeIntersectsConditionalDirective(range.getAsRange()))
309     return false;
310 
311   std::pair<FileID, unsigned> beginInfo = SM.getDecomposedLoc(range.getBegin());
312   std::pair<FileID, unsigned> endInfo = SM.getDecomposedLoc(range.getEnd());
313   if (beginInfo.first != endInfo.first ||
314       beginInfo.second > endInfo.second)
315     return false;
316 
317   Offs = FileOffset(beginInfo.first, beginInfo.second);
318   Len = endInfo.second - beginInfo.second;
319   return true;
320 }
321 
canReplaceText(SourceLocation loc,StringRef text,FileOffset & Offs,unsigned & Len)322 bool Commit::canReplaceText(SourceLocation loc, StringRef text,
323                             FileOffset &Offs, unsigned &Len) {
324   assert(!text.empty());
325 
326   if (!canInsert(loc, Offs))
327     return false;
328 
329   // Try to load the file buffer.
330   bool invalidTemp = false;
331   StringRef file = SourceMgr.getBufferData(Offs.getFID(), &invalidTemp);
332   if (invalidTemp)
333     return false;
334 
335   Len = text.size();
336   return file.substr(Offs.getOffset()).startswith(text);
337 }
338 
isAtStartOfMacroExpansion(SourceLocation loc,SourceLocation * MacroBegin) const339 bool Commit::isAtStartOfMacroExpansion(SourceLocation loc,
340                                        SourceLocation *MacroBegin) const {
341   return Lexer::isAtStartOfMacroExpansion(loc, SourceMgr, LangOpts, MacroBegin);
342 }
isAtEndOfMacroExpansion(SourceLocation loc,SourceLocation * MacroEnd) const343 bool Commit::isAtEndOfMacroExpansion(SourceLocation loc,
344                                      SourceLocation *MacroEnd) const {
345   return Lexer::isAtEndOfMacroExpansion(loc, SourceMgr, LangOpts, MacroEnd);
346 }
347