| 1 |
//===-- IncludeFixerTest.cpp - Include fixer 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 "InMemorySymbolIndex.h" |
| 10 |
#include "IncludeFixer.h" |
| 11 |
#include "SymbolIndexManager.h" |
| 12 |
#include "unittests/Tooling/RewriterTestContext.h" |
| 13 |
#include "clang/Tooling/Tooling.h" |
| 14 |
#include "gtest/gtest.h" |
| 15 |
|
| 16 |
namespace clang { |
| 17 |
namespace include_fixer { |
| 18 |
namespace { |
| 19 |
|
| 20 |
using find_all_symbols::SymbolInfo; |
| 21 |
using find_all_symbols::SymbolAndSignals; |
| 22 |
|
| 23 |
static bool runOnCode(tooling::ToolAction *ToolAction, StringRef Code, |
| 24 |
StringRef FileName, |
| 25 |
const std::vector<std::string> &ExtraArgs) { |
| 26 |
llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem( |
| 27 |
new llvm::vfs::InMemoryFileSystem); |
| 28 |
llvm::IntrusiveRefCntPtr<FileManager> Files( |
| 29 |
new FileManager(FileSystemOptions(), InMemoryFileSystem)); |
| 30 |
// FIXME: Investigate why -fms-compatibility breaks tests. |
| 31 |
std::vector<std::string> Args = {"include_fixer", "-fsyntax-only", |
| 32 |
"-fno-ms-compatibility", |
| 33 |
std::string(FileName)}; |
| 34 |
Args.insert(Args.end(), ExtraArgs.begin(), ExtraArgs.end()); |
| 35 |
tooling::ToolInvocation Invocation( |
| 36 |
Args, ToolAction, Files.get(), |
| 37 |
std::make_shared<PCHContainerOperations>()); |
| 38 |
|
| 39 |
InMemoryFileSystem->addFile(FileName, 0, |
| 40 |
llvm::MemoryBuffer::getMemBuffer(Code)); |
| 41 |
|
| 42 |
InMemoryFileSystem->addFile("foo.h", 0, |
| 43 |
llvm::MemoryBuffer::getMemBuffer("\n")); |
| 44 |
InMemoryFileSystem->addFile("dir/bar.h", 0, |
| 45 |
llvm::MemoryBuffer::getMemBuffer("\n")); |
| 46 |
InMemoryFileSystem->addFile("dir/otherdir/qux.h", 0, |
| 47 |
llvm::MemoryBuffer::getMemBuffer("\n")); |
| 48 |
InMemoryFileSystem->addFile("header.h", 0, |
| 49 |
llvm::MemoryBuffer::getMemBuffer("bar b;")); |
| 50 |
return Invocation.run(); |
| 51 |
} |
| 52 |
|
| 53 |
static std::string runIncludeFixer( |
| 54 |
StringRef Code, |
| 55 |
const std::vector<std::string> &ExtraArgs = std::vector<std::string>()) { |
| 56 |
std::vector<SymbolAndSignals> Symbols = { |
| 57 |
{SymbolInfo("string", SymbolInfo::SymbolKind::Class, "<string>", |
| 58 |
{{SymbolInfo::ContextType::Namespace, "std"}}), |
| 59 |
SymbolInfo::Signals{}}, |
| 60 |
{SymbolInfo("sting", SymbolInfo::SymbolKind::Class, "\"sting\"", |
| 61 |
{{SymbolInfo::ContextType::Namespace, "std"}}), |
| 62 |
SymbolInfo::Signals{}}, |
| 63 |
{SymbolInfo("foo", SymbolInfo::SymbolKind::Class, |
| 64 |
"\"dir/otherdir/qux.h\"", |
| 65 |
{{SymbolInfo::ContextType::Namespace, "b"}, |
| 66 |
{SymbolInfo::ContextType::Namespace, "a"}}), |
| 67 |
SymbolInfo::Signals{}}, |
| 68 |
{SymbolInfo("bar", SymbolInfo::SymbolKind::Class, "\"bar.h\"", |
| 69 |
{{SymbolInfo::ContextType::Namespace, "b"}, |
| 70 |
{SymbolInfo::ContextType::Namespace, "a"}}), |
| 71 |
SymbolInfo::Signals{}}, |
| 72 |
{SymbolInfo("bar", SymbolInfo::SymbolKind::Class, "\"bar2.h\"", |
| 73 |
{{SymbolInfo::ContextType::Namespace, "c"}, |
| 74 |
{SymbolInfo::ContextType::Namespace, "a"}}), |
| 75 |
SymbolInfo::Signals{}}, |
| 76 |
{SymbolInfo("Green", SymbolInfo::SymbolKind::Class, "\"color.h\"", |
| 77 |
{{SymbolInfo::ContextType::EnumDecl, "Color"}, |
| 78 |
{SymbolInfo::ContextType::Namespace, "b"}, |
| 79 |
{SymbolInfo::ContextType::Namespace, "a"}}), |
| 80 |
SymbolInfo::Signals{}}, |
| 81 |
{SymbolInfo("Vector", SymbolInfo::SymbolKind::Class, "\"Vector.h\"", |
| 82 |
{{SymbolInfo::ContextType::Namespace, "__a"}, |
| 83 |
{SymbolInfo::ContextType::Namespace, "a"}}), |
| 84 |
SymbolInfo::Signals{/*Seen=*/2, 0}}, |
| 85 |
{SymbolInfo("Vector", SymbolInfo::SymbolKind::Class, "\"Vector.h\"", |
| 86 |
{{SymbolInfo::ContextType::Namespace, "a"}}), |
| 87 |
SymbolInfo::Signals{/*Seen=*/2, 0}}, |
| 88 |
{SymbolInfo("StrCat", SymbolInfo::SymbolKind::Class, "\"strcat.h\"", |
| 89 |
{{SymbolInfo::ContextType::Namespace, "str"}}), |
| 90 |
SymbolInfo::Signals{}}, |
| 91 |
{SymbolInfo("str", SymbolInfo::SymbolKind::Class, "\"str.h\"", {}), |
| 92 |
SymbolInfo::Signals{}}, |
| 93 |
{SymbolInfo("foo2", SymbolInfo::SymbolKind::Class, "\"foo2.h\"", {}), |
| 94 |
SymbolInfo::Signals{}}, |
| 95 |
}; |
| 96 |
auto SymbolIndexMgr = std::make_unique<SymbolIndexManager>(); |
| 97 |
SymbolIndexMgr->addSymbolIndex( |
| 98 |
[=]() { return std::make_unique<InMemorySymbolIndex>(Symbols); }); |
| 99 |
|
| 100 |
std::vector<IncludeFixerContext> FixerContexts; |
| 101 |
IncludeFixerActionFactory Factory(*SymbolIndexMgr, FixerContexts, "llvm"); |
| 102 |
std::string FakeFileName = "input.cc"; |
| 103 |
runOnCode(&Factory, Code, FakeFileName, ExtraArgs); |
| 104 |
assert(FixerContexts.size() == 1); |
| 105 |
if (FixerContexts.front().getHeaderInfos().empty()) |
| 106 |
return std::string(Code); |
| 107 |
auto Replaces = createIncludeFixerReplacements(Code, FixerContexts.front()); |
| 108 |
EXPECT_TRUE(static_cast<bool>(Replaces)) |
| 109 |
<< llvm::toString(Replaces.takeError()) << "\n"; |
| 110 |
if (!Replaces) |
| 111 |
return ""; |
| 112 |
RewriterTestContext Context; |
| 113 |
FileID ID = Context.createInMemoryFile(FakeFileName, Code); |
| 114 |
tooling::applyAllReplacements(*Replaces, Context.Rewrite); |
| 115 |
return Context.getRewrittenText(ID); |
| 116 |
} |
| 117 |
|
| 118 |
TEST(IncludeFixer, Typo) { |
| 119 |
EXPECT_EQ("#include <string>\nstd::string foo;\n", |
| 120 |
runIncludeFixer("std::string foo;\n")); |
| 121 |
|
| 122 |
EXPECT_EQ("// comment\n#include \"foo.h\"\n#include <string>\n" |
| 123 |
"std::string foo;\n#include \"dir/bar.h\"\n", |
| 124 |
runIncludeFixer("// comment\n#include \"foo.h\"\nstd::string foo;\n" |
| 125 |
"#include \"dir/bar.h\"\n")); |
| 126 |
|
| 127 |
EXPECT_EQ("#include \"foo.h\"\n#include <string>\nstd::string foo;\n", |
| 128 |
runIncludeFixer("#include \"foo.h\"\nstd::string foo;\n")); |
| 129 |
|
| 130 |
EXPECT_EQ( |
| 131 |
"#include \"foo.h\"\n#include <string>\nstd::string::size_type foo;\n", |
| 132 |
runIncludeFixer("#include \"foo.h\"\nstd::string::size_type foo;\n")); |
| 133 |
|
| 134 |
EXPECT_EQ("#include <string>\nstd::string foo;\n", |
| 135 |
runIncludeFixer("string foo;\n")); |
| 136 |
|
| 137 |
// Should not match std::string. |
| 138 |
EXPECT_EQ("::string foo;\n", runIncludeFixer("::string foo;\n")); |
| 139 |
} |
| 140 |
|
| 141 |
TEST(IncludeFixer, IncompleteType) { |
| 142 |
EXPECT_EQ( |
| 143 |
"#include \"foo.h\"\n#include <string>\n" |
| 144 |
"namespace std {\nclass string;\n}\nstd::string foo;\n", |
| 145 |
runIncludeFixer("#include \"foo.h\"\n" |
| 146 |
"namespace std {\nclass string;\n}\nstring foo;\n")); |
| 147 |
|
| 148 |
EXPECT_EQ("#include <string>\n" |
| 149 |
"class string;\ntypedef string foo;\nfoo f;\n", |
| 150 |
runIncludeFixer("class string;\ntypedef string foo;\nfoo f;\n")); |
| 151 |
} |
| 152 |
|
| 153 |
TEST(IncludeFixer, MinimizeInclude) { |
| 154 |
std::vector<std::string> IncludePath = {"-Idir/"}; |
| 155 |
EXPECT_EQ("#include \"otherdir/qux.h\"\na::b::foo bar;\n", |
| 156 |
runIncludeFixer("a::b::foo bar;\n", IncludePath)); |
| 157 |
|
| 158 |
IncludePath = {"-isystemdir"}; |
| 159 |
EXPECT_EQ("#include <otherdir/qux.h>\na::b::foo bar;\n", |
| 160 |
runIncludeFixer("a::b::foo bar;\n", IncludePath)); |
| 161 |
|
| 162 |
IncludePath = {"-iquotedir"}; |
| 163 |
EXPECT_EQ("#include \"otherdir/qux.h\"\na::b::foo bar;\n", |
| 164 |
runIncludeFixer("a::b::foo bar;\n", IncludePath)); |
| 165 |
|
| 166 |
IncludePath = {"-Idir", "-Idir/otherdir"}; |
| 167 |
EXPECT_EQ("#include \"qux.h\"\na::b::foo bar;\n", |
| 168 |
runIncludeFixer("a::b::foo bar;\n", IncludePath)); |
| 169 |
} |
| 170 |
|
| 171 |
TEST(IncludeFixer, NestedName) { |
| 172 |
EXPECT_EQ("#include \"dir/otherdir/qux.h\"\n" |
| 173 |
"int x = a::b::foo(0);\n", |
| 174 |
runIncludeFixer("int x = a::b::foo(0);\n")); |
| 175 |
|
| 176 |
// FIXME: Handle simple macros. |
| 177 |
EXPECT_EQ("#define FOO a::b::foo\nint x = FOO;\n", |
| 178 |
runIncludeFixer("#define FOO a::b::foo\nint x = FOO;\n")); |
| 179 |
EXPECT_EQ("#define FOO(x) a::##x\nint x = FOO(b::foo);\n", |
| 180 |
runIncludeFixer("#define FOO(x) a::##x\nint x = FOO(b::foo);\n")); |
| 181 |
|
| 182 |
// The empty namespace is cleaned up by clang-format after clang-include-fixer |
| 183 |
// finishes. |
| 184 |
EXPECT_EQ("#include \"dir/otherdir/qux.h\"\n" |
| 185 |
"\nint a = a::b::foo(0);\n", |
| 186 |
runIncludeFixer("namespace a {}\nint a = a::b::foo(0);\n")); |
| 187 |
} |
| 188 |
|
| 189 |
TEST(IncludeFixer, MultipleMissingSymbols) { |
| 190 |
EXPECT_EQ("#include <string>\nstd::string bar;\nstd::sting foo;\n", |
| 191 |
runIncludeFixer("std::string bar;\nstd::sting foo;\n")); |
| 192 |
} |
| 193 |
|
| 194 |
TEST(IncludeFixer, ScopedNamespaceSymbols) { |
| 195 |
EXPECT_EQ("#include \"bar.h\"\nnamespace a {\nb::bar b;\n}", |
| 196 |
runIncludeFixer("namespace a {\nb::bar b;\n}")); |
| 197 |
EXPECT_EQ("#include \"bar.h\"\nnamespace A {\na::b::bar b;\n}", |
| 198 |
runIncludeFixer("namespace A {\na::b::bar b;\n}")); |
| 199 |
EXPECT_EQ("#include \"bar.h\"\nnamespace a {\nvoid func() { b::bar b; }\n} " |
| 200 |
"// namespace a", |
| 201 |
runIncludeFixer("namespace a {\nvoid func() { b::bar b; }\n}")); |
| 202 |
EXPECT_EQ("namespace A { c::b::bar b; }\n", |
| 203 |
runIncludeFixer("namespace A { c::b::bar b; }\n")); |
| 204 |
// FIXME: The header should not be added here. Remove this after we support |
| 205 |
// full match. |
| 206 |
EXPECT_EQ("#include \"bar.h\"\nnamespace A {\na::b::bar b;\n}", |
| 207 |
runIncludeFixer("namespace A {\nb::bar b;\n}")); |
| 208 |
|
| 209 |
// Finds candidates for "str::StrCat". |
| 210 |
EXPECT_EQ("#include \"strcat.h\"\nnamespace foo2 {\nstr::StrCat b;\n}", |
| 211 |
runIncludeFixer("namespace foo2 {\nstr::StrCat b;\n}")); |
| 212 |
// str::StrCat2 doesn't exist. |
| 213 |
// In these two cases, StrCat2 is a nested class of class str. |
| 214 |
EXPECT_EQ("#include \"str.h\"\nnamespace foo2 {\nstr::StrCat2 b;\n}", |
| 215 |
runIncludeFixer("namespace foo2 {\nstr::StrCat2 b;\n}")); |
| 216 |
EXPECT_EQ("#include \"str.h\"\nnamespace ns {\nstr::StrCat2 b;\n}", |
| 217 |
runIncludeFixer("namespace ns {\nstr::StrCat2 b;\n}")); |
| 218 |
} |
| 219 |
|
| 220 |
TEST(IncludeFixer, EnumConstantSymbols) { |
| 221 |
EXPECT_EQ("#include \"color.h\"\nint test = a::b::Green;\n", |
| 222 |
runIncludeFixer("int test = a::b::Green;\n")); |
| 223 |
} |
| 224 |
|
| 225 |
TEST(IncludeFixer, IgnoreSymbolFromHeader) { |
| 226 |
std::string Code = "#include \"header.h\""; |
| 227 |
EXPECT_EQ(Code, runIncludeFixer(Code)); |
| 228 |
} |
| 229 |
|
| 230 |
// FIXME: add test cases for inserting and sorting multiple headers when |
| 231 |
// clang-include-fixer supports multiple headers insertion. |
| 232 |
TEST(IncludeFixer, InsertAndSortSingleHeader) { |
| 233 |
// Insert one header. |
| 234 |
std::string Code = "#include \"a.h\"\n" |
| 235 |
"#include \"foo.h\"\n" |
| 236 |
"\n" |
| 237 |
"namespace a {\nb::bar b;\n}\n"; |
| 238 |
std::string Expected = "#include \"a.h\"\n" |
| 239 |
"#include \"bar.h\"\n" |
| 240 |
"#include \"foo.h\"\n" |
| 241 |
"\n" |
| 242 |
"namespace a {\nb::bar b;\n}\n"; |
| 243 |
EXPECT_EQ(Expected, runIncludeFixer(Code)); |
| 244 |
} |
| 245 |
|
| 246 |
TEST(IncludeFixer, DoNotDeleteMatchedSymbol) { |
| 247 |
EXPECT_EQ("#include \"Vector.h\"\na::Vector v;", |
| 248 |
runIncludeFixer("a::Vector v;")); |
| 249 |
} |
| 250 |
|
| 251 |
TEST(IncludeFixer, FixNamespaceQualifiers) { |
| 252 |
EXPECT_EQ("#include \"bar.h\"\na::b::bar b;\n", |
| 253 |
runIncludeFixer("b::bar b;\n")); |
| 254 |
EXPECT_EQ("#include \"bar.h\"\na::b::bar b;\n", |
| 255 |
runIncludeFixer("a::b::bar b;\n")); |
| 256 |
EXPECT_EQ("#include \"bar.h\"\na::b::bar b;\n", |
| 257 |
runIncludeFixer("bar b;\n")); |
| 258 |
EXPECT_EQ("#include \"bar.h\"\nnamespace a {\nb::bar b;\n}\n", |
| 259 |
runIncludeFixer("namespace a {\nb::bar b;\n}\n")); |
| 260 |
EXPECT_EQ("#include \"bar.h\"\nnamespace a {\nb::bar b;\n}\n", |
| 261 |
runIncludeFixer("namespace a {\nbar b;\n}\n")); |
| 262 |
EXPECT_EQ("#include \"bar.h\"\nnamespace a {\nnamespace b{\nbar b;\n}\n} " |
| 263 |
"// namespace a\n", |
| 264 |
runIncludeFixer("namespace a {\nnamespace b{\nbar b;\n}\n}\n")); |
| 265 |
EXPECT_EQ("c::b::bar b;\n", |
| 266 |
runIncludeFixer("c::b::bar b;\n")); |
| 267 |
EXPECT_EQ("#include \"bar.h\"\nnamespace d {\na::b::bar b;\n}\n", |
| 268 |
runIncludeFixer("namespace d {\nbar b;\n}\n")); |
| 269 |
EXPECT_EQ("#include \"bar2.h\"\nnamespace c {\na::c::bar b;\n}\n", |
| 270 |
runIncludeFixer("namespace c {\nbar b;\n}\n")); |
| 271 |
|
| 272 |
// Test common qualifiers reduction. |
| 273 |
EXPECT_EQ("#include \"bar.h\"\nnamespace a {\nnamespace d {\nb::bar b;\n}\n} " |
| 274 |
"// namespace a\n", |
| 275 |
runIncludeFixer("namespace a {\nnamespace d {\nbar b;\n}\n}\n")); |
| 276 |
EXPECT_EQ("#include \"bar.h\"\nnamespace d {\nnamespace a {\na::b::bar " |
| 277 |
"b;\n}\n} // namespace d\n", |
| 278 |
runIncludeFixer("namespace d {\nnamespace a {\nbar b;\n}\n}\n")); |
| 279 |
|
| 280 |
// Test nested classes. |
| 281 |
EXPECT_EQ("#include \"bar.h\"\nnamespace d {\na::b::bar::t b;\n}\n", |
| 282 |
runIncludeFixer("namespace d {\nbar::t b;\n}\n")); |
| 283 |
EXPECT_EQ("#include \"bar.h\"\nnamespace c {\na::b::bar::t b;\n}\n", |
| 284 |
runIncludeFixer("namespace c {\nbar::t b;\n}\n")); |
| 285 |
EXPECT_EQ("#include \"bar.h\"\nnamespace a {\nb::bar::t b;\n}\n", |
| 286 |
runIncludeFixer("namespace a {\nbar::t b;\n}\n")); |
| 287 |
|
| 288 |
EXPECT_EQ("#include \"color.h\"\nint test = a::b::Green;\n", |
| 289 |
runIncludeFixer("int test = Green;\n")); |
| 290 |
EXPECT_EQ("#include \"color.h\"\nnamespace d {\nint test = a::b::Green;\n}\n", |
| 291 |
runIncludeFixer("namespace d {\nint test = Green;\n}\n")); |
| 292 |
EXPECT_EQ("#include \"color.h\"\nnamespace a {\nint test = b::Green;\n}\n", |
| 293 |
runIncludeFixer("namespace a {\nint test = Green;\n}\n")); |
| 294 |
|
| 295 |
// Test global scope operator. |
| 296 |
EXPECT_EQ("#include \"bar.h\"\n::a::b::bar b;\n", |
| 297 |
runIncludeFixer("::a::b::bar b;\n")); |
| 298 |
EXPECT_EQ("#include \"bar.h\"\nnamespace a {\n::a::b::bar b;\n}\n", |
| 299 |
runIncludeFixer("namespace a {\n::a::b::bar b;\n}\n")); |
| 300 |
} |
| 301 |
|
| 302 |
TEST(IncludeFixer, FixNamespaceQualifiersForAllInstances) { |
| 303 |
const char TestCode[] = R"( |
| 304 |
namespace a { |
| 305 |
bar b; |
| 306 |
int func1() { |
| 307 |
bar a; |
| 308 |
bar *p = new bar(); |
| 309 |
return 0; |
| 310 |
} |
| 311 |
} // namespace a |
| 312 |
|
| 313 |
namespace a { |
| 314 |
bar func2() { |
| 315 |
bar f; |
| 316 |
return f; |
| 317 |
} |
| 318 |
} // namespace a |
| 319 |
|
| 320 |
// Non-fixed cases: |
| 321 |
void f() { |
| 322 |
bar b; |
| 323 |
} |
| 324 |
|
| 325 |
namespace a { |
| 326 |
namespace c { |
| 327 |
bar b; |
| 328 |
} // namespace c |
| 329 |
} // namespace a |
| 330 |
)"; |
| 331 |
|
| 332 |
const char ExpectedCode[] = R"( |
| 333 |
#include "bar.h" |
| 334 |
namespace a { |
| 335 |
b::bar b; |
| 336 |
int func1() { |
| 337 |
b::bar a; |
| 338 |
b::bar *p = new b::bar(); |
| 339 |
return 0; |
| 340 |
} |
| 341 |
} // namespace a |
| 342 |
|
| 343 |
namespace a { |
| 344 |
b::bar func2() { |
| 345 |
b::bar f; |
| 346 |
return f; |
| 347 |
} |
| 348 |
} // namespace a |
| 349 |
|
| 350 |
// Non-fixed cases: |
| 351 |
void f() { |
| 352 |
bar b; |
| 353 |
} |
| 354 |
|
| 355 |
namespace a { |
| 356 |
namespace c { |
| 357 |
bar b; |
| 358 |
} // namespace c |
| 359 |
} // namespace a |
| 360 |
)"; |
| 361 |
|
| 362 |
EXPECT_EQ(ExpectedCode, runIncludeFixer(TestCode)); |
| 363 |
} |
| 364 |
|
| 365 |
TEST(IncludeFixer, DontAddQualifiersForMissingCompleteType) { |
| 366 |
EXPECT_EQ("#include \"bar.h\"\nclass bar;\nvoid f() {\nbar* b;\nb->f();\n}", |
| 367 |
runIncludeFixer("class bar;\nvoid f() {\nbar* b;\nb->f();\n}")); |
| 368 |
} |
| 369 |
|
| 370 |
} // namespace |
| 371 |
} // namespace include_fixer |
| 372 |
} // namespace clang |