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