1 //===- unittest/Tooling/RefactoringTest.cpp - Refactoring unit tests ------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "RewriterTestContext.h"
11 #include "clang/AST/ASTConsumer.h"
12 #include "clang/AST/ASTContext.h"
13 #include "clang/AST/DeclCXX.h"
14 #include "clang/AST/DeclGroup.h"
15 #include "clang/AST/RecursiveASTVisitor.h"
16 #include "clang/Basic/Diagnostic.h"
17 #include "clang/Basic/DiagnosticOptions.h"
18 #include "clang/Basic/FileManager.h"
19 #include "clang/Basic/LangOptions.h"
20 #include "clang/Basic/SourceManager.h"
21 #include "clang/Frontend/CompilerInstance.h"
22 #include "clang/Frontend/FrontendAction.h"
23 #include "clang/Frontend/TextDiagnosticPrinter.h"
24 #include "clang/Rewrite/Core/Rewriter.h"
25 #include "clang/Tooling/Refactoring.h"
26 #include "clang/Tooling/Tooling.h"
27 #include "llvm/ADT/SmallString.h"
28 #include "llvm/Support/Path.h"
29 #include "gtest/gtest.h"
30 
31 namespace clang {
32 namespace tooling {
33 
34 class ReplacementTest : public ::testing::Test {
35  protected:
36   Replacement createReplacement(SourceLocation Start, unsigned Length,
37                                 llvm::StringRef ReplacementText) {
38     return Replacement(Context.Sources, Start, Length, ReplacementText);
39   }
40 
41   RewriterTestContext Context;
42 };
43 
44 TEST_F(ReplacementTest, CanDeleteAllText) {
45   FileID ID = Context.createInMemoryFile("input.cpp", "text");
46   SourceLocation Location = Context.getLocation(ID, 1, 1);
47   Replacement Replace(createReplacement(Location, 4, ""));
48   EXPECT_TRUE(Replace.apply(Context.Rewrite));
49   EXPECT_EQ("", Context.getRewrittenText(ID));
50 }
51 
52 TEST_F(ReplacementTest, CanDeleteAllTextInTextWithNewlines) {
53   FileID ID = Context.createInMemoryFile("input.cpp", "line1\nline2\nline3");
54   SourceLocation Location = Context.getLocation(ID, 1, 1);
55   Replacement Replace(createReplacement(Location, 17, ""));
56   EXPECT_TRUE(Replace.apply(Context.Rewrite));
57   EXPECT_EQ("", Context.getRewrittenText(ID));
58 }
59 
60 TEST_F(ReplacementTest, CanAddText) {
61   FileID ID = Context.createInMemoryFile("input.cpp", "");
62   SourceLocation Location = Context.getLocation(ID, 1, 1);
63   Replacement Replace(createReplacement(Location, 0, "result"));
64   EXPECT_TRUE(Replace.apply(Context.Rewrite));
65   EXPECT_EQ("result", Context.getRewrittenText(ID));
66 }
67 
68 TEST_F(ReplacementTest, CanReplaceTextAtPosition) {
69   FileID ID = Context.createInMemoryFile("input.cpp",
70                                          "line1\nline2\nline3\nline4");
71   SourceLocation Location = Context.getLocation(ID, 2, 3);
72   Replacement Replace(createReplacement(Location, 12, "x"));
73   EXPECT_TRUE(Replace.apply(Context.Rewrite));
74   EXPECT_EQ("line1\nlixne4", Context.getRewrittenText(ID));
75 }
76 
77 TEST_F(ReplacementTest, CanReplaceTextAtPositionMultipleTimes) {
78   FileID ID = Context.createInMemoryFile("input.cpp",
79                                          "line1\nline2\nline3\nline4");
80   SourceLocation Location1 = Context.getLocation(ID, 2, 3);
81   Replacement Replace1(createReplacement(Location1, 12, "x\ny\n"));
82   EXPECT_TRUE(Replace1.apply(Context.Rewrite));
83   EXPECT_EQ("line1\nlix\ny\nne4", Context.getRewrittenText(ID));
84 
85   // Since the original source has not been modified, the (4, 4) points to the
86   // 'e' in the original content.
87   SourceLocation Location2 = Context.getLocation(ID, 4, 4);
88   Replacement Replace2(createReplacement(Location2, 1, "f"));
89   EXPECT_TRUE(Replace2.apply(Context.Rewrite));
90   EXPECT_EQ("line1\nlix\ny\nnf4", Context.getRewrittenText(ID));
91 }
92 
93 TEST_F(ReplacementTest, ApplyFailsForNonExistentLocation) {
94   Replacement Replace("nonexistent-file.cpp", 0, 1, "");
95   EXPECT_FALSE(Replace.apply(Context.Rewrite));
96 }
97 
98 TEST_F(ReplacementTest, CanRetrivePath) {
99   Replacement Replace("/path/to/file.cpp", 0, 1, "");
100   EXPECT_EQ("/path/to/file.cpp", Replace.getFilePath());
101 }
102 
103 TEST_F(ReplacementTest, ReturnsInvalidPath) {
104   Replacement Replace1(Context.Sources, SourceLocation(), 0, "");
105   EXPECT_TRUE(Replace1.getFilePath().empty());
106 
107   Replacement Replace2;
108   EXPECT_TRUE(Replace2.getFilePath().empty());
109 }
110 
111 TEST_F(ReplacementTest, CanApplyReplacements) {
112   FileID ID = Context.createInMemoryFile("input.cpp",
113                                          "line1\nline2\nline3\nline4");
114   Replacements Replaces;
115   Replaces.insert(Replacement(Context.Sources, Context.getLocation(ID, 2, 1),
116                               5, "replaced"));
117   Replaces.insert(Replacement(Context.Sources, Context.getLocation(ID, 3, 1),
118                               5, "other"));
119   EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
120   EXPECT_EQ("line1\nreplaced\nother\nline4", Context.getRewrittenText(ID));
121 }
122 
123 // FIXME: Remove this test case when Replacements is implemented as std::vector
124 // instead of std::set. The other ReplacementTest tests will need to be updated
125 // at that point as well.
126 TEST_F(ReplacementTest, VectorCanApplyReplacements) {
127   FileID ID = Context.createInMemoryFile("input.cpp",
128                                          "line1\nline2\nline3\nline4");
129   std::vector<Replacement> Replaces;
130   Replaces.push_back(Replacement(Context.Sources, Context.getLocation(ID, 2, 1),
131                                  5, "replaced"));
132   Replaces.push_back(
133       Replacement(Context.Sources, Context.getLocation(ID, 3, 1), 5, "other"));
134   EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
135   EXPECT_EQ("line1\nreplaced\nother\nline4", Context.getRewrittenText(ID));
136 }
137 
138 TEST_F(ReplacementTest, SkipsDuplicateReplacements) {
139   FileID ID = Context.createInMemoryFile("input.cpp",
140                                          "line1\nline2\nline3\nline4");
141   Replacements Replaces;
142   Replaces.insert(Replacement(Context.Sources, Context.getLocation(ID, 2, 1),
143                               5, "replaced"));
144   Replaces.insert(Replacement(Context.Sources, Context.getLocation(ID, 2, 1),
145                               5, "replaced"));
146   Replaces.insert(Replacement(Context.Sources, Context.getLocation(ID, 2, 1),
147                               5, "replaced"));
148   EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
149   EXPECT_EQ("line1\nreplaced\nline3\nline4", Context.getRewrittenText(ID));
150 }
151 
152 TEST_F(ReplacementTest, ApplyAllFailsIfOneApplyFails) {
153   // This test depends on the value of the file name of an invalid source
154   // location being in the range ]a, z[.
155   FileID IDa = Context.createInMemoryFile("a.cpp", "text");
156   FileID IDz = Context.createInMemoryFile("z.cpp", "text");
157   Replacements Replaces;
158   Replaces.insert(Replacement(Context.Sources, Context.getLocation(IDa, 1, 1),
159                               4, "a"));
160   Replaces.insert(Replacement(Context.Sources, SourceLocation(),
161                               5, "2"));
162   Replaces.insert(Replacement(Context.Sources, Context.getLocation(IDz, 1, 1),
163                               4, "z"));
164   EXPECT_FALSE(applyAllReplacements(Replaces, Context.Rewrite));
165   EXPECT_EQ("a", Context.getRewrittenText(IDa));
166   EXPECT_EQ("z", Context.getRewrittenText(IDz));
167 }
168 
169 TEST(ShiftedCodePositionTest, FindsNewCodePosition) {
170   Replacements Replaces;
171   Replaces.insert(Replacement("", 0, 1, ""));
172   Replaces.insert(Replacement("", 4, 3, " "));
173   // Assume ' int   i;' is turned into 'int i;' and cursor is located at '|'.
174   EXPECT_EQ(0u, shiftedCodePosition(Replaces, 0)); // |int   i;
175   EXPECT_EQ(0u, shiftedCodePosition(Replaces, 1)); //  |nt   i;
176   EXPECT_EQ(1u, shiftedCodePosition(Replaces, 2)); //  i|t   i;
177   EXPECT_EQ(2u, shiftedCodePosition(Replaces, 3)); //  in|   i;
178   EXPECT_EQ(3u, shiftedCodePosition(Replaces, 4)); //  int|  i;
179   EXPECT_EQ(4u, shiftedCodePosition(Replaces, 5)); //  int | i;
180   EXPECT_EQ(4u, shiftedCodePosition(Replaces, 6)); //  int  |i;
181   EXPECT_EQ(4u, shiftedCodePosition(Replaces, 7)); //  int   |;
182   EXPECT_EQ(5u, shiftedCodePosition(Replaces, 8)); //  int   i|
183 }
184 
185 // FIXME: Remove this test case when Replacements is implemented as std::vector
186 // instead of std::set. The other ReplacementTest tests will need to be updated
187 // at that point as well.
188 TEST(ShiftedCodePositionTest, VectorFindsNewCodePositionWithInserts) {
189   std::vector<Replacement> Replaces;
190   Replaces.push_back(Replacement("", 0, 1, ""));
191   Replaces.push_back(Replacement("", 4, 3, " "));
192   // Assume ' int   i;' is turned into 'int i;' and cursor is located at '|'.
193   EXPECT_EQ(0u, shiftedCodePosition(Replaces, 0)); // |int   i;
194   EXPECT_EQ(0u, shiftedCodePosition(Replaces, 1)); //  |nt   i;
195   EXPECT_EQ(1u, shiftedCodePosition(Replaces, 2)); //  i|t   i;
196   EXPECT_EQ(2u, shiftedCodePosition(Replaces, 3)); //  in|   i;
197   EXPECT_EQ(3u, shiftedCodePosition(Replaces, 4)); //  int|  i;
198   EXPECT_EQ(4u, shiftedCodePosition(Replaces, 5)); //  int | i;
199   EXPECT_EQ(4u, shiftedCodePosition(Replaces, 6)); //  int  |i;
200   EXPECT_EQ(4u, shiftedCodePosition(Replaces, 7)); //  int   |;
201   EXPECT_EQ(5u, shiftedCodePosition(Replaces, 8)); //  int   i|
202 }
203 
204 TEST(ShiftedCodePositionTest, FindsNewCodePositionWithInserts) {
205   Replacements Replaces;
206   Replaces.insert(Replacement("", 4, 0, "\"\n\""));
207   // Assume '"12345678"' is turned into '"1234"\n"5678"'.
208   EXPECT_EQ(4u, shiftedCodePosition(Replaces, 4)); // "123|5678"
209   EXPECT_EQ(8u, shiftedCodePosition(Replaces, 5)); // "1234|678"
210 }
211 
212 class FlushRewrittenFilesTest : public ::testing::Test {
213 public:
214    FlushRewrittenFilesTest() {}
215 
216   ~FlushRewrittenFilesTest() {
217     for (llvm::StringMap<std::string>::iterator I = TemporaryFiles.begin(),
218                                                 E = TemporaryFiles.end();
219          I != E; ++I) {
220       llvm::StringRef Name = I->second;
221       llvm::error_code EC = llvm::sys::fs::remove(Name);
222       (void)EC;
223       assert(!EC);
224     }
225   }
226 
227   FileID createFile(llvm::StringRef Name, llvm::StringRef Content) {
228     SmallString<1024> Path;
229     int FD;
230     llvm::error_code EC =
231         llvm::sys::fs::createTemporaryFile(Name, "", FD, Path);
232     assert(!EC);
233     (void)EC;
234 
235     llvm::raw_fd_ostream OutStream(FD, true);
236     OutStream << Content;
237     OutStream.close();
238     const FileEntry *File = Context.Files.getFile(Path);
239     assert(File != NULL);
240 
241     StringRef Found = TemporaryFiles.GetOrCreateValue(Name, Path.str()).second;
242     assert(Found == Path);
243     (void)Found;
244     return Context.Sources.createFileID(File, SourceLocation(), SrcMgr::C_User);
245   }
246 
247   std::string getFileContentFromDisk(llvm::StringRef Name) {
248     std::string Path = TemporaryFiles.lookup(Name);
249     assert(!Path.empty());
250     // We need to read directly from the FileManager without relaying through
251     // a FileEntry, as otherwise we'd read through an already opened file
252     // descriptor, which might not see the changes made.
253     // FIXME: Figure out whether there is a way to get the SourceManger to
254     // reopen the file.
255     return Context.Files.getBufferForFile(Path, NULL)->getBuffer();
256   }
257 
258   llvm::StringMap<std::string> TemporaryFiles;
259   RewriterTestContext Context;
260 };
261 
262 TEST_F(FlushRewrittenFilesTest, StoresChangesOnDisk) {
263   FileID ID = createFile("input.cpp", "line1\nline2\nline3\nline4");
264   Replacements Replaces;
265   Replaces.insert(Replacement(Context.Sources, Context.getLocation(ID, 2, 1),
266                               5, "replaced"));
267   EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
268   EXPECT_FALSE(Context.Rewrite.overwriteChangedFiles());
269   EXPECT_EQ("line1\nreplaced\nline3\nline4",
270             getFileContentFromDisk("input.cpp"));
271 }
272 
273 namespace {
274 template <typename T>
275 class TestVisitor : public clang::RecursiveASTVisitor<T> {
276 public:
277   bool runOver(StringRef Code) {
278     return runToolOnCode(new TestAction(this), Code);
279   }
280 
281 protected:
282   clang::SourceManager *SM;
283 
284 private:
285   class FindConsumer : public clang::ASTConsumer {
286   public:
287     FindConsumer(TestVisitor *Visitor) : Visitor(Visitor) {}
288 
289     virtual void HandleTranslationUnit(clang::ASTContext &Context) {
290       Visitor->TraverseDecl(Context.getTranslationUnitDecl());
291     }
292 
293   private:
294     TestVisitor *Visitor;
295   };
296 
297   class TestAction : public clang::ASTFrontendAction {
298   public:
299     TestAction(TestVisitor *Visitor) : Visitor(Visitor) {}
300 
301     virtual clang::ASTConsumer* CreateASTConsumer(
302         clang::CompilerInstance& compiler, llvm::StringRef dummy) {
303       Visitor->SM = &compiler.getSourceManager();
304       /// TestConsumer will be deleted by the framework calling us.
305       return new FindConsumer(Visitor);
306     }
307 
308   private:
309     TestVisitor *Visitor;
310   };
311 };
312 } // end namespace
313 
314 void expectReplacementAt(const Replacement &Replace,
315                          StringRef File, unsigned Offset, unsigned Length) {
316   ASSERT_TRUE(Replace.isApplicable());
317   EXPECT_EQ(File, Replace.getFilePath());
318   EXPECT_EQ(Offset, Replace.getOffset());
319   EXPECT_EQ(Length, Replace.getLength());
320 }
321 
322 class ClassDeclXVisitor : public TestVisitor<ClassDeclXVisitor> {
323 public:
324   bool VisitCXXRecordDecl(CXXRecordDecl *Record) {
325     if (Record->getName() == "X") {
326       Replace = Replacement(*SM, Record, "");
327     }
328     return true;
329   }
330   Replacement Replace;
331 };
332 
333 TEST(Replacement, CanBeConstructedFromNode) {
334   ClassDeclXVisitor ClassDeclX;
335   EXPECT_TRUE(ClassDeclX.runOver("     class X;"));
336   expectReplacementAt(ClassDeclX.Replace, "input.cc", 5, 7);
337 }
338 
339 TEST(Replacement, ReplacesAtSpellingLocation) {
340   ClassDeclXVisitor ClassDeclX;
341   EXPECT_TRUE(ClassDeclX.runOver("#define A(Y) Y\nA(class X);"));
342   expectReplacementAt(ClassDeclX.Replace, "input.cc", 17, 7);
343 }
344 
345 class CallToFVisitor : public TestVisitor<CallToFVisitor> {
346 public:
347   bool VisitCallExpr(CallExpr *Call) {
348     if (Call->getDirectCallee()->getName() == "F") {
349       Replace = Replacement(*SM, Call, "");
350     }
351     return true;
352   }
353   Replacement Replace;
354 };
355 
356 TEST(Replacement, FunctionCall) {
357   CallToFVisitor CallToF;
358   EXPECT_TRUE(CallToF.runOver("void F(); void G() { F(); }"));
359   expectReplacementAt(CallToF.Replace, "input.cc", 21, 3);
360 }
361 
362 TEST(Replacement, TemplatedFunctionCall) {
363   CallToFVisitor CallToF;
364   EXPECT_TRUE(CallToF.runOver(
365         "template <typename T> void F(); void G() { F<int>(); }"));
366   expectReplacementAt(CallToF.Replace, "input.cc", 43, 8);
367 }
368 
369 TEST(Range, overlaps) {
370   EXPECT_TRUE(Range(10, 10).overlapsWith(Range(0, 11)));
371   EXPECT_TRUE(Range(0, 11).overlapsWith(Range(10, 10)));
372   EXPECT_FALSE(Range(10, 10).overlapsWith(Range(0, 10)));
373   EXPECT_FALSE(Range(0, 10).overlapsWith(Range(10, 10)));
374   EXPECT_TRUE(Range(0, 10).overlapsWith(Range(2, 6)));
375   EXPECT_TRUE(Range(2, 6).overlapsWith(Range(0, 10)));
376 }
377 
378 TEST(Range, contains) {
379   EXPECT_TRUE(Range(0, 10).contains(Range(0, 10)));
380   EXPECT_TRUE(Range(0, 10).contains(Range(2, 6)));
381   EXPECT_FALSE(Range(2, 6).contains(Range(0, 10)));
382   EXPECT_FALSE(Range(0, 10).contains(Range(0, 11)));
383 }
384 
385 TEST(DeduplicateTest, removesDuplicates) {
386   std::vector<Replacement> Input;
387   Input.push_back(Replacement("fileA", 50, 0, " foo "));
388   Input.push_back(Replacement("fileA", 10, 3, " bar "));
389   Input.push_back(Replacement("fileA", 10, 2, " bar ")); // Length differs
390   Input.push_back(Replacement("fileA", 9,  3, " bar ")); // Offset differs
391   Input.push_back(Replacement("fileA", 50, 0, " foo ")); // Duplicate
392   Input.push_back(Replacement("fileA", 51, 3, " bar "));
393   Input.push_back(Replacement("fileB", 51, 3, " bar ")); // Filename differs!
394   Input.push_back(Replacement("fileA", 51, 3, " moo ")); // Replacement text
395                                                          // differs!
396 
397   std::vector<Replacement> Expected;
398   Expected.push_back(Replacement("fileA", 9,  3, " bar "));
399   Expected.push_back(Replacement("fileA", 10, 2, " bar "));
400   Expected.push_back(Replacement("fileA", 10, 3, " bar "));
401   Expected.push_back(Replacement("fileA", 50, 0, " foo "));
402   Expected.push_back(Replacement("fileA", 51, 3, " bar "));
403   Expected.push_back(Replacement("fileA", 51, 3, " moo "));
404   Expected.push_back(Replacement("fileB", 51, 3, " bar "));
405 
406   std::vector<Range> Conflicts; // Ignored for this test
407   deduplicate(Input, Conflicts);
408 
409   ASSERT_TRUE(Expected == Input);
410 }
411 
412 TEST(DeduplicateTest, detectsConflicts) {
413   {
414     std::vector<Replacement> Input;
415     Input.push_back(Replacement("fileA", 0, 5, " foo "));
416     Input.push_back(Replacement("fileA", 0, 5, " foo ")); // Duplicate not a
417                                                           // conflict.
418     Input.push_back(Replacement("fileA", 2, 6, " bar "));
419     Input.push_back(Replacement("fileA", 7, 3, " moo "));
420 
421     std::vector<Range> Conflicts;
422     deduplicate(Input, Conflicts);
423 
424     // One duplicate is removed and the remaining three items form one
425     // conflicted range.
426     ASSERT_EQ(3u, Input.size());
427     ASSERT_EQ(1u, Conflicts.size());
428     ASSERT_EQ(0u, Conflicts.front().getOffset());
429     ASSERT_EQ(3u, Conflicts.front().getLength());
430   }
431   {
432     std::vector<Replacement> Input;
433 
434     // Expected sorted order is shown. It is the sorted order to which the
435     // returned conflict info refers to.
436     Input.push_back(Replacement("fileA", 0,  5, " foo "));  // 0
437     Input.push_back(Replacement("fileA", 5,  5, " bar "));  // 1
438     Input.push_back(Replacement("fileA", 6,  0, " bar "));  // 3
439     Input.push_back(Replacement("fileA", 5,  5, " moo "));  // 2
440     Input.push_back(Replacement("fileA", 7,  2, " bar "));  // 4
441     Input.push_back(Replacement("fileA", 15, 5, " golf ")); // 5
442     Input.push_back(Replacement("fileA", 16, 5, " bag "));  // 6
443     Input.push_back(Replacement("fileA", 10, 3, " club ")); // 7
444 
445     // #3 is special in that it is completely contained by another conflicting
446     // Replacement. #4 ensures #3 hasn't messed up the conflicting range size.
447 
448     std::vector<Range> Conflicts;
449     deduplicate(Input, Conflicts);
450 
451     // No duplicates
452     ASSERT_EQ(8u, Input.size());
453     ASSERT_EQ(2u, Conflicts.size());
454     ASSERT_EQ(1u, Conflicts[0].getOffset());
455     ASSERT_EQ(4u, Conflicts[0].getLength());
456     ASSERT_EQ(6u, Conflicts[1].getOffset());
457     ASSERT_EQ(2u, Conflicts[1].getLength());
458   }
459 }
460 
461 } // end namespace tooling
462 } // end namespace clang
463