14#include "clang/Testing/CommandLineArgs.h"
15#include "clang/Tooling/ArgumentsAdjusters.h"
16#include "llvm/ADT/ArrayRef.h"
17#include "llvm/ADT/STLExtras.h"
18#include "llvm/ADT/ScopeExit.h"
19#include "llvm/ADT/StringExtras.h"
20#include "llvm/ADT/StringRef.h"
21#include "llvm/Config/llvm-config.h"
22#include "llvm/Support/FileSystem.h"
23#include "llvm/Support/Path.h"
24#include "llvm/Support/Process.h"
25#include "llvm/Support/TargetSelect.h"
27#include "gmock/gmock.h"
28#include "gtest/gtest.h"
35using ::testing::Contains;
36using ::testing::ElementsAre;
37using ::testing::HasSubstr;
47 llvm::InitializeAllTargetInfos();
48 std::string Target = getAnyTargetForTesting();
50 Mangler.ClangPath =
testPath(
"fake/clang");
51 Mangler.ResourceDir =
testPath(
"fake/resources");
52 Mangler.Sysroot =
testPath(
"fake/sysroot");
53 tooling::CompileCommand Cmd;
54 Cmd.CommandLine = {Target +
"-clang++",
"--",
"foo.cc",
"bar.cc"};
55 Mangler(Cmd,
"foo.cc");
56 EXPECT_THAT(Cmd.CommandLine,
57 ElementsAre(
testPath(
"fake/" + Target +
"-clang++"),
58 "--target=" + Target,
"--driver-mode=g++",
59 "-resource-dir=" +
testPath(
"fake/resources"),
60 "-isysroot",
testPath(
"fake/sysroot"),
"--",
66 Mangler.ClangPath =
testPath(
"clang");
68 tooling::CompileCommand Cmd;
69 Cmd.CommandLine = {
"clang",
"foo.cc"};
71 Mangler(Cmd,
"foo.h");
73 EXPECT_THAT(Cmd.CommandLine, ElementsAre(
testPath(
"clang"),
"-x",
74 "c++-header",
"--",
"foo.h"));
79 Mangler.ResourceDir =
testPath(
"fake/resources");
80 tooling::CompileCommand Cmd;
81 Cmd.CommandLine = {
"clang++",
"foo.cc"};
82 Mangler(Cmd,
"foo.cc");
83 EXPECT_THAT(Cmd.CommandLine,
84 Contains(
"-resource-dir=" +
testPath(
"fake/resources")));
89 Mangler.Sysroot =
testPath(
"fake/sysroot");
91 tooling::CompileCommand Cmd;
92 Cmd.CommandLine = {
"clang++",
"foo.cc"};
93 Mangler(Cmd,
"foo.cc");
94 EXPECT_THAT(llvm::join(Cmd.CommandLine,
" "),
95 HasSubstr(
"-isysroot " +
testPath(
"fake/sysroot")));
100 Mangler.ClangPath =
testPath(
"fake/clang");
102 tooling::CompileCommand Cmd;
103 Cmd.CommandLine = {
"clang++",
"foo.cc"};
104 Mangler(Cmd,
"foo.cc");
105 EXPECT_EQ(
testPath(
"fake/clang++"), Cmd.CommandLine.front());
107 Cmd.CommandLine = {
"unknown-binary",
"foo.cc"};
108 Mangler(Cmd,
"foo.cc");
109 EXPECT_EQ(
testPath(
"fake/unknown-binary"), Cmd.CommandLine.front());
111 Cmd.CommandLine = {
testPath(
"path/clang++"),
"foo.cc"};
112 Mangler(Cmd,
"foo.cc");
113 EXPECT_EQ(
testPath(
"path/clang++"), Cmd.CommandLine.front());
115 Cmd.CommandLine = {
"foo/unknown-binary",
"foo.cc"};
116 Mangler(Cmd,
"foo.cc");
117 EXPECT_EQ(
"foo/unknown-binary", Cmd.CommandLine.front());
125 *result_listener << arg.message();
138 llvm::SmallString<256> TempDir;
139 ASSERT_THAT(llvm::sys::fs::createUniqueDirectory(
"ClangPathResolve", TempDir),
142 ASSERT_THAT(llvm::sys::fs::real_path(TempDir.str(), TempDir), ok());
143 llvm::scope_exit CleanDir(
144 [&] { llvm::sys::fs::remove_directories(TempDir); });
145 ASSERT_THAT(llvm::sys::fs::create_directory(TempDir +
"/bin"), ok());
146 ASSERT_THAT(llvm::sys::fs::create_directory(TempDir +
"/lib"), ok());
148 ASSERT_THAT(llvm::sys::fs::openFileForWrite(TempDir +
"/lib/bar", FD), ok());
149 ASSERT_THAT(llvm::sys::Process::SafelyCloseFileDescriptor(FD), ok());
150 ::chmod((TempDir +
"/lib/bar").str().c_str(), 0755);
152 llvm::sys::fs::create_link(TempDir +
"/lib/bar", TempDir +
"/bin/foo"),
157 Mangler.ClangPath =
testPath(
"fake/clang");
158 tooling::CompileCommand Cmd;
159 Cmd.CommandLine = {(TempDir +
"/bin/foo").str(),
"foo.cc"};
160 Mangler(Cmd,
"foo.cc");
162 EXPECT_EQ((TempDir +
"/lib/foo").str(), Cmd.CommandLine.front());
165 ASSERT_TRUE(::getenv(
"PATH"));
166 llvm::scope_exit RestorePath([OldPath = std::string(::getenv(
"PATH"))] {
167 ::setenv(
"PATH", OldPath.c_str(), 1);
169 ::setenv(
"PATH", (TempDir +
"/bin").str().c_str(), 1);
173 Mangler.ClangPath =
testPath(
"fake/clang");
175 Cmd.CommandLine = {
"foo",
"foo.cc"};
176 Mangler(Cmd,
"foo.cc");
178 EXPECT_EQ((TempDir +
"/lib/foo").str(), Cmd.CommandLine.front());
181 Cmd.CommandLine = {
"foo",
"-no-canonical-prefixes",
"foo.cc"};
182 Mangler(Cmd,
"foo.cc");
183 EXPECT_EQ((TempDir +
"/bin/foo").str(), Cmd.CommandLine.front());
189 tooling::CompileCommand Cmd;
190 Cmd.CommandLine = {
"clang++",
"foo.cc"};
194 for (
auto &Arg : Argv)
196 C = llvm::toUpper(C);
198 Cfg.CompileFlags.Edits.push_back([](std::vector<std::string> &Argv) {
199 Argv = tooling::getInsertArgumentAdjuster(
"--hello")(Argv,
"");
202 Mangler(Cmd,
"foo.cc");
208 EXPECT_THAT(Cmd.CommandLine,
209 ElementsAre(_,
"--driver-mode=g++",
"--hello",
"--",
"FOO.CC"));
212static std::string strip(llvm::StringRef Arg, llvm::StringRef Argv) {
213 llvm::SmallVector<llvm::StringRef> Parts;
214 llvm::SplitString(Argv, Parts);
215 std::vector<std::string> Args = {Parts.begin(), Parts.end()};
222TEST(ArgStripperTest, Spellings) {
224 EXPECT_EQ(strip(
"-pedantic",
"clang -pedantic foo.cc"),
"clang foo.cc");
225 EXPECT_EQ(strip(
"-pedantic",
"clang --pedantic foo.cc"),
"clang foo.cc");
226 EXPECT_EQ(strip(
"--pedantic",
"clang -pedantic foo.cc"),
"clang foo.cc");
227 EXPECT_EQ(strip(
"--pedantic",
"clang --pedantic foo.cc"),
"clang foo.cc");
229 EXPECT_EQ(strip(
"-x",
"clang -x c++ foo.cc"),
"clang foo.cc");
230 EXPECT_EQ(strip(
"-x",
"clang --language=c++ foo.cc"),
"clang foo.cc");
231 EXPECT_EQ(strip(
"--language=",
"clang -x c++ foo.cc"),
"clang foo.cc");
232 EXPECT_EQ(strip(
"--language=",
"clang --language=c++ foo.cc"),
236TEST(ArgStripperTest, UnknownFlag) {
237 EXPECT_EQ(strip(
"-xyzzy",
"clang -xyzzy foo.cc"),
"clang foo.cc");
238 EXPECT_EQ(strip(
"-xyz*",
"clang -xyzzy foo.cc"),
"clang foo.cc");
239 EXPECT_EQ(strip(
"-xyzzy",
"clang -Xclang -xyzzy foo.cc"),
"clang foo.cc");
242TEST(ArgStripperTest, Xclang) {
244 EXPECT_EQ(strip(
"-ast-dump",
"clang -Xclang -ast-dump foo.cc"),
247 EXPECT_EQ(strip(
"-add-plugin",
"clang -Xclang -add-plugin -Xclang z foo.cc"),
251TEST(ArgStripperTest, ClangCL) {
254 EXPECT_EQ(strip(
"-I",
"clang -I /usr/inc /Interesting/file.cc"),
255 "clang /Interesting/file.cc");
257 EXPECT_EQ(strip(
"-I",
"clang-cl -I /usr/inc /Interesting/file.cc"),
260 EXPECT_EQ(strip(
"-I",
"CL.EXE -I /usr/inc /Interesting/file.cc"),
"CL.EXE");
262 EXPECT_EQ(strip(
"-I",
"cc -I /usr/inc /Interesting/file.cc --driver-mode=cl"),
263 "cc --driver-mode=cl");
266TEST(ArgStripperTest, ArgStyles) {
268 EXPECT_EQ(strip(
"-Qn",
"clang -Qn foo.cc"),
"clang foo.cc");
269 EXPECT_EQ(strip(
"-Qn",
"clang -QnZ foo.cc"),
"clang -QnZ foo.cc");
271 EXPECT_EQ(strip(
"-std=",
"clang -std= foo.cc"),
"clang foo.cc");
272 EXPECT_EQ(strip(
"-std=",
"clang -std=c++11 foo.cc"),
"clang foo.cc");
274 EXPECT_EQ(strip(
"-mllvm",
"clang -mllvm X foo.cc"),
"clang foo.cc");
275 EXPECT_EQ(strip(
"-mllvm",
"clang -mllvmX foo.cc"),
"clang -mllvmX foo.cc");
276 EXPECT_EQ(strip(
"-mllvm",
"clang -mllvm=X foo.cc"),
"clang foo.cc");
277 EXPECT_EQ(strip(
"-o",
"clang --output=x --output y foo.cc"),
"clang foo.cc");
278 EXPECT_EQ(strip(
"-o",
"clang --output-class-directory=x foo.cc"),
279 "clang --output-class-directory=x foo.cc");
281 EXPECT_EQ(strip(
"/link",
"clang-cl /link b c d foo.cc"),
"clang-cl");
282 EXPECT_EQ(strip(
"/link",
"clang-cl /linka b c d foo.cc"),
"clang-cl");
284 EXPECT_EQ(strip(
"-Wl,",
"clang -Wl,x,y foo.cc"),
"clang foo.cc");
285 EXPECT_EQ(strip(
"-Wl,",
"clang -Wl, foo.cc"),
"clang foo.cc");
287 EXPECT_EQ(strip(
"-segaddr",
"clang -segaddr a b foo.cc"),
"clang foo.cc");
288 EXPECT_EQ(strip(
"-segaddr",
"clang -segaddra b foo.cc"),
289 "clang -segaddra b foo.cc");
291 EXPECT_EQ(strip(
"-G",
"clang -GX foo.cc"),
"clang foo.cc");
292 EXPECT_EQ(strip(
"-G",
"clang -G X foo.cc"),
"clang foo.cc");
294 EXPECT_EQ(strip(
"-plugin-arg-",
"clang -cc1 -plugin-arg-X Y foo.cc"),
295 "clang -cc1 foo.cc");
296 EXPECT_EQ(strip(
"-plugin-arg-",
"clang -cc1 -plugin-arg- Y foo.cc"),
297 "clang -cc1 foo.cc");
300TEST(ArgStripperTest, EndOfList) {
303 EXPECT_EQ(strip(
"-I",
"clang -Xclang"),
"clang -Xclang");
304 EXPECT_EQ(strip(
"-I",
"clang -Xclang -I"),
"clang");
305 EXPECT_EQ(strip(
"-I",
"clang -I -Xclang"),
"clang");
306 EXPECT_EQ(strip(
"-I",
"clang -I"),
"clang");
309TEST(ArgStripperTest, Multiple) {
313 std::vector<std::string> Args = {
"clang",
"-o",
"foo.o",
"foo.cc",
"-c"};
315 EXPECT_THAT(Args, ElementsAre(
"clang",
"foo.cc"));
323 std::vector<std::string> Args = {
"clang",
"-Wfoo",
"-Wno-bar",
"-Werror",
326 EXPECT_THAT(Args, ElementsAre(
"clang",
"foo.cc"));
332 std::vector<std::string> Args = {
"clang",
"-Wunused",
"-Wno-unused",
335 EXPECT_THAT(Args, ElementsAre(
"clang",
"-Wno-unused",
"foo.cc"));
339TEST(ArgStripperTest, Define) {
344 std::vector<std::string> Args = {
"clang",
"-Dfoo",
"-Dbar=baz",
"foo.cc"};
346 EXPECT_THAT(Args, ElementsAre(
"clang",
"foo.cc"));
352 std::vector<std::string> Args = {
"clang",
"-Dfoo",
"-Dbar=baz",
"foo.cc"};
354 EXPECT_THAT(Args, ElementsAre(
"clang",
"-Dfoo",
"-Dbar=baz",
"foo.cc"));
357 EXPECT_THAT(Args, ElementsAre(
"clang",
"-Dbar=baz",
"foo.cc"));
360 EXPECT_THAT(Args, ElementsAre(
"clang",
"foo.cc"));
364TEST(ArgStripperTest, OrderDependent) {
369 S.strip(
"-include-pch");
370 std::vector<std::string> Args = {
"clang",
"-include-pch",
"foo.pch",
373 EXPECT_THAT(Args, ElementsAre(
"clang",
"foo.cc"));
377 std::vector<llvm::StringRef> Args = {
"one",
"two",
"thr ee",
378 "f\"o\"ur",
"fi\\ve",
"$"};
379 const char *Expected = R
"(one two "thr ee" "f\"o\"ur" "fi\\ve" $)";
386 tooling::CompileCommand Cmd;
387 Cmd.CommandLine = {
"clang",
"/Users/foo.cc"};
388 Mangler(Cmd,
"/Users/foo.cc");
389 EXPECT_THAT(llvm::ArrayRef(Cmd.CommandLine).take_back(2),
390 ElementsAre(
"--",
"/Users/foo.cc"));
391 EXPECT_THAT(llvm::ArrayRef(Cmd.CommandLine).drop_back(2),
392 Not(Contains(
"/Users/foo.cc")));
397 tooling::CompileCommand Cmd;
398 Cmd.CommandLine = {
"clang",
"--driver-mode=cl",
"bar.cc",
"/Users/foo.cc"};
399 Mangler(Cmd,
"bar.cc");
400 EXPECT_THAT(llvm::ArrayRef(Cmd.CommandLine).take_back(2),
401 ElementsAre(
"--",
"bar.cc"));
402 EXPECT_THAT(llvm::ArrayRef(Cmd.CommandLine).drop_back(2),
403 Not(Contains(
"bar.cc")));
407 tooling::CompileCommand Cmd;
408 Cmd.CommandLine = {
"clang",
"foo.cc",
"bar.cc"};
409 Mangler(Cmd,
"baz.cc");
410 EXPECT_THAT(llvm::ArrayRef(Cmd.CommandLine).take_back(2),
411 ElementsAre(
"--",
"baz.cc"));
413 llvm::ArrayRef(Cmd.CommandLine).drop_back(2),
414 testing::AllOf(Not(Contains(
"foo.cc")), Not(Contains(
"bar.cc"))));
420 tooling::CompileCommand Cmd;
421 Cmd.CommandLine = {
"clang",
"-arch",
"foo",
"-arch",
"bar",
"/Users/foo.cc"};
422 Mangler(Cmd,
"/Users/foo.cc");
423 EXPECT_EQ(llvm::count_if(Cmd.CommandLine,
424 [](llvm::StringRef Arg) { return Arg ==
"-arch"; }),
428 Cmd.CommandLine = {
"clang",
"-arch",
"foo",
"/Users/foo.cc"};
429 Mangler(Cmd,
"/Users/foo.cc");
430 EXPECT_EQ(llvm::count_if(Cmd.CommandLine,
431 [](llvm::StringRef Arg) { return Arg ==
"-arch"; }),
437 tooling::CompileCommand Cmd;
438 Cmd.CommandLine = {};
440 Mangler(Cmd,
"foo.cc");
445 tooling::CompileCommand Cmd;
453 Mangler(Cmd,
"a.cc");
454 EXPECT_THAT(Cmd.CommandLine, Contains(
"foo"));
459 Mangler.ResourceDir =
testPath(
"fake/resources");
462 tooling::CompileCommand Cmd;
463 Cmd.CommandLine = {
"clang++",
"-resource-dir",
testPath(
"true/resources"),
465 Mangler(Cmd,
"foo.cc");
466 EXPECT_THAT(llvm::join(Cmd.CommandLine,
" "),
467 HasSubstr(
"-resource-dir " +
testPath(
"true/resources")));
468 EXPECT_THAT(llvm::join(Cmd.CommandLine,
" "),
469 Not(HasSubstr(
testPath(
"fake/resources"))));
473 tooling::CompileCommand Cmd;
474 Cmd.CommandLine = {
"clang++",
"-resource-dir=" +
testPath(
"true/resources"),
476 Mangler(Cmd,
"foo.cc");
477 EXPECT_THAT(llvm::join(Cmd.CommandLine,
" "),
478 HasSubstr(
"-resource-dir=" +
testPath(
"true/resources")));
479 EXPECT_THAT(llvm::join(Cmd.CommandLine,
" "),
480 Not(HasSubstr(
testPath(
"fake/resources"))));
486 Mangler.Sysroot =
testPath(
"fake/sysroot");
489 tooling::CompileCommand Cmd;
490 Cmd.CommandLine = {
"clang++",
"-isysroot",
testPath(
"true/sysroot"),
492 Mangler(Cmd,
"foo.cc");
493 EXPECT_THAT(llvm::join(Cmd.CommandLine,
" "),
494 HasSubstr(
"-isysroot " +
testPath(
"true/sysroot")));
495 EXPECT_THAT(llvm::join(Cmd.CommandLine,
" "),
496 Not(HasSubstr(
testPath(
"fake/sysroot"))));
500 tooling::CompileCommand Cmd;
501 Cmd.CommandLine = {
"clang++",
"-isysroot" +
testPath(
"true/sysroot"),
503 Mangler(Cmd,
"foo.cc");
504 EXPECT_THAT(llvm::join(Cmd.CommandLine,
" "),
505 HasSubstr(
"-isysroot" +
testPath(
"true/sysroot")));
506 EXPECT_THAT(llvm::join(Cmd.CommandLine,
" "),
507 Not(HasSubstr(
testPath(
"fake/sysroot"))));
511 tooling::CompileCommand Cmd;
512 Cmd.CommandLine = {
"clang++",
"--sysroot",
testPath(
"true/sysroot"),
514 Mangler(Cmd,
"foo.cc");
515 EXPECT_THAT(llvm::join(Cmd.CommandLine,
" "),
516 HasSubstr(
"--sysroot " +
testPath(
"true/sysroot")));
517 EXPECT_THAT(llvm::join(Cmd.CommandLine,
" "),
518 Not(HasSubstr(
testPath(
"fake/sysroot"))));
522 tooling::CompileCommand Cmd;
523 Cmd.CommandLine = {
"clang++",
"--sysroot=" +
testPath(
"true/sysroot"),
525 Mangler(Cmd,
"foo.cc");
526 EXPECT_THAT(llvm::join(Cmd.CommandLine,
" "),
527 HasSubstr(
"--sysroot=" +
testPath(
"true/sysroot")));
528 EXPECT_THAT(llvm::join(Cmd.CommandLine,
" "),
529 Not(HasSubstr(
testPath(
"fake/sysroot"))));
535 tooling::CompileCommand Cmd;
536 Cmd.CommandLine = {
"clang++",
"-std=c++23",
"--unknown-flag",
537 "--unknown-option=abcd"};
538 Mangler(Cmd,
"foo.cc");
539 EXPECT_THAT(Cmd.CommandLine, Not(Contains(
"--unknown-flag")));
540 EXPECT_THAT(Cmd.CommandLine, Not(Contains(
"--unknown-option=abcd")));
541 EXPECT_THAT(Cmd.CommandLine, Contains(
"-std=c++23"));
546 tooling::CompileCommand Cmd;
547 Cmd.CommandLine = {
"clang-cl",
"/std:c++latest",
"--",
"/Users/foo.cc"};
548 Mangler(Cmd,
"/Users/foo.cc");
550 EXPECT_THAT(llvm::join(Cmd.CommandLine,
" "), HasSubstr(
"/std:c++latest"));
558 tooling::CompileCommand Cmd;
559 Cmd.CommandLine = {
"clang-cl",
"/std:c++23preview",
"--",
"/Users/foo.cc"};
560 Mangler(Cmd,
"/Users/foo.hpp");
561 EXPECT_THAT(llvm::join(Cmd.CommandLine,
" "),
562 HasSubstr(
"/std:c++23preview"));
566 tooling::CompileCommand Cmd;
567 Cmd.CommandLine = {
"clang-cl",
"/std:clatest",
"--",
"/Users/foo.c"};
568 Mangler(Cmd,
"/Users/foo.h");
569 EXPECT_THAT(llvm::join(Cmd.CommandLine,
" "), HasSubstr(
"/std:clatest"));
573 tooling::CompileCommand Cmd;
574 Cmd.CommandLine = {
"clang-cl",
"/std:c++latest",
"--",
"/Users/foo.cc"};
575 Mangler(Cmd,
"/Users/foo.hpp");
576 EXPECT_THAT(llvm::join(Cmd.CommandLine,
" "), HasSubstr(
"/std:c++latest"));
void strip(llvm::StringRef Arg)
WithContextValue extends Context::current() with a single value.
FIXME: Skip testing on windows temporarily due to the different escaping code mode.
@ Warning
A warning message.
std::string testPath(PathRef File, llvm::sys::path::Style Style)
TEST(BackgroundQueueTest, Priority)
std::string printArgv(llvm::ArrayRef< llvm::StringRef > Args)
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
static CommandMangler forTests()
Settings that express user/project preferences and control clangd behavior.
static clangd::Key< Config > Key
Context key which can be used to set the current Config.
struct clang::clangd::Config::@347104204155140144054042115114221214347344026246 CompileFlags
Controls how the compile command for the current file is determined.
std::vector< llvm::unique_function< void(std::vector< std::string > &) const > > Edits
Edits to apply to the compile command, in sequence.