clang-tools 24.0.0git
ConfigCompileTests.cpp
Go to the documentation of this file.
1//===-- ConfigCompileTests.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 "Config.h"
10#include "ConfigFragment.h"
11#include "ConfigTesting.h"
12#include "Diagnostics.h"
13#include "Feature.h"
14#include "TestFS.h"
15#include "clang/Basic/DiagnosticSema.h"
16#include "llvm/ADT/StringRef.h"
17#include "llvm/Support/Path.h"
18#include "llvm/Support/SourceMgr.h"
19#include "gmock/gmock.h"
20#include "gtest/gtest.h"
21#include <optional>
22#include <string>
23
24namespace clang {
25namespace clangd {
26namespace config {
27namespace {
28using ::testing::AllOf;
29using ::testing::Contains;
30using ::testing::ElementsAre;
31using ::testing::IsEmpty;
32using ::testing::SizeIs;
33using ::testing::StartsWith;
34using ::testing::UnorderedElementsAre;
35
36class ConfigCompileTests : public ::testing::Test {
37protected:
38 CapturedDiags Diags;
39 Config Conf;
40 Fragment Frag;
41 Params Parm;
42
43 bool compileAndApply() {
44 Conf = Config();
45 Diags.Diagnostics.clear();
46 auto Compiled = std::move(Frag).compile(Diags.callback());
47 return Compiled(Parm, Conf);
48 }
49};
50
51TEST_F(ConfigCompileTests, Condition) {
52 // No condition.
53 Frag = {};
54 Frag.CompileFlags.Add.emplace_back("X");
55 EXPECT_TRUE(compileAndApply()) << "Empty config";
56 EXPECT_THAT(Diags.Diagnostics, IsEmpty());
57 EXPECT_THAT(Conf.CompileFlags.Edits, SizeIs(1));
58
59 // Regex with no file.
60 Frag = {};
61 Frag.If.PathMatch.emplace_back("fo*");
62 EXPECT_FALSE(compileAndApply());
63 EXPECT_THAT(Diags.Diagnostics, IsEmpty());
64 EXPECT_THAT(Conf.CompileFlags.Edits, SizeIs(0));
65
66 // Following tests have a file path set.
67 Parm.Path = "bar";
68
69 // Non-matching regex.
70 Frag = {};
71 Frag.If.PathMatch.emplace_back("fo*");
72 EXPECT_FALSE(compileAndApply());
73 EXPECT_THAT(Diags.Diagnostics, IsEmpty());
74
75 // Matching regex.
76 Frag = {};
77 Frag.If.PathMatch.emplace_back("fo*");
78 Frag.If.PathMatch.emplace_back("ba*r");
79 EXPECT_TRUE(compileAndApply());
80 EXPECT_THAT(Diags.Diagnostics, IsEmpty());
81
82 // Excluded regex.
83 Frag = {};
84 Frag.If.PathMatch.emplace_back("b.*");
85 Frag.If.PathExclude.emplace_back(".*r");
86 EXPECT_FALSE(compileAndApply()) << "Included but also excluded";
87 EXPECT_THAT(Diags.Diagnostics, IsEmpty());
88
89 // Invalid regex.
90 Frag = {};
91 Frag.If.PathMatch.emplace_back("**]@theu");
92 EXPECT_TRUE(compileAndApply());
93 EXPECT_THAT(Diags.Diagnostics, SizeIs(1));
94 EXPECT_THAT(Diags.Diagnostics.front().Message, StartsWith("Invalid regex"));
95
96 // Valid regex and unknown key.
97 Frag = {};
98 Frag.If.HasUnrecognizedCondition = true;
99 Frag.If.PathMatch.emplace_back("ba*r");
100 EXPECT_FALSE(compileAndApply());
101 EXPECT_THAT(Diags.Diagnostics, IsEmpty());
102
103 // Only matches case-insensitively.
104 Frag = {};
105 Frag.If.PathMatch.emplace_back("B.*R");
106 EXPECT_THAT(Diags.Diagnostics, IsEmpty());
107#ifdef CLANGD_PATH_CASE_INSENSITIVE
108 EXPECT_TRUE(compileAndApply());
109#else
110 EXPECT_FALSE(compileAndApply());
111#endif
112
113 Frag = {};
114 Frag.If.PathExclude.emplace_back("B.*R");
115 EXPECT_THAT(Diags.Diagnostics, IsEmpty());
116#ifdef CLANGD_PATH_CASE_INSENSITIVE
117 EXPECT_FALSE(compileAndApply());
118#else
119 EXPECT_TRUE(compileAndApply());
120#endif
121}
122
123TEST_F(ConfigCompileTests, CompileCommands) {
124 Frag.CompileFlags.Compiler.emplace("tpc.exe");
125 Frag.CompileFlags.Add.emplace_back("-foo");
126 Frag.CompileFlags.Remove.emplace_back("--include-directory=");
127 std::vector<std::string> Argv = {"clang", "-I", "bar/", "--", "a.cc"};
128 EXPECT_TRUE(compileAndApply());
129 EXPECT_THAT(Conf.CompileFlags.Edits, SizeIs(3));
130 for (auto &Edit : Conf.CompileFlags.Edits)
131 Edit(Argv);
132 EXPECT_THAT(Argv, ElementsAre("tpc.exe", "-foo", "--", "a.cc"));
133}
134
135TEST_F(ConfigCompileTests, CompilationDatabase) {
136 Frag.CompileFlags.CompilationDatabase.emplace("None");
137 EXPECT_TRUE(compileAndApply());
138 EXPECT_EQ(Conf.CompileFlags.CDBSearch.Policy,
139 Config::CDBSearchSpec::NoCDBSearch);
140
141 Frag.CompileFlags.CompilationDatabase.emplace("Ancestors");
142 EXPECT_TRUE(compileAndApply());
143 EXPECT_EQ(Conf.CompileFlags.CDBSearch.Policy,
144 Config::CDBSearchSpec::Ancestors);
145
146 // Relative path not allowed without directory set.
147 Frag.CompileFlags.CompilationDatabase.emplace("Something");
148 EXPECT_TRUE(compileAndApply());
149 EXPECT_EQ(Conf.CompileFlags.CDBSearch.Policy,
150 Config::CDBSearchSpec::Ancestors)
151 << "default value";
152 EXPECT_THAT(Diags.Diagnostics,
153 ElementsAre(diagMessage(
154 "CompilationDatabase must be an absolute path, because this "
155 "fragment is not associated with any directory.")));
156
157 // Relative path allowed if directory is set.
158 Frag.Source.Directory = testRoot();
159 EXPECT_TRUE(compileAndApply());
160 EXPECT_EQ(Conf.CompileFlags.CDBSearch.Policy,
161 Config::CDBSearchSpec::FixedDir);
162 EXPECT_EQ(Conf.CompileFlags.CDBSearch.FixedCDBPath, testPath("Something"));
163 EXPECT_THAT(Diags.Diagnostics, IsEmpty());
164
165 // Absolute path allowed.
166 Frag.Source.Directory.clear();
167 Frag.CompileFlags.CompilationDatabase.emplace(testPath("Something2"));
168 EXPECT_TRUE(compileAndApply());
169 EXPECT_EQ(Conf.CompileFlags.CDBSearch.Policy,
170 Config::CDBSearchSpec::FixedDir);
171 EXPECT_EQ(Conf.CompileFlags.CDBSearch.FixedCDBPath, testPath("Something2"));
172 EXPECT_THAT(Diags.Diagnostics, IsEmpty());
173}
174
175TEST_F(ConfigCompileTests, Index) {
176 Frag.Index.Background.emplace("Skip");
177 EXPECT_TRUE(compileAndApply());
178 EXPECT_EQ(Conf.Index.Background, Config::BackgroundPolicy::Skip);
179
180 Frag = {};
181 Frag.Index.Background.emplace("Foo");
182 EXPECT_TRUE(compileAndApply());
183 EXPECT_EQ(Conf.Index.Background, Config::BackgroundPolicy::Build)
184 << "by default";
185 EXPECT_THAT(
186 Diags.Diagnostics,
187 ElementsAre(diagMessage(
188 "Invalid Background value 'Foo'. Valid values are Build, Skip.")));
189}
190
191TEST_F(ConfigCompileTests, PathSpecMatch) {
192 auto BarPath = llvm::sys::path::convert_to_slash(testPath("foo/bar.h"));
193 Parm.Path = BarPath;
194
195 struct {
196 std::string Directory;
197 std::string PathSpec;
198 bool ShouldMatch;
199 } Cases[] = {
200 {
201 // Absolute path matches.
202 "",
203 llvm::sys::path::convert_to_slash(testPath("foo/bar.h")),
204 true,
205 },
206 {
207 // Absolute path fails.
208 "",
209 llvm::sys::path::convert_to_slash(testPath("bar/bar.h")),
210 false,
211 },
212 {
213 // Relative should fail to match as /foo/bar.h doesn't reside under
214 // /baz/.
215 testPath("baz"),
216 "bar\\.h",
217 false,
218 },
219 {
220 // Relative should pass with /foo as directory.
221 testPath("foo"),
222 "bar\\.h",
223 true,
224 },
225 };
226
227 // PathMatch
228 for (const auto &Case : Cases) {
229 Frag = {};
230 Frag.If.PathMatch.emplace_back(Case.PathSpec);
231 Frag.Source.Directory = Case.Directory;
232 EXPECT_EQ(compileAndApply(), Case.ShouldMatch);
233 ASSERT_THAT(Diags.Diagnostics, IsEmpty());
234 }
235
236 // PathEclude
237 for (const auto &Case : Cases) {
238 SCOPED_TRACE(Case.Directory);
239 SCOPED_TRACE(Case.PathSpec);
240 Frag = {};
241 Frag.If.PathExclude.emplace_back(Case.PathSpec);
242 Frag.Source.Directory = Case.Directory;
243 EXPECT_NE(compileAndApply(), Case.ShouldMatch);
244 ASSERT_THAT(Diags.Diagnostics, IsEmpty());
245 }
246}
247
248TEST_F(ConfigCompileTests, DiagnosticsIncludeCleaner) {
249 // Defaults to Strict.
250 EXPECT_TRUE(compileAndApply());
251 EXPECT_EQ(Conf.Diagnostics.UnusedIncludes, Config::IncludesPolicy::Strict);
252
253 Frag = {};
254 Frag.Diagnostics.UnusedIncludes.emplace("None");
255 EXPECT_TRUE(compileAndApply());
256 EXPECT_EQ(Conf.Diagnostics.UnusedIncludes, Config::IncludesPolicy::None);
257
258 Frag = {};
259 Frag.Diagnostics.UnusedIncludes.emplace("Strict");
260 EXPECT_TRUE(compileAndApply());
261 EXPECT_EQ(Conf.Diagnostics.UnusedIncludes, Config::IncludesPolicy::Strict);
262
263 Frag = {};
264 EXPECT_TRUE(Conf.Diagnostics.Includes.IgnoreHeader.empty())
265 << Conf.Diagnostics.Includes.IgnoreHeader.size();
266 Frag.Diagnostics.Includes.IgnoreHeader.push_back(
267 Located<std::string>("foo.h"));
268 Frag.Diagnostics.Includes.IgnoreHeader.push_back(
269 Located<std::string>(".*inc"));
270 EXPECT_TRUE(compileAndApply());
271 auto HeaderFilter = [this](llvm::StringRef Path) {
272 for (auto &Filter : Conf.Diagnostics.Includes.IgnoreHeader) {
273 if (Filter(Path))
274 return true;
275 }
276 return false;
277 };
278 EXPECT_TRUE(HeaderFilter("foo.h"));
279 EXPECT_FALSE(HeaderFilter("bar.h"));
280
281 Frag = {};
282 EXPECT_FALSE(Conf.Diagnostics.Includes.AnalyzeAngledIncludes);
283 Frag.Diagnostics.Includes.AnalyzeAngledIncludes = true;
284 EXPECT_TRUE(compileAndApply());
285 EXPECT_TRUE(Conf.Diagnostics.Includes.AnalyzeAngledIncludes);
286}
287
288TEST_F(ConfigCompileTests, DiagnosticSuppression) {
289 Frag.Diagnostics.Suppress.emplace_back("bugprone-use-after-move");
290 Frag.Diagnostics.Suppress.emplace_back("unreachable-code");
291 Frag.Diagnostics.Suppress.emplace_back("-Wunused-variable");
292 Frag.Diagnostics.Suppress.emplace_back("typecheck_bool_condition");
293 Frag.Diagnostics.Suppress.emplace_back("err_unexpected_friend");
294 Frag.Diagnostics.Suppress.emplace_back("warn_alloca");
295 EXPECT_TRUE(compileAndApply());
296 EXPECT_THAT(Conf.Diagnostics.Suppress.keys(),
297 UnorderedElementsAre("bugprone-use-after-move",
298 "unreachable-code", "unused-variable",
299 "typecheck_bool_condition",
300 "unexpected_friend", "warn_alloca"));
301 Frag.Diagnostics.Suppress.emplace_back("*");
302 EXPECT_TRUE(compileAndApply());
303 EXPECT_TRUE(Conf.Diagnostics.SuppressAll);
304 EXPECT_THAT(Conf.Diagnostics.Suppress, IsEmpty());
305}
306
307TEST_F(ConfigCompileTests, Tidy) {
308 auto &Tidy = Frag.Diagnostics.ClangTidy;
309 Tidy.Add.emplace_back("bugprone-use-after-move");
310 Tidy.Add.emplace_back("llvm-*");
311 Tidy.Remove.emplace_back("llvm-include-order");
312 Tidy.Remove.emplace_back("readability-*");
313 Tidy.CheckOptions.emplace_back(std::make_pair(
314 std::string("example-check.ExampleOption"), std::string("0")));
315 EXPECT_TRUE(compileAndApply());
316 EXPECT_EQ(Conf.Diagnostics.ClangTidy.CheckOptions.size(), 1U);
317 EXPECT_EQ(Conf.Diagnostics.ClangTidy.CheckOptions.lookup(
318 "example-check.ExampleOption"),
319 "0");
320#if CLANGD_TIDY_CHECKS
321 EXPECT_EQ(
322 Conf.Diagnostics.ClangTidy.Checks,
323 "bugprone-use-after-move,llvm-*,-llvm-include-order,-readability-*");
324 EXPECT_THAT(Diags.Diagnostics, IsEmpty());
325#else // !CLANGD_TIDY_CHECKS
326 EXPECT_EQ(Conf.Diagnostics.ClangTidy.Checks, "llvm-*,-readability-*");
327 EXPECT_THAT(
328 Diags.Diagnostics,
329 ElementsAre(
330 diagMessage(
331 "clang-tidy check 'bugprone-use-after-move' was not found"),
332 diagMessage("clang-tidy check 'llvm-include-order' was not found")));
333#endif
334}
335
336TEST_F(ConfigCompileTests, TidyExperimentalCustomChecks) {
337 EXPECT_FALSE(Conf.Diagnostics.ClangTidy.ExperimentalCustomChecks);
338
339 Frag.Diagnostics.ClangTidy.ExperimentalCustomChecks = true;
340 EXPECT_TRUE(compileAndApply());
341 EXPECT_TRUE(Conf.Diagnostics.ClangTidy.ExperimentalCustomChecks);
342
343 Fragment Override;
344 Override.Diagnostics.ClangTidy.ExperimentalCustomChecks = false;
345 auto Compiled = std::move(Override).compile(Diags.callback());
346 EXPECT_TRUE(Compiled(Parm, Conf));
347 EXPECT_FALSE(Conf.Diagnostics.ClangTidy.ExperimentalCustomChecks);
348}
349
350TEST_F(ConfigCompileTests, TidyBadChecks) {
351 auto &Tidy = Frag.Diagnostics.ClangTidy;
352 Tidy.Add.emplace_back("unknown-check");
353 Tidy.Remove.emplace_back("*");
354 Tidy.Remove.emplace_back("llvm-includeorder");
355 EXPECT_TRUE(compileAndApply());
356 // Ensure bad checks are stripped from the glob.
357 EXPECT_EQ(Conf.Diagnostics.ClangTidy.Checks, "-*");
358 EXPECT_THAT(
359 Diags.Diagnostics,
360 ElementsAre(
361 AllOf(diagMessage("clang-tidy check 'unknown-check' was not found"),
362 diagKind(llvm::SourceMgr::DK_Warning)),
363 AllOf(
364 diagMessage("clang-tidy check 'llvm-includeorder' was not found"),
365 diagKind(llvm::SourceMgr::DK_Warning))));
366}
367
368TEST_F(ConfigCompileTests, ExternalServerNeedsTrusted) {
369 Fragment::IndexBlock::ExternalBlock External;
370 External.Server.emplace("xxx");
371 Frag.Index.External = std::move(External);
372 compileAndApply();
373 EXPECT_THAT(
374 Diags.Diagnostics,
375 ElementsAre(diagMessage(
376 "Remote index may not be specified by untrusted configuration. "
377 "Copy this into user config to use it.")));
378 EXPECT_EQ(Conf.Index.External.Kind, Config::ExternalIndexSpec::None);
379}
380
381TEST_F(ConfigCompileTests, ExternalBlockWarnOnMultipleSource) {
382 Frag.Source.Trusted = true;
383 Fragment::IndexBlock::ExternalBlock External;
384 External.File.emplace("");
385 External.Server.emplace("");
386 Frag.Index.External = std::move(External);
387 compileAndApply();
388#ifdef CLANGD_ENABLE_REMOTE
389 EXPECT_THAT(
390 Diags.Diagnostics,
391 Contains(
392 AllOf(diagMessage("Exactly one of File, Server or None must be set."),
393 diagKind(llvm::SourceMgr::DK_Error))));
394#else
395 ASSERT_TRUE(Conf.Index.External.hasValue());
396 EXPECT_EQ(Conf.Index.External->Kind, Config::ExternalIndexSpec::File);
397#endif
398}
399
400TEST_F(ConfigCompileTests, ExternalBlockDisableWithNone) {
401 compileAndApply();
402 EXPECT_EQ(Conf.Index.External.Kind, Config::ExternalIndexSpec::None);
403
404 Fragment::IndexBlock::ExternalBlock External;
405 External.IsNone = true;
406 Frag.Index.External = std::move(External);
407 compileAndApply();
408 EXPECT_EQ(Conf.Index.External.Kind, Config::ExternalIndexSpec::None);
409}
410
411TEST_F(ConfigCompileTests, ExternalBlockErrOnNoSource) {
412 Frag.Index.External.emplace(Fragment::IndexBlock::ExternalBlock{});
413 compileAndApply();
414 EXPECT_THAT(
415 Diags.Diagnostics,
416 Contains(
417 AllOf(diagMessage("Exactly one of File, Server or None must be set."),
418 diagKind(llvm::SourceMgr::DK_Error))));
419}
420
421TEST_F(ConfigCompileTests, ExternalBlockDisablesBackgroundIndex) {
422 auto BazPath = testPath("foo/bar/baz.h", llvm::sys::path::Style::posix);
423 Parm.Path = BazPath;
424 Frag.Index.Background.emplace("Build");
425 Fragment::IndexBlock::ExternalBlock External;
426 External.File.emplace(testPath("foo"));
427 External.MountPoint.emplace(
428 testPath("foo/bar", llvm::sys::path::Style::posix));
429 Frag.Index.External = std::move(External);
430 compileAndApply();
431 EXPECT_EQ(Conf.Index.Background, Config::BackgroundPolicy::Skip);
432}
433
434TEST_F(ConfigCompileTests, ExternalBlockMountPoint) {
435 auto GetFrag = [](llvm::StringRef Directory,
436 std::optional<const char *> MountPoint) {
437 Fragment Frag;
438 Frag.Source.Directory = Directory.str();
439 Fragment::IndexBlock::ExternalBlock External;
440 External.File.emplace(testPath("foo"));
441 if (MountPoint)
442 External.MountPoint.emplace(*MountPoint);
443 Frag.Index.External = std::move(External);
444 return Frag;
445 };
446
447 auto BarPath = testPath("foo/bar.h", llvm::sys::path::Style::posix);
448 BarPath = llvm::sys::path::convert_to_slash(BarPath);
449 Parm.Path = BarPath;
450 // Non-absolute MountPoint without a directory raises an error.
451 Frag = GetFrag("", "foo");
452 compileAndApply();
453 ASSERT_THAT(
454 Diags.Diagnostics,
455 ElementsAre(
456 AllOf(diagMessage("MountPoint must be an absolute path, because this "
457 "fragment is not associated with any directory."),
458 diagKind(llvm::SourceMgr::DK_Error))));
459 EXPECT_EQ(Conf.Index.External.Kind, Config::ExternalIndexSpec::None);
460
461 auto FooPath = testPath("foo/", llvm::sys::path::Style::posix);
462 FooPath = llvm::sys::path::convert_to_slash(FooPath);
463 // Ok when relative.
464 Frag = GetFrag(testRoot(), "foo/");
465 compileAndApply();
466 ASSERT_THAT(Diags.Diagnostics, IsEmpty());
467 ASSERT_EQ(Conf.Index.External.Kind, Config::ExternalIndexSpec::File);
468 EXPECT_THAT(Conf.Index.External.MountPoint, FooPath);
469
470 // None defaults to ".".
471 Frag = GetFrag(FooPath, std::nullopt);
472 compileAndApply();
473 ASSERT_THAT(Diags.Diagnostics, IsEmpty());
474 ASSERT_EQ(Conf.Index.External.Kind, Config::ExternalIndexSpec::File);
475 EXPECT_THAT(Conf.Index.External.MountPoint, FooPath);
476
477 // Without a file, external index is empty.
478 Parm.Path = "";
479 Frag = GetFrag("", FooPath.c_str());
480 compileAndApply();
481 ASSERT_THAT(Diags.Diagnostics, IsEmpty());
482 ASSERT_EQ(Conf.Index.External.Kind, Config::ExternalIndexSpec::None);
483
484 // File outside MountPoint, no index.
485 auto BazPath = testPath("bar/baz.h", llvm::sys::path::Style::posix);
486 BazPath = llvm::sys::path::convert_to_slash(BazPath);
487 Parm.Path = BazPath;
488 Frag = GetFrag("", FooPath.c_str());
489 compileAndApply();
490 ASSERT_THAT(Diags.Diagnostics, IsEmpty());
491 ASSERT_EQ(Conf.Index.External.Kind, Config::ExternalIndexSpec::None);
492
493 // File under MountPoint, index should be set.
494 BazPath = testPath("foo/baz.h", llvm::sys::path::Style::posix);
495 BazPath = llvm::sys::path::convert_to_slash(BazPath);
496 Parm.Path = BazPath;
497 Frag = GetFrag("", FooPath.c_str());
498 compileAndApply();
499 ASSERT_THAT(Diags.Diagnostics, IsEmpty());
500 ASSERT_EQ(Conf.Index.External.Kind, Config::ExternalIndexSpec::File);
501 EXPECT_THAT(Conf.Index.External.MountPoint, FooPath);
502
503 // Only matches case-insensitively.
504 BazPath = testPath("fOo/baz.h", llvm::sys::path::Style::posix);
505 BazPath = llvm::sys::path::convert_to_slash(BazPath);
506 Parm.Path = BazPath;
507
508 FooPath = testPath("FOO/", llvm::sys::path::Style::posix);
509 FooPath = llvm::sys::path::convert_to_slash(FooPath);
510 Frag = GetFrag("", FooPath.c_str());
511 compileAndApply();
512 ASSERT_THAT(Diags.Diagnostics, IsEmpty());
513#ifdef CLANGD_PATH_CASE_INSENSITIVE
514 ASSERT_EQ(Conf.Index.External.Kind, Config::ExternalIndexSpec::File);
515 EXPECT_THAT(Conf.Index.External.MountPoint, FooPath);
516#else
517 ASSERT_EQ(Conf.Index.External.Kind, Config::ExternalIndexSpec::None);
518#endif
519}
520
521TEST_F(ConfigCompileTests, AllScopes) {
522 // Defaults to true.
523 EXPECT_TRUE(compileAndApply());
524 EXPECT_TRUE(Conf.Completion.AllScopes);
525
526 Frag = {};
527 Frag.Completion.AllScopes = false;
528 EXPECT_TRUE(compileAndApply());
529 EXPECT_FALSE(Conf.Completion.AllScopes);
530
531 Frag = {};
532 Frag.Completion.AllScopes = true;
533 EXPECT_TRUE(compileAndApply());
534 EXPECT_TRUE(Conf.Completion.AllScopes);
535}
536
537TEST_F(ConfigCompileTests, Style) {
538 Frag = {};
539 Frag.Style.FullyQualifiedNamespaces.push_back(std::string("foo"));
540 Frag.Style.FullyQualifiedNamespaces.push_back(std::string("bar"));
541 EXPECT_TRUE(compileAndApply());
542 EXPECT_THAT(Conf.Style.FullyQualifiedNamespaces, ElementsAre("foo", "bar"));
543
544 {
545 Frag = {};
546 EXPECT_TRUE(Conf.Style.QuotedHeaders.empty())
547 << Conf.Style.QuotedHeaders.size();
548 Frag.Style.QuotedHeaders.push_back(Located<std::string>("foo.h"));
549 Frag.Style.QuotedHeaders.push_back(Located<std::string>(".*inc"));
550 EXPECT_TRUE(compileAndApply());
551 auto HeaderFilter = [this](llvm::StringRef Path) {
552 for (auto &Filter : Conf.Style.QuotedHeaders) {
553 if (Filter(Path))
554 return true;
555 }
556 return false;
557 };
558 EXPECT_TRUE(HeaderFilter("foo.h"));
559 EXPECT_TRUE(HeaderFilter("prefix/foo.h"));
560 EXPECT_FALSE(HeaderFilter("bar.h"));
561 EXPECT_FALSE(HeaderFilter("foo.h/bar.h"));
562 }
563
564 {
565 Frag = {};
566 EXPECT_TRUE(Conf.Style.AngledHeaders.empty())
567 << Conf.Style.AngledHeaders.size();
568 Frag.Style.AngledHeaders.push_back(Located<std::string>("foo.h"));
569 Frag.Style.AngledHeaders.push_back(Located<std::string>(".*inc"));
570 EXPECT_TRUE(compileAndApply());
571 auto HeaderFilter = [this](llvm::StringRef Path) {
572 for (auto &Filter : Conf.Style.AngledHeaders) {
573 if (Filter(Path))
574 return true;
575 }
576 return false;
577 };
578 EXPECT_TRUE(HeaderFilter("foo.h"));
579 EXPECT_FALSE(HeaderFilter("bar.h"));
580 }
581}
582} // namespace
583} // namespace config
584} // namespace clangd
585} // namespace clang
Directory
static cl::opt< std::string > Directory(cl::Positional, cl::Required, cl::desc("<Search Root Directory>"))
Config
static cl::opt< std::string > Config("config", desc(R"( Specifies a configuration in YAML/JSON format: -config="{Checks:' *', CheckOptions:{x:y}}" When the value is empty, clang-tidy will attempt to find a file named .clang-tidy for each source file in its parent directories. )"), cl::init(""), cl::cat(ClangTidyCategory))
clang::clangd
FIXME: Skip testing on windows temporarily due to the different escaping code mode.
Definition AST.cpp:44
clang::clangd::TEST_F
TEST_F(BackgroundIndexTest, NoCrashOnErrorFile)
Definition BackgroundIndexTests.cpp:94
clang::clangd::testPath
std::string testPath(PathRef File, llvm::sys::path::Style Style)
Definition TestFS.cpp:94
clang::clangd::HeaderFilter
llvm::ArrayRef< std::function< bool(llvm::StringRef)> > HeaderFilter
Definition Headers.h:36
clang::clangd::Path
std::string Path
A typedef to represent a file path.
Definition Path.h:26
clang::clangd::testRoot
const char * testRoot()
Definition TestFS.cpp:85
clang
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Definition ApplyReplacements.h:27
clang::clangd::Config::IncludesPolicy::Strict
@ Strict
Diagnose missing and unused includes.
Definition Config.h:99
clang::clangd::config::Fragment::DiagnosticsBlock::ClangTidyBlock::ExperimentalCustomChecks
std::optional< Located< bool > > ExperimentalCustomChecks
Whether to enable experimental query-based custom checks configured in .clang-tidy files.
Definition ConfigFragment.h:303
clang::clangd::config::Fragment::IndexBlock::ExternalBlock
An external index uses data source outside of clangd itself.
Definition ConfigFragment.h:195
clang::clangd::config::Fragment::IndexBlock::ExternalBlock::Server
std::optional< Located< std::string > > Server
Address and port number for a clangd-index-server.
Definition ConfigFragment.h:204
clang::clangd::config::Fragment::IndexBlock::ExternalBlock::IsNone
Located< bool > IsNone
Whether the block is explicitly set to None.
Definition ConfigFragment.h:198
clang::clangd::config::Fragment::IndexBlock::ExternalBlock::File
std::optional< Located< std::string > > File
Path to an index file generated by clangd-indexer.
Definition ConfigFragment.h:201
clang::clangd::config::Fragment::SourceInfo::Directory
std::string Directory
Absolute path to directory the fragment is associated with.
Definition ConfigFragment.h:95
clang::clangd::config::Fragment
A chunk of configuration obtained from a config file, LSP, or elsewhere.
Definition ConfigFragment.h:63
clang::clangd::config::Located
An entity written in config along, with its optional location in the file.
Definition ConfigFragment.h:48
Generated on for clang-tools by doxygen 1.14.0