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)
122 OS << "Expected existing replacement: " << ExpectedExisting->toString()
123 << "\n";
124 if (RE.getExistingReplacement())
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)
131 OS << "Expected new replacement: " << ExpectedNew->toString() << "\n";
132 if (RE.getNewReplacement())
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[std::string(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[std::string(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 auto File = Context.Files.getOptionalFileRef(Path);
612 assert(File);
613
614 StringRef Found =
615 TemporaryFiles.insert(std::make_pair(Name, std::string(Path.str())))
616 .first->second;
617 assert(Found == Path);
618 (void)Found;
619 return Context.Sources.createFileID(*File, SourceLocation(),
620 SrcMgr::C_User);
621 }
622
getFileContentFromDisk(llvm::StringRef Name)623 std::string getFileContentFromDisk(llvm::StringRef Name) {
624 std::string Path = TemporaryFiles.lookup(Name);
625 assert(!Path.empty());
626 // We need to read directly from the FileManager without relaying through
627 // a FileEntry, as otherwise we'd read through an already opened file
628 // descriptor, which might not see the changes made.
629 // FIXME: Figure out whether there is a way to get the SourceManger to
630 // reopen the file.
631 auto FileBuffer = Context.Files.getBufferForFile(Path);
632 return std::string((*FileBuffer)->getBuffer());
633 }
634
635 llvm::StringMap<std::string> TemporaryFiles;
636 RewriterTestContext Context;
637 };
638
TEST_F(FlushRewrittenFilesTest,StoresChangesOnDisk)639 TEST_F(FlushRewrittenFilesTest, StoresChangesOnDisk) {
640 FileID ID = createFile("input.cpp", "line1\nline2\nline3\nline4");
641 Replacements Replaces = toReplacements({Replacement(
642 Context.Sources, Context.getLocation(ID, 2, 1), 5, "replaced")});
643 EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
644 EXPECT_FALSE(Context.Rewrite.overwriteChangedFiles());
645 EXPECT_EQ("line1\nreplaced\nline3\nline4",
646 getFileContentFromDisk("input.cpp"));
647 }
648
649 namespace {
650 template <typename T>
651 class TestVisitor : public clang::RecursiveASTVisitor<T> {
652 public:
runOver(StringRef Code)653 bool runOver(StringRef Code) {
654 return runToolOnCode(std::make_unique<TestAction>(this), Code);
655 }
656
657 protected:
658 clang::SourceManager *SM;
659 clang::ASTContext *Context;
660
661 private:
662 class FindConsumer : public clang::ASTConsumer {
663 public:
FindConsumer(TestVisitor * Visitor)664 FindConsumer(TestVisitor *Visitor) : Visitor(Visitor) {}
665
HandleTranslationUnit(clang::ASTContext & Context)666 void HandleTranslationUnit(clang::ASTContext &Context) override {
667 Visitor->TraverseDecl(Context.getTranslationUnitDecl());
668 }
669
670 private:
671 TestVisitor *Visitor;
672 };
673
674 class TestAction : public clang::ASTFrontendAction {
675 public:
TestAction(TestVisitor * Visitor)676 TestAction(TestVisitor *Visitor) : Visitor(Visitor) {}
677
678 std::unique_ptr<clang::ASTConsumer>
CreateASTConsumer(clang::CompilerInstance & compiler,llvm::StringRef dummy)679 CreateASTConsumer(clang::CompilerInstance &compiler,
680 llvm::StringRef dummy) override {
681 Visitor->SM = &compiler.getSourceManager();
682 Visitor->Context = &compiler.getASTContext();
683 /// TestConsumer will be deleted by the framework calling us.
684 return std::make_unique<FindConsumer>(Visitor);
685 }
686
687 private:
688 TestVisitor *Visitor;
689 };
690 };
691 } // end namespace
692
expectReplacementAt(const Replacement & Replace,StringRef File,unsigned Offset,unsigned Length)693 void expectReplacementAt(const Replacement &Replace,
694 StringRef File, unsigned Offset, unsigned Length) {
695 ASSERT_TRUE(Replace.isApplicable());
696 EXPECT_EQ(File, Replace.getFilePath());
697 EXPECT_EQ(Offset, Replace.getOffset());
698 EXPECT_EQ(Length, Replace.getLength());
699 }
700
701 class ClassDeclXVisitor : public TestVisitor<ClassDeclXVisitor> {
702 public:
VisitCXXRecordDecl(CXXRecordDecl * Record)703 bool VisitCXXRecordDecl(CXXRecordDecl *Record) {
704 if (Record->getName() == "X") {
705 Replace = Replacement(*SM, Record, "");
706 }
707 return true;
708 }
709 Replacement Replace;
710 };
711
TEST(Replacement,CanBeConstructedFromNode)712 TEST(Replacement, CanBeConstructedFromNode) {
713 ClassDeclXVisitor ClassDeclX;
714 EXPECT_TRUE(ClassDeclX.runOver(" class X;"));
715 expectReplacementAt(ClassDeclX.Replace, "input.cc", 5, 7);
716 }
717
TEST(Replacement,ReplacesAtSpellingLocation)718 TEST(Replacement, ReplacesAtSpellingLocation) {
719 ClassDeclXVisitor ClassDeclX;
720 EXPECT_TRUE(ClassDeclX.runOver("#define A(Y) Y\nA(class X);"));
721 expectReplacementAt(ClassDeclX.Replace, "input.cc", 17, 7);
722 }
723
724 class CallToFVisitor : public TestVisitor<CallToFVisitor> {
725 public:
VisitCallExpr(CallExpr * Call)726 bool VisitCallExpr(CallExpr *Call) {
727 if (Call->getDirectCallee()->getName() == "F") {
728 Replace = Replacement(*SM, Call, "");
729 }
730 return true;
731 }
732 Replacement Replace;
733 };
734
TEST(Replacement,FunctionCall)735 TEST(Replacement, FunctionCall) {
736 CallToFVisitor CallToF;
737 EXPECT_TRUE(CallToF.runOver("void F(); void G() { F(); }"));
738 expectReplacementAt(CallToF.Replace, "input.cc", 21, 3);
739 }
740
TEST(Replacement,TemplatedFunctionCall)741 TEST(Replacement, TemplatedFunctionCall) {
742 CallToFVisitor CallToF;
743 EXPECT_TRUE(CallToF.runOver(
744 "template <typename T> void F(); void G() { F<int>(); }"));
745 expectReplacementAt(CallToF.Replace, "input.cc", 43, 8);
746 }
747
748 class NestedNameSpecifierAVisitor
749 : public TestVisitor<NestedNameSpecifierAVisitor> {
750 public:
TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNSLoc)751 bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNSLoc) {
752 if (NNSLoc.getNestedNameSpecifier()) {
753 if (const NamespaceDecl* NS = NNSLoc.getNestedNameSpecifier()->getAsNamespace()) {
754 if (NS->getName() == "a") {
755 Replace = Replacement(*SM, &NNSLoc, "", Context->getLangOpts());
756 }
757 }
758 }
759 return TestVisitor<NestedNameSpecifierAVisitor>::TraverseNestedNameSpecifierLoc(
760 NNSLoc);
761 }
762 Replacement Replace;
763 };
764
TEST(Replacement,ColonColon)765 TEST(Replacement, ColonColon) {
766 NestedNameSpecifierAVisitor VisitNNSA;
767 EXPECT_TRUE(VisitNNSA.runOver("namespace a { void f() { ::a::f(); } }"));
768 expectReplacementAt(VisitNNSA.Replace, "input.cc", 25, 5);
769 }
770
TEST(Range,overlaps)771 TEST(Range, overlaps) {
772 EXPECT_TRUE(Range(10, 10).overlapsWith(Range(0, 11)));
773 EXPECT_TRUE(Range(0, 11).overlapsWith(Range(10, 10)));
774 EXPECT_FALSE(Range(10, 10).overlapsWith(Range(0, 10)));
775 EXPECT_FALSE(Range(0, 10).overlapsWith(Range(10, 10)));
776 EXPECT_TRUE(Range(0, 10).overlapsWith(Range(2, 6)));
777 EXPECT_TRUE(Range(2, 6).overlapsWith(Range(0, 10)));
778 }
779
TEST(Range,contains)780 TEST(Range, contains) {
781 EXPECT_TRUE(Range(0, 10).contains(Range(0, 10)));
782 EXPECT_TRUE(Range(0, 10).contains(Range(2, 6)));
783 EXPECT_FALSE(Range(2, 6).contains(Range(0, 10)));
784 EXPECT_FALSE(Range(0, 10).contains(Range(0, 11)));
785 }
786
TEST(Range,CalculateRangesOfReplacements)787 TEST(Range, CalculateRangesOfReplacements) {
788 // Before: aaaabbbbbbz
789 // After : bbbbbbzzzzzzoooooooooooooooo
790 Replacements Replaces = toReplacements(
791 {Replacement("foo", 0, 4, ""), Replacement("foo", 10, 1, "zzzzzz"),
792 Replacement("foo", 11, 0, "oooooooooooooooo")});
793
794 std::vector<Range> Ranges = Replaces.getAffectedRanges();
795
796 EXPECT_EQ(2ul, Ranges.size());
797 EXPECT_TRUE(Ranges[0].getOffset() == 0);
798 EXPECT_TRUE(Ranges[0].getLength() == 0);
799 EXPECT_TRUE(Ranges[1].getOffset() == 6);
800 EXPECT_TRUE(Ranges[1].getLength() == 22);
801 }
802
TEST(Range,CalculateRangesOfInsertionAroundReplacement)803 TEST(Range, CalculateRangesOfInsertionAroundReplacement) {
804 Replacements Replaces = toReplacements(
805 {Replacement("foo", 0, 2, ""), Replacement("foo", 0, 0, "ba")});
806
807 std::vector<Range> Ranges = Replaces.getAffectedRanges();
808
809 EXPECT_EQ(1ul, Ranges.size());
810 EXPECT_EQ(0u, Ranges[0].getOffset());
811 EXPECT_EQ(2u, Ranges[0].getLength());
812 }
813
TEST(Range,RangesAfterEmptyReplacements)814 TEST(Range, RangesAfterEmptyReplacements) {
815 std::vector<Range> Ranges = {Range(5, 6), Range(10, 5)};
816 Replacements Replaces;
817 std::vector<Range> Expected = {Range(5, 10)};
818 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
819 }
820
TEST(Range,RangesAfterReplacements)821 TEST(Range, RangesAfterReplacements) {
822 std::vector<Range> Ranges = {Range(5, 2), Range(10, 5)};
823 Replacements Replaces = toReplacements({Replacement("foo", 0, 2, "1234")});
824 std::vector<Range> Expected = {Range(0, 4), Range(7, 2), Range(12, 5)};
825 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
826 }
827
TEST(Range,RangesBeforeReplacements)828 TEST(Range, RangesBeforeReplacements) {
829 std::vector<Range> Ranges = {Range(5, 2), Range(10, 5)};
830 Replacements Replaces = toReplacements({Replacement("foo", 20, 2, "1234")});
831 std::vector<Range> Expected = {Range(5, 2), Range(10, 5), Range(20, 4)};
832 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
833 }
834
TEST(Range,NotAffectedByReplacements)835 TEST(Range, NotAffectedByReplacements) {
836 std::vector<Range> Ranges = {Range(0, 2), Range(5, 2), Range(10, 5)};
837 Replacements Replaces = toReplacements({Replacement("foo", 3, 2, "12"),
838 Replacement("foo", 12, 2, "12"),
839 Replacement("foo", 20, 5, "")});
840 std::vector<Range> Expected = {Range(0, 2), Range(3, 4), Range(10, 5),
841 Range(20, 0)};
842 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
843 }
844
TEST(Range,RangesWithNonOverlappingReplacements)845 TEST(Range, RangesWithNonOverlappingReplacements) {
846 std::vector<Range> Ranges = {Range(0, 2), Range(5, 2), Range(10, 5)};
847 Replacements Replaces = toReplacements({Replacement("foo", 3, 1, ""),
848 Replacement("foo", 6, 1, "123"),
849 Replacement("foo", 20, 2, "12345")});
850 std::vector<Range> Expected = {Range(0, 2), Range(3, 0), Range(4, 4),
851 Range(11, 5), Range(21, 5)};
852 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
853 }
854
TEST(Range,RangesWithOverlappingReplacements)855 TEST(Range, RangesWithOverlappingReplacements) {
856 std::vector<Range> Ranges = {Range(0, 2), Range(5, 2), Range(15, 5),
857 Range(30, 5)};
858 Replacements Replaces = toReplacements(
859 {Replacement("foo", 1, 3, ""), Replacement("foo", 6, 1, "123"),
860 Replacement("foo", 13, 3, "1"), Replacement("foo", 25, 15, "")});
861 std::vector<Range> Expected = {Range(0, 1), Range(2, 4), Range(12, 5),
862 Range(22, 0)};
863 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
864 }
865
TEST(Range,MergeIntoOneRange)866 TEST(Range, MergeIntoOneRange) {
867 std::vector<Range> Ranges = {Range(0, 2), Range(5, 2), Range(15, 5)};
868 Replacements Replaces =
869 toReplacements({Replacement("foo", 1, 15, "1234567890")});
870 std::vector<Range> Expected = {Range(0, 15)};
871 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
872 }
873
TEST(Range,ReplacementsStartingAtRangeOffsets)874 TEST(Range, ReplacementsStartingAtRangeOffsets) {
875 std::vector<Range> Ranges = {Range(0, 2), Range(5, 5), Range(15, 5)};
876 Replacements Replaces = toReplacements(
877 {Replacement("foo", 0, 2, "12"), Replacement("foo", 5, 1, "123"),
878 Replacement("foo", 7, 4, "12345"), Replacement("foo", 15, 10, "12")});
879 std::vector<Range> Expected = {Range(0, 2), Range(5, 9), Range(18, 2)};
880 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
881 }
882
TEST(Range,ReplacementsEndingAtRangeEnds)883 TEST(Range, ReplacementsEndingAtRangeEnds) {
884 std::vector<Range> Ranges = {Range(0, 2), Range(5, 2), Range(15, 5)};
885 Replacements Replaces = toReplacements(
886 {Replacement("foo", 6, 1, "123"), Replacement("foo", 17, 3, "12")});
887 std::vector<Range> Expected = {Range(0, 2), Range(5, 4), Range(17, 4)};
888 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
889 }
890
TEST(Range,AjacentReplacements)891 TEST(Range, AjacentReplacements) {
892 std::vector<Range> Ranges = {Range(0, 0), Range(15, 5)};
893 Replacements Replaces = toReplacements(
894 {Replacement("foo", 1, 2, "123"), Replacement("foo", 12, 3, "1234")});
895 std::vector<Range> Expected = {Range(0, 0), Range(1, 3), Range(13, 9)};
896 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
897 }
898
TEST(Range,MergeRangesAfterReplacements)899 TEST(Range, MergeRangesAfterReplacements) {
900 std::vector<Range> Ranges = {Range(8, 0), Range(5, 2), Range(9, 0), Range(0, 1)};
901 Replacements Replaces = toReplacements({Replacement("foo", 1, 3, ""),
902 Replacement("foo", 7, 0, "12"),
903 Replacement("foo", 9, 2, "")});
904 std::vector<Range> Expected = {Range(0, 1), Range(2, 4), Range(7, 0),
905 Range(8, 0)};
906 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
907 }
908
TEST(Range,ConflictingRangesBeforeReplacements)909 TEST(Range, ConflictingRangesBeforeReplacements) {
910 std::vector<Range> Ranges = {Range(8, 3), Range(5, 4), Range(9, 1)};
911 Replacements Replaces = toReplacements({Replacement("foo", 1, 3, "")});
912 std::vector<Range> Expected = {Range(1, 0), Range(2, 6)};
913 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
914 }
915
916 class MergeReplacementsTest : public ::testing::Test {
917 protected:
mergeAndTestRewrite(StringRef Code,StringRef Intermediate,StringRef Result,const Replacements & First,const Replacements & Second)918 void mergeAndTestRewrite(StringRef Code, StringRef Intermediate,
919 StringRef Result, const Replacements &First,
920 const Replacements &Second) {
921 // These are mainly to verify the test itself and make it easier to read.
922 auto AfterFirst = applyAllReplacements(Code, First);
923 EXPECT_TRUE(static_cast<bool>(AfterFirst));
924 auto InSequenceRewrite = applyAllReplacements(*AfterFirst, Second);
925 EXPECT_TRUE(static_cast<bool>(InSequenceRewrite));
926 EXPECT_EQ(Intermediate, *AfterFirst);
927 EXPECT_EQ(Result, *InSequenceRewrite);
928
929 tooling::Replacements Merged = First.merge(Second);
930 auto MergedRewrite = applyAllReplacements(Code, Merged);
931 EXPECT_TRUE(static_cast<bool>(MergedRewrite));
932 EXPECT_EQ(*InSequenceRewrite, *MergedRewrite);
933 if (*InSequenceRewrite != *MergedRewrite)
934 for (tooling::Replacement M : Merged)
935 llvm::errs() << M.getOffset() << " " << M.getLength() << " "
936 << M.getReplacementText() << "\n";
937 }
mergeAndTestRewrite(StringRef Code,const Replacements & First,const Replacements & Second)938 void mergeAndTestRewrite(StringRef Code, const Replacements &First,
939 const Replacements &Second) {
940 auto AfterFirst = applyAllReplacements(Code, First);
941 EXPECT_TRUE(static_cast<bool>(AfterFirst));
942 auto InSequenceRewrite = applyAllReplacements(*AfterFirst, Second);
943 tooling::Replacements Merged = First.merge(Second);
944 auto MergedRewrite = applyAllReplacements(Code, Merged);
945 EXPECT_TRUE(static_cast<bool>(MergedRewrite));
946 EXPECT_EQ(*InSequenceRewrite, *MergedRewrite);
947 if (*InSequenceRewrite != *MergedRewrite)
948 for (tooling::Replacement M : Merged)
949 llvm::errs() << M.getOffset() << " " << M.getLength() << " "
950 << M.getReplacementText() << "\n";
951 }
952 };
953
TEST_F(MergeReplacementsTest,Offsets)954 TEST_F(MergeReplacementsTest, Offsets) {
955 mergeAndTestRewrite("aaa", "aabab", "cacabab",
956 toReplacements({{"", 2, 0, "b"}, {"", 3, 0, "b"}}),
957 toReplacements({{"", 0, 0, "c"}, {"", 1, 0, "c"}}));
958 mergeAndTestRewrite("aaa", "babaa", "babacac",
959 toReplacements({{"", 0, 0, "b"}, {"", 1, 0, "b"}}),
960 toReplacements({{"", 4, 0, "c"}, {"", 5, 0, "c"}}));
961 mergeAndTestRewrite("aaaa", "aaa", "aac", toReplacements({{"", 1, 1, ""}}),
962 toReplacements({{"", 2, 1, "c"}}));
963
964 mergeAndTestRewrite("aa", "bbabba", "bbabcba",
965 toReplacements({{"", 0, 0, "bb"}, {"", 1, 0, "bb"}}),
966 toReplacements({{"", 4, 0, "c"}}));
967 }
968
TEST_F(MergeReplacementsTest,Concatenations)969 TEST_F(MergeReplacementsTest, Concatenations) {
970 // Basic concatenations. It is important to merge these into a single
971 // replacement to ensure the correct order.
972 {
973 auto First = toReplacements({{"", 0, 0, "a"}});
974 auto Second = toReplacements({{"", 1, 0, "b"}});
975 EXPECT_EQ(toReplacements({{"", 0, 0, "ab"}}), First.merge(Second));
976 }
977 {
978 auto First = toReplacements({{"", 0, 0, "a"}});
979 auto Second = toReplacements({{"", 0, 0, "b"}});
980 EXPECT_EQ(toReplacements({{"", 0, 0, "ba"}}), First.merge(Second));
981 }
982 mergeAndTestRewrite("", "a", "ab", toReplacements({{"", 0, 0, "a"}}),
983 toReplacements({{"", 1, 0, "b"}}));
984 mergeAndTestRewrite("", "a", "ba", toReplacements({{"", 0, 0, "a"}}),
985 toReplacements({{"", 0, 0, "b"}}));
986 }
987
TEST_F(MergeReplacementsTest,NotChangingLengths)988 TEST_F(MergeReplacementsTest, NotChangingLengths) {
989 mergeAndTestRewrite("aaaa", "abba", "acca",
990 toReplacements({{"", 1, 2, "bb"}}),
991 toReplacements({{"", 1, 2, "cc"}}));
992 mergeAndTestRewrite("aaaa", "abba", "abcc",
993 toReplacements({{"", 1, 2, "bb"}}),
994 toReplacements({{"", 2, 2, "cc"}}));
995 mergeAndTestRewrite("aaaa", "abba", "ccba",
996 toReplacements({{"", 1, 2, "bb"}}),
997 toReplacements({{"", 0, 2, "cc"}}));
998 mergeAndTestRewrite("aaaaaa", "abbdda", "abccda",
999 toReplacements({{"", 1, 2, "bb"}, {"", 3, 2, "dd"}}),
1000 toReplacements({{"", 2, 2, "cc"}}));
1001 }
1002
TEST_F(MergeReplacementsTest,OverlappingRanges)1003 TEST_F(MergeReplacementsTest, OverlappingRanges) {
1004 mergeAndTestRewrite("aaa", "bbd", "bcbcd",
1005 toReplacements({{"", 0, 1, "bb"}, {"", 1, 2, "d"}}),
1006 toReplacements({{"", 1, 0, "c"}, {"", 2, 0, "c"}}));
1007
1008 mergeAndTestRewrite("aaaa", "aabbaa", "acccca",
1009 toReplacements({{"", 2, 0, "bb"}}),
1010 toReplacements({{"", 1, 4, "cccc"}}));
1011 mergeAndTestRewrite("aaaa", "aababa", "acccca",
1012 toReplacements({{"", 2, 0, "b"}, {"", 3, 0, "b"}}),
1013 toReplacements({{"", 1, 4, "cccc"}}));
1014 mergeAndTestRewrite("aaaaaa", "abbbba", "abba",
1015 toReplacements({{"", 1, 4, "bbbb"}}),
1016 toReplacements({{"", 2, 2, ""}}));
1017 mergeAndTestRewrite("aaaa", "aa", "cc",
1018 toReplacements({{"", 1, 1, ""}, {"", 2, 1, ""}}),
1019 toReplacements({{"", 0, 2, "cc"}}));
1020 mergeAndTestRewrite("aa", "abbba", "abcbcba",
1021 toReplacements({{"", 1, 0, "bbb"}}),
1022 toReplacements({{"", 2, 0, "c"}, {"", 3, 0, "c"}}));
1023
1024 mergeAndTestRewrite(
1025 "aaa", "abbab", "ccdd",
1026 toReplacements({{"", 0, 1, ""}, {"", 2, 0, "bb"}, {"", 3, 0, "b"}}),
1027 toReplacements({{"", 0, 2, "cc"}, {"", 2, 3, "dd"}}));
1028 mergeAndTestRewrite(
1029 "aa", "babbab", "ccdd",
1030 toReplacements({{"", 0, 0, "b"}, {"", 1, 0, "bb"}, {"", 2, 0, "b"}}),
1031 toReplacements({{"", 0, 3, "cc"}, {"", 3, 3, "dd"}}));
1032 }
1033
usesWindowsPaths()1034 static constexpr bool usesWindowsPaths() {
1035 return is_style_windows(llvm::sys::path::Style::native);
1036 }
1037
TEST(DeduplicateByFileTest,PathsWithDots)1038 TEST(DeduplicateByFileTest, PathsWithDots) {
1039 std::map<std::string, Replacements> FileToReplaces;
1040 llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> VFS(
1041 new llvm::vfs::InMemoryFileSystem());
1042 FileManager FileMgr(FileSystemOptions(), VFS);
1043 StringRef Path1 = usesWindowsPaths() ? "a\\b\\..\\.\\c.h" : "a/b/.././c.h";
1044 StringRef Path2 = usesWindowsPaths() ? "a\\c.h" : "a/c.h";
1045 EXPECT_TRUE(VFS->addFile(Path1, 0, llvm::MemoryBuffer::getMemBuffer("")));
1046 EXPECT_TRUE(VFS->addFile(Path2, 0, llvm::MemoryBuffer::getMemBuffer("")));
1047 FileToReplaces[std::string(Path1)] = Replacements();
1048 FileToReplaces[std::string(Path2)] = Replacements();
1049 FileToReplaces = groupReplacementsByFile(FileMgr, FileToReplaces);
1050 EXPECT_EQ(1u, FileToReplaces.size());
1051 EXPECT_EQ(Path1, FileToReplaces.begin()->first);
1052 }
1053
TEST(DeduplicateByFileTest,PathWithDotSlash)1054 TEST(DeduplicateByFileTest, PathWithDotSlash) {
1055 std::map<std::string, Replacements> FileToReplaces;
1056 llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> VFS(
1057 new llvm::vfs::InMemoryFileSystem());
1058 FileManager FileMgr(FileSystemOptions(), VFS);
1059 StringRef Path1 = usesWindowsPaths() ? ".\\a\\b\\c.h" : "./a/b/c.h";
1060 StringRef Path2 = usesWindowsPaths() ? "a\\b\\c.h" : "a/b/c.h";
1061 EXPECT_TRUE(VFS->addFile(Path1, 0, llvm::MemoryBuffer::getMemBuffer("")));
1062 EXPECT_TRUE(VFS->addFile(Path2, 0, llvm::MemoryBuffer::getMemBuffer("")));
1063 FileToReplaces[std::string(Path1)] = Replacements();
1064 FileToReplaces[std::string(Path2)] = Replacements();
1065 FileToReplaces = groupReplacementsByFile(FileMgr, FileToReplaces);
1066 EXPECT_EQ(1u, FileToReplaces.size());
1067 EXPECT_EQ(Path1, FileToReplaces.begin()->first);
1068 }
1069
TEST(DeduplicateByFileTest,NonExistingFilePath)1070 TEST(DeduplicateByFileTest, NonExistingFilePath) {
1071 std::map<std::string, Replacements> FileToReplaces;
1072 llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> VFS(
1073 new llvm::vfs::InMemoryFileSystem());
1074 FileManager FileMgr(FileSystemOptions(), VFS);
1075 StringRef Path1 = usesWindowsPaths() ? ".\\a\\b\\c.h" : "./a/b/c.h";
1076 StringRef Path2 = usesWindowsPaths() ? "a\\b\\c.h" : "a/b/c.h";
1077 FileToReplaces[std::string(Path1)] = Replacements();
1078 FileToReplaces[std::string(Path2)] = Replacements();
1079 FileToReplaces = groupReplacementsByFile(FileMgr, FileToReplaces);
1080 EXPECT_TRUE(FileToReplaces.empty());
1081 }
1082
1083 class AtomicChangeTest : public ::testing::Test {
1084 protected:
SetUp()1085 void SetUp() override {
1086 DefaultFileID = Context.createInMemoryFile("input.cpp", DefaultCode);
1087 DefaultLoc = Context.Sources.getLocForStartOfFile(DefaultFileID)
1088 .getLocWithOffset(20);
1089 assert(DefaultLoc.isValid() && "Default location must be valid.");
1090 }
1091
1092 RewriterTestContext Context;
1093 std::string DefaultCode = std::string(100, 'a');
1094 unsigned DefaultOffset = 20;
1095 SourceLocation DefaultLoc;
1096 FileID DefaultFileID;
1097 };
1098
TEST_F(AtomicChangeTest,AtomicChangeToYAML)1099 TEST_F(AtomicChangeTest, AtomicChangeToYAML) {
1100 AtomicChange Change(Context.Sources, DefaultLoc);
1101 llvm::Error Err =
1102 Change.insert(Context.Sources, DefaultLoc, "aa", /*InsertAfter=*/false);
1103 ASSERT_TRUE(!Err);
1104 Err = Change.insert(Context.Sources, DefaultLoc.getLocWithOffset(10), "bb",
1105 /*InsertAfter=*/false);
1106 ASSERT_TRUE(!Err);
1107 Change.addHeader("a.h");
1108 Change.removeHeader("b.h");
1109 std::string YAMLString = Change.toYAMLString();
1110
1111 // NOTE: If this test starts to fail for no obvious reason, check whitespace.
1112 ASSERT_STREQ("---\n"
1113 "Key: 'input.cpp:20'\n"
1114 "FilePath: input.cpp\n"
1115 "Error: ''\n"
1116 "InsertedHeaders:\n"
1117 " - a.h\n"
1118 "RemovedHeaders:\n"
1119 " - b.h\n"
1120 "Replacements:\n"
1121 " - FilePath: input.cpp\n"
1122 " Offset: 20\n"
1123 " Length: 0\n"
1124 " ReplacementText: aa\n"
1125 " - FilePath: input.cpp\n"
1126 " Offset: 30\n"
1127 " Length: 0\n"
1128 " ReplacementText: bb\n"
1129 "...\n",
1130 YAMLString.c_str());
1131 }
1132
TEST_F(AtomicChangeTest,YAMLToAtomicChange)1133 TEST_F(AtomicChangeTest, YAMLToAtomicChange) {
1134 std::string YamlContent = "---\n"
1135 "Key: 'input.cpp:20'\n"
1136 "FilePath: input.cpp\n"
1137 "Error: 'ok'\n"
1138 "InsertedHeaders:\n"
1139 " - a.h\n"
1140 "RemovedHeaders:\n"
1141 " - b.h\n"
1142 "Replacements:\n"
1143 " - FilePath: input.cpp\n"
1144 " Offset: 20\n"
1145 " Length: 0\n"
1146 " ReplacementText: aa\n"
1147 " - FilePath: input.cpp\n"
1148 " Offset: 30\n"
1149 " Length: 0\n"
1150 " ReplacementText: bb\n"
1151 "...\n";
1152 AtomicChange ExpectedChange(Context.Sources, DefaultLoc);
1153 llvm::Error Err = ExpectedChange.insert(Context.Sources, DefaultLoc, "aa",
1154 /*InsertAfter=*/false);
1155 ASSERT_TRUE(!Err);
1156 Err = ExpectedChange.insert(Context.Sources, DefaultLoc.getLocWithOffset(10),
1157 "bb", /*InsertAfter=*/false);
1158 ASSERT_TRUE(!Err);
1159
1160 ExpectedChange.addHeader("a.h");
1161 ExpectedChange.removeHeader("b.h");
1162 ExpectedChange.setError("ok");
1163
1164 AtomicChange ActualChange = AtomicChange::convertFromYAML(YamlContent);
1165 EXPECT_EQ(ExpectedChange.getKey(), ActualChange.getKey());
1166 EXPECT_EQ(ExpectedChange.getFilePath(), ActualChange.getFilePath());
1167 EXPECT_EQ(ExpectedChange.getError(), ActualChange.getError());
1168 EXPECT_EQ(ExpectedChange.getInsertedHeaders(),
1169 ActualChange.getInsertedHeaders());
1170 EXPECT_EQ(ExpectedChange.getRemovedHeaders(),
1171 ActualChange.getRemovedHeaders());
1172 EXPECT_EQ(ExpectedChange.getReplacements().size(),
1173 ActualChange.getReplacements().size());
1174 EXPECT_EQ(2u, ActualChange.getReplacements().size());
1175 EXPECT_EQ(*ExpectedChange.getReplacements().begin(),
1176 *ActualChange.getReplacements().begin());
1177 EXPECT_EQ(*(++ExpectedChange.getReplacements().begin()),
1178 *(++ActualChange.getReplacements().begin()));
1179 }
1180
TEST_F(AtomicChangeTest,CheckKeyAndKeyFile)1181 TEST_F(AtomicChangeTest, CheckKeyAndKeyFile) {
1182 AtomicChange Change(Context.Sources, DefaultLoc);
1183 EXPECT_EQ("input.cpp:20", Change.getKey());
1184 EXPECT_EQ("input.cpp", Change.getFilePath());
1185 }
1186
TEST_F(AtomicChangeTest,Replace)1187 TEST_F(AtomicChangeTest, Replace) {
1188 AtomicChange Change(Context.Sources, DefaultLoc);
1189 llvm::Error Err = Change.replace(Context.Sources, DefaultLoc, 2, "aa");
1190 ASSERT_TRUE(!Err);
1191 EXPECT_EQ(Change.getReplacements().size(), 1u);
1192 EXPECT_EQ(*Change.getReplacements().begin(),
1193 Replacement(Context.Sources, DefaultLoc, 2, "aa"));
1194
1195 // Add a new replacement that conflicts with the existing one.
1196 Err = Change.replace(Context.Sources, DefaultLoc, 3, "ab");
1197 EXPECT_TRUE((bool)Err);
1198 llvm::consumeError(std::move(Err));
1199 EXPECT_EQ(Change.getReplacements().size(), 1u);
1200 }
1201
TEST_F(AtomicChangeTest,ReplaceWithRange)1202 TEST_F(AtomicChangeTest, ReplaceWithRange) {
1203 AtomicChange Change(Context.Sources, DefaultLoc);
1204 SourceLocation End = DefaultLoc.getLocWithOffset(20);
1205 llvm::Error Err = Change.replace(
1206 Context.Sources, CharSourceRange::getCharRange(DefaultLoc, End), "aa");
1207 ASSERT_TRUE(!Err);
1208 EXPECT_EQ(Change.getReplacements().size(), 1u);
1209 EXPECT_EQ(*Change.getReplacements().begin(),
1210 Replacement(Context.Sources, DefaultLoc, 20, "aa"));
1211 }
1212
TEST_F(AtomicChangeTest,InsertBefore)1213 TEST_F(AtomicChangeTest, InsertBefore) {
1214 AtomicChange Change(Context.Sources, DefaultLoc);
1215 llvm::Error Err = Change.insert(Context.Sources, DefaultLoc, "aa");
1216 ASSERT_TRUE(!Err);
1217 EXPECT_EQ(Change.getReplacements().size(), 1u);
1218 EXPECT_EQ(*Change.getReplacements().begin(),
1219 Replacement(Context.Sources, DefaultLoc, 0, "aa"));
1220 Err = Change.insert(Context.Sources, DefaultLoc, "b", /*InsertAfter=*/false);
1221 ASSERT_TRUE(!Err);
1222 EXPECT_EQ(Change.getReplacements().size(), 1u);
1223 EXPECT_EQ(*Change.getReplacements().begin(),
1224 Replacement(Context.Sources, DefaultLoc, 0, "baa"));
1225 }
1226
TEST_F(AtomicChangeTest,InsertAfter)1227 TEST_F(AtomicChangeTest, InsertAfter) {
1228 AtomicChange Change(Context.Sources, DefaultLoc);
1229 llvm::Error Err = Change.insert(Context.Sources, DefaultLoc, "aa");
1230 ASSERT_TRUE(!Err);
1231 EXPECT_EQ(Change.getReplacements().size(), 1u);
1232 EXPECT_EQ(*Change.getReplacements().begin(),
1233 Replacement(Context.Sources, DefaultLoc, 0, "aa"));
1234 Err = Change.insert(Context.Sources, DefaultLoc, "b");
1235 ASSERT_TRUE(!Err);
1236 EXPECT_EQ(Change.getReplacements().size(), 1u);
1237 EXPECT_EQ(*Change.getReplacements().begin(),
1238 Replacement(Context.Sources, DefaultLoc, 0, "aab"));
1239 }
1240
TEST_F(AtomicChangeTest,InsertBeforeWithInvalidLocation)1241 TEST_F(AtomicChangeTest, InsertBeforeWithInvalidLocation) {
1242 AtomicChange Change(Context.Sources, DefaultLoc);
1243 llvm::Error Err =
1244 Change.insert(Context.Sources, DefaultLoc, "a", /*InsertAfter=*/false);
1245 ASSERT_TRUE(!Err);
1246
1247 // Invalid location.
1248 Err = Change.insert(Context.Sources, SourceLocation(), "a",
1249 /*InsertAfter=*/false);
1250 ASSERT_TRUE((bool)Err);
1251 EXPECT_TRUE(checkReplacementError(
1252 std::move(Err), replacement_error::wrong_file_path,
1253 Replacement(Context.Sources, DefaultLoc, 0, "a"),
1254 Replacement(Context.Sources, SourceLocation(), 0, "a")));
1255 }
1256
TEST_F(AtomicChangeTest,InsertBeforeToWrongFile)1257 TEST_F(AtomicChangeTest, InsertBeforeToWrongFile) {
1258 AtomicChange Change(Context.Sources, DefaultLoc);
1259 llvm::Error Err =
1260 Change.insert(Context.Sources, DefaultLoc, "a", /*InsertAfter=*/false);
1261 ASSERT_TRUE(!Err);
1262
1263 // Inserting at a different file.
1264 FileID NewID = Context.createInMemoryFile("extra.cpp", DefaultCode);
1265 SourceLocation NewLoc = Context.Sources.getLocForStartOfFile(NewID);
1266 Err = Change.insert(Context.Sources, NewLoc, "b", /*InsertAfter=*/false);
1267 ASSERT_TRUE((bool)Err);
1268 EXPECT_TRUE(
1269 checkReplacementError(std::move(Err), replacement_error::wrong_file_path,
1270 Replacement(Context.Sources, DefaultLoc, 0, "a"),
1271 Replacement(Context.Sources, NewLoc, 0, "b")));
1272 }
1273
TEST_F(AtomicChangeTest,InsertAfterWithInvalidLocation)1274 TEST_F(AtomicChangeTest, InsertAfterWithInvalidLocation) {
1275 AtomicChange Change(Context.Sources, DefaultLoc);
1276 llvm::Error Err = Change.insert(Context.Sources, DefaultLoc, "a");
1277 ASSERT_TRUE(!Err);
1278
1279 // Invalid location.
1280 Err = Change.insert(Context.Sources, SourceLocation(), "b");
1281 ASSERT_TRUE((bool)Err);
1282 EXPECT_TRUE(checkReplacementError(
1283 std::move(Err), replacement_error::wrong_file_path,
1284 Replacement(Context.Sources, DefaultLoc, 0, "a"),
1285 Replacement(Context.Sources, SourceLocation(), 0, "b")));
1286 }
1287
TEST_F(AtomicChangeTest,Metadata)1288 TEST_F(AtomicChangeTest, Metadata) {
1289 AtomicChange Change(Context.Sources, DefaultLoc, 17);
1290 const llvm::Any &Metadata = Change.getMetadata();
1291 ASSERT_TRUE(llvm::any_isa<int>(Metadata));
1292 EXPECT_EQ(llvm::any_cast<int>(Metadata), 17);
1293 }
1294
TEST_F(AtomicChangeTest,NoMetadata)1295 TEST_F(AtomicChangeTest, NoMetadata) {
1296 AtomicChange Change(Context.Sources, DefaultLoc);
1297 EXPECT_FALSE(Change.getMetadata().hasValue());
1298 }
1299
1300 class ApplyAtomicChangesTest : public ::testing::Test {
1301 protected:
ApplyAtomicChangesTest()1302 ApplyAtomicChangesTest() : FilePath("file.cc") {
1303 Spec.Cleanup = true;
1304 Spec.Format = ApplyChangesSpec::kAll;
1305 Spec.Style = format::getLLVMStyle();
1306 }
1307
~ApplyAtomicChangesTest()1308 ~ApplyAtomicChangesTest() override {}
1309
setInput(llvm::StringRef Input)1310 void setInput(llvm::StringRef Input) {
1311 Code = std::string(Input);
1312 FID = Context.createInMemoryFile(FilePath, Code);
1313 }
1314
getLoc(unsigned Offset) const1315 SourceLocation getLoc(unsigned Offset) const {
1316 return Context.Sources.getLocForStartOfFile(FID).getLocWithOffset(Offset);
1317 }
1318
replacementToAtomicChange(llvm::StringRef Key,unsigned Offset,unsigned Length,llvm::StringRef Text)1319 AtomicChange replacementToAtomicChange(llvm::StringRef Key, unsigned Offset,
1320 unsigned Length,
1321 llvm::StringRef Text) {
1322 AtomicChange Change(FilePath, Key);
1323 llvm::Error Err =
1324 Change.replace(Context.Sources, getLoc(Offset), Length, Text);
1325 EXPECT_FALSE(Err);
1326 return Change;
1327 }
1328
rewrite(bool FailureExpected=false)1329 std::string rewrite(bool FailureExpected = false) {
1330 llvm::Expected<std::string> ChangedCode =
1331 applyAtomicChanges(FilePath, Code, Changes, Spec);
1332 EXPECT_EQ(FailureExpected, !ChangedCode);
1333 if (!ChangedCode) {
1334 llvm::errs() << "Failed to apply changes: "
1335 << llvm::toString(ChangedCode.takeError()) << "\n";
1336 return "";
1337 }
1338 return *ChangedCode;
1339 }
1340
1341 RewriterTestContext Context;
1342 FileID FID;
1343 ApplyChangesSpec Spec;
1344 std::string Code;
1345 std::string FilePath;
1346 llvm::SmallVector<AtomicChange, 8> Changes;
1347 };
1348
TEST_F(ApplyAtomicChangesTest,BasicRefactoring)1349 TEST_F(ApplyAtomicChangesTest, BasicRefactoring) {
1350 setInput("int a;");
1351 AtomicChange Change(FilePath, "key1");
1352 Changes.push_back(replacementToAtomicChange("key1", 4, 1, "b"));
1353 EXPECT_EQ("int b;", rewrite());
1354 }
1355
TEST_F(ApplyAtomicChangesTest,SeveralRefactorings)1356 TEST_F(ApplyAtomicChangesTest, SeveralRefactorings) {
1357 setInput("int a;\n"
1358 "int b;");
1359 Changes.push_back(replacementToAtomicChange("key1", 0, 3, "float"));
1360 Changes.push_back(replacementToAtomicChange("key2", 4, 1, "f"));
1361 Changes.push_back(replacementToAtomicChange("key3", 11, 1, "g"));
1362 Changes.push_back(replacementToAtomicChange("key4", 7, 3, "float"));
1363 EXPECT_EQ("float f;\n"
1364 "float g;",
1365 rewrite());
1366 }
1367
TEST_F(ApplyAtomicChangesTest,IgnorePathsInRefactorings)1368 TEST_F(ApplyAtomicChangesTest, IgnorePathsInRefactorings) {
1369 setInput("int a;\n"
1370 "int b;");
1371 Changes.push_back(replacementToAtomicChange("key1", 4, 1, "aa"));
1372
1373 FileID ID = Context.createInMemoryFile("AnotherFile", "12345678912345");
1374 Changes.emplace_back("AnotherFile", "key2");
1375 auto Err = Changes.back().replace(
1376 Context.Sources,
1377 Context.Sources.getLocForStartOfFile(ID).getLocWithOffset(11), 1, "bb");
1378 ASSERT_TRUE(!Err);
1379 EXPECT_EQ("int aa;\n"
1380 "int bb;",
1381 rewrite());
1382 }
1383
TEST_F(ApplyAtomicChangesTest,AppliesDuplicateInsertions)1384 TEST_F(ApplyAtomicChangesTest, AppliesDuplicateInsertions) {
1385 setInput("int a;");
1386 Changes.push_back(replacementToAtomicChange("key1", 5, 0, "b"));
1387 Changes.push_back(replacementToAtomicChange("key2", 5, 0, "b"));
1388 EXPECT_EQ("int abb;", rewrite());
1389 }
1390
TEST_F(ApplyAtomicChangesTest,BailsOnOverlappingRefactorings)1391 TEST_F(ApplyAtomicChangesTest, BailsOnOverlappingRefactorings) {
1392 setInput("int a;");
1393 Changes.push_back(replacementToAtomicChange("key1", 0, 5, "float f"));
1394 Changes.push_back(replacementToAtomicChange("key2", 4, 1, "b"));
1395 EXPECT_EQ("", rewrite(/*FailureExpected=*/true));
1396 }
1397
TEST_F(ApplyAtomicChangesTest,BasicReformatting)1398 TEST_F(ApplyAtomicChangesTest, BasicReformatting) {
1399 setInput("int a;");
1400 Changes.push_back(replacementToAtomicChange("key1", 5, 1, "b"));
1401 EXPECT_EQ("int b;", rewrite());
1402 }
1403
TEST_F(ApplyAtomicChangesTest,OnlyFormatWhenViolateColumnLimits)1404 TEST_F(ApplyAtomicChangesTest, OnlyFormatWhenViolateColumnLimits) {
1405 Spec.Format = ApplyChangesSpec::kViolations;
1406 Spec.Style.ColumnLimit = 8;
1407 setInput("int a;\n"
1408 "int a;\n"
1409 "int aaaaaaaa;\n");
1410 Changes.push_back(replacementToAtomicChange("key1", 5, 1, "x"));
1411 Changes.push_back(replacementToAtomicChange("key2", 15, 1, "x"));
1412 Changes.push_back(replacementToAtomicChange("key3", 23, 8, "xx"));
1413 EXPECT_EQ("int x;\n"
1414 "int x;\n"
1415 "int xx;\n",
1416 rewrite());
1417 }
1418
TEST_F(ApplyAtomicChangesTest,LastLineViolateColumnLimits)1419 TEST_F(ApplyAtomicChangesTest, LastLineViolateColumnLimits) {
1420 Spec.Format = ApplyChangesSpec::kViolations;
1421 Spec.Style.ColumnLimit = 8;
1422 setInput("int a;\n"
1423 "int a;");
1424 Changes.push_back(replacementToAtomicChange("key1", 0, 1, "i"));
1425 Changes.push_back(replacementToAtomicChange("key2", 15, 2, "y;"));
1426 EXPECT_EQ("int a;\n"
1427 "int y;",
1428 rewrite());
1429 }
1430
TEST_F(ApplyAtomicChangesTest,LastLineWithNewlineViolateColumnLimits)1431 TEST_F(ApplyAtomicChangesTest, LastLineWithNewlineViolateColumnLimits) {
1432 Spec.Format = ApplyChangesSpec::kViolations;
1433 Spec.Style.ColumnLimit = 8;
1434 setInput("int a;\n"
1435 "int a;\n");
1436 Changes.push_back(replacementToAtomicChange("key1", 0, 1, "i"));
1437 Changes.push_back(replacementToAtomicChange("key2", 14, 3, "y;\n"));
1438 EXPECT_EQ("int a;\n"
1439 "int y;\n",
1440 rewrite());
1441 }
1442
TEST_F(ApplyAtomicChangesTest,Longer)1443 TEST_F(ApplyAtomicChangesTest, Longer) {
1444 setInput("int a;");
1445 Changes.push_back(replacementToAtomicChange("key1", 5, 1, "bbb"));
1446 EXPECT_EQ("int bbb;", rewrite());
1447 }
1448
TEST_F(ApplyAtomicChangesTest,Shorter)1449 TEST_F(ApplyAtomicChangesTest, Shorter) {
1450 setInput("int aaa;");
1451 Changes.push_back(replacementToAtomicChange("key1", 5, 3, "b"));
1452 EXPECT_EQ("int b;", rewrite());
1453 }
1454
TEST_F(ApplyAtomicChangesTest,OnlyFormatChangedLines)1455 TEST_F(ApplyAtomicChangesTest, OnlyFormatChangedLines) {
1456 setInput("int aaa;\n"
1457 "int a = b;\n"
1458 "int bbb;");
1459 Changes.push_back(replacementToAtomicChange("key1", 14, 1, "b"));
1460 EXPECT_EQ("int aaa;\n"
1461 "int b = b;\n"
1462 "int bbb;",
1463 rewrite());
1464 }
1465
TEST_F(ApplyAtomicChangesTest,DisableFormatting)1466 TEST_F(ApplyAtomicChangesTest, DisableFormatting) {
1467 Spec.Format = ApplyChangesSpec::kNone;
1468 setInput("int aaa;\n"
1469 "int a = b;\n"
1470 "int bbb;");
1471 Changes.push_back(replacementToAtomicChange("key1", 14, 1, "b"));
1472 EXPECT_EQ("int aaa;\n"
1473 "int b = b;\n"
1474 "int bbb;",
1475 rewrite());
1476 }
1477
TEST_F(ApplyAtomicChangesTest,AdaptsToLocalPointerStyle)1478 TEST_F(ApplyAtomicChangesTest, AdaptsToLocalPointerStyle) {
1479 setInput("int *aaa;\n"
1480 "int *bbb;");
1481 Changes.push_back(replacementToAtomicChange("key1", 0, 0, "int* ccc;\n"));
1482 EXPECT_EQ("int *ccc;\n"
1483 "int *aaa;\n"
1484 "int *bbb;",
1485 rewrite());
1486 }
1487
TEST_F(ApplyAtomicChangesTest,AcceptsSurroundingFormatting)1488 TEST_F(ApplyAtomicChangesTest, AcceptsSurroundingFormatting) {
1489 setInput(" int aaa;\n"
1490 " int a = b;\n"
1491 " int bbb;");
1492 Changes.push_back(replacementToAtomicChange("key1", 20, 1, "b"));
1493 EXPECT_EQ(" int aaa;\n"
1494 " int b = b;\n"
1495 " int bbb;",
1496 rewrite());
1497 }
1498
TEST_F(ApplyAtomicChangesTest,BailsOutOnConflictingChanges)1499 TEST_F(ApplyAtomicChangesTest, BailsOutOnConflictingChanges) {
1500 setInput("int c;\n"
1501 "int f;");
1502 // Insertions at the same offset are only allowed in the same AtomicChange.
1503 Changes.push_back(replacementToAtomicChange("key1", 0, 0, "int a;\n"));
1504 Changes.push_back(replacementToAtomicChange("key2", 0, 0, "int b;\n"));
1505 EXPECT_EQ("", rewrite(/*FailureExpected=*/true));
1506 }
1507
TEST_F(ApplyAtomicChangesTest,InsertsNewIncludesInRightOrder)1508 TEST_F(ApplyAtomicChangesTest, InsertsNewIncludesInRightOrder) {
1509 setInput("int a;");
1510 Changes.emplace_back(FilePath, "key1");
1511 Changes.back().addHeader("b");
1512 Changes.back().addHeader("c");
1513 Changes.emplace_back(FilePath, "key2");
1514 Changes.back().addHeader("a");
1515 EXPECT_EQ("#include \"a\"\n"
1516 "#include \"b\"\n"
1517 "#include \"c\"\n"
1518 "int a;",
1519 rewrite());
1520 }
1521
TEST_F(ApplyAtomicChangesTest,RemoveAndSortIncludes)1522 TEST_F(ApplyAtomicChangesTest, RemoveAndSortIncludes) {
1523 setInput("#include \"a\"\n"
1524 "#include \"b\"\n"
1525 "#include \"c\"\n"
1526 "\n"
1527 "int a;");
1528 Changes.emplace_back(FilePath, "key1");
1529 Changes.back().removeHeader("b");
1530 EXPECT_EQ("#include \"a\"\n"
1531 "#include \"c\"\n"
1532 "\n"
1533 "int a;",
1534 rewrite());
1535 }
TEST_F(ApplyAtomicChangesTest,InsertsSystemIncludes)1536 TEST_F(ApplyAtomicChangesTest, InsertsSystemIncludes) {
1537 setInput("#include <asys>\n"
1538 "#include <csys>\n"
1539 "\n"
1540 "#include \"a\"\n"
1541 "#include \"c\"\n");
1542 Changes.emplace_back(FilePath, "key1");
1543 Changes.back().addHeader("<asys>"); // Already exists.
1544 Changes.back().addHeader("<b>");
1545 Changes.back().addHeader("<d>");
1546 Changes.back().addHeader("\"b-already-escaped\"");
1547 EXPECT_EQ("#include <asys>\n"
1548 "#include <b>\n"
1549 "#include <csys>\n"
1550 "#include <d>\n"
1551 "\n"
1552 "#include \"a\"\n"
1553 "#include \"b-already-escaped\"\n"
1554 "#include \"c\"\n",
1555 rewrite());
1556 }
1557
TEST_F(ApplyAtomicChangesTest,RemoveSystemIncludes)1558 TEST_F(ApplyAtomicChangesTest, RemoveSystemIncludes) {
1559 setInput("#include <a>\n"
1560 "#include <b>\n"
1561 "\n"
1562 "#include \"c\""
1563 "\n"
1564 "int a;");
1565 Changes.emplace_back(FilePath, "key1");
1566 Changes.back().removeHeader("<a>");
1567 EXPECT_EQ("#include <b>\n"
1568 "\n"
1569 "#include \"c\""
1570 "\n"
1571 "int a;",
1572 rewrite());
1573 }
1574
TEST_F(ApplyAtomicChangesTest,DoNotFormatFollowingLinesIfSeparatedWithNewline)1575 TEST_F(ApplyAtomicChangesTest,
1576 DoNotFormatFollowingLinesIfSeparatedWithNewline) {
1577 setInput("#ifndef __H__\n"
1578 "#define __H__\n"
1579 "#include \"b\"\n"
1580 "\n"
1581 "int a;\n"
1582 "int a;\n"
1583 "int a;\n"
1584 "#endif // __H__\n");
1585 Changes.push_back(replacementToAtomicChange("key1",
1586 llvm::StringRef("#ifndef __H__\n"
1587 "#define __H__\n"
1588 "\n"
1589 "#include \"b\"\n"
1590 "int a;\n"
1591 "int ")
1592 .size(),
1593 1, "b"));
1594 Changes.back().addHeader("a");
1595 EXPECT_EQ("#ifndef __H__\n"
1596 "#define __H__\n"
1597 "#include \"a\"\n"
1598 "#include \"b\"\n"
1599 "\n"
1600 "int a;\n"
1601 "int b;\n"
1602 "int a;\n"
1603 "#endif // __H__\n",
1604 rewrite());
1605 }
1606
TEST_F(ApplyAtomicChangesTest,FormatsCorrectLineWhenHeaderIsRemoved)1607 TEST_F(ApplyAtomicChangesTest, FormatsCorrectLineWhenHeaderIsRemoved) {
1608 setInput("#include \"a\"\n"
1609 "\n"
1610 "int a;\n"
1611 "int a;\n"
1612 "int a;");
1613 Changes.push_back(replacementToAtomicChange("key1", 27, 1, "b"));
1614 Changes.back().removeHeader("a");
1615 EXPECT_EQ("\n"
1616 "int a;\n"
1617 "int b;\n"
1618 "int a;",
1619 rewrite());
1620 }
1621
TEST_F(ApplyAtomicChangesTest,CleansUpCtorInitializers)1622 TEST_F(ApplyAtomicChangesTest, CleansUpCtorInitializers) {
1623 setInput("A::A() : a(), b() {}\n"
1624 "A::A() : a(), b() {}\n"
1625 "A::A() : a(), b() {}\n"
1626 "A::A() : a()/**/, b() {}\n"
1627 "A::A() : a() ,// \n"
1628 " /**/ b() {}");
1629 Changes.emplace_back(FilePath, "key1");
1630 auto Err = Changes.back().replace(Context.Sources, getLoc(9), 3, "");
1631 ASSERT_TRUE(!Err);
1632 Err = Changes.back().replace(Context.Sources, getLoc(35), 3, "");
1633 ASSERT_TRUE(!Err);
1634 Err = Changes.back().replace(Context.Sources, getLoc(51), 3, "");
1635 ASSERT_TRUE(!Err);
1636 Err = Changes.back().replace(Context.Sources, getLoc(56), 3, "");
1637 ASSERT_TRUE(!Err);
1638 Err = Changes.back().replace(Context.Sources, getLoc(72), 3, "");
1639 ASSERT_TRUE(!Err);
1640 Err = Changes.back().replace(Context.Sources, getLoc(97), 3, "");
1641 ASSERT_TRUE(!Err);
1642 Err = Changes.back().replace(Context.Sources, getLoc(118), 3, "");
1643 ASSERT_TRUE(!Err);
1644 EXPECT_EQ("A::A() : b() {}\n"
1645 "A::A() : a() {}\n"
1646 "A::A() {}\n"
1647 "A::A() : b() {}\n"
1648 "A::A() {}",
1649 rewrite());
1650 }
1651
TEST_F(ApplyAtomicChangesTest,CleansUpParameterLists)1652 TEST_F(ApplyAtomicChangesTest, CleansUpParameterLists) {
1653 setInput("void f(int i, float f, string s);\n"
1654 "f(1, 2.0f, \"a\");\n"
1655 "g(1, 1);");
1656 Changes.emplace_back(FilePath, "key1");
1657 auto Err = Changes.back().replace(Context.Sources, getLoc(7), 5, "");
1658 ASSERT_TRUE(!Err);
1659 Err = Changes.back().replace(Context.Sources, getLoc(23), 8, "");
1660 ASSERT_TRUE(!Err);
1661 Err = Changes.back().replace(Context.Sources, getLoc(36), 1, "");
1662 ASSERT_TRUE(!Err);
1663 Err = Changes.back().replace(Context.Sources, getLoc(45), 3, "");
1664 ASSERT_TRUE(!Err);
1665 Err = Changes.back().replace(Context.Sources, getLoc(53), 1, "");
1666 ASSERT_TRUE(!Err);
1667 Err = Changes.back().replace(Context.Sources, getLoc(56), 1, "");
1668 ASSERT_TRUE(!Err);
1669 EXPECT_EQ("void f(float f);\n"
1670 "f(2.0f);\n"
1671 "g();",
1672 rewrite());
1673 }
1674
TEST_F(ApplyAtomicChangesTest,DisableCleanup)1675 TEST_F(ApplyAtomicChangesTest, DisableCleanup) {
1676 Spec.Cleanup = false;
1677 setInput("void f(int i, float f, string s);\n"
1678 "f(1, 2.0f, \"a\");\n"
1679 "g(1, 1);");
1680 Changes.emplace_back(FilePath, "key1");
1681 auto Err = Changes.back().replace(Context.Sources, getLoc(7), 5, "");
1682 ASSERT_TRUE(!Err);
1683 Err = Changes.back().replace(Context.Sources, getLoc(23), 8, "");
1684 ASSERT_TRUE(!Err);
1685 Err = Changes.back().replace(Context.Sources, getLoc(36), 1, "");
1686 ASSERT_TRUE(!Err);
1687 Err = Changes.back().replace(Context.Sources, getLoc(45), 3, "");
1688 ASSERT_TRUE(!Err);
1689 Err = Changes.back().replace(Context.Sources, getLoc(53), 1, "");
1690 ASSERT_TRUE(!Err);
1691 Err = Changes.back().replace(Context.Sources, getLoc(56), 1, "");
1692 ASSERT_TRUE(!Err);
1693 EXPECT_EQ("void f(, float f, );\n"
1694 "f(, 2.0f, );\n"
1695 "g(, );",
1696 rewrite());
1697 }
1698
TEST_F(ApplyAtomicChangesTest,EverythingDeleted)1699 TEST_F(ApplyAtomicChangesTest, EverythingDeleted) {
1700 setInput("int a;");
1701 Changes.push_back(replacementToAtomicChange("key1", 0, 6, ""));
1702 EXPECT_EQ("", rewrite());
1703 }
1704
TEST_F(ApplyAtomicChangesTest,DoesNotDeleteInserts)1705 TEST_F(ApplyAtomicChangesTest, DoesNotDeleteInserts) {
1706 setInput("int a;\n"
1707 "int b;");
1708 Changes.emplace_back(FilePath, "key1");
1709 auto Err = Changes.back().replace(Context.Sources, getLoc(4), 1, "");
1710 ASSERT_TRUE(!Err);
1711 Err = Changes.back().replace(Context.Sources, getLoc(4), 0, "b");
1712 ASSERT_TRUE(!Err);
1713 Err = Changes.back().replace(Context.Sources, getLoc(11), 0, "a");
1714 ASSERT_TRUE(!Err);
1715 Err = Changes.back().replace(Context.Sources, getLoc(11), 1, "");
1716 ASSERT_TRUE(!Err);
1717 EXPECT_EQ("int b;\n"
1718 "int a;",
1719 rewrite());
1720 }
1721
1722 } // end namespace tooling
1723 } // end namespace clang
1724