clang-tools  17.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/StringRef.h"
39 #include "llvm/Support/FileSystem.h"
40 #include "llvm/Support/FormatVariadic.h"
41 #include "llvm/Support/Path.h"
42 #include "llvm/Support/Regex.h"
43 #include "llvm/Support/SMLoc.h"
44 #include "llvm/Support/SourceMgr.h"
45 #include <algorithm>
46 #include <memory>
47 #include <optional>
48 #include <string>
49 #include <vector>
50 
51 namespace clang {
52 namespace clangd {
53 namespace config {
54 namespace {
55 
56 // Returns an empty stringref if Path is not under FragmentDir. Returns Path
57 // as-is when FragmentDir is empty.
58 llvm::StringRef configRelative(llvm::StringRef Path,
59  llvm::StringRef FragmentDir) {
60  if (FragmentDir.empty())
61  return Path;
62  if (!Path.consume_front(FragmentDir))
63  return llvm::StringRef();
64  return Path.empty() ? "." : Path;
65 }
66 
67 struct CompiledFragmentImpl {
68  // The independent conditions to check before using settings from this config.
69  // The following fragment has *two* conditions:
70  // If: { Platform: [mac, linux], PathMatch: foo/.* }
71  // All of them must be satisfied: the platform and path conditions are ANDed.
72  // The OR logic for the platform condition is implemented inside the function.
73  std::vector<llvm::unique_function<bool(const Params &) const>> Conditions;
74  // Mutations that this fragment will apply to the configuration.
75  // These are invoked only if the conditions are satisfied.
76  std::vector<llvm::unique_function<void(const Params &, Config &) const>>
78 
79  bool operator()(const Params &P, Config &C) const {
80  for (const auto &C : Conditions) {
81  if (!C(P)) {
82  dlog("Config fragment {0}: condition not met", this);
83  return false;
84  }
85  }
86  dlog("Config fragment {0}: applying {1} rules", this, Apply.size());
87  for (const auto &A : Apply)
88  A(P, C);
89  return true;
90  }
91 };
92 
93 // Wrapper around condition compile() functions to reduce arg-passing.
94 struct FragmentCompiler {
95  FragmentCompiler(CompiledFragmentImpl &Out, DiagnosticCallback D,
96  llvm::SourceMgr *SM)
97  : Out(Out), Diagnostic(D), SourceMgr(SM) {}
98  CompiledFragmentImpl &Out;
101  // Normalized Fragment::SourceInfo::Directory.
102  std::string FragmentDirectory;
103  bool Trusted = false;
104 
105  std::optional<llvm::Regex>
106  compileRegex(const Located<std::string> &Text,
107  llvm::Regex::RegexFlags Flags = llvm::Regex::NoFlags) {
108  std::string Anchored = "^(" + *Text + ")$";
109  llvm::Regex Result(Anchored, Flags);
110  std::string RegexError;
111  if (!Result.isValid(RegexError)) {
112  diag(Error, "Invalid regex " + Anchored + ": " + RegexError, Text.Range);
113  return std::nullopt;
114  }
115  return std::move(Result);
116  }
117 
118  std::optional<std::string> makeAbsolute(Located<std::string> Path,
119  llvm::StringLiteral Description,
120  llvm::sys::path::Style Style) {
121  if (llvm::sys::path::is_absolute(*Path))
122  return *Path;
123  if (FragmentDirectory.empty()) {
124  diag(Error,
125  llvm::formatv(
126  "{0} must be an absolute path, because this fragment is not "
127  "associated with any directory.",
128  Description)
129  .str(),
130  Path.Range);
131  return std::nullopt;
132  }
133  llvm::SmallString<256> AbsPath = llvm::StringRef(*Path);
135  llvm::sys::path::native(AbsPath, Style);
136  return AbsPath.str().str();
137  }
138 
139  // Helper with similar API to StringSwitch, for parsing enum values.
140  template <typename T> class EnumSwitch {
141  FragmentCompiler &Outer;
142  llvm::StringRef EnumName;
143  const Located<std::string> &Input;
144  std::optional<T> Result;
145  llvm::SmallVector<llvm::StringLiteral> ValidValues;
146 
147  public:
148  EnumSwitch(llvm::StringRef EnumName, const Located<std::string> &In,
149  FragmentCompiler &Outer)
150  : Outer(Outer), EnumName(EnumName), Input(In) {}
151 
152  EnumSwitch &map(llvm::StringLiteral Name, T Value) {
153  assert(!llvm::is_contained(ValidValues, Name) && "Duplicate value!");
154  ValidValues.push_back(Name);
155  if (!Result && *Input == Name)
156  Result = Value;
157  return *this;
158  }
159 
160  std::optional<T> value() {
161  if (!Result)
162  Outer.diag(
163  Warning,
164  llvm::formatv("Invalid {0} value '{1}'. Valid values are {2}.",
165  EnumName, *Input, llvm::join(ValidValues, ", "))
166  .str(),
167  Input.Range);
168  return Result;
169  };
170  };
171 
172  // Attempt to parse a specified string into an enum.
173  // Yields std::nullopt and produces a diagnostic on failure.
174  //
175  // std::optional<T> Value = compileEnum<En>("Foo", Frag.Foo)
176  // .map("Foo", Enum::Foo)
177  // .map("Bar", Enum::Bar)
178  // .value();
179  template <typename T>
180  EnumSwitch<T> compileEnum(llvm::StringRef EnumName,
181  const Located<std::string> &In) {
182  return EnumSwitch<T>(EnumName, In, *this);
183  }
184 
185  void compile(Fragment &&F) {
186  Trusted = F.Source.Trusted;
187  if (!F.Source.Directory.empty()) {
188  FragmentDirectory = llvm::sys::path::convert_to_slash(F.Source.Directory);
189  if (FragmentDirectory.back() != '/')
190  FragmentDirectory += '/';
191  }
192  compile(std::move(F.If));
193  compile(std::move(F.CompileFlags));
194  compile(std::move(F.Index));
195  compile(std::move(F.Diagnostics));
196  compile(std::move(F.Completion));
197  compile(std::move(F.Hover));
198  compile(std::move(F.InlayHints));
199  compile(std::move(F.Style));
200  }
201 
202  void compile(Fragment::IfBlock &&F) {
203  if (F.HasUnrecognizedCondition)
204  Out.Conditions.push_back([&](const Params &) { return false; });
205 
206 #ifdef CLANGD_PATH_CASE_INSENSITIVE
207  llvm::Regex::RegexFlags Flags = llvm::Regex::IgnoreCase;
208 #else
209  llvm::Regex::RegexFlags Flags = llvm::Regex::NoFlags;
210 #endif
211 
212  auto PathMatch = std::make_unique<std::vector<llvm::Regex>>();
213  for (auto &Entry : F.PathMatch) {
214  if (auto RE = compileRegex(Entry, Flags))
215  PathMatch->push_back(std::move(*RE));
216  }
217  if (!PathMatch->empty()) {
218  Out.Conditions.push_back(
219  [PathMatch(std::move(PathMatch)),
220  FragmentDir(FragmentDirectory)](const Params &P) {
221  if (P.Path.empty())
222  return false;
223  llvm::StringRef Path = configRelative(P.Path, FragmentDir);
224  // Ignore the file if it is not nested under Fragment.
225  if (Path.empty())
226  return false;
227  return llvm::any_of(*PathMatch, [&](const llvm::Regex &RE) {
228  return RE.match(Path);
229  });
230  });
231  }
232 
233  auto PathExclude = std::make_unique<std::vector<llvm::Regex>>();
234  for (auto &Entry : F.PathExclude) {
235  if (auto RE = compileRegex(Entry, Flags))
236  PathExclude->push_back(std::move(*RE));
237  }
238  if (!PathExclude->empty()) {
239  Out.Conditions.push_back(
240  [PathExclude(std::move(PathExclude)),
241  FragmentDir(FragmentDirectory)](const Params &P) {
242  if (P.Path.empty())
243  return false;
244  llvm::StringRef Path = configRelative(P.Path, FragmentDir);
245  // Ignore the file if it is not nested under Fragment.
246  if (Path.empty())
247  return true;
248  return llvm::none_of(*PathExclude, [&](const llvm::Regex &RE) {
249  return RE.match(Path);
250  });
251  });
252  }
253  }
254 
255  void compile(Fragment::CompileFlagsBlock &&F) {
256  if (F.Compiler)
257  Out.Apply.push_back(
258  [Compiler(std::move(**F.Compiler))](const Params &, Config &C) {
259  C.CompileFlags.Edits.push_back(
260  [Compiler](std::vector<std::string> &Args) {
261  if (!Args.empty())
262  Args.front() = Compiler;
263  });
264  });
265 
266  if (!F.Remove.empty()) {
267  auto Remove = std::make_shared<ArgStripper>();
268  for (auto &A : F.Remove)
269  Remove->strip(*A);
270  Out.Apply.push_back([Remove(std::shared_ptr<const ArgStripper>(
271  std::move(Remove)))](const Params &, Config &C) {
272  C.CompileFlags.Edits.push_back(
273  [Remove](std::vector<std::string> &Args) {
274  Remove->process(Args);
275  });
276  });
277  }
278 
279  if (!F.Add.empty()) {
280  std::vector<std::string> Add;
281  for (auto &A : F.Add)
282  Add.push_back(std::move(*A));
283  Out.Apply.push_back([Add(std::move(Add))](const Params &, Config &C) {
284  C.CompileFlags.Edits.push_back([Add](std::vector<std::string> &Args) {
285  // The point to insert at. Just append when `--` isn't present.
286  auto It = llvm::find(Args, "--");
287  Args.insert(It, Add.begin(), Add.end());
288  });
289  });
290  }
291 
292  if (F.CompilationDatabase) {
293  std::optional<Config::CDBSearchSpec> Spec;
294  if (**F.CompilationDatabase == "Ancestors") {
295  Spec.emplace();
296  Spec->Policy = Config::CDBSearchSpec::Ancestors;
297  } else if (**F.CompilationDatabase == "None") {
298  Spec.emplace();
299  Spec->Policy = Config::CDBSearchSpec::NoCDBSearch;
300  } else {
301  if (auto Path =
302  makeAbsolute(*F.CompilationDatabase, "CompilationDatabase",
303  llvm::sys::path::Style::native)) {
304  // Drop trailing slash to put the path in canonical form.
305  // Should makeAbsolute do this?
306  llvm::StringRef Rel = llvm::sys::path::relative_path(*Path);
307  if (!Rel.empty() && llvm::sys::path::is_separator(Rel.back()))
308  Path->pop_back();
309 
310  Spec.emplace();
311  Spec->Policy = Config::CDBSearchSpec::FixedDir;
312  Spec->FixedCDBPath = std::move(Path);
313  }
314  }
315  if (Spec)
316  Out.Apply.push_back(
317  [Spec(std::move(*Spec))](const Params &, Config &C) {
318  C.CompileFlags.CDBSearch = Spec;
319  });
320  }
321  }
322 
323  void compile(Fragment::IndexBlock &&F) {
324  if (F.Background) {
325  if (auto Val = compileEnum<Config::BackgroundPolicy>("Background",
326  **F.Background)
327  .map("Build", Config::BackgroundPolicy::Build)
328  .map("Skip", Config::BackgroundPolicy::Skip)
329  .value())
330  Out.Apply.push_back(
331  [Val](const Params &, Config &C) { C.Index.Background = *Val; });
332  }
333  if (F.External)
334  compile(std::move(**F.External), F.External->Range);
335  if (F.StandardLibrary)
336  Out.Apply.push_back(
337  [Val(**F.StandardLibrary)](const Params &, Config &C) {
338  C.Index.StandardLibrary = Val;
339  });
340  }
341 
342  void compile(Fragment::IndexBlock::ExternalBlock &&External,
343  llvm::SMRange BlockRange) {
344  if (External.Server && !Trusted) {
345  diag(Error,
346  "Remote index may not be specified by untrusted configuration. "
347  "Copy this into user config to use it.",
348  External.Server->Range);
349  return;
350  }
351 #ifndef CLANGD_ENABLE_REMOTE
352  if (External.Server) {
353  elog("Clangd isn't compiled with remote index support, ignoring Server: "
354  "{0}",
355  *External.Server);
356  External.Server.reset();
357  }
358 #endif
359  // Make sure exactly one of the Sources is set.
360  unsigned SourceCount = External.File.has_value() +
361  External.Server.has_value() + *External.IsNone;
362  if (SourceCount != 1) {
363  diag(Error, "Exactly one of File, Server or None must be set.",
364  BlockRange);
365  return;
366  }
367  Config::ExternalIndexSpec Spec;
368  if (External.Server) {
370  Spec.Location = std::move(**External.Server);
371  } else if (External.File) {
373  auto AbsPath = makeAbsolute(std::move(*External.File), "File",
374  llvm::sys::path::Style::native);
375  if (!AbsPath)
376  return;
377  Spec.Location = std::move(*AbsPath);
378  } else {
379  assert(*External.IsNone);
381  }
382  if (Spec.Kind != Config::ExternalIndexSpec::None) {
383  // Make sure MountPoint is an absolute path with forward slashes.
384  if (!External.MountPoint)
385  External.MountPoint.emplace(FragmentDirectory);
386  if ((**External.MountPoint).empty()) {
387  diag(Error, "A mountpoint is required.", BlockRange);
388  return;
389  }
390  auto AbsPath = makeAbsolute(std::move(*External.MountPoint), "MountPoint",
391  llvm::sys::path::Style::posix);
392  if (!AbsPath)
393  return;
394  Spec.MountPoint = std::move(*AbsPath);
395  }
396  Out.Apply.push_back([Spec(std::move(Spec))](const Params &P, Config &C) {
397  if (Spec.Kind == Config::ExternalIndexSpec::None) {
398  C.Index.External = Spec;
399  return;
400  }
401  if (P.Path.empty() || !pathStartsWith(Spec.MountPoint, P.Path,
402  llvm::sys::path::Style::posix))
403  return;
404  C.Index.External = Spec;
405  // Disable background indexing for the files under the mountpoint.
406  // Note that this will overwrite statements in any previous fragments
407  // (including the current one).
408  C.Index.Background = Config::BackgroundPolicy::Skip;
409  });
410  }
411 
412  void compile(Fragment::DiagnosticsBlock &&F) {
413  std::vector<std::string> Normalized;
414  for (const auto &Suppressed : F.Suppress) {
415  if (*Suppressed == "*") {
416  Out.Apply.push_back([&](const Params &, Config &C) {
417  C.Diagnostics.SuppressAll = true;
418  C.Diagnostics.Suppress.clear();
419  });
420  return;
421  }
422  Normalized.push_back(normalizeSuppressedCode(*Suppressed).str());
423  }
424  if (!Normalized.empty())
425  Out.Apply.push_back(
426  [Normalized(std::move(Normalized))](const Params &, Config &C) {
427  if (C.Diagnostics.SuppressAll)
428  return;
429  for (llvm::StringRef N : Normalized)
430  C.Diagnostics.Suppress.insert(N);
431  });
432 
433  if (F.UnusedIncludes)
434  if (auto Val =
435  compileEnum<Config::UnusedIncludesPolicy>("UnusedIncludes",
436  **F.UnusedIncludes)
437  .map("Strict", Config::UnusedIncludesPolicy::Strict)
438  .map("Experiment", Config::UnusedIncludesPolicy::Experiment)
439  .map("None", Config::UnusedIncludesPolicy::None)
440  .value())
441  Out.Apply.push_back([Val](const Params &, Config &C) {
442  C.Diagnostics.UnusedIncludes = *Val;
443  });
444  compile(std::move(F.Includes));
445 
446  compile(std::move(F.ClangTidy));
447  }
448 
449  void compile(Fragment::StyleBlock &&F) {
450  if (!F.FullyQualifiedNamespaces.empty()) {
451  std::vector<std::string> FullyQualifiedNamespaces;
452  for (auto &N : F.FullyQualifiedNamespaces) {
453  // Normalize the data by dropping both leading and trailing ::
454  StringRef Namespace(*N);
455  Namespace.consume_front("::");
456  Namespace.consume_back("::");
457  FullyQualifiedNamespaces.push_back(Namespace.str());
458  }
459  Out.Apply.push_back([FullyQualifiedNamespaces(
460  std::move(FullyQualifiedNamespaces))](
461  const Params &, Config &C) {
462  C.Style.FullyQualifiedNamespaces.insert(
463  C.Style.FullyQualifiedNamespaces.begin(),
464  FullyQualifiedNamespaces.begin(), FullyQualifiedNamespaces.end());
465  });
466  }
467  }
468 
469  void appendTidyCheckSpec(std::string &CurSpec,
470  const Located<std::string> &Arg, bool IsPositive) {
471  StringRef Str = StringRef(*Arg).trim();
472  // Don't support negating here, its handled if the item is in the Add or
473  // Remove list.
474  if (Str.startswith("-") || Str.contains(',')) {
475  diag(Error, "Invalid clang-tidy check name", Arg.Range);
476  return;
477  }
478  if (!Str.contains('*') && !isRegisteredTidyCheck(Str)) {
479  diag(Warning,
480  llvm::formatv("clang-tidy check '{0}' was not found", Str).str(),
481  Arg.Range);
482  return;
483  }
484  CurSpec += ',';
485  if (!IsPositive)
486  CurSpec += '-';
487  CurSpec += Str;
488  }
489 
490  void compile(Fragment::DiagnosticsBlock::ClangTidyBlock &&F) {
491  std::string Checks;
492  for (auto &CheckGlob : F.Add)
493  appendTidyCheckSpec(Checks, CheckGlob, true);
494 
495  for (auto &CheckGlob : F.Remove)
496  appendTidyCheckSpec(Checks, CheckGlob, false);
497 
498  if (!Checks.empty())
499  Out.Apply.push_back(
500  [Checks = std::move(Checks)](const Params &, Config &C) {
501  C.Diagnostics.ClangTidy.Checks.append(
502  Checks,
503  C.Diagnostics.ClangTidy.Checks.empty() ? /*skip comma*/ 1 : 0,
504  std::string::npos);
505  });
506  if (!F.CheckOptions.empty()) {
507  std::vector<std::pair<std::string, std::string>> CheckOptions;
508  for (auto &Opt : F.CheckOptions)
509  CheckOptions.emplace_back(std::move(*Opt.first),
510  std::move(*Opt.second));
511  Out.Apply.push_back(
512  [CheckOptions = std::move(CheckOptions)](const Params &, Config &C) {
513  for (auto &StringPair : CheckOptions)
514  C.Diagnostics.ClangTidy.CheckOptions.insert_or_assign(
515  StringPair.first, StringPair.second);
516  });
517  }
518  }
519 
520  void compile(Fragment::DiagnosticsBlock::IncludesBlock &&F) {
521 #ifdef CLANGD_PATH_CASE_INSENSITIVE
522  static llvm::Regex::RegexFlags Flags = llvm::Regex::IgnoreCase;
523 #else
524  static llvm::Regex::RegexFlags Flags = llvm::Regex::NoFlags;
525 #endif
526  auto Filters = std::make_shared<std::vector<llvm::Regex>>();
527  for (auto &HeaderPattern : F.IgnoreHeader) {
528  // Anchor on the right.
529  std::string AnchoredPattern = "(" + *HeaderPattern + ")$";
530  llvm::Regex CompiledRegex(AnchoredPattern, Flags);
531  std::string RegexError;
532  if (!CompiledRegex.isValid(RegexError)) {
533  diag(Warning,
534  llvm::formatv("Invalid regular expression '{0}': {1}",
535  *HeaderPattern, RegexError)
536  .str(),
537  HeaderPattern.Range);
538  continue;
539  }
540  Filters->push_back(std::move(CompiledRegex));
541  }
542  if (Filters->empty())
543  return;
544  auto Filter = [Filters](llvm::StringRef Path) {
545  for (auto &Regex : *Filters)
546  if (Regex.match(Path))
547  return true;
548  return false;
549  };
550  Out.Apply.push_back([Filter](const Params &, Config &C) {
551  C.Diagnostics.Includes.IgnoreHeader.emplace_back(Filter);
552  });
553  }
554 
555  void compile(Fragment::CompletionBlock &&F) {
556  if (F.AllScopes) {
557  Out.Apply.push_back(
558  [AllScopes(**F.AllScopes)](const Params &, Config &C) {
559  C.Completion.AllScopes = AllScopes;
560  });
561  }
562  }
563 
564  void compile(Fragment::HoverBlock &&F) {
565  if (F.ShowAKA) {
566  Out.Apply.push_back([ShowAKA(**F.ShowAKA)](const Params &, Config &C) {
567  C.Hover.ShowAKA = ShowAKA;
568  });
569  }
570  }
571 
572  void compile(Fragment::InlayHintsBlock &&F) {
573  if (F.Enabled)
574  Out.Apply.push_back([Value(**F.Enabled)](const Params &, Config &C) {
575  C.InlayHints.Enabled = Value;
576  });
577  if (F.ParameterNames)
578  Out.Apply.push_back(
579  [Value(**F.ParameterNames)](const Params &, Config &C) {
580  C.InlayHints.Parameters = Value;
581  });
582  if (F.DeducedTypes)
583  Out.Apply.push_back([Value(**F.DeducedTypes)](const Params &, Config &C) {
584  C.InlayHints.DeducedTypes = Value;
585  });
586  if (F.Designators)
587  Out.Apply.push_back([Value(**F.Designators)](const Params &, Config &C) {
588  C.InlayHints.Designators = Value;
589  });
590  }
591 
592  constexpr static llvm::SourceMgr::DiagKind Error = llvm::SourceMgr::DK_Error;
593  constexpr static llvm::SourceMgr::DiagKind Warning =
594  llvm::SourceMgr::DK_Warning;
595  void diag(llvm::SourceMgr::DiagKind Kind, llvm::StringRef Message,
596  llvm::SMRange Range) {
597  if (Range.isValid() && SourceMgr != nullptr)
598  Diagnostic(SourceMgr->GetMessage(Range.Start, Kind, Message, Range));
599  else
600  Diagnostic(llvm::SMDiagnostic("", Kind, Message));
601  }
602 };
603 
604 } // namespace
605 
606 CompiledFragment Fragment::compile(DiagnosticCallback D) && {
607  llvm::StringRef ConfigFile = "<unknown>";
608  std::pair<unsigned, unsigned> LineCol = {0, 0};
609  if (auto *SM = Source.Manager.get()) {
610  unsigned BufID = SM->getMainFileID();
611  LineCol = SM->getLineAndColumn(Source.Location, BufID);
612  ConfigFile = SM->getBufferInfo(BufID).Buffer->getBufferIdentifier();
613  }
614  trace::Span Tracer("ConfigCompile");
615  SPAN_ATTACH(Tracer, "ConfigFile", ConfigFile);
616  auto Result = std::make_shared<CompiledFragmentImpl>();
617  vlog("Config fragment: compiling {0}:{1} -> {2} (trusted={3})", ConfigFile,
618  LineCol.first, Result.get(), Source.Trusted);
619 
620  FragmentCompiler{*Result, D, Source.Manager.get()}.compile(std::move(*this));
621  // Return as cheaply-copyable wrapper.
622  return [Result(std::move(Result))](const Params &P, Config &C) {
623  return (*Result)(P, C);
624  };
625 }
626 
627 } // namespace config
628 } // namespace clangd
629 } // namespace clang
dlog
#define dlog(...)
Definition: Logger.h:101
Range
CharSourceRange Range
SourceRange for the file name.
Definition: IncludeOrderCheck.cpp:37
Flags
MixFlags Flags
Definition: EasilySwappableParametersCheck.cpp:1096
Apply
std::vector< llvm::unique_function< void(const Params &, Config &) const > > Apply
Definition: ConfigCompile.cpp:77
clang::clangd::Config::BackgroundPolicy::Skip
@ Skip
clang::clangd::Config::CDBSearchSpec::FixedDir
@ FixedDir
Definition: Config.h:57
clang::clangd::Path
std::string Path
A typedef to represent a file path.
Definition: Path.h:26
Tracer
std::unique_ptr< trace::EventTracer > Tracer
Definition: TraceTests.cpp:161
Path.h
Checks
static cl::opt< std::string > Checks("checks", cl::desc(R"( Comma-separated list of globs with optional '-' prefix. Globs are processed in order of appearance in the list. Globs without '-' prefix add checks with matching names to the set, globs with the '-' prefix remove checks with matching names from the set of enabled checks. This option's value is appended to the value of the 'Checks' option in .clang-tidy file, if any. )"), cl::init(""), cl::cat(ClangTidyCategory))
clang::clangd::Config::ExternalIndexSpec::File
@ File
Definition: Config.h:74
clang::tidy::bugprone::Message
static const char Message[]
Definition: ReservedIdentifierCheck.cpp:30
Kind
BindArgumentKind Kind
Definition: AvoidBindCheck.cpp:57
Feature.h
Text
std::string Text
Definition: HTMLGenerator.cpp:82
ConfigProvider.h
Trace.h
Outer
std::pair< Context, Canceler > Outer
Definition: CancellationTests.cpp:49
clang::clangd::Config
Settings that express user/project preferences and control clangd behavior.
Definition: Config.h:44
clang::tidy::cppcoreguidelines::join
static std::string join(ArrayRef< SpecialMemberFunctionsCheck::SpecialMemberFunctionKind > SMFS, llvm::StringRef AndOr)
Definition: SpecialMemberFunctionsCheck.cpp:76
ConfigFile
static cl::opt< std::string > ConfigFile("config-file", cl::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))
Trusted
bool Trusted
Definition: ConfigCompile.cpp:103
SourceMgr
llvm::SourceMgr * SourceMgr
Definition: ConfigCompile.cpp:100
run-clang-tidy.make_absolute
def make_absolute(f, directory)
Definition: run-clang-tidy.py:86
clang::clangd::Config::CDBSearchSpec::NoCDBSearch
@ NoCDBSearch
Definition: Config.h:57
Error
constexpr static llvm::SourceMgr::DiagKind Error
Definition: ConfigCompile.cpp:592
ns1::ns2::A
@ A
Definition: CategoricalFeature.h:3
ns1::ns2::D
@ D
Definition: CategoricalFeature.h:3
Diagnostic
DiagnosticCallback Diagnostic
Definition: ConfigCompile.cpp:99
Config
static cl::opt< std::string > Config("config", cl::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))
TidyProvider.h
CompileCommands.h
Logger.h
Args
llvm::json::Object Args
Definition: Trace.cpp:138
Description
const char * Description
Definition: Dexp.cpp:362
SPAN_ATTACH
#define SPAN_ATTACH(S, Name, Expr)
Attach a key-value pair to a Span event.
Definition: Trace.h:164
clang::clangd::pathStartsWith
bool pathStartsWith(PathRef Ancestor, PathRef Path, llvm::sys::path::Style Style)
Checks if Ancestor is a proper ancestor of Path.
Definition: Path.cpp:36
clang::clangd::vlog
void vlog(const char *Fmt, Ts &&... Vals)
Definition: Logger.h:72
Diagnostics.h
clang::clangd::isRegisteredTidyCheck
bool isRegisteredTidyCheck(llvm::StringRef Check)
Returns if Check is a registered clang-tidy check.
Definition: TidyProvider.cpp:293
Name
Token Name
Definition: MacroToEnumCheck.cpp:87
clang::clangd::config::CompiledFragment
std::function< bool(const Params &, Config &)> CompiledFragment
A chunk of configuration that has been fully analyzed and is ready to apply.
Definition: ConfigProvider.h:56
clang::clangd::Config::ExternalIndexSpec::None
@ None
Definition: Config.h:74
Entry
Definition: Modularize.cpp:427
Config.h
FragmentDirectory
std::string FragmentDirectory
Definition: ConfigCompile.cpp:102
clang::clangd::Config::CDBSearchSpec::Ancestors
@ Ancestors
Definition: Config.h:57
Conditions
std::vector< llvm::unique_function< bool(const Params &) const > > Conditions
Definition: ConfigCompile.cpp:73
C
const Criteria C
Definition: FunctionCognitiveComplexityCheck.cpp:91
if
if(CLANG_PLUGIN_SUPPORT) export_executable_symbols_for_plugins(clang-tidy) endif() install(PROGRAMS clang-tidy-diff.py DESTINATION "$
Definition: clang-tidy/tool/CMakeLists.txt:59
clang::clangd::config::Params
Describes the context used to evaluate configuration fragments.
Definition: ConfigProvider.h:33
clang
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Definition: ApplyReplacements.h:27
clang::clangd::normalizeSuppressedCode
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...
Definition: Diagnostics.cpp:905
clang::clangd::SymbolKind::Namespace
@ Namespace
Out
CompiledFragmentImpl & Out
Definition: ConfigCompile.cpp:98
ConfigFragment.h
clang::clangd::elog
void elog(const char *Fmt, Ts &&... Vals)
Definition: Logger.h:61
clang::clangd::Config::BackgroundPolicy::Build
@ Build
Warning
constexpr static llvm::SourceMgr::DiagKind Warning
Definition: ConfigCompile.cpp:593
clang::clangd::Config::ExternalIndexSpec::Server
@ Server
Definition: Config.h:74
clang::clangd::config::DiagnosticCallback
llvm::function_ref< void(const llvm::SMDiagnostic &)> DiagnosticCallback
Used to report problems in parsing or interpreting a config.
Definition: ConfigProvider.h:49
clang::clangd::trace::Span
Records an event whose duration is the lifetime of the Span object.
Definition: Trace.h:143