1 //===- unittest/Tooling/RefactoringTest.cpp - Refactoring unit tests ------===//
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/Tooling/Refactoring.h"
10 #include "ReplacementTest.h"
11 #include "RewriterTestContext.h"
12 #include "clang/AST/ASTConsumer.h"
13 #include "clang/AST/ASTContext.h"
14 #include "clang/AST/DeclCXX.h"
15 #include "clang/AST/DeclGroup.h"
16 #include "clang/AST/RecursiveASTVisitor.h"
17 #include "clang/Basic/Diagnostic.h"
18 #include "clang/Basic/DiagnosticOptions.h"
19 #include "clang/Basic/FileManager.h"
20 #include "clang/Basic/LangOptions.h"
21 #include "clang/Basic/SourceManager.h"
22 #include "clang/Format/Format.h"
23 #include "clang/Frontend/CompilerInstance.h"
24 #include "clang/Frontend/FrontendAction.h"
25 #include "clang/Frontend/TextDiagnosticPrinter.h"
26 #include "clang/Rewrite/Core/Rewriter.h"
27 #include "clang/Tooling/Refactoring/AtomicChange.h"
28 #include "clang/Tooling/Tooling.h"
29 #include "llvm/ADT/SmallString.h"
30 #include "llvm/Support/VirtualFileSystem.h"
31 #include "gtest/gtest.h"
32
33 namespace clang {
34 namespace tooling {
35
TEST_F(ReplacementTest,CanDeleteAllText)36 TEST_F(ReplacementTest, CanDeleteAllText) {
37 FileID ID = Context.createInMemoryFile("input.cpp", "text");
38 SourceLocation Location = Context.getLocation(ID, 1, 1);
39 Replacement Replace(createReplacement(Location, 4, ""));
40 EXPECT_TRUE(Replace.apply(Context.Rewrite));
41 EXPECT_EQ("", Context.getRewrittenText(ID));
42 }
43
TEST_F(ReplacementTest,CanDeleteAllTextInTextWithNewlines)44 TEST_F(ReplacementTest, CanDeleteAllTextInTextWithNewlines) {
45 FileID ID = Context.createInMemoryFile("input.cpp", "line1\nline2\nline3");
46 SourceLocation Location = Context.getLocation(ID, 1, 1);
47 Replacement Replace(createReplacement(Location, 17, ""));
48 EXPECT_TRUE(Replace.apply(Context.Rewrite));
49 EXPECT_EQ("", Context.getRewrittenText(ID));
50 }
51
TEST_F(ReplacementTest,CanAddText)52 TEST_F(ReplacementTest, CanAddText) {
53 FileID ID = Context.createInMemoryFile("input.cpp", "");
54 SourceLocation Location = Context.getLocation(ID, 1, 1);
55 Replacement Replace(createReplacement(Location, 0, "result"));
56 EXPECT_TRUE(Replace.apply(Context.Rewrite));
57 EXPECT_EQ("result", Context.getRewrittenText(ID));
58 }
59
TEST_F(ReplacementTest,CanReplaceTextAtPosition)60 TEST_F(ReplacementTest, CanReplaceTextAtPosition) {
61 FileID ID = Context.createInMemoryFile("input.cpp",
62 "line1\nline2\nline3\nline4");
63 SourceLocation Location = Context.getLocation(ID, 2, 3);
64 Replacement Replace(createReplacement(Location, 12, "x"));
65 EXPECT_TRUE(Replace.apply(Context.Rewrite));
66 EXPECT_EQ("line1\nlixne4", Context.getRewrittenText(ID));
67 }
68
TEST_F(ReplacementTest,CanReplaceTextAtPositionMultipleTimes)69 TEST_F(ReplacementTest, CanReplaceTextAtPositionMultipleTimes) {
70 FileID ID = Context.createInMemoryFile("input.cpp",
71 "line1\nline2\nline3\nline4");
72 SourceLocation Location1 = Context.getLocation(ID, 2, 3);
73 Replacement Replace1(createReplacement(Location1, 12, "x\ny\n"));
74 EXPECT_TRUE(Replace1.apply(Context.Rewrite));
75 EXPECT_EQ("line1\nlix\ny\nne4", Context.getRewrittenText(ID));
76
77 // Since the original source has not been modified, the (4, 4) points to the
78 // 'e' in the original content.
79 SourceLocation Location2 = Context.getLocation(ID, 4, 4);
80 Replacement Replace2(createReplacement(Location2, 1, "f"));
81 EXPECT_TRUE(Replace2.apply(Context.Rewrite));
82 EXPECT_EQ("line1\nlix\ny\nnf4", Context.getRewrittenText(ID));
83 }
84
TEST_F(ReplacementTest,ApplyFailsForNonExistentLocation)85 TEST_F(ReplacementTest, ApplyFailsForNonExistentLocation) {
86 Replacement Replace("nonexistent-file.cpp", 0, 1, "");
87 EXPECT_FALSE(Replace.apply(Context.Rewrite));
88 }
89
TEST_F(ReplacementTest,CanRetrivePath)90 TEST_F(ReplacementTest, CanRetrivePath) {
91 Replacement Replace("/path/to/file.cpp", 0, 1, "");
92 EXPECT_EQ("/path/to/file.cpp", Replace.getFilePath());
93 }
94
TEST_F(ReplacementTest,ReturnsInvalidPath)95 TEST_F(ReplacementTest, ReturnsInvalidPath) {
96 Replacement Replace1(Context.Sources, SourceLocation(), 0, "");
97 EXPECT_TRUE(Replace1.getFilePath().empty());
98
99 Replacement Replace2;
100 EXPECT_TRUE(Replace2.getFilePath().empty());
101 }
102
103 // Checks that an llvm::Error instance contains a ReplacementError with expected
104 // error code, expected new replacement, and expected existing replacement.
checkReplacementError(llvm::Error && Error,replacement_error ExpectedErr,llvm::Optional<Replacement> ExpectedExisting,llvm::Optional<Replacement> ExpectedNew)105 static bool checkReplacementError(llvm::Error &&Error,
106 replacement_error ExpectedErr,
107 llvm::Optional<Replacement> ExpectedExisting,
108 llvm::Optional<Replacement> ExpectedNew) {
109 if (!Error) {
110 llvm::errs() << "Error is a success.";
111 return false;
112 }
113 std::string ErrorMessage;
114 llvm::raw_string_ostream OS(ErrorMessage);
115 llvm::handleAllErrors(std::move(Error), [&](const ReplacementError &RE) {
116 llvm::errs() << "Handling error...\n";
117 if (ExpectedErr != RE.get())
118 OS << "Unexpected error code: " << int(RE.get()) << "\n";
119 if (ExpectedExisting != RE.getExistingReplacement()) {
120 OS << "Expected Existing != Actual Existing.\n";
121 if (ExpectedExisting.hasValue())
122 OS << "Expected existing replacement: " << ExpectedExisting->toString()
123 << "\n";
124 if (RE.getExistingReplacement().hasValue())
125 OS << "Actual existing replacement: "
126 << RE.getExistingReplacement()->toString() << "\n";
127 }
128 if (ExpectedNew != RE.getNewReplacement()) {
129 OS << "Expected New != Actual New.\n";
130 if (ExpectedNew.hasValue())
131 OS << "Expected new replacement: " << ExpectedNew->toString() << "\n";
132 if (RE.getNewReplacement().hasValue())
133 OS << "Actual new replacement: " << RE.getNewReplacement()->toString()
134 << "\n";
135 }
136 });
137 OS.flush();
138 if (ErrorMessage.empty()) return true;
139 llvm::errs() << ErrorMessage;
140 return false;
141 }
142
TEST_F(ReplacementTest,FailAddReplacements)143 TEST_F(ReplacementTest, FailAddReplacements) {
144 Replacements Replaces;
145 Replacement Deletion("x.cc", 0, 10, "3");
146 auto Err = Replaces.add(Deletion);
147 EXPECT_TRUE(!Err);
148 llvm::consumeError(std::move(Err));
149
150 Replacement OverlappingReplacement("x.cc", 0, 2, "a");
151 Err = Replaces.add(OverlappingReplacement);
152 EXPECT_TRUE(checkReplacementError(std::move(Err),
153 replacement_error::overlap_conflict,
154 Deletion, OverlappingReplacement));
155
156 Replacement ContainedReplacement("x.cc", 2, 2, "a");
157 Err = Replaces.add(Replacement(ContainedReplacement));
158 EXPECT_TRUE(checkReplacementError(std::move(Err),
159 replacement_error::overlap_conflict,
160 Deletion, ContainedReplacement));
161
162 Replacement WrongPathReplacement("y.cc", 20, 2, "");
163 Err = Replaces.add(WrongPathReplacement);
164 EXPECT_TRUE(checkReplacementError(std::move(Err),
165 replacement_error::wrong_file_path,
166 Deletion, WrongPathReplacement));
167
168 EXPECT_EQ(1u, Replaces.size());
169 EXPECT_EQ(Deletion, *Replaces.begin());
170 }
171
TEST_F(ReplacementTest,DeletionInReplacements)172 TEST_F(ReplacementTest, DeletionInReplacements) {
173 Replacements Replaces;
174 Replacement R("x.cc", 0, 10, "3");
175 auto Err = Replaces.add(R);
176 EXPECT_TRUE(!Err);
177 llvm::consumeError(std::move(Err));
178 Err = Replaces.add(Replacement("x.cc", 0, 2, ""));
179 EXPECT_TRUE(!Err);
180 llvm::consumeError(std::move(Err));
181 Err = Replaces.add(Replacement("x.cc", 2, 2, ""));
182 EXPECT_TRUE(!Err);
183 llvm::consumeError(std::move(Err));
184 EXPECT_EQ(1u, Replaces.size());
185 EXPECT_EQ(R, *Replaces.begin());
186 }
187
TEST_F(ReplacementTest,OverlappingReplacements)188 TEST_F(ReplacementTest, OverlappingReplacements) {
189 Replacements Replaces;
190 auto Err = Replaces.add(Replacement("x.cc", 0, 3, "345"));
191 EXPECT_TRUE(!Err);
192 llvm::consumeError(std::move(Err));
193 Err = Replaces.add(Replacement("x.cc", 2, 3, "543"));
194 EXPECT_TRUE(!Err);
195 llvm::consumeError(std::move(Err));
196
197 EXPECT_EQ(1u, Replaces.size());
198 EXPECT_EQ(Replacement("x.cc", 0, 5, "34543"), *Replaces.begin());
199
200 Err = Replaces.add(Replacement("x.cc", 2, 1, "5"));
201 EXPECT_TRUE(!Err);
202 llvm::consumeError(std::move(Err));
203 EXPECT_EQ(1u, Replaces.size());
204 EXPECT_EQ(Replacement("x.cc", 0, 5, "34543"), *Replaces.begin());
205 }
206
TEST_F(ReplacementTest,AddAdjacentInsertionAndReplacement)207 TEST_F(ReplacementTest, AddAdjacentInsertionAndReplacement) {
208 Replacements Replaces;
209 // Test adding an insertion at the offset of an existing replacement.
210 auto Err = Replaces.add(Replacement("x.cc", 10, 3, "replace"));
211 EXPECT_TRUE(!Err);
212 llvm::consumeError(std::move(Err));
213 Err = Replaces.add(Replacement("x.cc", 10, 0, "insert"));
214 EXPECT_TRUE(!Err);
215 llvm::consumeError(std::move(Err));
216 EXPECT_EQ(Replaces.size(), 2u);
217
218 Replaces.clear();
219 // Test overlap with an existing insertion.
220 Err = Replaces.add(Replacement("x.cc", 10, 0, "insert"));
221 EXPECT_TRUE(!Err);
222 llvm::consumeError(std::move(Err));
223 Err = Replaces.add(Replacement("x.cc", 10, 3, "replace"));
224 EXPECT_TRUE(!Err);
225 llvm::consumeError(std::move(Err));
226 EXPECT_EQ(Replaces.size(), 2u);
227 }
228
TEST_F(ReplacementTest,MergeNewDeletions)229 TEST_F(ReplacementTest, MergeNewDeletions) {
230 Replacements Replaces;
231 Replacement ContainingReplacement("x.cc", 0, 10, "");
232 auto Err = Replaces.add(ContainingReplacement);
233 EXPECT_TRUE(!Err);
234 llvm::consumeError(std::move(Err));
235
236 Err = Replaces.add(Replacement("x.cc", 5, 3, ""));
237 EXPECT_TRUE(!Err);
238 llvm::consumeError(std::move(Err));
239
240 Err = Replaces.add(Replacement("x.cc", 0, 10, ""));
241 EXPECT_TRUE(!Err);
242 llvm::consumeError(std::move(Err));
243
244 Err = Replaces.add(Replacement("x.cc", 5, 5, ""));
245 EXPECT_TRUE(!Err);
246 llvm::consumeError(std::move(Err));
247
248 EXPECT_EQ(1u, Replaces.size());
249 EXPECT_EQ(*Replaces.begin(), ContainingReplacement);
250 }
251
TEST_F(ReplacementTest,MergeOverlappingButNotAdjacentReplacement)252 TEST_F(ReplacementTest, MergeOverlappingButNotAdjacentReplacement) {
253 Replacements Replaces;
254 auto Err = Replaces.add(Replacement("x.cc", 0, 2, ""));
255 EXPECT_TRUE(!Err);
256 llvm::consumeError(std::move(Err));
257
258 Err = Replaces.add(Replacement("x.cc", 5, 5, ""));
259 EXPECT_TRUE(!Err);
260 llvm::consumeError(std::move(Err));
261
262 Replacement After = Replacement("x.cc", 10, 5, "");
263 Err = Replaces.add(After);
264 EXPECT_TRUE(!Err);
265 llvm::consumeError(std::move(Err));
266
267 Replacement ContainingReplacement("x.cc", 0, 10, "");
268 Err = Replaces.add(ContainingReplacement);
269 EXPECT_TRUE(!Err);
270 llvm::consumeError(std::move(Err));
271
272 EXPECT_EQ(2u, Replaces.size());
273 EXPECT_EQ(*Replaces.begin(), ContainingReplacement);
274 EXPECT_EQ(*(++Replaces.begin()), After);
275 }
276
TEST_F(ReplacementTest,InsertionBeforeMergedDeletions)277 TEST_F(ReplacementTest, InsertionBeforeMergedDeletions) {
278 Replacements Replaces;
279
280 Replacement Insertion("x.cc", 0, 0, "123");
281 auto Err = Replaces.add(Insertion);
282 EXPECT_TRUE(!Err);
283 llvm::consumeError(std::move(Err));
284
285 Err = Replaces.add(Replacement("x.cc", 5, 5, ""));
286 EXPECT_TRUE(!Err);
287 llvm::consumeError(std::move(Err));
288
289 Replacement Deletion("x.cc", 0, 10, "");
290 Err = Replaces.add(Deletion);
291 EXPECT_TRUE(!Err);
292 llvm::consumeError(std::move(Err));
293
294 EXPECT_EQ(2u, Replaces.size());
295 EXPECT_EQ(*Replaces.begin(), Insertion);
296 EXPECT_EQ(*(++Replaces.begin()), Deletion);
297 }
298
TEST_F(ReplacementTest,MergeOverlappingDeletions)299 TEST_F(ReplacementTest, MergeOverlappingDeletions) {
300 Replacements Replaces;
301 auto Err = Replaces.add(Replacement("x.cc", 0, 2, ""));
302 EXPECT_TRUE(!Err);
303 llvm::consumeError(std::move(Err));
304
305 Err = Replaces.add(Replacement("x.cc", 0, 5, ""));
306 EXPECT_TRUE(!Err);
307 llvm::consumeError(std::move(Err));
308
309 EXPECT_EQ(1u, Replaces.size());
310 EXPECT_EQ(Replacement("x.cc", 0, 5, ""), *Replaces.begin());
311
312 Err = Replaces.add(Replacement("x.cc", 1, 5, ""));
313 EXPECT_TRUE(!Err);
314 llvm::consumeError(std::move(Err));
315 EXPECT_EQ(1u, Replaces.size());
316 EXPECT_EQ(Replacement("x.cc", 0, 6, ""), *Replaces.begin());
317 }
318
TEST_F(ReplacementTest,FailedMergeExistingDeletions)319 TEST_F(ReplacementTest, FailedMergeExistingDeletions) {
320 Replacements Replaces;
321 Replacement First("x.cc", 0, 2, "");
322 auto Err = Replaces.add(First);
323 EXPECT_TRUE(!Err);
324 llvm::consumeError(std::move(Err));
325
326 Replacement Second("x.cc", 5, 5, "");
327 Err = Replaces.add(Second);
328 EXPECT_TRUE(!Err);
329 llvm::consumeError(std::move(Err));
330
331 Err = Replaces.add(Replacement("x.cc", 1, 10, ""));
332 EXPECT_TRUE(!Err);
333 llvm::consumeError(std::move(Err));
334
335 EXPECT_EQ(1u, Replaces.size());
336 EXPECT_EQ(Replacement("x.cc", 0, 11, ""), *Replaces.begin());
337 }
338
TEST_F(ReplacementTest,FailAddRegression)339 TEST_F(ReplacementTest, FailAddRegression) {
340 Replacements Replaces;
341 // Create two replacements, where the second one is an insertion of the empty
342 // string exactly at the end of the first one.
343 auto Err = Replaces.add(Replacement("x.cc", 0, 10, "1"));
344 EXPECT_TRUE(!Err);
345 llvm::consumeError(std::move(Err));
346 Err = Replaces.add(Replacement("x.cc", 10, 0, ""));
347 EXPECT_TRUE(!Err);
348 llvm::consumeError(std::move(Err));
349
350 // Make sure we find the overlap with the first entry when inserting a
351 // replacement that ends exactly at the seam of the existing replacements.
352 Replacement OverlappingReplacement("x.cc", 5, 5, "fail");
353 Err = Replaces.add(OverlappingReplacement);
354 EXPECT_TRUE(checkReplacementError(std::move(Err),
355 replacement_error::overlap_conflict,
356 *Replaces.begin(), OverlappingReplacement));
357
358 Err = Replaces.add(Replacement("x.cc", 10, 0, ""));
359 EXPECT_TRUE(!Err);
360 llvm::consumeError(std::move(Err));
361 }
362
TEST_F(ReplacementTest,InsertAtOffsetOfReplacement)363 TEST_F(ReplacementTest, InsertAtOffsetOfReplacement) {
364 Replacements Replaces;
365 auto Err = Replaces.add(Replacement("x.cc", 10, 2, ""));
366 EXPECT_TRUE(!Err);
367 llvm::consumeError(std::move(Err));
368 Err = Replaces.add(Replacement("x.cc", 10, 0, ""));
369 EXPECT_TRUE(!Err);
370 llvm::consumeError(std::move(Err));
371 EXPECT_EQ(Replaces.size(), 2u);
372
373 Replaces.clear();
374 Err = Replaces.add(Replacement("x.cc", 10, 0, ""));
375 EXPECT_TRUE(!Err);
376 llvm::consumeError(std::move(Err));
377 Err = Replaces.add(Replacement("x.cc", 10, 2, ""));
378 EXPECT_TRUE(!Err);
379 llvm::consumeError(std::move(Err));
380 EXPECT_EQ(Replaces.size(), 2u);
381 }
382
TEST_F(ReplacementTest,AddInsertAtOtherInsertWhenOderIndependent)383 TEST_F(ReplacementTest, AddInsertAtOtherInsertWhenOderIndependent) {
384 Replacements Replaces;
385 auto Err = Replaces.add(Replacement("x.cc", 10, 0, "a"));
386 EXPECT_TRUE(!Err);
387 llvm::consumeError(std::move(Err));
388 Replacement ConflictInsertion("x.cc", 10, 0, "b");
389 Err = Replaces.add(ConflictInsertion);
390 EXPECT_TRUE(checkReplacementError(std::move(Err),
391 replacement_error::insert_conflict,
392 *Replaces.begin(), ConflictInsertion));
393
394 Replaces.clear();
395 Err = Replaces.add(Replacement("x.cc", 10, 0, "a"));
396 EXPECT_TRUE(!Err);
397 llvm::consumeError(std::move(Err));
398 Err = Replaces.add(Replacement("x.cc", 10, 0, "aa"));
399 EXPECT_TRUE(!Err);
400 llvm::consumeError(std::move(Err));
401 EXPECT_EQ(1u, Replaces.size());
402 EXPECT_EQ(Replacement("x.cc", 10, 0, "aaa"), *Replaces.begin());
403
404 Replaces.clear();
405 Err = Replaces.add(Replacement("x.cc", 10, 0, ""));
406 EXPECT_TRUE(!Err);
407 llvm::consumeError(std::move(Err));
408 Err = Replaces.add(Replacement("x.cc", 10, 3, ""));
409 EXPECT_TRUE(!Err);
410 llvm::consumeError(std::move(Err));
411 Err = Replaces.add(Replacement("x.cc", 10, 0, ""));
412 EXPECT_TRUE(!Err);
413 llvm::consumeError(std::move(Err));
414 EXPECT_EQ(2u, Replaces.size());
415 EXPECT_EQ(Replacement("x.cc", 10, 0, ""), *Replaces.begin());
416 EXPECT_EQ(Replacement("x.cc", 10, 3, ""), *std::next(Replaces.begin()));
417 }
418
TEST_F(ReplacementTest,InsertBetweenAdjacentReplacements)419 TEST_F(ReplacementTest, InsertBetweenAdjacentReplacements) {
420 Replacements Replaces;
421 auto Err = Replaces.add(Replacement("x.cc", 10, 5, "a"));
422 EXPECT_TRUE(!Err);
423 llvm::consumeError(std::move(Err));
424 Err = Replaces.add(Replacement("x.cc", 8, 2, "a"));
425 EXPECT_TRUE(!Err);
426 llvm::consumeError(std::move(Err));
427 Err = Replaces.add(Replacement("x.cc", 10, 0, "b"));
428 EXPECT_TRUE(!Err);
429 llvm::consumeError(std::move(Err));
430 }
431
TEST_F(ReplacementTest,CanApplyReplacements)432 TEST_F(ReplacementTest, CanApplyReplacements) {
433 FileID ID = Context.createInMemoryFile("input.cpp",
434 "line1\nline2\nline3\nline4");
435 Replacements Replaces =
436 toReplacements({Replacement(Context.Sources,
437 Context.getLocation(ID, 2, 1), 5, "replaced"),
438 Replacement(Context.Sources,
439 Context.getLocation(ID, 3, 1), 5, "other")});
440 EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
441 EXPECT_EQ("line1\nreplaced\nother\nline4", Context.getRewrittenText(ID));
442 }
443
444 // Verifies that replacement/deletion is applied before insertion at the same
445 // offset.
TEST_F(ReplacementTest,InsertAndDelete)446 TEST_F(ReplacementTest, InsertAndDelete) {
447 FileID ID = Context.createInMemoryFile("input.cpp",
448 "line1\nline2\nline3\nline4");
449 Replacements Replaces = toReplacements(
450 {Replacement(Context.Sources, Context.getLocation(ID, 2, 1), 6, ""),
451 Replacement(Context.Sources, Context.getLocation(ID, 2, 1), 0,
452 "other\n")});
453 EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
454 EXPECT_EQ("line1\nother\nline3\nline4", Context.getRewrittenText(ID));
455 }
456
TEST_F(ReplacementTest,AdjacentReplacements)457 TEST_F(ReplacementTest, AdjacentReplacements) {
458 FileID ID = Context.createInMemoryFile("input.cpp",
459 "ab");
460 Replacements Replaces = toReplacements(
461 {Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 1, "x"),
462 Replacement(Context.Sources, Context.getLocation(ID, 1, 2), 1, "y")});
463 EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
464 EXPECT_EQ("xy", Context.getRewrittenText(ID));
465 }
466
TEST_F(ReplacementTest,AddDuplicateReplacements)467 TEST_F(ReplacementTest, AddDuplicateReplacements) {
468 FileID ID = Context.createInMemoryFile("input.cpp",
469 "line1\nline2\nline3\nline4");
470 auto Replaces = toReplacements({Replacement(
471 Context.Sources, Context.getLocation(ID, 2, 1), 5, "replaced")});
472
473 auto Err = Replaces.add(Replacement(
474 Context.Sources, Context.getLocation(ID, 2, 1), 5, "replaced"));
475 EXPECT_TRUE(!Err);
476 llvm::consumeError(std::move(Err));
477
478 Err = Replaces.add(Replacement(Context.Sources, Context.getLocation(ID, 2, 1),
479 5, "replaced"));
480 EXPECT_TRUE(!Err);
481 llvm::consumeError(std::move(Err));
482
483 EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
484 EXPECT_EQ("line1\nreplaced\nline3\nline4", Context.getRewrittenText(ID));
485 }
486
TEST_F(ReplacementTest,FailOrderDependentReplacements)487 TEST_F(ReplacementTest, FailOrderDependentReplacements) {
488 FileID ID = Context.createInMemoryFile("input.cpp",
489 "line1\nline2\nline3\nline4");
490 auto Replaces = toReplacements({Replacement(
491 Context.Sources, Context.getLocation(ID, 2, 1), 5, "other")});
492
493 Replacement ConflictReplacement(Context.Sources,
494 Context.getLocation(ID, 2, 1), 5, "rehto");
495 auto Err = Replaces.add(ConflictReplacement);
496 EXPECT_TRUE(checkReplacementError(std::move(Err),
497 replacement_error::overlap_conflict,
498 *Replaces.begin(), ConflictReplacement));
499
500 EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
501 EXPECT_EQ("line1\nother\nline3\nline4", Context.getRewrittenText(ID));
502 }
503
TEST_F(ReplacementTest,InvalidSourceLocationFailsApplyAll)504 TEST_F(ReplacementTest, InvalidSourceLocationFailsApplyAll) {
505 Replacements Replaces =
506 toReplacements({Replacement(Context.Sources, SourceLocation(), 5, "2")});
507
508 EXPECT_FALSE(applyAllReplacements(Replaces, Context.Rewrite));
509 }
510
TEST_F(ReplacementTest,MultipleFilesReplaceAndFormat)511 TEST_F(ReplacementTest, MultipleFilesReplaceAndFormat) {
512 // Column limit is 20.
513 std::string Code1 = "Long *a =\n"
514 " new Long();\n"
515 "long x = 1;";
516 std::string Expected1 = "auto a = new Long();\n"
517 "long x =\n"
518 " 12345678901;";
519 std::string Code2 = "int x = 123;\n"
520 "int y = 0;";
521 std::string Expected2 = "int x =\n"
522 " 1234567890123;\n"
523 "int y = 10;";
524 StringRef File1 = "format_1.cpp";
525 StringRef File2 = "format_2.cpp";
526 FileID ID1 = Context.createInMemoryFile(File1, Code1);
527 FileID ID2 = Context.createInMemoryFile(File2, Code2);
528
529 // Scrambled the order of replacements.
530 std::map<std::string, Replacements> FileToReplaces;
531 FileToReplaces[File1] = toReplacements(
532 {tooling::Replacement(Context.Sources, Context.getLocation(ID1, 1, 1), 6,
533 "auto "),
534 tooling::Replacement(Context.Sources, Context.getLocation(ID1, 3, 10), 1,
535 "12345678901")});
536 FileToReplaces[File2] = toReplacements(
537 {tooling::Replacement(Context.Sources, Context.getLocation(ID2, 1, 12), 0,
538 "4567890123"),
539 tooling::Replacement(Context.Sources, Context.getLocation(ID2, 2, 9), 1,
540 "10")});
541 EXPECT_TRUE(
542 formatAndApplyAllReplacements(FileToReplaces, Context.Rewrite,
543 "{BasedOnStyle: LLVM, ColumnLimit: 20}"));
544 EXPECT_EQ(Expected1, Context.getRewrittenText(ID1));
545 EXPECT_EQ(Expected2, Context.getRewrittenText(ID2));
546 }
547
TEST(ShiftedCodePositionTest,FindsNewCodePosition)548 TEST(ShiftedCodePositionTest, FindsNewCodePosition) {
549 Replacements Replaces =
550 toReplacements({Replacement("", 0, 1, ""), Replacement("", 4, 3, " ")});
551 // Assume ' int i;' is turned into 'int i;' and cursor is located at '|'.
552 EXPECT_EQ(0u, Replaces.getShiftedCodePosition(0)); // |int i;
553 EXPECT_EQ(0u, Replaces.getShiftedCodePosition(1)); // |nt i;
554 EXPECT_EQ(1u, Replaces.getShiftedCodePosition(2)); // i|t i;
555 EXPECT_EQ(2u, Replaces.getShiftedCodePosition(3)); // in| i;
556 EXPECT_EQ(3u, Replaces.getShiftedCodePosition(4)); // int| i;
557 EXPECT_EQ(3u, Replaces.getShiftedCodePosition(5)); // int | i;
558 EXPECT_EQ(3u, Replaces.getShiftedCodePosition(6)); // int |i;
559 EXPECT_EQ(4u, Replaces.getShiftedCodePosition(7)); // int |;
560 EXPECT_EQ(5u, Replaces.getShiftedCodePosition(8)); // int i|
561 }
562
TEST(ShiftedCodePositionTest,FindsNewCodePositionWithInserts)563 TEST(ShiftedCodePositionTest, FindsNewCodePositionWithInserts) {
564 Replacements Replaces = toReplacements({Replacement("", 4, 0, "\"\n\"")});
565 // Assume '"12345678"' is turned into '"1234"\n"5678"'.
566 EXPECT_EQ(3u, Replaces.getShiftedCodePosition(3)); // "123|5678"
567 EXPECT_EQ(7u, Replaces.getShiftedCodePosition(4)); // "1234|678"
568 EXPECT_EQ(8u, Replaces.getShiftedCodePosition(5)); // "12345|78"
569 }
570
TEST(ShiftedCodePositionTest,FindsNewCodePositionInReplacedText)571 TEST(ShiftedCodePositionTest, FindsNewCodePositionInReplacedText) {
572 // Replace the first four characters with "abcd".
573 auto Replaces = toReplacements({Replacement("", 0, 4, "abcd")});
574 for (unsigned i = 0; i < 3; ++i)
575 EXPECT_EQ(i, Replaces.getShiftedCodePosition(i));
576 }
577
TEST(ShiftedCodePositionTest,NoReplacementText)578 TEST(ShiftedCodePositionTest, NoReplacementText) {
579 Replacements Replaces = toReplacements({Replacement("", 0, 42, "")});
580 EXPECT_EQ(0u, Replaces.getShiftedCodePosition(0));
581 EXPECT_EQ(0u, Replaces.getShiftedCodePosition(39));
582 EXPECT_EQ(3u, Replaces.getShiftedCodePosition(45));
583 EXPECT_EQ(0u, Replaces.getShiftedCodePosition(42));
584 }
585
586 class FlushRewrittenFilesTest : public ::testing::Test {
587 public:
FlushRewrittenFilesTest()588 FlushRewrittenFilesTest() {}
589
~FlushRewrittenFilesTest()590 ~FlushRewrittenFilesTest() override {
591 for (llvm::StringMap<std::string>::iterator I = TemporaryFiles.begin(),
592 E = TemporaryFiles.end();
593 I != E; ++I) {
594 llvm::StringRef Name = I->second;
595 std::error_code EC = llvm::sys::fs::remove(Name);
596 (void)EC;
597 assert(!EC);
598 }
599 }
600
createFile(llvm::StringRef Name,llvm::StringRef Content)601 FileID createFile(llvm::StringRef Name, llvm::StringRef Content) {
602 SmallString<1024> Path;
603 int FD;
604 std::error_code EC = llvm::sys::fs::createTemporaryFile(Name, "", FD, Path);
605 assert(!EC);
606 (void)EC;
607
608 llvm::raw_fd_ostream OutStream(FD, true);
609 OutStream << Content;
610 OutStream.close();
611 const FileEntry *File = Context.Files.getFile(Path);
612 assert(File != nullptr);
613
614 StringRef Found =
615 TemporaryFiles.insert(std::make_pair(Name, Path.str())).first->second;
616 assert(Found == Path);
617 (void)Found;
618 return Context.Sources.createFileID(File, SourceLocation(), SrcMgr::C_User);
619 }
620
getFileContentFromDisk(llvm::StringRef Name)621 std::string getFileContentFromDisk(llvm::StringRef Name) {
622 std::string Path = TemporaryFiles.lookup(Name);
623 assert(!Path.empty());
624 // We need to read directly from the FileManager without relaying through
625 // a FileEntry, as otherwise we'd read through an already opened file
626 // descriptor, which might not see the changes made.
627 // FIXME: Figure out whether there is a way to get the SourceManger to
628 // reopen the file.
629 auto FileBuffer = Context.Files.getBufferForFile(Path);
630 return (*FileBuffer)->getBuffer();
631 }
632
633 llvm::StringMap<std::string> TemporaryFiles;
634 RewriterTestContext Context;
635 };
636
TEST_F(FlushRewrittenFilesTest,StoresChangesOnDisk)637 TEST_F(FlushRewrittenFilesTest, StoresChangesOnDisk) {
638 FileID ID = createFile("input.cpp", "line1\nline2\nline3\nline4");
639 Replacements Replaces = toReplacements({Replacement(
640 Context.Sources, Context.getLocation(ID, 2, 1), 5, "replaced")});
641 EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
642 EXPECT_FALSE(Context.Rewrite.overwriteChangedFiles());
643 EXPECT_EQ("line1\nreplaced\nline3\nline4",
644 getFileContentFromDisk("input.cpp"));
645 }
646
647 namespace {
648 template <typename T>
649 class TestVisitor : public clang::RecursiveASTVisitor<T> {
650 public:
runOver(StringRef Code)651 bool runOver(StringRef Code) {
652 return runToolOnCode(new TestAction(this), Code);
653 }
654
655 protected:
656 clang::SourceManager *SM;
657 clang::ASTContext *Context;
658
659 private:
660 class FindConsumer : public clang::ASTConsumer {
661 public:
FindConsumer(TestVisitor * Visitor)662 FindConsumer(TestVisitor *Visitor) : Visitor(Visitor) {}
663
HandleTranslationUnit(clang::ASTContext & Context)664 void HandleTranslationUnit(clang::ASTContext &Context) override {
665 Visitor->TraverseDecl(Context.getTranslationUnitDecl());
666 }
667
668 private:
669 TestVisitor *Visitor;
670 };
671
672 class TestAction : public clang::ASTFrontendAction {
673 public:
TestAction(TestVisitor * Visitor)674 TestAction(TestVisitor *Visitor) : Visitor(Visitor) {}
675
676 std::unique_ptr<clang::ASTConsumer>
CreateASTConsumer(clang::CompilerInstance & compiler,llvm::StringRef dummy)677 CreateASTConsumer(clang::CompilerInstance &compiler,
678 llvm::StringRef dummy) override {
679 Visitor->SM = &compiler.getSourceManager();
680 Visitor->Context = &compiler.getASTContext();
681 /// TestConsumer will be deleted by the framework calling us.
682 return llvm::make_unique<FindConsumer>(Visitor);
683 }
684
685 private:
686 TestVisitor *Visitor;
687 };
688 };
689 } // end namespace
690
expectReplacementAt(const Replacement & Replace,StringRef File,unsigned Offset,unsigned Length)691 void expectReplacementAt(const Replacement &Replace,
692 StringRef File, unsigned Offset, unsigned Length) {
693 ASSERT_TRUE(Replace.isApplicable());
694 EXPECT_EQ(File, Replace.getFilePath());
695 EXPECT_EQ(Offset, Replace.getOffset());
696 EXPECT_EQ(Length, Replace.getLength());
697 }
698
699 class ClassDeclXVisitor : public TestVisitor<ClassDeclXVisitor> {
700 public:
VisitCXXRecordDecl(CXXRecordDecl * Record)701 bool VisitCXXRecordDecl(CXXRecordDecl *Record) {
702 if (Record->getName() == "X") {
703 Replace = Replacement(*SM, Record, "");
704 }
705 return true;
706 }
707 Replacement Replace;
708 };
709
TEST(Replacement,CanBeConstructedFromNode)710 TEST(Replacement, CanBeConstructedFromNode) {
711 ClassDeclXVisitor ClassDeclX;
712 EXPECT_TRUE(ClassDeclX.runOver(" class X;"));
713 expectReplacementAt(ClassDeclX.Replace, "input.cc", 5, 7);
714 }
715
TEST(Replacement,ReplacesAtSpellingLocation)716 TEST(Replacement, ReplacesAtSpellingLocation) {
717 ClassDeclXVisitor ClassDeclX;
718 EXPECT_TRUE(ClassDeclX.runOver("#define A(Y) Y\nA(class X);"));
719 expectReplacementAt(ClassDeclX.Replace, "input.cc", 17, 7);
720 }
721
722 class CallToFVisitor : public TestVisitor<CallToFVisitor> {
723 public:
VisitCallExpr(CallExpr * Call)724 bool VisitCallExpr(CallExpr *Call) {
725 if (Call->getDirectCallee()->getName() == "F") {
726 Replace = Replacement(*SM, Call, "");
727 }
728 return true;
729 }
730 Replacement Replace;
731 };
732
TEST(Replacement,FunctionCall)733 TEST(Replacement, FunctionCall) {
734 CallToFVisitor CallToF;
735 EXPECT_TRUE(CallToF.runOver("void F(); void G() { F(); }"));
736 expectReplacementAt(CallToF.Replace, "input.cc", 21, 3);
737 }
738
TEST(Replacement,TemplatedFunctionCall)739 TEST(Replacement, TemplatedFunctionCall) {
740 CallToFVisitor CallToF;
741 EXPECT_TRUE(CallToF.runOver(
742 "template <typename T> void F(); void G() { F<int>(); }"));
743 expectReplacementAt(CallToF.Replace, "input.cc", 43, 8);
744 }
745
746 class NestedNameSpecifierAVisitor
747 : public TestVisitor<NestedNameSpecifierAVisitor> {
748 public:
TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNSLoc)749 bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNSLoc) {
750 if (NNSLoc.getNestedNameSpecifier()) {
751 if (const NamespaceDecl* NS = NNSLoc.getNestedNameSpecifier()->getAsNamespace()) {
752 if (NS->getName() == "a") {
753 Replace = Replacement(*SM, &NNSLoc, "", Context->getLangOpts());
754 }
755 }
756 }
757 return TestVisitor<NestedNameSpecifierAVisitor>::TraverseNestedNameSpecifierLoc(
758 NNSLoc);
759 }
760 Replacement Replace;
761 };
762
TEST(Replacement,ColonColon)763 TEST(Replacement, ColonColon) {
764 NestedNameSpecifierAVisitor VisitNNSA;
765 EXPECT_TRUE(VisitNNSA.runOver("namespace a { void f() { ::a::f(); } }"));
766 expectReplacementAt(VisitNNSA.Replace, "input.cc", 25, 5);
767 }
768
TEST(Range,overlaps)769 TEST(Range, overlaps) {
770 EXPECT_TRUE(Range(10, 10).overlapsWith(Range(0, 11)));
771 EXPECT_TRUE(Range(0, 11).overlapsWith(Range(10, 10)));
772 EXPECT_FALSE(Range(10, 10).overlapsWith(Range(0, 10)));
773 EXPECT_FALSE(Range(0, 10).overlapsWith(Range(10, 10)));
774 EXPECT_TRUE(Range(0, 10).overlapsWith(Range(2, 6)));
775 EXPECT_TRUE(Range(2, 6).overlapsWith(Range(0, 10)));
776 }
777
TEST(Range,contains)778 TEST(Range, contains) {
779 EXPECT_TRUE(Range(0, 10).contains(Range(0, 10)));
780 EXPECT_TRUE(Range(0, 10).contains(Range(2, 6)));
781 EXPECT_FALSE(Range(2, 6).contains(Range(0, 10)));
782 EXPECT_FALSE(Range(0, 10).contains(Range(0, 11)));
783 }
784
TEST(Range,CalculateRangesOfReplacements)785 TEST(Range, CalculateRangesOfReplacements) {
786 // Before: aaaabbbbbbz
787 // After : bbbbbbzzzzzzoooooooooooooooo
788 Replacements Replaces = toReplacements(
789 {Replacement("foo", 0, 4, ""), Replacement("foo", 10, 1, "zzzzzz"),
790 Replacement("foo", 11, 0, "oooooooooooooooo")});
791
792 std::vector<Range> Ranges = Replaces.getAffectedRanges();
793
794 EXPECT_EQ(2ul, Ranges.size());
795 EXPECT_TRUE(Ranges[0].getOffset() == 0);
796 EXPECT_TRUE(Ranges[0].getLength() == 0);
797 EXPECT_TRUE(Ranges[1].getOffset() == 6);
798 EXPECT_TRUE(Ranges[1].getLength() == 22);
799 }
800
TEST(Range,CalculateRangesOfInsertionAroundReplacement)801 TEST(Range, CalculateRangesOfInsertionAroundReplacement) {
802 Replacements Replaces = toReplacements(
803 {Replacement("foo", 0, 2, ""), Replacement("foo", 0, 0, "ba")});
804
805 std::vector<Range> Ranges = Replaces.getAffectedRanges();
806
807 EXPECT_EQ(1ul, Ranges.size());
808 EXPECT_EQ(0u, Ranges[0].getOffset());
809 EXPECT_EQ(2u, Ranges[0].getLength());
810 }
811
TEST(Range,RangesAfterEmptyReplacements)812 TEST(Range, RangesAfterEmptyReplacements) {
813 std::vector<Range> Ranges = {Range(5, 6), Range(10, 5)};
814 Replacements Replaces;
815 std::vector<Range> Expected = {Range(5, 10)};
816 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
817 }
818
TEST(Range,RangesAfterReplacements)819 TEST(Range, RangesAfterReplacements) {
820 std::vector<Range> Ranges = {Range(5, 2), Range(10, 5)};
821 Replacements Replaces = toReplacements({Replacement("foo", 0, 2, "1234")});
822 std::vector<Range> Expected = {Range(0, 4), Range(7, 2), Range(12, 5)};
823 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
824 }
825
TEST(Range,RangesBeforeReplacements)826 TEST(Range, RangesBeforeReplacements) {
827 std::vector<Range> Ranges = {Range(5, 2), Range(10, 5)};
828 Replacements Replaces = toReplacements({Replacement("foo", 20, 2, "1234")});
829 std::vector<Range> Expected = {Range(5, 2), Range(10, 5), Range(20, 4)};
830 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
831 }
832
TEST(Range,NotAffectedByReplacements)833 TEST(Range, NotAffectedByReplacements) {
834 std::vector<Range> Ranges = {Range(0, 2), Range(5, 2), Range(10, 5)};
835 Replacements Replaces = toReplacements({Replacement("foo", 3, 2, "12"),
836 Replacement("foo", 12, 2, "12"),
837 Replacement("foo", 20, 5, "")});
838 std::vector<Range> Expected = {Range(0, 2), Range(3, 4), Range(10, 5),
839 Range(20, 0)};
840 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
841 }
842
TEST(Range,RangesWithNonOverlappingReplacements)843 TEST(Range, RangesWithNonOverlappingReplacements) {
844 std::vector<Range> Ranges = {Range(0, 2), Range(5, 2), Range(10, 5)};
845 Replacements Replaces = toReplacements({Replacement("foo", 3, 1, ""),
846 Replacement("foo", 6, 1, "123"),
847 Replacement("foo", 20, 2, "12345")});
848 std::vector<Range> Expected = {Range(0, 2), Range(3, 0), Range(4, 4),
849 Range(11, 5), Range(21, 5)};
850 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
851 }
852
TEST(Range,RangesWithOverlappingReplacements)853 TEST(Range, RangesWithOverlappingReplacements) {
854 std::vector<Range> Ranges = {Range(0, 2), Range(5, 2), Range(15, 5),
855 Range(30, 5)};
856 Replacements Replaces = toReplacements(
857 {Replacement("foo", 1, 3, ""), Replacement("foo", 6, 1, "123"),
858 Replacement("foo", 13, 3, "1"), Replacement("foo", 25, 15, "")});
859 std::vector<Range> Expected = {Range(0, 1), Range(2, 4), Range(12, 5),
860 Range(22, 0)};
861 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
862 }
863
TEST(Range,MergeIntoOneRange)864 TEST(Range, MergeIntoOneRange) {
865 std::vector<Range> Ranges = {Range(0, 2), Range(5, 2), Range(15, 5)};
866 Replacements Replaces =
867 toReplacements({Replacement("foo", 1, 15, "1234567890")});
868 std::vector<Range> Expected = {Range(0, 15)};
869 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
870 }
871
TEST(Range,ReplacementsStartingAtRangeOffsets)872 TEST(Range, ReplacementsStartingAtRangeOffsets) {
873 std::vector<Range> Ranges = {Range(0, 2), Range(5, 5), Range(15, 5)};
874 Replacements Replaces = toReplacements(
875 {Replacement("foo", 0, 2, "12"), Replacement("foo", 5, 1, "123"),
876 Replacement("foo", 7, 4, "12345"), Replacement("foo", 15, 10, "12")});
877 std::vector<Range> Expected = {Range(0, 2), Range(5, 9), Range(18, 2)};
878 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
879 }
880
TEST(Range,ReplacementsEndingAtRangeEnds)881 TEST(Range, ReplacementsEndingAtRangeEnds) {
882 std::vector<Range> Ranges = {Range(0, 2), Range(5, 2), Range(15, 5)};
883 Replacements Replaces = toReplacements(
884 {Replacement("foo", 6, 1, "123"), Replacement("foo", 17, 3, "12")});
885 std::vector<Range> Expected = {Range(0, 2), Range(5, 4), Range(17, 4)};
886 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
887 }
888
TEST(Range,AjacentReplacements)889 TEST(Range, AjacentReplacements) {
890 std::vector<Range> Ranges = {Range(0, 0), Range(15, 5)};
891 Replacements Replaces = toReplacements(
892 {Replacement("foo", 1, 2, "123"), Replacement("foo", 12, 3, "1234")});
893 std::vector<Range> Expected = {Range(0, 0), Range(1, 3), Range(13, 9)};
894 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
895 }
896
TEST(Range,MergeRangesAfterReplacements)897 TEST(Range, MergeRangesAfterReplacements) {
898 std::vector<Range> Ranges = {Range(8, 0), Range(5, 2), Range(9, 0), Range(0, 1)};
899 Replacements Replaces = toReplacements({Replacement("foo", 1, 3, ""),
900 Replacement("foo", 7, 0, "12"),
901 Replacement("foo", 9, 2, "")});
902 std::vector<Range> Expected = {Range(0, 1), Range(2, 4), Range(7, 0),
903 Range(8, 0)};
904 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
905 }
906
TEST(Range,ConflictingRangesBeforeReplacements)907 TEST(Range, ConflictingRangesBeforeReplacements) {
908 std::vector<Range> Ranges = {Range(8, 3), Range(5, 4), Range(9, 1)};
909 Replacements Replaces = toReplacements({Replacement("foo", 1, 3, "")});
910 std::vector<Range> Expected = {Range(1, 0), Range(2, 6)};
911 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
912 }
913
914 class MergeReplacementsTest : public ::testing::Test {
915 protected:
mergeAndTestRewrite(StringRef Code,StringRef Intermediate,StringRef Result,const Replacements & First,const Replacements & Second)916 void mergeAndTestRewrite(StringRef Code, StringRef Intermediate,
917 StringRef Result, const Replacements &First,
918 const Replacements &Second) {
919 // These are mainly to verify the test itself and make it easier to read.
920 auto AfterFirst = applyAllReplacements(Code, First);
921 EXPECT_TRUE(static_cast<bool>(AfterFirst));
922 auto InSequenceRewrite = applyAllReplacements(*AfterFirst, Second);
923 EXPECT_TRUE(static_cast<bool>(InSequenceRewrite));
924 EXPECT_EQ(Intermediate, *AfterFirst);
925 EXPECT_EQ(Result, *InSequenceRewrite);
926
927 tooling::Replacements Merged = First.merge(Second);
928 auto MergedRewrite = applyAllReplacements(Code, Merged);
929 EXPECT_TRUE(static_cast<bool>(MergedRewrite));
930 EXPECT_EQ(*InSequenceRewrite, *MergedRewrite);
931 if (*InSequenceRewrite != *MergedRewrite)
932 for (tooling::Replacement M : Merged)
933 llvm::errs() << M.getOffset() << " " << M.getLength() << " "
934 << M.getReplacementText() << "\n";
935 }
mergeAndTestRewrite(StringRef Code,const Replacements & First,const Replacements & Second)936 void mergeAndTestRewrite(StringRef Code, const Replacements &First,
937 const Replacements &Second) {
938 auto AfterFirst = applyAllReplacements(Code, First);
939 EXPECT_TRUE(static_cast<bool>(AfterFirst));
940 auto InSequenceRewrite = applyAllReplacements(*AfterFirst, Second);
941 tooling::Replacements Merged = First.merge(Second);
942 auto MergedRewrite = applyAllReplacements(Code, Merged);
943 EXPECT_TRUE(static_cast<bool>(MergedRewrite));
944 EXPECT_EQ(*InSequenceRewrite, *MergedRewrite);
945 if (*InSequenceRewrite != *MergedRewrite)
946 for (tooling::Replacement M : Merged)
947 llvm::errs() << M.getOffset() << " " << M.getLength() << " "
948 << M.getReplacementText() << "\n";
949 }
950 };
951
TEST_F(MergeReplacementsTest,Offsets)952 TEST_F(MergeReplacementsTest, Offsets) {
953 mergeAndTestRewrite("aaa", "aabab", "cacabab",
954 toReplacements({{"", 2, 0, "b"}, {"", 3, 0, "b"}}),
955 toReplacements({{"", 0, 0, "c"}, {"", 1, 0, "c"}}));
956 mergeAndTestRewrite("aaa", "babaa", "babacac",
957 toReplacements({{"", 0, 0, "b"}, {"", 1, 0, "b"}}),
958 toReplacements({{"", 4, 0, "c"}, {"", 5, 0, "c"}}));
959 mergeAndTestRewrite("aaaa", "aaa", "aac", toReplacements({{"", 1, 1, ""}}),
960 toReplacements({{"", 2, 1, "c"}}));
961
962 mergeAndTestRewrite("aa", "bbabba", "bbabcba",
963 toReplacements({{"", 0, 0, "bb"}, {"", 1, 0, "bb"}}),
964 toReplacements({{"", 4, 0, "c"}}));
965 }
966
TEST_F(MergeReplacementsTest,Concatenations)967 TEST_F(MergeReplacementsTest, Concatenations) {
968 // Basic concatenations. It is important to merge these into a single
969 // replacement to ensure the correct order.
970 {
971 auto First = toReplacements({{"", 0, 0, "a"}});
972 auto Second = toReplacements({{"", 1, 0, "b"}});
973 EXPECT_EQ(toReplacements({{"", 0, 0, "ab"}}), First.merge(Second));
974 }
975 {
976 auto First = toReplacements({{"", 0, 0, "a"}});
977 auto Second = toReplacements({{"", 0, 0, "b"}});
978 EXPECT_EQ(toReplacements({{"", 0, 0, "ba"}}), First.merge(Second));
979 }
980 mergeAndTestRewrite("", "a", "ab", toReplacements({{"", 0, 0, "a"}}),
981 toReplacements({{"", 1, 0, "b"}}));
982 mergeAndTestRewrite("", "a", "ba", toReplacements({{"", 0, 0, "a"}}),
983 toReplacements({{"", 0, 0, "b"}}));
984 }
985
TEST_F(MergeReplacementsTest,NotChangingLengths)986 TEST_F(MergeReplacementsTest, NotChangingLengths) {
987 mergeAndTestRewrite("aaaa", "abba", "acca",
988 toReplacements({{"", 1, 2, "bb"}}),
989 toReplacements({{"", 1, 2, "cc"}}));
990 mergeAndTestRewrite("aaaa", "abba", "abcc",
991 toReplacements({{"", 1, 2, "bb"}}),
992 toReplacements({{"", 2, 2, "cc"}}));
993 mergeAndTestRewrite("aaaa", "abba", "ccba",
994 toReplacements({{"", 1, 2, "bb"}}),
995 toReplacements({{"", 0, 2, "cc"}}));
996 mergeAndTestRewrite("aaaaaa", "abbdda", "abccda",
997 toReplacements({{"", 1, 2, "bb"}, {"", 3, 2, "dd"}}),
998 toReplacements({{"", 2, 2, "cc"}}));
999 }
1000
TEST_F(MergeReplacementsTest,OverlappingRanges)1001 TEST_F(MergeReplacementsTest, OverlappingRanges) {
1002 mergeAndTestRewrite("aaa", "bbd", "bcbcd",
1003 toReplacements({{"", 0, 1, "bb"}, {"", 1, 2, "d"}}),
1004 toReplacements({{"", 1, 0, "c"}, {"", 2, 0, "c"}}));
1005
1006 mergeAndTestRewrite("aaaa", "aabbaa", "acccca",
1007 toReplacements({{"", 2, 0, "bb"}}),
1008 toReplacements({{"", 1, 4, "cccc"}}));
1009 mergeAndTestRewrite("aaaa", "aababa", "acccca",
1010 toReplacements({{"", 2, 0, "b"}, {"", 3, 0, "b"}}),
1011 toReplacements({{"", 1, 4, "cccc"}}));
1012 mergeAndTestRewrite("aaaaaa", "abbbba", "abba",
1013 toReplacements({{"", 1, 4, "bbbb"}}),
1014 toReplacements({{"", 2, 2, ""}}));
1015 mergeAndTestRewrite("aaaa", "aa", "cc",
1016 toReplacements({{"", 1, 1, ""}, {"", 2, 1, ""}}),
1017 toReplacements({{"", 0, 2, "cc"}}));
1018 mergeAndTestRewrite("aa", "abbba", "abcbcba",
1019 toReplacements({{"", 1, 0, "bbb"}}),
1020 toReplacements({{"", 2, 0, "c"}, {"", 3, 0, "c"}}));
1021
1022 mergeAndTestRewrite(
1023 "aaa", "abbab", "ccdd",
1024 toReplacements({{"", 0, 1, ""}, {"", 2, 0, "bb"}, {"", 3, 0, "b"}}),
1025 toReplacements({{"", 0, 2, "cc"}, {"", 2, 3, "dd"}}));
1026 mergeAndTestRewrite(
1027 "aa", "babbab", "ccdd",
1028 toReplacements({{"", 0, 0, "b"}, {"", 1, 0, "bb"}, {"", 2, 0, "b"}}),
1029 toReplacements({{"", 0, 3, "cc"}, {"", 3, 3, "dd"}}));
1030 }
1031
TEST(DeduplicateByFileTest,PathsWithDots)1032 TEST(DeduplicateByFileTest, PathsWithDots) {
1033 std::map<std::string, Replacements> FileToReplaces;
1034 llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> VFS(
1035 new llvm::vfs::InMemoryFileSystem());
1036 FileManager FileMgr(FileSystemOptions(), VFS);
1037 #if !defined(_WIN32)
1038 StringRef Path1 = "a/b/.././c.h";
1039 StringRef Path2 = "a/c.h";
1040 #else
1041 StringRef Path1 = "a\\b\\..\\.\\c.h";
1042 StringRef Path2 = "a\\c.h";
1043 #endif
1044 EXPECT_TRUE(VFS->addFile(Path1, 0, llvm::MemoryBuffer::getMemBuffer("")));
1045 EXPECT_TRUE(VFS->addFile(Path2, 0, llvm::MemoryBuffer::getMemBuffer("")));
1046 FileToReplaces[Path1] = Replacements();
1047 FileToReplaces[Path2] = Replacements();
1048 FileToReplaces = groupReplacementsByFile(FileMgr, FileToReplaces);
1049 EXPECT_EQ(1u, FileToReplaces.size());
1050 EXPECT_EQ(Path1, FileToReplaces.begin()->first);
1051 }
1052
TEST(DeduplicateByFileTest,PathWithDotSlash)1053 TEST(DeduplicateByFileTest, PathWithDotSlash) {
1054 std::map<std::string, Replacements> FileToReplaces;
1055 llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> VFS(
1056 new llvm::vfs::InMemoryFileSystem());
1057 FileManager FileMgr(FileSystemOptions(), VFS);
1058 #if !defined(_WIN32)
1059 StringRef Path1 = "./a/b/c.h";
1060 StringRef Path2 = "a/b/c.h";
1061 #else
1062 StringRef Path1 = ".\\a\\b\\c.h";
1063 StringRef Path2 = "a\\b\\c.h";
1064 #endif
1065 EXPECT_TRUE(VFS->addFile(Path1, 0, llvm::MemoryBuffer::getMemBuffer("")));
1066 EXPECT_TRUE(VFS->addFile(Path2, 0, llvm::MemoryBuffer::getMemBuffer("")));
1067 FileToReplaces[Path1] = Replacements();
1068 FileToReplaces[Path2] = Replacements();
1069 FileToReplaces = groupReplacementsByFile(FileMgr, FileToReplaces);
1070 EXPECT_EQ(1u, FileToReplaces.size());
1071 EXPECT_EQ(Path1, FileToReplaces.begin()->first);
1072 }
1073
TEST(DeduplicateByFileTest,NonExistingFilePath)1074 TEST(DeduplicateByFileTest, NonExistingFilePath) {
1075 std::map<std::string, Replacements> FileToReplaces;
1076 llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> VFS(
1077 new llvm::vfs::InMemoryFileSystem());
1078 FileManager FileMgr(FileSystemOptions(), VFS);
1079 #if !defined(_WIN32)
1080 StringRef Path1 = "./a/b/c.h";
1081 StringRef Path2 = "a/b/c.h";
1082 #else
1083 StringRef Path1 = ".\\a\\b\\c.h";
1084 StringRef Path2 = "a\\b\\c.h";
1085 #endif
1086 FileToReplaces[Path1] = Replacements();
1087 FileToReplaces[Path2] = Replacements();
1088 FileToReplaces = groupReplacementsByFile(FileMgr, FileToReplaces);
1089 EXPECT_TRUE(FileToReplaces.empty());
1090 }
1091
1092 class AtomicChangeTest : public ::testing::Test {
1093 protected:
SetUp()1094 void SetUp() override {
1095 DefaultFileID = Context.createInMemoryFile("input.cpp", DefaultCode);
1096 DefaultLoc = Context.Sources.getLocForStartOfFile(DefaultFileID)
1097 .getLocWithOffset(20);
1098 assert(DefaultLoc.isValid() && "Default location must be valid.");
1099 }
1100
1101 RewriterTestContext Context;
1102 std::string DefaultCode = std::string(100, 'a');
1103 unsigned DefaultOffset = 20;
1104 SourceLocation DefaultLoc;
1105 FileID DefaultFileID;
1106 };
1107
TEST_F(AtomicChangeTest,AtomicChangeToYAML)1108 TEST_F(AtomicChangeTest, AtomicChangeToYAML) {
1109 AtomicChange Change(Context.Sources, DefaultLoc);
1110 llvm::Error Err =
1111 Change.insert(Context.Sources, DefaultLoc, "aa", /*InsertAfter=*/false);
1112 ASSERT_TRUE(!Err);
1113 Err = Change.insert(Context.Sources, DefaultLoc.getLocWithOffset(10), "bb",
1114 /*InsertAfter=*/false);
1115 ASSERT_TRUE(!Err);
1116 Change.addHeader("a.h");
1117 Change.removeHeader("b.h");
1118 std::string YAMLString = Change.toYAMLString();
1119
1120 // NOTE: If this test starts to fail for no obvious reason, check whitespace.
1121 ASSERT_STREQ("---\n"
1122 "Key: 'input.cpp:20'\n"
1123 "FilePath: input.cpp\n"
1124 "Error: ''\n"
1125 "InsertedHeaders:\n"
1126 " - a.h\n"
1127 "RemovedHeaders:\n"
1128 " - b.h\n"
1129 "Replacements:\n"
1130 " - FilePath: input.cpp\n"
1131 " Offset: 20\n"
1132 " Length: 0\n"
1133 " ReplacementText: aa\n"
1134 " - FilePath: input.cpp\n"
1135 " Offset: 30\n"
1136 " Length: 0\n"
1137 " ReplacementText: bb\n"
1138 "...\n",
1139 YAMLString.c_str());
1140 }
1141
TEST_F(AtomicChangeTest,YAMLToAtomicChange)1142 TEST_F(AtomicChangeTest, YAMLToAtomicChange) {
1143 std::string YamlContent = "---\n"
1144 "Key: 'input.cpp:20'\n"
1145 "FilePath: input.cpp\n"
1146 "Error: 'ok'\n"
1147 "InsertedHeaders:\n"
1148 " - a.h\n"
1149 "RemovedHeaders:\n"
1150 " - b.h\n"
1151 "Replacements:\n"
1152 " - FilePath: input.cpp\n"
1153 " Offset: 20\n"
1154 " Length: 0\n"
1155 " ReplacementText: aa\n"
1156 " - FilePath: input.cpp\n"
1157 " Offset: 30\n"
1158 " Length: 0\n"
1159 " ReplacementText: bb\n"
1160 "...\n";
1161 AtomicChange ExpectedChange(Context.Sources, DefaultLoc);
1162 llvm::Error Err = ExpectedChange.insert(Context.Sources, DefaultLoc, "aa",
1163 /*InsertAfter=*/false);
1164 ASSERT_TRUE(!Err);
1165 Err = ExpectedChange.insert(Context.Sources, DefaultLoc.getLocWithOffset(10),
1166 "bb", /*InsertAfter=*/false);
1167 ASSERT_TRUE(!Err);
1168
1169 ExpectedChange.addHeader("a.h");
1170 ExpectedChange.removeHeader("b.h");
1171 ExpectedChange.setError("ok");
1172
1173 AtomicChange ActualChange = AtomicChange::convertFromYAML(YamlContent);
1174 EXPECT_EQ(ExpectedChange.getKey(), ActualChange.getKey());
1175 EXPECT_EQ(ExpectedChange.getFilePath(), ActualChange.getFilePath());
1176 EXPECT_EQ(ExpectedChange.getError(), ActualChange.getError());
1177 EXPECT_EQ(ExpectedChange.getInsertedHeaders(),
1178 ActualChange.getInsertedHeaders());
1179 EXPECT_EQ(ExpectedChange.getRemovedHeaders(),
1180 ActualChange.getRemovedHeaders());
1181 EXPECT_EQ(ExpectedChange.getReplacements().size(),
1182 ActualChange.getReplacements().size());
1183 EXPECT_EQ(2u, ActualChange.getReplacements().size());
1184 EXPECT_EQ(*ExpectedChange.getReplacements().begin(),
1185 *ActualChange.getReplacements().begin());
1186 EXPECT_EQ(*(++ExpectedChange.getReplacements().begin()),
1187 *(++ActualChange.getReplacements().begin()));
1188 }
1189
TEST_F(AtomicChangeTest,CheckKeyAndKeyFile)1190 TEST_F(AtomicChangeTest, CheckKeyAndKeyFile) {
1191 AtomicChange Change(Context.Sources, DefaultLoc);
1192 EXPECT_EQ("input.cpp:20", Change.getKey());
1193 EXPECT_EQ("input.cpp", Change.getFilePath());
1194 }
1195
TEST_F(AtomicChangeTest,Replace)1196 TEST_F(AtomicChangeTest, Replace) {
1197 AtomicChange Change(Context.Sources, DefaultLoc);
1198 llvm::Error Err = Change.replace(Context.Sources, DefaultLoc, 2, "aa");
1199 ASSERT_TRUE(!Err);
1200 EXPECT_EQ(Change.getReplacements().size(), 1u);
1201 EXPECT_EQ(*Change.getReplacements().begin(),
1202 Replacement(Context.Sources, DefaultLoc, 2, "aa"));
1203
1204 // Add a new replacement that conflicts with the existing one.
1205 Err = Change.replace(Context.Sources, DefaultLoc, 3, "ab");
1206 EXPECT_TRUE((bool)Err);
1207 llvm::consumeError(std::move(Err));
1208 EXPECT_EQ(Change.getReplacements().size(), 1u);
1209 }
1210
TEST_F(AtomicChangeTest,ReplaceWithRange)1211 TEST_F(AtomicChangeTest, ReplaceWithRange) {
1212 AtomicChange Change(Context.Sources, DefaultLoc);
1213 SourceLocation End = DefaultLoc.getLocWithOffset(20);
1214 llvm::Error Err = Change.replace(
1215 Context.Sources, CharSourceRange::getCharRange(DefaultLoc, End), "aa");
1216 ASSERT_TRUE(!Err);
1217 EXPECT_EQ(Change.getReplacements().size(), 1u);
1218 EXPECT_EQ(*Change.getReplacements().begin(),
1219 Replacement(Context.Sources, DefaultLoc, 20, "aa"));
1220 }
1221
TEST_F(AtomicChangeTest,InsertBefore)1222 TEST_F(AtomicChangeTest, InsertBefore) {
1223 AtomicChange Change(Context.Sources, DefaultLoc);
1224 llvm::Error Err = Change.insert(Context.Sources, DefaultLoc, "aa");
1225 ASSERT_TRUE(!Err);
1226 EXPECT_EQ(Change.getReplacements().size(), 1u);
1227 EXPECT_EQ(*Change.getReplacements().begin(),
1228 Replacement(Context.Sources, DefaultLoc, 0, "aa"));
1229 Err = Change.insert(Context.Sources, DefaultLoc, "b", /*InsertAfter=*/false);
1230 ASSERT_TRUE(!Err);
1231 EXPECT_EQ(Change.getReplacements().size(), 1u);
1232 EXPECT_EQ(*Change.getReplacements().begin(),
1233 Replacement(Context.Sources, DefaultLoc, 0, "baa"));
1234 }
1235
TEST_F(AtomicChangeTest,InsertAfter)1236 TEST_F(AtomicChangeTest, InsertAfter) {
1237 AtomicChange Change(Context.Sources, DefaultLoc);
1238 llvm::Error Err = Change.insert(Context.Sources, DefaultLoc, "aa");
1239 ASSERT_TRUE(!Err);
1240 EXPECT_EQ(Change.getReplacements().size(), 1u);
1241 EXPECT_EQ(*Change.getReplacements().begin(),
1242 Replacement(Context.Sources, DefaultLoc, 0, "aa"));
1243 Err = Change.insert(Context.Sources, DefaultLoc, "b");
1244 ASSERT_TRUE(!Err);
1245 EXPECT_EQ(Change.getReplacements().size(), 1u);
1246 EXPECT_EQ(*Change.getReplacements().begin(),
1247 Replacement(Context.Sources, DefaultLoc, 0, "aab"));
1248 }
1249
TEST_F(AtomicChangeTest,InsertBeforeWithInvalidLocation)1250 TEST_F(AtomicChangeTest, InsertBeforeWithInvalidLocation) {
1251 AtomicChange Change(Context.Sources, DefaultLoc);
1252 llvm::Error Err =
1253 Change.insert(Context.Sources, DefaultLoc, "a", /*InsertAfter=*/false);
1254 ASSERT_TRUE(!Err);
1255
1256 // Invalid location.
1257 Err = Change.insert(Context.Sources, SourceLocation(), "a",
1258 /*InsertAfter=*/false);
1259 ASSERT_TRUE((bool)Err);
1260 EXPECT_TRUE(checkReplacementError(
1261 std::move(Err), replacement_error::wrong_file_path,
1262 Replacement(Context.Sources, DefaultLoc, 0, "a"),
1263 Replacement(Context.Sources, SourceLocation(), 0, "a")));
1264 }
1265
TEST_F(AtomicChangeTest,InsertBeforeToWrongFile)1266 TEST_F(AtomicChangeTest, InsertBeforeToWrongFile) {
1267 AtomicChange Change(Context.Sources, DefaultLoc);
1268 llvm::Error Err =
1269 Change.insert(Context.Sources, DefaultLoc, "a", /*InsertAfter=*/false);
1270 ASSERT_TRUE(!Err);
1271
1272 // Inserting at a different file.
1273 FileID NewID = Context.createInMemoryFile("extra.cpp", DefaultCode);
1274 SourceLocation NewLoc = Context.Sources.getLocForStartOfFile(NewID);
1275 Err = Change.insert(Context.Sources, NewLoc, "b", /*InsertAfter=*/false);
1276 ASSERT_TRUE((bool)Err);
1277 EXPECT_TRUE(
1278 checkReplacementError(std::move(Err), replacement_error::wrong_file_path,
1279 Replacement(Context.Sources, DefaultLoc, 0, "a"),
1280 Replacement(Context.Sources, NewLoc, 0, "b")));
1281 }
1282
TEST_F(AtomicChangeTest,InsertAfterWithInvalidLocation)1283 TEST_F(AtomicChangeTest, InsertAfterWithInvalidLocation) {
1284 AtomicChange Change(Context.Sources, DefaultLoc);
1285 llvm::Error Err = Change.insert(Context.Sources, DefaultLoc, "a");
1286 ASSERT_TRUE(!Err);
1287
1288 // Invalid location.
1289 Err = Change.insert(Context.Sources, SourceLocation(), "b");
1290 ASSERT_TRUE((bool)Err);
1291 EXPECT_TRUE(checkReplacementError(
1292 std::move(Err), replacement_error::wrong_file_path,
1293 Replacement(Context.Sources, DefaultLoc, 0, "a"),
1294 Replacement(Context.Sources, SourceLocation(), 0, "b")));
1295 }
1296
1297 class ApplyAtomicChangesTest : public ::testing::Test {
1298 protected:
ApplyAtomicChangesTest()1299 ApplyAtomicChangesTest() : FilePath("file.cc") {
1300 Spec.Cleanup = true;
1301 Spec.Format = ApplyChangesSpec::kAll;
1302 Spec.Style = format::getLLVMStyle();
1303 }
1304
~ApplyAtomicChangesTest()1305 ~ApplyAtomicChangesTest() override {}
1306
setInput(llvm::StringRef Input)1307 void setInput(llvm::StringRef Input) {
1308 Code = Input;
1309 FID = Context.createInMemoryFile(FilePath, Code);
1310 }
1311
getLoc(unsigned Offset) const1312 SourceLocation getLoc(unsigned Offset) const {
1313 return Context.Sources.getLocForStartOfFile(FID).getLocWithOffset(Offset);
1314 }
1315
replacementToAtomicChange(llvm::StringRef Key,unsigned Offset,unsigned Length,llvm::StringRef Text)1316 AtomicChange replacementToAtomicChange(llvm::StringRef Key, unsigned Offset,
1317 unsigned Length,
1318 llvm::StringRef Text) {
1319 AtomicChange Change(FilePath, Key);
1320 llvm::Error Err =
1321 Change.replace(Context.Sources, getLoc(Offset), Length, Text);
1322 EXPECT_FALSE(Err);
1323 return Change;
1324 }
1325
rewrite(bool FailureExpected=false)1326 std::string rewrite(bool FailureExpected = false) {
1327 llvm::Expected<std::string> ChangedCode =
1328 applyAtomicChanges(FilePath, Code, Changes, Spec);
1329 EXPECT_EQ(FailureExpected, !ChangedCode);
1330 if (!ChangedCode) {
1331 llvm::errs() << "Failed to apply changes: "
1332 << llvm::toString(ChangedCode.takeError()) << "\n";
1333 return "";
1334 }
1335 return *ChangedCode;
1336 }
1337
1338 RewriterTestContext Context;
1339 FileID FID;
1340 ApplyChangesSpec Spec;
1341 std::string Code;
1342 std::string FilePath;
1343 llvm::SmallVector<AtomicChange, 8> Changes;
1344 };
1345
TEST_F(ApplyAtomicChangesTest,BasicRefactoring)1346 TEST_F(ApplyAtomicChangesTest, BasicRefactoring) {
1347 setInput("int a;");
1348 AtomicChange Change(FilePath, "key1");
1349 Changes.push_back(replacementToAtomicChange("key1", 4, 1, "b"));
1350 EXPECT_EQ("int b;", rewrite());
1351 }
1352
TEST_F(ApplyAtomicChangesTest,SeveralRefactorings)1353 TEST_F(ApplyAtomicChangesTest, SeveralRefactorings) {
1354 setInput("int a;\n"
1355 "int b;");
1356 Changes.push_back(replacementToAtomicChange("key1", 0, 3, "float"));
1357 Changes.push_back(replacementToAtomicChange("key2", 4, 1, "f"));
1358 Changes.push_back(replacementToAtomicChange("key3", 11, 1, "g"));
1359 Changes.push_back(replacementToAtomicChange("key4", 7, 3, "float"));
1360 EXPECT_EQ("float f;\n"
1361 "float g;",
1362 rewrite());
1363 }
1364
TEST_F(ApplyAtomicChangesTest,IgnorePathsInRefactorings)1365 TEST_F(ApplyAtomicChangesTest, IgnorePathsInRefactorings) {
1366 setInput("int a;\n"
1367 "int b;");
1368 Changes.push_back(replacementToAtomicChange("key1", 4, 1, "aa"));
1369
1370 FileID ID = Context.createInMemoryFile("AnotherFile", "12345678912345");
1371 Changes.emplace_back("AnotherFile", "key2");
1372 auto Err = Changes.back().replace(
1373 Context.Sources,
1374 Context.Sources.getLocForStartOfFile(ID).getLocWithOffset(11), 1, "bb");
1375 ASSERT_TRUE(!Err);
1376 EXPECT_EQ("int aa;\n"
1377 "int bb;",
1378 rewrite());
1379 }
1380
TEST_F(ApplyAtomicChangesTest,AppliesDuplicateInsertions)1381 TEST_F(ApplyAtomicChangesTest, AppliesDuplicateInsertions) {
1382 setInput("int a;");
1383 Changes.push_back(replacementToAtomicChange("key1", 5, 0, "b"));
1384 Changes.push_back(replacementToAtomicChange("key2", 5, 0, "b"));
1385 EXPECT_EQ("int abb;", rewrite());
1386 }
1387
TEST_F(ApplyAtomicChangesTest,BailsOnOverlappingRefactorings)1388 TEST_F(ApplyAtomicChangesTest, BailsOnOverlappingRefactorings) {
1389 setInput("int a;");
1390 Changes.push_back(replacementToAtomicChange("key1", 0, 5, "float f"));
1391 Changes.push_back(replacementToAtomicChange("key2", 4, 1, "b"));
1392 EXPECT_EQ("", rewrite(/*FailureExpected=*/true));
1393 }
1394
TEST_F(ApplyAtomicChangesTest,BasicReformatting)1395 TEST_F(ApplyAtomicChangesTest, BasicReformatting) {
1396 setInput("int a;");
1397 Changes.push_back(replacementToAtomicChange("key1", 5, 1, "b"));
1398 EXPECT_EQ("int b;", rewrite());
1399 }
1400
TEST_F(ApplyAtomicChangesTest,OnlyFormatWhenViolateColumnLimits)1401 TEST_F(ApplyAtomicChangesTest, OnlyFormatWhenViolateColumnLimits) {
1402 Spec.Format = ApplyChangesSpec::kViolations;
1403 Spec.Style.ColumnLimit = 8;
1404 setInput("int a;\n"
1405 "int a;\n"
1406 "int aaaaaaaa;\n");
1407 Changes.push_back(replacementToAtomicChange("key1", 5, 1, "x"));
1408 Changes.push_back(replacementToAtomicChange("key2", 15, 1, "x"));
1409 Changes.push_back(replacementToAtomicChange("key3", 23, 8, "xx"));
1410 EXPECT_EQ("int x;\n"
1411 "int x;\n"
1412 "int xx;\n",
1413 rewrite());
1414 }
1415
TEST_F(ApplyAtomicChangesTest,LastLineViolateColumnLimits)1416 TEST_F(ApplyAtomicChangesTest, LastLineViolateColumnLimits) {
1417 Spec.Format = ApplyChangesSpec::kViolations;
1418 Spec.Style.ColumnLimit = 8;
1419 setInput("int a;\n"
1420 "int a;");
1421 Changes.push_back(replacementToAtomicChange("key1", 0, 1, "i"));
1422 Changes.push_back(replacementToAtomicChange("key2", 15, 2, "y;"));
1423 EXPECT_EQ("int a;\n"
1424 "int y;",
1425 rewrite());
1426 }
1427
TEST_F(ApplyAtomicChangesTest,LastLineWithNewlineViolateColumnLimits)1428 TEST_F(ApplyAtomicChangesTest, LastLineWithNewlineViolateColumnLimits) {
1429 Spec.Format = ApplyChangesSpec::kViolations;
1430 Spec.Style.ColumnLimit = 8;
1431 setInput("int a;\n"
1432 "int a;\n");
1433 Changes.push_back(replacementToAtomicChange("key1", 0, 1, "i"));
1434 Changes.push_back(replacementToAtomicChange("key2", 14, 3, "y;\n"));
1435 EXPECT_EQ("int a;\n"
1436 "int y;\n",
1437 rewrite());
1438 }
1439
TEST_F(ApplyAtomicChangesTest,Longer)1440 TEST_F(ApplyAtomicChangesTest, Longer) {
1441 setInput("int a;");
1442 Changes.push_back(replacementToAtomicChange("key1", 5, 1, "bbb"));
1443 EXPECT_EQ("int bbb;", rewrite());
1444 }
1445
TEST_F(ApplyAtomicChangesTest,Shorter)1446 TEST_F(ApplyAtomicChangesTest, Shorter) {
1447 setInput("int aaa;");
1448 Changes.push_back(replacementToAtomicChange("key1", 5, 3, "b"));
1449 EXPECT_EQ("int b;", rewrite());
1450 }
1451
TEST_F(ApplyAtomicChangesTest,OnlyFormatChangedLines)1452 TEST_F(ApplyAtomicChangesTest, OnlyFormatChangedLines) {
1453 setInput("int aaa;\n"
1454 "int a = b;\n"
1455 "int bbb;");
1456 Changes.push_back(replacementToAtomicChange("key1", 14, 1, "b"));
1457 EXPECT_EQ("int aaa;\n"
1458 "int b = b;\n"
1459 "int bbb;",
1460 rewrite());
1461 }
1462
TEST_F(ApplyAtomicChangesTest,DisableFormatting)1463 TEST_F(ApplyAtomicChangesTest, DisableFormatting) {
1464 Spec.Format = ApplyChangesSpec::kNone;
1465 setInput("int aaa;\n"
1466 "int a = b;\n"
1467 "int bbb;");
1468 Changes.push_back(replacementToAtomicChange("key1", 14, 1, "b"));
1469 EXPECT_EQ("int aaa;\n"
1470 "int b = b;\n"
1471 "int bbb;",
1472 rewrite());
1473 }
1474
TEST_F(ApplyAtomicChangesTest,AdaptsToLocalPointerStyle)1475 TEST_F(ApplyAtomicChangesTest, AdaptsToLocalPointerStyle) {
1476 setInput("int *aaa;\n"
1477 "int *bbb;");
1478 Changes.push_back(replacementToAtomicChange("key1", 0, 0, "int* ccc;\n"));
1479 EXPECT_EQ("int *ccc;\n"
1480 "int *aaa;\n"
1481 "int *bbb;",
1482 rewrite());
1483 }
1484
TEST_F(ApplyAtomicChangesTest,AcceptsSurroundingFormatting)1485 TEST_F(ApplyAtomicChangesTest, AcceptsSurroundingFormatting) {
1486 setInput(" int aaa;\n"
1487 " int a = b;\n"
1488 " int bbb;");
1489 Changes.push_back(replacementToAtomicChange("key1", 20, 1, "b"));
1490 EXPECT_EQ(" int aaa;\n"
1491 " int b = b;\n"
1492 " int bbb;",
1493 rewrite());
1494 }
1495
TEST_F(ApplyAtomicChangesTest,BailsOutOnConflictingChanges)1496 TEST_F(ApplyAtomicChangesTest, BailsOutOnConflictingChanges) {
1497 setInput("int c;\n"
1498 "int f;");
1499 // Insertions at the same offset are only allowed in the same AtomicChange.
1500 Changes.push_back(replacementToAtomicChange("key1", 0, 0, "int a;\n"));
1501 Changes.push_back(replacementToAtomicChange("key2", 0, 0, "int b;\n"));
1502 EXPECT_EQ("", rewrite(/*FailureExpected=*/true));
1503 }
1504
TEST_F(ApplyAtomicChangesTest,InsertsNewIncludesInRightOrder)1505 TEST_F(ApplyAtomicChangesTest, InsertsNewIncludesInRightOrder) {
1506 setInput("int a;");
1507 Changes.emplace_back(FilePath, "key1");
1508 Changes.back().addHeader("b");
1509 Changes.back().addHeader("c");
1510 Changes.emplace_back(FilePath, "key2");
1511 Changes.back().addHeader("a");
1512 EXPECT_EQ("#include \"a\"\n"
1513 "#include \"b\"\n"
1514 "#include \"c\"\n"
1515 "int a;",
1516 rewrite());
1517 }
1518
TEST_F(ApplyAtomicChangesTest,RemoveAndSortIncludes)1519 TEST_F(ApplyAtomicChangesTest, RemoveAndSortIncludes) {
1520 setInput("#include \"a\"\n"
1521 "#include \"b\"\n"
1522 "#include \"c\"\n"
1523 "\n"
1524 "int a;");
1525 Changes.emplace_back(FilePath, "key1");
1526 Changes.back().removeHeader("b");
1527 EXPECT_EQ("#include \"a\"\n"
1528 "#include \"c\"\n"
1529 "\n"
1530 "int a;",
1531 rewrite());
1532 }
TEST_F(ApplyAtomicChangesTest,InsertsSystemIncludes)1533 TEST_F(ApplyAtomicChangesTest, InsertsSystemIncludes) {
1534 setInput("#include <asys>\n"
1535 "#include <csys>\n"
1536 "\n"
1537 "#include \"a\"\n"
1538 "#include \"c\"\n");
1539 Changes.emplace_back(FilePath, "key1");
1540 Changes.back().addHeader("<asys>"); // Already exists.
1541 Changes.back().addHeader("<b>");
1542 Changes.back().addHeader("<d>");
1543 Changes.back().addHeader("\"b-already-escaped\"");
1544 EXPECT_EQ("#include <asys>\n"
1545 "#include <b>\n"
1546 "#include <csys>\n"
1547 "#include <d>\n"
1548 "\n"
1549 "#include \"a\"\n"
1550 "#include \"b-already-escaped\"\n"
1551 "#include \"c\"\n",
1552 rewrite());
1553 }
1554
TEST_F(ApplyAtomicChangesTest,RemoveSystemIncludes)1555 TEST_F(ApplyAtomicChangesTest, RemoveSystemIncludes) {
1556 setInput("#include <a>\n"
1557 "#include <b>\n"
1558 "\n"
1559 "#include \"c\""
1560 "\n"
1561 "int a;");
1562 Changes.emplace_back(FilePath, "key1");
1563 Changes.back().removeHeader("<a>");
1564 EXPECT_EQ("#include <b>\n"
1565 "\n"
1566 "#include \"c\""
1567 "\n"
1568 "int a;",
1569 rewrite());
1570 }
1571
TEST_F(ApplyAtomicChangesTest,DoNotFormatFollowingLinesIfSeparatedWithNewline)1572 TEST_F(ApplyAtomicChangesTest,
1573 DoNotFormatFollowingLinesIfSeparatedWithNewline) {
1574 setInput("#ifndef __H__\n"
1575 "#define __H__\n"
1576 "#include \"b\"\n"
1577 "\n"
1578 "int a;\n"
1579 "int a;\n"
1580 "int a;\n"
1581 "#endif // __H__\n");
1582 Changes.push_back(replacementToAtomicChange("key1",
1583 llvm::StringRef("#ifndef __H__\n"
1584 "#define __H__\n"
1585 "\n"
1586 "#include \"b\"\n"
1587 "int a;\n"
1588 "int ")
1589 .size(),
1590 1, "b"));
1591 Changes.back().addHeader("a");
1592 EXPECT_EQ("#ifndef __H__\n"
1593 "#define __H__\n"
1594 "#include \"a\"\n"
1595 "#include \"b\"\n"
1596 "\n"
1597 "int a;\n"
1598 "int b;\n"
1599 "int a;\n"
1600 "#endif // __H__\n",
1601 rewrite());
1602 }
1603
TEST_F(ApplyAtomicChangesTest,FormatsCorrectLineWhenHeaderIsRemoved)1604 TEST_F(ApplyAtomicChangesTest, FormatsCorrectLineWhenHeaderIsRemoved) {
1605 setInput("#include \"a\"\n"
1606 "\n"
1607 "int a;\n"
1608 "int a;\n"
1609 "int a;");
1610 Changes.push_back(replacementToAtomicChange("key1", 27, 1, "b"));
1611 Changes.back().removeHeader("a");
1612 EXPECT_EQ("\n"
1613 "int a;\n"
1614 "int b;\n"
1615 "int a;",
1616 rewrite());
1617 }
1618
TEST_F(ApplyAtomicChangesTest,CleansUpCtorInitializers)1619 TEST_F(ApplyAtomicChangesTest, CleansUpCtorInitializers) {
1620 setInput("A::A() : a(), b() {}\n"
1621 "A::A() : a(), b() {}\n"
1622 "A::A() : a(), b() {}\n"
1623 "A::A() : a()/**/, b() {}\n"
1624 "A::A() : a() ,// \n"
1625 " /**/ b() {}");
1626 Changes.emplace_back(FilePath, "key1");
1627 auto Err = Changes.back().replace(Context.Sources, getLoc(9), 3, "");
1628 ASSERT_TRUE(!Err);
1629 Err = Changes.back().replace(Context.Sources, getLoc(35), 3, "");
1630 ASSERT_TRUE(!Err);
1631 Err = Changes.back().replace(Context.Sources, getLoc(51), 3, "");
1632 ASSERT_TRUE(!Err);
1633 Err = Changes.back().replace(Context.Sources, getLoc(56), 3, "");
1634 ASSERT_TRUE(!Err);
1635 Err = Changes.back().replace(Context.Sources, getLoc(72), 3, "");
1636 ASSERT_TRUE(!Err);
1637 Err = Changes.back().replace(Context.Sources, getLoc(97), 3, "");
1638 ASSERT_TRUE(!Err);
1639 Err = Changes.back().replace(Context.Sources, getLoc(118), 3, "");
1640 ASSERT_TRUE(!Err);
1641 EXPECT_EQ("A::A() : b() {}\n"
1642 "A::A() : a() {}\n"
1643 "A::A() {}\n"
1644 "A::A() : b() {}\n"
1645 "A::A() {}",
1646 rewrite());
1647 }
1648
TEST_F(ApplyAtomicChangesTest,CleansUpParameterLists)1649 TEST_F(ApplyAtomicChangesTest, CleansUpParameterLists) {
1650 setInput("void f(int i, float f, string s);\n"
1651 "f(1, 2.0f, \"a\");\n"
1652 "g(1, 1);");
1653 Changes.emplace_back(FilePath, "key1");
1654 auto Err = Changes.back().replace(Context.Sources, getLoc(7), 5, "");
1655 ASSERT_TRUE(!Err);
1656 Err = Changes.back().replace(Context.Sources, getLoc(23), 8, "");
1657 ASSERT_TRUE(!Err);
1658 Err = Changes.back().replace(Context.Sources, getLoc(36), 1, "");
1659 ASSERT_TRUE(!Err);
1660 Err = Changes.back().replace(Context.Sources, getLoc(45), 3, "");
1661 ASSERT_TRUE(!Err);
1662 Err = Changes.back().replace(Context.Sources, getLoc(53), 1, "");
1663 ASSERT_TRUE(!Err);
1664 Err = Changes.back().replace(Context.Sources, getLoc(56), 1, "");
1665 ASSERT_TRUE(!Err);
1666 EXPECT_EQ("void f(float f);\n"
1667 "f(2.0f);\n"
1668 "g();",
1669 rewrite());
1670 }
1671
TEST_F(ApplyAtomicChangesTest,DisableCleanup)1672 TEST_F(ApplyAtomicChangesTest, DisableCleanup) {
1673 Spec.Cleanup = false;
1674 setInput("void f(int i, float f, string s);\n"
1675 "f(1, 2.0f, \"a\");\n"
1676 "g(1, 1);");
1677 Changes.emplace_back(FilePath, "key1");
1678 auto Err = Changes.back().replace(Context.Sources, getLoc(7), 5, "");
1679 ASSERT_TRUE(!Err);
1680 Err = Changes.back().replace(Context.Sources, getLoc(23), 8, "");
1681 ASSERT_TRUE(!Err);
1682 Err = Changes.back().replace(Context.Sources, getLoc(36), 1, "");
1683 ASSERT_TRUE(!Err);
1684 Err = Changes.back().replace(Context.Sources, getLoc(45), 3, "");
1685 ASSERT_TRUE(!Err);
1686 Err = Changes.back().replace(Context.Sources, getLoc(53), 1, "");
1687 ASSERT_TRUE(!Err);
1688 Err = Changes.back().replace(Context.Sources, getLoc(56), 1, "");
1689 ASSERT_TRUE(!Err);
1690 EXPECT_EQ("void f(, float f, );\n"
1691 "f(, 2.0f, );\n"
1692 "g(, );",
1693 rewrite());
1694 }
1695
TEST_F(ApplyAtomicChangesTest,EverythingDeleted)1696 TEST_F(ApplyAtomicChangesTest, EverythingDeleted) {
1697 setInput("int a;");
1698 Changes.push_back(replacementToAtomicChange("key1", 0, 6, ""));
1699 EXPECT_EQ("", rewrite());
1700 }
1701
TEST_F(ApplyAtomicChangesTest,DoesNotDeleteInserts)1702 TEST_F(ApplyAtomicChangesTest, DoesNotDeleteInserts) {
1703 setInput("int a;\n"
1704 "int b;");
1705 Changes.emplace_back(FilePath, "key1");
1706 auto Err = Changes.back().replace(Context.Sources, getLoc(4), 1, "");
1707 ASSERT_TRUE(!Err);
1708 Err = Changes.back().replace(Context.Sources, getLoc(4), 0, "b");
1709 ASSERT_TRUE(!Err);
1710 Err = Changes.back().replace(Context.Sources, getLoc(11), 0, "a");
1711 ASSERT_TRUE(!Err);
1712 Err = Changes.back().replace(Context.Sources, getLoc(11), 1, "");
1713 ASSERT_TRUE(!Err);
1714 EXPECT_EQ("int b;\n"
1715 "int a;",
1716 rewrite());
1717 }
1718
1719 } // end namespace tooling
1720 } // end namespace clang
1721