clang-tools 20.0.0git
ConfigCompile.cpp
Go to the documentation of this file.
1//===--- ConfigCompile.cpp - Translating Fragments into Config ------------===//
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// Fragments are applied to Configs in two steps:
10//
11// 1. (When the fragment is first loaded)
12// FragmentCompiler::compile() traverses the Fragment and creates
13// function objects that know how to apply the configuration.
14// 2. (Every time a config is required)
15// CompiledFragment() executes these functions to populate the Config.
16//
17// Work could be split between these steps in different ways. We try to
18// do as much work as possible in the first step. For example, regexes are
19// compiled in stage 1 and captured by the apply function. This is because:
20//
21// - it's more efficient, as the work done in stage 1 must only be done once
22// - problems can be reported in stage 1, in stage 2 we must silently recover
23//
24//===----------------------------------------------------------------------===//
25
26#include "CompileCommands.h"
27#include "Config.h"
28#include "ConfigFragment.h"
29#include "ConfigProvider.h"
30#include "Diagnostics.h"
31#include "Feature.h"
32#include "TidyProvider.h"
33#include "support/Logger.h"
34#include "support/Path.h"
35#include "support/Trace.h"
36#include "llvm/ADT/STLExtras.h"
37#include "llvm/ADT/SmallString.h"
38#include "llvm/ADT/StringExtras.h"
39#include "llvm/ADT/StringRef.h"
40#include "llvm/Support/FileSystem.h"
41#include "llvm/Support/FormatVariadic.h"
42#include "llvm/Support/Path.h"
43#include "llvm/Support/Regex.h"
44#include "llvm/Support/SMLoc.h"
45#include "llvm/Support/SourceMgr.h"
46#include <algorithm>
47#include <memory>
48#include <optional>
49#include <string>
50#include <vector>
51
52namespace clang {
53namespace clangd {
54namespace config {
55namespace {
56
57// Returns an empty stringref if Path is not under FragmentDir. Returns Path
58// as-is when FragmentDir is empty.
59llvm::StringRef configRelative(llvm::StringRef Path,
60 llvm::StringRef FragmentDir) {
61 if (FragmentDir.empty())
62 return Path;
63 if (!Path.consume_front(FragmentDir))
64 return llvm::StringRef();
65 return Path.empty() ? "." : Path;
66}
67
68struct CompiledFragmentImpl {
69 // The independent conditions to check before using settings from this config.
70 // The following fragment has *two* conditions:
71 // If: { Platform: [mac, linux], PathMatch: foo/.* }
72 // All of them must be satisfied: the platform and path conditions are ANDed.
73 // The OR logic for the platform condition is implemented inside the function.
74 std::vector<llvm::unique_function<bool(const Params &) const>> Conditions;
75 // Mutations that this fragment will apply to the configuration.
76 // These are invoked only if the conditions are satisfied.
77 std::vector<llvm::unique_function<void(const Params &, Config &) const>>
79
80 bool operator()(const Params &P, Config &C) const {
81 for (const auto &C : Conditions) {
82 if (!C(P)) {
83 dlog("Config fragment {0}: condition not met", this);
84 return false;
85 }
86 }
87 dlog("Config fragment {0}: applying {1} rules", this, Apply.size());
88 for (const auto &A : Apply)
89 A(P, C);
90 return true;
91 }
92};
93
94// Wrapper around condition compile() functions to reduce arg-passing.
95struct FragmentCompiler {
96 FragmentCompiler(CompiledFragmentImpl &Out, DiagnosticCallback D,
97 llvm::SourceMgr *SM)
98 : Out(Out), Diagnostic(D), SourceMgr(SM) {}
99 CompiledFragmentImpl &Out;
101 llvm::SourceMgr *SourceMgr;
102 // Normalized Fragment::SourceInfo::Directory.
103 std::string FragmentDirectory;
104 bool Trusted = false;
105
106 std::optional<llvm::Regex>
107 compileRegex(const Located<std::string> &Text,
108 llvm::Regex::RegexFlags Flags = llvm::Regex::NoFlags) {
109 std::string Anchored = "^(" + *Text + ")$";
110 llvm::Regex Result(Anchored, Flags);
111 std::string RegexError;
112 if (!Result.isValid(RegexError)) {
113 diag(Error, "Invalid regex " + Anchored + ": " + RegexError, Text.Range);
114 return std::nullopt;
115 }
116 return std::move(Result);
117 }
118
119 std::optional<std::string> makeAbsolute(Located<std::string> Path,
120 llvm::StringLiteral Description,
121 llvm::sys::path::Style Style) {
122 if (llvm::sys::path::is_absolute(*Path))
123 return *Path;
124 if (FragmentDirectory.empty()) {
125 diag(Error,
126 llvm::formatv(
127 "{0} must be an absolute path, because this fragment is not "
128 "associated with any directory.",
129 Description)
130 .str(),
131 Path.Range);
132 return std::nullopt;
133 }
134 llvm::SmallString<256> AbsPath = llvm::StringRef(*Path);
135 llvm::sys::fs::make_absolute(FragmentDirectory, AbsPath);
136 llvm::sys::path::native(AbsPath, Style);
137 return AbsPath.str().str();
138 }
139
140 // Helper with similar API to StringSwitch, for parsing enum values.
141 template <typename T> class EnumSwitch {
142 FragmentCompiler &Outer;
143 llvm::StringRef EnumName;
144 const Located<std::string> &Input;
145 std::optional<T> Result;
146 llvm::SmallVector<llvm::StringLiteral> ValidValues;
147
148 public:
149 EnumSwitch(llvm::StringRef EnumName, const Located<std::string> &In,
150 FragmentCompiler &Outer)
151 : Outer(Outer), EnumName(EnumName), Input(In) {}
152
153 EnumSwitch &map(llvm::StringLiteral Name, T Value) {
154 assert(!llvm::is_contained(ValidValues, Name) && "Duplicate value!");
155 ValidValues.push_back(Name);
156 if (!Result && *Input == Name)
157 Result = Value;
158 return *this;
159 }
160
161 std::optional<T> value() {
162 if (!Result)
163 Outer.diag(
164 Warning,
165 llvm::formatv("Invalid {0} value '{1}'. Valid values are {2}.",
166 EnumName, *Input, llvm::join(ValidValues, ", "))
167 .str(),
168 Input.Range);
169 return Result;
170 };
171 };
172
173 // Attempt to parse a specified string into an enum.
174 // Yields std::nullopt and produces a diagnostic on failure.
175 //
176 // std::optional<T> Value = compileEnum<En>("Foo", Frag.Foo)
177 // .map("Foo", Enum::Foo)
178 // .map("Bar", Enum::Bar)
179 // .value();
180 template <typename T>
181 EnumSwitch<T> compileEnum(llvm::StringRef EnumName,
182 const Located<std::string> &In) {
183 return EnumSwitch<T>(EnumName, In, *this);
184 }
185
186 void compile(Fragment &&F) {
187 Trusted = F.Source.Trusted;
188 if (!F.Source.Directory.empty()) {
189 FragmentDirectory = llvm::sys::path::convert_to_slash(F.Source.Directory);
190 if (FragmentDirectory.back() != '/')
191 FragmentDirectory += '/';
192 }
193 compile(std::move(F.If));
194 compile(std::move(F.CompileFlags));
195 compile(std::move(F.Index));
196 compile(std::move(F.Diagnostics));
197 compile(std::move(F.Completion));
198 compile(std::move(F.Hover));
199 compile(std::move(F.InlayHints));
200 compile(std::move(F.SemanticTokens));
201 compile(std::move(F.Style));
202 }
203
204 void compile(Fragment::IfBlock &&F) {
205 if (F.HasUnrecognizedCondition)
206 Out.Conditions.push_back([&](const Params &) { return false; });
207
208#ifdef CLANGD_PATH_CASE_INSENSITIVE
209 llvm::Regex::RegexFlags Flags = llvm::Regex::IgnoreCase;
210#else
211 llvm::Regex::RegexFlags Flags = llvm::Regex::NoFlags;
212#endif
213
214 auto PathMatch = std::make_unique<std::vector<llvm::Regex>>();
215 for (auto &Entry : F.PathMatch) {
216 if (auto RE = compileRegex(Entry, Flags))
217 PathMatch->push_back(std::move(*RE));
218 }
219 if (!PathMatch->empty()) {
220 Out.Conditions.push_back(
221 [PathMatch(std::move(PathMatch)),
222 FragmentDir(FragmentDirectory)](const Params &P) {
223 if (P.Path.empty())
224 return false;
225 llvm::StringRef Path = configRelative(P.Path, FragmentDir);
226 // Ignore the file if it is not nested under Fragment.
227 if (Path.empty())
228 return false;
229 return llvm::any_of(*PathMatch, [&](const llvm::Regex &RE) {
230 return RE.match(Path);
231 });
232 });
233 }
234
235 auto PathExclude = std::make_unique<std::vector<llvm::Regex>>();
236 for (auto &Entry : F.PathExclude) {
237 if (auto RE = compileRegex(Entry, Flags))
238 PathExclude->push_back(std::move(*RE));
239 }
240 if (!PathExclude->empty()) {
241 Out.Conditions.push_back(
242 [PathExclude(std::move(PathExclude)),
243 FragmentDir(FragmentDirectory)](const Params &P) {
244 if (P.Path.empty())
245 return false;
246 llvm::StringRef Path = configRelative(P.Path, FragmentDir);
247 // Ignore the file if it is not nested under Fragment.
248 if (Path.empty())
249 return true;
250 return llvm::none_of(*PathExclude, [&](const llvm::Regex &RE) {
251 return RE.match(Path);
252 });
253 });
254 }
255 }
256
257 void compile(Fragment::CompileFlagsBlock &&F) {
258 if (F.Compiler)
259 Out.Apply.push_back(
260 [Compiler(std::move(**F.Compiler))](const Params &, Config &C) {
261 C.CompileFlags.Edits.push_back(
262 [Compiler](std::vector<std::string> &Args) {
263 if (!Args.empty())
264 Args.front() = Compiler;
265 });
266 });
267
268 if (!F.Remove.empty()) {
269 auto Remove = std::make_shared<ArgStripper>();
270 for (auto &A : F.Remove)
271 Remove->strip(*A);
272 Out.Apply.push_back([Remove(std::shared_ptr<const ArgStripper>(
273 std::move(Remove)))](const Params &, Config &C) {
274 C.CompileFlags.Edits.push_back(
275 [Remove](std::vector<std::string> &Args) {
276 Remove->process(Args);
277 });
278 });
279 }
280
281 if (!F.Add.empty()) {
282 std::vector<std::string> Add;
283 for (auto &A : F.Add)
284 Add.push_back(std::move(*A));
285 Out.Apply.push_back([Add(std::move(Add))](const Params &, Config &C) {
286 C.CompileFlags.Edits.push_back([Add](std::vector<std::string> &Args) {
287 // The point to insert at. Just append when `--` isn't present.
288 auto It = llvm::find(Args, "--");
289 Args.insert(It, Add.begin(), Add.end());
290 });
291 });
292 }
293
294 if (F.CompilationDatabase) {
295 std::optional<Config::CDBSearchSpec> Spec;
296 if (**F.CompilationDatabase == "Ancestors") {
297 Spec.emplace();
299 } else if (**F.CompilationDatabase == "None") {
300 Spec.emplace();
302 } else {
303 if (auto Path =
304 makeAbsolute(*F.CompilationDatabase, "CompilationDatabase",
305 llvm::sys::path::Style::native)) {
306 // Drop trailing slash to put the path in canonical form.
307 // Should makeAbsolute do this?
308 llvm::StringRef Rel = llvm::sys::path::relative_path(*Path);
309 if (!Rel.empty() && llvm::sys::path::is_separator(Rel.back()))
310 Path->pop_back();
311
312 Spec.emplace();
313 Spec->Policy = Config::CDBSearchSpec::FixedDir;
314 Spec->FixedCDBPath = std::move(Path);
315 }
316 }
317 if (Spec)
318 Out.Apply.push_back(
319 [Spec(std::move(*Spec))](const Params &, Config &C) {
320 C.CompileFlags.CDBSearch = Spec;
321 });
322 }
323 }
324
325 void compile(Fragment::IndexBlock &&F) {
326 if (F.Background) {
327 if (auto Val =
328 compileEnum<Config::BackgroundPolicy>("Background", *F.Background)
331 .value())
332 Out.Apply.push_back(
333 [Val](const Params &, Config &C) { C.Index.Background = *Val; });
334 }
335 if (F.External)
336 compile(std::move(**F.External), F.External->Range);
337 if (F.StandardLibrary)
338 Out.Apply.push_back(
339 [Val(**F.StandardLibrary)](const Params &, Config &C) {
340 C.Index.StandardLibrary = Val;
341 });
342 }
343
344 void compile(Fragment::IndexBlock::ExternalBlock &&External,
345 llvm::SMRange BlockRange) {
346 if (External.Server && !Trusted) {
347 diag(Error,
348 "Remote index may not be specified by untrusted configuration. "
349 "Copy this into user config to use it.",
350 External.Server->Range);
351 return;
352 }
353#ifndef CLANGD_ENABLE_REMOTE
354 if (External.Server) {
355 elog("Clangd isn't compiled with remote index support, ignoring Server: "
356 "{0}",
357 *External.Server);
358 External.Server.reset();
359 }
360#endif
361 // Make sure exactly one of the Sources is set.
362 unsigned SourceCount = External.File.has_value() +
363 External.Server.has_value() + *External.IsNone;
364 if (SourceCount != 1) {
365 diag(Error, "Exactly one of File, Server or None must be set.",
366 BlockRange);
367 return;
368 }
369 Config::ExternalIndexSpec Spec;
370 if (External.Server) {
372 Spec.Location = std::move(**External.Server);
373 } else if (External.File) {
375 auto AbsPath = makeAbsolute(std::move(*External.File), "File",
376 llvm::sys::path::Style::native);
377 if (!AbsPath)
378 return;
379 Spec.Location = std::move(*AbsPath);
380 } else {
381 assert(*External.IsNone);
383 }
384 if (Spec.Kind != Config::ExternalIndexSpec::None) {
385 // Make sure MountPoint is an absolute path with forward slashes.
386 if (!External.MountPoint)
387 External.MountPoint.emplace(FragmentDirectory);
388 if ((**External.MountPoint).empty()) {
389 diag(Error, "A mountpoint is required.", BlockRange);
390 return;
391 }
392 auto AbsPath = makeAbsolute(std::move(*External.MountPoint), "MountPoint",
393 llvm::sys::path::Style::posix);
394 if (!AbsPath)
395 return;
396 Spec.MountPoint = std::move(*AbsPath);
397 }
398 Out.Apply.push_back([Spec(std::move(Spec))](const Params &P, Config &C) {
399 if (Spec.Kind == Config::ExternalIndexSpec::None) {
400 C.Index.External = Spec;
401 return;
402 }
403 if (P.Path.empty() || !pathStartsWith(Spec.MountPoint, P.Path,
404 llvm::sys::path::Style::posix))
405 return;
406 C.Index.External = Spec;
407 // Disable background indexing for the files under the mountpoint.
408 // Note that this will overwrite statements in any previous fragments
409 // (including the current one).
410 C.Index.Background = Config::BackgroundPolicy::Skip;
411 });
412 }
413
414 void compile(Fragment::DiagnosticsBlock &&F) {
415 std::vector<std::string> Normalized;
416 for (const auto &Suppressed : F.Suppress) {
417 if (*Suppressed == "*") {
418 Out.Apply.push_back([&](const Params &, Config &C) {
419 C.Diagnostics.SuppressAll = true;
420 C.Diagnostics.Suppress.clear();
421 });
422 return;
423 }
424 Normalized.push_back(normalizeSuppressedCode(*Suppressed).str());
425 }
426 if (!Normalized.empty())
427 Out.Apply.push_back(
428 [Normalized(std::move(Normalized))](const Params &, Config &C) {
429 if (C.Diagnostics.SuppressAll)
430 return;
431 for (llvm::StringRef N : Normalized)
432 C.Diagnostics.Suppress.insert(N);
433 });
434
435 if (F.UnusedIncludes) {
436 auto Val = compileEnum<Config::IncludesPolicy>("UnusedIncludes",
437 **F.UnusedIncludes)
438 .map("Strict", Config::IncludesPolicy::Strict)
439 .map("None", Config::IncludesPolicy::None)
440 .value();
441 if (!Val && **F.UnusedIncludes == "Experiment") {
442 diag(Warning,
443 "Experiment is deprecated for UnusedIncludes, use Strict instead.",
444 F.UnusedIncludes->Range);
446 }
447 if (Val) {
448 Out.Apply.push_back([Val](const Params &, Config &C) {
449 C.Diagnostics.UnusedIncludes = *Val;
450 });
451 }
452 }
453
454 if (F.MissingIncludes)
455 if (auto Val = compileEnum<Config::IncludesPolicy>("MissingIncludes",
456 **F.MissingIncludes)
457 .map("Strict", Config::IncludesPolicy::Strict)
458 .map("None", Config::IncludesPolicy::None)
459 .value())
460 Out.Apply.push_back([Val](const Params &, Config &C) {
461 C.Diagnostics.MissingIncludes = *Val;
462 });
463
464 compile(std::move(F.Includes));
465 compile(std::move(F.ClangTidy));
466 }
467
468 void compile(Fragment::StyleBlock &&F) {
469 if (!F.FullyQualifiedNamespaces.empty()) {
470 std::vector<std::string> FullyQualifiedNamespaces;
471 for (auto &N : F.FullyQualifiedNamespaces) {
472 // Normalize the data by dropping both leading and trailing ::
473 StringRef Namespace(*N);
474 Namespace.consume_front("::");
475 Namespace.consume_back("::");
476 FullyQualifiedNamespaces.push_back(Namespace.str());
477 }
478 Out.Apply.push_back([FullyQualifiedNamespaces(
479 std::move(FullyQualifiedNamespaces))](
480 const Params &, Config &C) {
481 C.Style.FullyQualifiedNamespaces.insert(
482 C.Style.FullyQualifiedNamespaces.begin(),
483 FullyQualifiedNamespaces.begin(), FullyQualifiedNamespaces.end());
484 });
485 }
486 }
487
488 void appendTidyCheckSpec(std::string &CurSpec,
489 const Located<std::string> &Arg, bool IsPositive) {
490 StringRef Str = StringRef(*Arg).trim();
491 // Don't support negating here, its handled if the item is in the Add or
492 // Remove list.
493 if (Str.starts_with("-") || Str.contains(',')) {
494 diag(Error, "Invalid clang-tidy check name", Arg.Range);
495 return;
496 }
497 if (!Str.contains('*')) {
498 if (!isRegisteredTidyCheck(Str)) {
499 diag(Warning,
500 llvm::formatv("clang-tidy check '{0}' was not found", Str).str(),
501 Arg.Range);
502 return;
503 }
504 auto Fast = isFastTidyCheck(Str);
505 if (!Fast.has_value()) {
506 diag(Warning,
507 llvm::formatv(
508 "Latency of clang-tidy check '{0}' is not known. "
509 "It will only run if ClangTidy.FastCheckFilter is Loose or None",
510 Str)
511 .str(),
512 Arg.Range);
513 } else if (!*Fast) {
514 diag(Warning,
515 llvm::formatv(
516 "clang-tidy check '{0}' is slow. "
517 "It will only run if ClangTidy.FastCheckFilter is None",
518 Str)
519 .str(),
520 Arg.Range);
521 }
522 }
523 CurSpec += ',';
524 if (!IsPositive)
525 CurSpec += '-';
526 CurSpec += Str;
527 }
528
529 void compile(Fragment::DiagnosticsBlock::ClangTidyBlock &&F) {
530 std::string Checks;
531 for (auto &CheckGlob : F.Add)
532 appendTidyCheckSpec(Checks, CheckGlob, true);
533
534 for (auto &CheckGlob : F.Remove)
535 appendTidyCheckSpec(Checks, CheckGlob, false);
536
537 if (!Checks.empty())
538 Out.Apply.push_back(
539 [Checks = std::move(Checks)](const Params &, Config &C) {
540 C.Diagnostics.ClangTidy.Checks.append(
541 Checks,
542 C.Diagnostics.ClangTidy.Checks.empty() ? /*skip comma*/ 1 : 0,
543 std::string::npos);
544 });
545 if (!F.CheckOptions.empty()) {
546 std::vector<std::pair<std::string, std::string>> CheckOptions;
547 for (auto &Opt : F.CheckOptions)
548 CheckOptions.emplace_back(std::move(*Opt.first),
549 std::move(*Opt.second));
550 Out.Apply.push_back(
551 [CheckOptions = std::move(CheckOptions)](const Params &, Config &C) {
552 for (auto &StringPair : CheckOptions)
553 C.Diagnostics.ClangTidy.CheckOptions.insert_or_assign(
554 StringPair.first, StringPair.second);
555 });
556 }
557 if (F.FastCheckFilter.has_value())
558 if (auto Val = compileEnum<Config::FastCheckPolicy>("FastCheckFilter",
559 *F.FastCheckFilter)
560 .map("Strict", Config::FastCheckPolicy::Strict)
561 .map("Loose", Config::FastCheckPolicy::Loose)
563 .value())
564 Out.Apply.push_back([Val](const Params &, Config &C) {
565 C.Diagnostics.ClangTidy.FastCheckFilter = *Val;
566 });
567 }
568
569 void compile(Fragment::DiagnosticsBlock::IncludesBlock &&F) {
570#ifdef CLANGD_PATH_CASE_INSENSITIVE
571 static llvm::Regex::RegexFlags Flags = llvm::Regex::IgnoreCase;
572#else
573 static llvm::Regex::RegexFlags Flags = llvm::Regex::NoFlags;
574#endif
575 std::shared_ptr<std::vector<llvm::Regex>> Filters;
576 if (!F.IgnoreHeader.empty()) {
577 Filters = std::make_shared<std::vector<llvm::Regex>>();
578 for (auto &HeaderPattern : F.IgnoreHeader) {
579 // Anchor on the right.
580 std::string AnchoredPattern = "(" + *HeaderPattern + ")$";
581 llvm::Regex CompiledRegex(AnchoredPattern, Flags);
582 std::string RegexError;
583 if (!CompiledRegex.isValid(RegexError)) {
584 diag(Warning,
585 llvm::formatv("Invalid regular expression '{0}': {1}",
586 *HeaderPattern, RegexError)
587 .str(),
588 HeaderPattern.Range);
589 continue;
590 }
591 Filters->push_back(std::move(CompiledRegex));
592 }
593 }
594 // Optional to override the resulting AnalyzeAngledIncludes
595 // only if it's explicitly set in the current fragment.
596 // Otherwise it's inherited from parent fragment.
597 std::optional<bool> AnalyzeAngledIncludes;
598 if (F.AnalyzeAngledIncludes.has_value())
599 AnalyzeAngledIncludes = **F.AnalyzeAngledIncludes;
600 if (!Filters && !AnalyzeAngledIncludes.has_value())
601 return;
602 Out.Apply.push_back([Filters = std::move(Filters),
603 AnalyzeAngledIncludes](const Params &, Config &C) {
604 if (Filters) {
605 auto Filter = [Filters](llvm::StringRef Path) {
606 for (auto &Regex : *Filters)
607 if (Regex.match(Path))
608 return true;
609 return false;
610 };
611 C.Diagnostics.Includes.IgnoreHeader.emplace_back(std::move(Filter));
612 }
613 if (AnalyzeAngledIncludes.has_value())
614 C.Diagnostics.Includes.AnalyzeAngledIncludes = *AnalyzeAngledIncludes;
615 });
616 }
617
618 void compile(Fragment::CompletionBlock &&F) {
619 if (F.AllScopes) {
620 Out.Apply.push_back(
621 [AllScopes(**F.AllScopes)](const Params &, Config &C) {
622 C.Completion.AllScopes = AllScopes;
623 });
624 }
625 }
626
627 void compile(Fragment::HoverBlock &&F) {
628 if (F.ShowAKA) {
629 Out.Apply.push_back([ShowAKA(**F.ShowAKA)](const Params &, Config &C) {
630 C.Hover.ShowAKA = ShowAKA;
631 });
632 }
633 }
634
635 void compile(Fragment::InlayHintsBlock &&F) {
636 if (F.Enabled)
637 Out.Apply.push_back([Value(**F.Enabled)](const Params &, Config &C) {
638 C.InlayHints.Enabled = Value;
639 });
640 if (F.ParameterNames)
641 Out.Apply.push_back(
642 [Value(**F.ParameterNames)](const Params &, Config &C) {
643 C.InlayHints.Parameters = Value;
644 });
645 if (F.DeducedTypes)
646 Out.Apply.push_back([Value(**F.DeducedTypes)](const Params &, Config &C) {
647 C.InlayHints.DeducedTypes = Value;
648 });
649 if (F.Designators)
650 Out.Apply.push_back([Value(**F.Designators)](const Params &, Config &C) {
651 C.InlayHints.Designators = Value;
652 });
653 if (F.BlockEnd)
654 Out.Apply.push_back([Value(**F.BlockEnd)](const Params &, Config &C) {
655 C.InlayHints.BlockEnd = Value;
656 });
657 if (F.TypeNameLimit)
658 Out.Apply.push_back(
659 [Value(**F.TypeNameLimit)](const Params &, Config &C) {
660 C.InlayHints.TypeNameLimit = Value;
661 });
662 }
663
664 void compile(Fragment::SemanticTokensBlock &&F) {
665 if (!F.DisabledKinds.empty()) {
666 std::vector<std::string> DisabledKinds;
667 for (auto &Kind : F.DisabledKinds)
668 DisabledKinds.push_back(std::move(*Kind));
669
670 Out.Apply.push_back(
671 [DisabledKinds(std::move(DisabledKinds))](const Params &, Config &C) {
672 for (auto &Kind : DisabledKinds) {
673 auto It = llvm::find(C.SemanticTokens.DisabledKinds, Kind);
674 if (It == C.SemanticTokens.DisabledKinds.end())
675 C.SemanticTokens.DisabledKinds.push_back(std::move(Kind));
676 }
677 });
678 }
679 if (!F.DisabledModifiers.empty()) {
680 std::vector<std::string> DisabledModifiers;
681 for (auto &Kind : F.DisabledModifiers)
682 DisabledModifiers.push_back(std::move(*Kind));
683
684 Out.Apply.push_back([DisabledModifiers(std::move(DisabledModifiers))](
685 const Params &, Config &C) {
686 for (auto &Kind : DisabledModifiers) {
687 auto It = llvm::find(C.SemanticTokens.DisabledModifiers, Kind);
688 if (It == C.SemanticTokens.DisabledModifiers.end())
689 C.SemanticTokens.DisabledModifiers.push_back(std::move(Kind));
690 }
691 });
692 }
693 }
694
695 constexpr static llvm::SourceMgr::DiagKind Error = llvm::SourceMgr::DK_Error;
696 constexpr static llvm::SourceMgr::DiagKind Warning =
697 llvm::SourceMgr::DK_Warning;
698 void diag(llvm::SourceMgr::DiagKind Kind, llvm::StringRef Message,
699 llvm::SMRange Range) {
700 if (Range.isValid() && SourceMgr != nullptr)
701 Diagnostic(SourceMgr->GetMessage(Range.Start, Kind, Message, Range));
702 else
703 Diagnostic(llvm::SMDiagnostic("", Kind, Message));
704 }
705};
706
707} // namespace
708
709CompiledFragment Fragment::compile(DiagnosticCallback D) && {
710 llvm::StringRef ConfigFile = "<unknown>";
711 std::pair<unsigned, unsigned> LineCol = {0, 0};
712 if (auto *SM = Source.Manager.get()) {
713 unsigned BufID = SM->getMainFileID();
714 LineCol = SM->getLineAndColumn(Source.Location, BufID);
715 ConfigFile = SM->getBufferInfo(BufID).Buffer->getBufferIdentifier();
716 }
717 trace::Span Tracer("ConfigCompile");
718 SPAN_ATTACH(Tracer, "ConfigFile", ConfigFile);
719 auto Result = std::make_shared<CompiledFragmentImpl>();
720 vlog("Config fragment: compiling {0}:{1} -> {2} (trusted={3})", ConfigFile,
721 LineCol.first, Result.get(), Source.Trusted);
722
723 FragmentCompiler{*Result, D, Source.Manager.get()}.compile(std::move(*this));
724 // Return as cheaply-copyable wrapper.
725 return [Result(std::move(Result))](const Params &P, Config &C) {
726 return (*Result)(P, C);
727 };
728}
729
730} // namespace config
731} // namespace clangd
732} // namespace clang
BindArgumentKind Kind
llvm::SmallString< 256U > Name
static cl::opt< std::string > ConfigFile("config-file", desc(R"( Specify the path of .clang-tidy or custom config file: e.g. --config-file=/some/path/myTidyConfigFile This option internally works exactly the same way as --config option after reading specified config file. Use either --config-file or --config, not both. )"), cl::init(""), cl::cat(ClangTidyCategory))
static constexpr llvm::SourceMgr::DiagKind Error
bool Trusted
CompiledFragmentImpl & Out
DiagnosticCallback Diagnostic
std::vector< llvm::unique_function< void(const Params &, Config &) const > > Apply
std::vector< llvm::unique_function< bool(const Params &) const > > Conditions
std::string FragmentDirectory
const Criteria C
CharSourceRange Range
SourceRange for the file name.
#define dlog(...)
Definition: Logger.h:101
llvm::json::Object Args
Definition: Trace.cpp:138
#define SPAN_ATTACH(S, Name, Expr)
Attach a key-value pair to a Span event.
Definition: Trace.h:164
Records an event whose duration is the lifetime of the Span object.
Definition: Trace.h:143
std::function< bool(const Params &, Config &)> CompiledFragment
A chunk of configuration that has been fully analyzed and is ready to apply.
llvm::function_ref< void(const llvm::SMDiagnostic &)> DiagnosticCallback
Used to report problems in parsing or interpreting a config.
@ Warning
A warning message.
@ Error
An error message.
std::string Path
A typedef to represent a file path.
Definition: Path.h:26
bool isRegisteredTidyCheck(llvm::StringRef Check)
Returns if Check is a registered clang-tidy check.
void vlog(const char *Fmt, Ts &&... Vals)
Definition: Logger.h:72
bool pathStartsWith(PathRef Ancestor, PathRef Path, llvm::sys::path::Style Style)
Checks if Ancestor is a proper ancestor of Path.
Definition: Path.cpp:36
std::optional< bool > isFastTidyCheck(llvm::StringRef Check)
Returns if Check is known-fast, known-slow, or its speed is unknown.
llvm::StringRef normalizeSuppressedCode(llvm::StringRef Code)
Take a user-specified diagnostic code, and convert it to a normalized form stored in the config and c...
void elog(const char *Fmt, Ts &&... Vals)
Definition: Logger.h:61
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Settings that express user/project preferences and control clangd behavior.
Definition: Config.h:44
@ Strict
Diagnose missing and unused includes.
Describes the context used to evaluate configuration fragments.