Debian Codegraph @

llvm-project/clang-tools-extra/clangd/unittests/CompileCommandsTests.cpp

raw
1 //===-- CompileCommandsTests.cpp ------------------------------------------===//
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 "CompileCommands.h"
10 #include "Config.h"
11 #include "TestFS.h"
12 #include "support/Context.h"
13
14 #include "clang/Tooling/ArgumentsAdjusters.h"
15 #include "llvm/ADT/ArrayRef.h"
16 #include "llvm/ADT/STLExtras.h"
17 #include "llvm/ADT/ScopeExit.h"
18 #include "llvm/ADT/StringExtras.h"
19 #include "llvm/ADT/StringRef.h"
20 #include "llvm/Support/FileSystem.h"
21 #include "llvm/Support/Path.h"
22 #include "llvm/Support/Process.h"
23
24 #include "gmock/gmock.h"
25 #include "gtest/gtest.h"
26
27 namespace clang {
28 namespace clangd {
29 namespace {
30
31 using ::testing::_;
32 using ::testing::Contains;
33 using ::testing::ElementsAre;
34 using ::testing::HasSubstr;
35 using ::testing::Not;
36
37 // Sadly, CommandMangler::detect(), which contains much of the logic, is
38 // a bunch of untested integration glue. We test the string manipulation here
39 // assuming its results are correct.
40
41 // Make use of all features and assert the exact command we get out.
42 // Other tests just verify presence/absence of certain args.
43 TEST(CommandMangler, Everything) {
44 auto Mangler = CommandMangler::forTests();
45 Mangler.ClangPath = testPath("fake/clang");
46 Mangler.ResourceDir = testPath("fake/resources");
47 Mangler.Sysroot = testPath("fake/sysroot");
48 tooling::CompileCommand Cmd;
49 Cmd.CommandLine = {"clang++", "--", "foo.cc", "bar.cc"};
50 Mangler(Cmd, "foo.cc");
51 EXPECT_THAT(Cmd.CommandLine,
52 ElementsAre(testPath("fake/clang++"),
53 "-resource-dir=" + testPath("fake/resources"),
54 "-isysroot", testPath("fake/sysroot"), "--",
55 "foo.cc"));
56 }
57
58 TEST(CommandMangler, FilenameMismatch) {
59 auto Mangler = CommandMangler::forTests();
60 Mangler.ClangPath = testPath("clang");
61 // Our compile flags refer to foo.cc...
62 tooling::CompileCommand Cmd;
63 Cmd.CommandLine = {"clang", "foo.cc"};
64 // but we're applying it to foo.h...
65 Mangler(Cmd, "foo.h");
66 // so transferCompileCommand should add -x c++-header to preserve semantics.
67 EXPECT_THAT(Cmd.CommandLine, ElementsAre(testPath("clang"), "-x",
68 "c++-header", "--", "foo.h"));
69 }
70
71 TEST(CommandMangler, ResourceDir) {
72 auto Mangler = CommandMangler::forTests();
73 Mangler.ResourceDir = testPath("fake/resources");
74 tooling::CompileCommand Cmd;
75 Cmd.CommandLine = {"clang++", "foo.cc"};
76 Mangler(Cmd, "foo.cc");
77 EXPECT_THAT(Cmd.CommandLine,
78 Contains("-resource-dir=" + testPath("fake/resources")));
79 }
80
81 TEST(CommandMangler, Sysroot) {
82 auto Mangler = CommandMangler::forTests();
83 Mangler.Sysroot = testPath("fake/sysroot");
84
85 tooling::CompileCommand Cmd;
86 Cmd.CommandLine = {"clang++", "foo.cc"};
87 Mangler(Cmd, "foo.cc");
88 EXPECT_THAT(llvm::join(Cmd.CommandLine, " "),
89 HasSubstr("-isysroot " + testPath("fake/sysroot")));
90 }
91
92 TEST(CommandMangler, ClangPath) {
93 auto Mangler = CommandMangler::forTests();
94 Mangler.ClangPath = testPath("fake/clang");
95
96 tooling::CompileCommand Cmd;
97 Cmd.CommandLine = {"clang++", "foo.cc"};
98 Mangler(Cmd, "foo.cc");
99 EXPECT_EQ(testPath("fake/clang++"), Cmd.CommandLine.front());
100
101 Cmd.CommandLine = {"unknown-binary", "foo.cc"};
102 Mangler(Cmd, "foo.cc");
103 EXPECT_EQ(testPath("fake/unknown-binary"), Cmd.CommandLine.front());
104
105 Cmd.CommandLine = {testPath("path/clang++"), "foo.cc"};
106 Mangler(Cmd, "foo.cc");
107 EXPECT_EQ(testPath("path/clang++"), Cmd.CommandLine.front());
108
109 Cmd.CommandLine = {"foo/unknown-binary", "foo.cc"};
110 Mangler(Cmd, "foo.cc");
111 EXPECT_EQ("foo/unknown-binary", Cmd.CommandLine.front());
112 }
113
114 // Only run the PATH/symlink resolving test on unix, we need to fiddle
115 // with permissions and environment variables...
116 #ifdef LLVM_ON_UNIX
117 MATCHER(ok, "") {
118 if (arg) {
119 *result_listener << arg.message();
120 return false;
121 }
122 return true;
123 }
124
125 TEST(CommandMangler, ClangPathResolve) {
126 // Set up filesystem:
127 // /temp/
128 // bin/
129 // foo -> temp/lib/bar
130 // lib/
131 // bar
132 llvm::SmallString<256> TempDir;
133 ASSERT_THAT(llvm::sys::fs::createUniqueDirectory("ClangPathResolve", TempDir),
134 ok());
135 // /var/tmp is a symlink on Mac. Resolve it so we're asserting the right path.
136 ASSERT_THAT(llvm::sys::fs::real_path(TempDir.str(), TempDir), ok());
137 auto CleanDir = llvm::make_scope_exit(
138 [&] { llvm::sys::fs::remove_directories(TempDir); });
139 ASSERT_THAT(llvm::sys::fs::create_directory(TempDir + "/bin"), ok());
140 ASSERT_THAT(llvm::sys::fs::create_directory(TempDir + "/lib"), ok());
141 int FD;
142 ASSERT_THAT(llvm::sys::fs::openFileForWrite(TempDir + "/lib/bar", FD), ok());
143 ASSERT_THAT(llvm::sys::Process::SafelyCloseFileDescriptor(FD), ok());
144 ::chmod((TempDir + "/lib/bar").str().c_str(), 0755); // executable
145 ASSERT_THAT(
146 llvm::sys::fs::create_link(TempDir + "/lib/bar", TempDir + "/bin/foo"),
147 ok());
148
149 // Test the case where the driver is an absolute path to a symlink.
150 auto Mangler = CommandMangler::forTests();
151 Mangler.ClangPath = testPath("fake/clang");
152 tooling::CompileCommand Cmd;
153 Cmd.CommandLine = {(TempDir + "/bin/foo").str(), "foo.cc"};
154 Mangler(Cmd, "foo.cc");
155 // Directory based on resolved symlink, basename preserved.
156 EXPECT_EQ((TempDir + "/lib/foo").str(), Cmd.CommandLine.front());
157
158 // Set PATH to point to temp/bin so we can find 'foo' on it.
159 ASSERT_TRUE(::getenv("PATH"));
160 auto RestorePath =
161 llvm::make_scope_exit([OldPath = std::string(::getenv("PATH"))] {
162 ::setenv("PATH", OldPath.c_str(), 1);
163 });
164 ::setenv("PATH", (TempDir + "/bin").str().c_str(), /*overwrite=*/1);
165
166 // Test the case where the driver is a $PATH-relative path to a symlink.
167 Mangler = CommandMangler::forTests();
168 Mangler.ClangPath = testPath("fake/clang");
169 // Driver found on PATH.
170 Cmd.CommandLine = {"foo", "foo.cc"};
171 Mangler(Cmd, "foo.cc");
172 // Found the symlink and resolved the path as above.
173 EXPECT_EQ((TempDir + "/lib/foo").str(), Cmd.CommandLine.front());
174
175 // Symlink not resolved with -no-canonical-prefixes.
176 Cmd.CommandLine = {"foo", "-no-canonical-prefixes", "foo.cc"};
177 Mangler(Cmd, "foo.cc");
178 EXPECT_EQ((TempDir + "/bin/foo").str(), Cmd.CommandLine.front());
179 }
180 #endif
181
182 TEST(CommandMangler, ConfigEdits) {
183 auto Mangler = CommandMangler::forTests();
184 tooling::CompileCommand Cmd;
185 Cmd.CommandLine = {"clang++", "foo.cc"};
186 {
187 Config Cfg;
188 Cfg.CompileFlags.Edits.push_back([](std::vector<std::string> &Argv) {
189 for (auto &Arg : Argv)
190 for (char &C : Arg)
191 C = llvm::toUpper(C);
192 });
193 Cfg.CompileFlags.Edits.push_back([](std::vector<std::string> &Argv) {
194 Argv = tooling::getInsertArgumentAdjuster("--hello")(Argv, "");
195 });
196 WithContextValue WithConfig(Config::Key, std::move(Cfg));
197 Mangler(Cmd, "foo.cc");
198 }
199 // Edits are applied in given order and before other mangling and they always
200 // go before filename.
201 EXPECT_THAT(Cmd.CommandLine, ElementsAre(_, "--hello", "--", "FOO.CC"));
202 }
203
204 static std::string strip(llvm::StringRef Arg, llvm::StringRef Argv) {
205 llvm::SmallVector<llvm::StringRef> Parts;
206 llvm::SplitString(Argv, Parts);
207 std::vector<std::string> Args = {Parts.begin(), Parts.end()};
208 ArgStripper S;
209 S.strip(Arg);
210 S.process(Args);
211 return printArgv(Args);
212 }
213
214 TEST(ArgStripperTest, Spellings) {
215 // May use alternate prefixes.
216 EXPECT_EQ(strip("-pedantic", "clang -pedantic foo.cc"), "clang foo.cc");
217 EXPECT_EQ(strip("-pedantic", "clang --pedantic foo.cc"), "clang foo.cc");
218 EXPECT_EQ(strip("--pedantic", "clang -pedantic foo.cc"), "clang foo.cc");
219 EXPECT_EQ(strip("--pedantic", "clang --pedantic foo.cc"), "clang foo.cc");
220 // May use alternate names.
221 EXPECT_EQ(strip("-x", "clang -x c++ foo.cc"), "clang foo.cc");
222 EXPECT_EQ(strip("-x", "clang --language=c++ foo.cc"), "clang foo.cc");
223 EXPECT_EQ(strip("--language=", "clang -x c++ foo.cc"), "clang foo.cc");
224 EXPECT_EQ(strip("--language=", "clang --language=c++ foo.cc"),
225 "clang foo.cc");
226 }
227
228 TEST(ArgStripperTest, UnknownFlag) {
229 EXPECT_EQ(strip("-xyzzy", "clang -xyzzy foo.cc"), "clang foo.cc");
230 EXPECT_EQ(strip("-xyz*", "clang -xyzzy foo.cc"), "clang foo.cc");
231 EXPECT_EQ(strip("-xyzzy", "clang -Xclang -xyzzy foo.cc"), "clang foo.cc");
232 }
233
234 TEST(ArgStripperTest, Xclang) {
235 // Flags may be -Xclang escaped.
236 EXPECT_EQ(strip("-ast-dump", "clang -Xclang -ast-dump foo.cc"),
237 "clang foo.cc");
238 // Args may be -Xclang escaped.
239 EXPECT_EQ(strip("-add-plugin", "clang -Xclang -add-plugin -Xclang z foo.cc"),
240 "clang foo.cc");
241 }
242
243 TEST(ArgStripperTest, ClangCL) {
244 // /I is a synonym for -I in clang-cl mode only.
245 // Not stripped by default.
246 EXPECT_EQ(strip("-I", "clang -I /usr/inc /Interesting/file.cc"),
247 "clang /Interesting/file.cc");
248 // Stripped when invoked as clang-cl.
249 EXPECT_EQ(strip("-I", "clang-cl -I /usr/inc /Interesting/file.cc"),
250 "clang-cl");
251 // Stripped when invoked as CL.EXE
252 EXPECT_EQ(strip("-I", "CL.EXE -I /usr/inc /Interesting/file.cc"), "CL.EXE");
253 // Stripped when passed --driver-mode=cl.
254 EXPECT_EQ(strip("-I", "cc -I /usr/inc /Interesting/file.cc --driver-mode=cl"),
255 "cc --driver-mode=cl");
256 }
257
258 TEST(ArgStripperTest, ArgStyles) {
259 // Flag
260 EXPECT_EQ(strip("-Qn", "clang -Qn foo.cc"), "clang foo.cc");
261 EXPECT_EQ(strip("-Qn", "clang -QnZ foo.cc"), "clang -QnZ foo.cc");
262 // Joined
263 EXPECT_EQ(strip("-std=", "clang -std= foo.cc"), "clang foo.cc");
264 EXPECT_EQ(strip("-std=", "clang -std=c++11 foo.cc"), "clang foo.cc");
265 // Separate
266 EXPECT_EQ(strip("-mllvm", "clang -mllvm X foo.cc"), "clang foo.cc");
267 EXPECT_EQ(strip("-mllvm", "clang -mllvmX foo.cc"), "clang -mllvmX foo.cc");
268 // RemainingArgsJoined
269 EXPECT_EQ(strip("/link", "clang-cl /link b c d foo.cc"), "clang-cl");
270 EXPECT_EQ(strip("/link", "clang-cl /linka b c d foo.cc"), "clang-cl");
271 // CommaJoined
272 EXPECT_EQ(strip("-Wl,", "clang -Wl,x,y foo.cc"), "clang foo.cc");
273 EXPECT_EQ(strip("-Wl,", "clang -Wl, foo.cc"), "clang foo.cc");
274 // MultiArg
275 EXPECT_EQ(strip("-segaddr", "clang -segaddr a b foo.cc"), "clang foo.cc");
276 EXPECT_EQ(strip("-segaddr", "clang -segaddra b foo.cc"),
277 "clang -segaddra b foo.cc");
278 // JoinedOrSeparate
279 EXPECT_EQ(strip("-G", "clang -GX foo.cc"), "clang foo.cc");
280 EXPECT_EQ(strip("-G", "clang -G X foo.cc"), "clang foo.cc");
281 // JoinedAndSeparate
282 EXPECT_EQ(strip("-plugin-arg-", "clang -cc1 -plugin-arg-X Y foo.cc"),
283 "clang -cc1 foo.cc");
284 EXPECT_EQ(strip("-plugin-arg-", "clang -cc1 -plugin-arg- Y foo.cc"),
285 "clang -cc1 foo.cc");
286 }
287
288 TEST(ArgStripperTest, EndOfList) {
289 // When we hit the end-of-args prematurely, we don't crash.
290 // We consume the incomplete args if we've matched the target option.
291 EXPECT_EQ(strip("-I", "clang -Xclang"), "clang -Xclang");
292 EXPECT_EQ(strip("-I", "clang -Xclang -I"), "clang");
293 EXPECT_EQ(strip("-I", "clang -I -Xclang"), "clang");
294 EXPECT_EQ(strip("-I", "clang -I"), "clang");
295 }
296
297 TEST(ArgStripperTest, Multiple) {
298 ArgStripper S;
299 S.strip("-o");
300 S.strip("-c");
301 std::vector<std::string> Args = {"clang", "-o", "foo.o", "foo.cc", "-c"};
302 S.process(Args);
303 EXPECT_THAT(Args, ElementsAre("clang", "foo.cc"));
304 }
305
306 TEST(ArgStripperTest, Warning) {
307 {
308 // -W is a flag name
309 ArgStripper S;
310 S.strip("-W");
311 std::vector<std::string> Args = {"clang", "-Wfoo", "-Wno-bar", "-Werror",
312 "foo.cc"};
313 S.process(Args);
314 EXPECT_THAT(Args, ElementsAre("clang", "foo.cc"));
315 }
316 {
317 // -Wfoo is not a flag name, matched literally.
318 ArgStripper S;
319 S.strip("-Wunused");
320 std::vector<std::string> Args = {"clang", "-Wunused", "-Wno-unused",
321 "foo.cc"};
322 S.process(Args);
323 EXPECT_THAT(Args, ElementsAre("clang", "-Wno-unused", "foo.cc"));
324 }
325 }
326
327 TEST(ArgStripperTest, Define) {
328 {
329 // -D is a flag name
330 ArgStripper S;
331 S.strip("-D");
332 std::vector<std::string> Args = {"clang", "-Dfoo", "-Dbar=baz", "foo.cc"};
333 S.process(Args);
334 EXPECT_THAT(Args, ElementsAre("clang", "foo.cc"));
335 }
336 {
337 // -Dbar is not: matched literally
338 ArgStripper S;
339 S.strip("-Dbar");
340 std::vector<std::string> Args = {"clang", "-Dfoo", "-Dbar=baz", "foo.cc"};
341 S.process(Args);
342 EXPECT_THAT(Args, ElementsAre("clang", "-Dfoo", "-Dbar=baz", "foo.cc"));
343 S.strip("-Dfoo");
344 S.process(Args);
345 EXPECT_THAT(Args, ElementsAre("clang", "-Dbar=baz", "foo.cc"));
346 S.strip("-Dbar=*");
347 S.process(Args);
348 EXPECT_THAT(Args, ElementsAre("clang", "foo.cc"));
349 }
350 }
351
352 TEST(ArgStripperTest, OrderDependent) {
353 ArgStripper S;
354 // If -include is stripped first, we see -pch as its arg and foo.pch remains.
355 // To get this case right, we must process -include-pch first.
356 S.strip("-include");
357 S.strip("-include-pch");
358 std::vector<std::string> Args = {"clang", "-include-pch", "foo.pch",
359 "foo.cc"};
360 S.process(Args);
361 EXPECT_THAT(Args, ElementsAre("clang", "foo.cc"));
362 }
363
364 TEST(PrintArgvTest, All) {
365 std::vector<llvm::StringRef> Args = {
366 "one", "two", "thr ee", "f\"o\"ur", "fi\\ve", "$"
367 };
368 const char *Expected = R"(one two "thr ee" "f\"o\"ur" "fi\\ve" $)";
369 EXPECT_EQ(Expected, printArgv(Args));
370 }
371
372 TEST(CommandMangler, InputsAfterDashDash) {
373 const auto Mangler = CommandMangler::forTests();
374 {
375 tooling::CompileCommand Cmd;
376 Cmd.CommandLine = {"clang", "/Users/foo.cc"};
377 Mangler(Cmd, "/Users/foo.cc");
378 EXPECT_THAT(llvm::ArrayRef(Cmd.CommandLine).take_back(2),
379 ElementsAre("--", "/Users/foo.cc"));
380 EXPECT_THAT(llvm::ArrayRef(Cmd.CommandLine).drop_back(2),
381 Not(Contains("/Users/foo.cc")));
382 }
383 // In CL mode /U triggers an undef operation, hence `/Users/foo.cc` shouldn't
384 // be interpreted as a file.
385 {
386 tooling::CompileCommand Cmd;
387 Cmd.CommandLine = {"clang", "--driver-mode=cl", "bar.cc", "/Users/foo.cc"};
388 Mangler(Cmd, "bar.cc");
389 EXPECT_THAT(llvm::ArrayRef(Cmd.CommandLine).take_back(2),
390 ElementsAre("--", "bar.cc"));
391 EXPECT_THAT(llvm::ArrayRef(Cmd.CommandLine).drop_back(2),
392 Not(Contains("bar.cc")));
393 }
394 // All inputs but the main file is dropped.
395 {
396 tooling::CompileCommand Cmd;
397 Cmd.CommandLine = {"clang", "foo.cc", "bar.cc"};
398 Mangler(Cmd, "baz.cc");
399 EXPECT_THAT(llvm::ArrayRef(Cmd.CommandLine).take_back(2),
400 ElementsAre("--", "baz.cc"));
401 EXPECT_THAT(
402 llvm::ArrayRef(Cmd.CommandLine).drop_back(2),
403 testing::AllOf(Not(Contains("foo.cc")), Not(Contains("bar.cc"))));
404 }
405 }
406
407 TEST(CommandMangler, StripsMultipleArch) {
408 const auto Mangler = CommandMangler::forTests();
409 tooling::CompileCommand Cmd;
410 Cmd.CommandLine = {"clang", "-arch", "foo", "-arch", "bar", "/Users/foo.cc"};
411 Mangler(Cmd, "/Users/foo.cc");
412 EXPECT_EQ(llvm::count_if(Cmd.CommandLine,
413 [](llvm::StringRef Arg) { return Arg == "-arch"; }),
414 0);
415
416 // Single arch option is preserved.
417 Cmd.CommandLine = {"clang", "-arch", "foo", "/Users/foo.cc"};
418 Mangler(Cmd, "/Users/foo.cc");
419 EXPECT_EQ(llvm::count_if(Cmd.CommandLine,
420 [](llvm::StringRef Arg) { return Arg == "-arch"; }),
421 1);
422 }
423
424 TEST(CommandMangler, EmptyArgs) {
425 const auto Mangler = CommandMangler::forTests();
426 tooling::CompileCommand Cmd;
427 Cmd.CommandLine = {};
428 // Make sure we don't crash.
429 Mangler(Cmd, "foo.cc");
430 }
431
432 TEST(CommandMangler, PathsAsPositional) {
433 const auto Mangler = CommandMangler::forTests();
434 tooling::CompileCommand Cmd;
435 Cmd.CommandLine = {
436 "clang",
437 "--driver-mode=cl",
438 "-I",
439 "foo",
440 };
441 // Make sure we don't crash.
442 Mangler(Cmd, "a.cc");
443 EXPECT_THAT(Cmd.CommandLine, Contains("foo"));
444 }
445 } // namespace
446 } // namespace clangd
447 } // namespace clang