Generate Config {Fragment structure, json schema, docs, YAML parser} from schema spec

[sammccall]

Summary

The generated files are checked in, and updated manually (tested).
This means we can consume them downstream from clangd-www & schemastore
without needing to run the whole LLVM build system.

[sammccall]

Restructure schema so $ref can use JSON pointers, fixing compat with yaml-language-server.

Add some VSCode extensions supported by yaml-language-server.

[sammccall]

fix external: none

[sammccall]

fix schema version

[sammccall]

This is definitely not ready to ship, but I'd like some high-level feedback before adding tests/polish.

Most important thing to look at is schema.yaml which would be the source of truth, followed by maybe Generate.cpp and the new structure of ConfigYAML (but no need to go through the code details at this point).

Particular questions I'd like opinions on:

worthwhile overall?

This isn't trivial: does it solve a big enough problem to be worth the complexity? (Benefit would be improved maintenance of existing config duplication, and being able to accept JSON-schema which IMO we shouldn't without automation).

better off parsing schema.json rather than defining a new format?

I don't think so (json-schema is too powerful a language, and it's IMO pretty verbose and painful to edit).
But the bias towards creating new things needs to be double-checked!

does the YAML structure seem OK?

I'm reasonably happy with the compromises I landed on e.g.

• distinction between lowercase for meta-properties and UpperCase for schema children
• ways to handle special casing around If.UnknownKey and Index.External = None

but maybe they only make sense in my own head

build-time generation vs checking in generated files

Generating at cmake-time is the obvious choice for *.inc, but the consumers of schema.json and doc.md aren't part of our build.

1. we could generate *.inc at build time, and say that it's up to some other repo(s) to run the llvm build system and produce+publish schema.json and doc.md
2. we could generate *.inc at build time, and check in schema.json and doc.md (need to update by rerunning the tool, we could have a test)
3. we could generate all files by hand and check them in

My feeling is that 1 is too burdensome to get these extra files.
2 is a bit more complicated than 3 (two ways to do things, and building the tool in host config adds some cmake complexity).
And I'm not sure it has any advantages: regenerating all the files isn't more work than regenerating half.

So I lean towards 3 but I don't have much confidence in what will be least annoying overall.

meta-schema.json

Once I got the tooling set up, having a schema+diagnostics for schema.yaml is pretty nice.
It provides a place to document the structure of the file, and gives a crisp answer to "is this change broken" (albeit one we won't actually have a test for).
OTOH it's not strictly necessary, and yet more stuff in the tree.

Enums in ConfigFragment.h

Previously these were strings in ConfigFragment.h, and the enums were defined in Config.h, which I think is where they belong in terms of dep structure.

However once schema.yaml knows about enums, it seems natural to generate the enum definitions and the code to parse them.

So options all have downsides:

1. put them in ConfigFragment.h and parse them in ConfigYAML, with the other generated code. Now Config needs to depend on ConfigFragment
2. generate them into Config.h and generate parsing code in ConfigCompile as today. This means we now need to inject generated code into 4 places instead of 2.
3. don't generate the enums, define & parse them by hand as today (and need to keep that code in sync)

I went with 1 in the code, but I really don't know what's best here.

Dir structure

With so many extra files, I created config/ and I think moving existing Config* sources to config/* seems like a clear improvement, but want to get an ack on this first as renaming is annoying.

[kadircet]

In D140745#4021783, @sammccall wrote:

worthwhile overall?

This isn't trivial: does it solve a big enough problem to be worth the complexity? (Benefit would be improved maintenance of existing config duplication, and being able to accept JSON-schema which IMO we shouldn't without automation).

I find the solution here valuable, especially considering all the times that we've failed to wire/test things properly when we introduced new config options and the lack of documentation in clangd-www. Also this will make introducing new options straightforward (no need to write fragments or parse logic).
Last time we discussed the concerns I had (at least the ones I can remember) were losing the readability we have in a C++ header file (when performing the fragment->config step) and difficulty about changing "parse" behavior every now and then, but considering all the bugs/outages we had ever since I think these concerns are OK to give up at this point (I also like the solution around only writing custom parse logic when needed).

better off parsing schema.json rather than defining a new format?

I don't think so (json-schema is too powerful a language, and it's IMO pretty verbose and painful to edit).
But the bias towards creating new things needs to be double-checked!

I also feel like editing the YAML format is easier than the JSON one, this might be an LLVM bias but considering the project is part of LLVM, I don't think that'll be a bad thing.

does the YAML structure seem OK?

I'm reasonably happy with the compromises I landed on e.g.

• distinction between lowercase for meta-properties and UpperCase for schema children
• ways to handle special casing around If.UnknownKey and Index.External = None

but maybe they only make sense in my own head

I am still a little unhappy with losing the readability through the new YAML format. but I also don't have any better alternatives and we still get to keep the Config.h so at least when writing features we still have a single C++ header to read.

build-time generation vs checking in generated files

Generating at cmake-time is the obvious choice for *.inc, but the consumers of schema.json and doc.md aren't part of our build.

1. we could generate *.inc at build time, and say that it's up to some other repo(s) to run the llvm build system and produce+publish schema.json and doc.md
2. we could generate *.inc at build time, and check in schema.json and doc.md (need to update by rerunning the tool, we could have a test)
3. we could generate all files by hand and check them in

My feeling is that 1 is too burdensome to get these extra files.
2 is a bit more complicated than 3 (two ways to do things, and building the tool in host config adds some cmake complexity).
And I'm not sure it has any advantages: regenerating all the files isn't more work than regenerating half.

So I lean towards 3 but I don't have much confidence in what will be least annoying overall.

I am actually more inclined towards option 1). Having *.inc generation as part of the build step and not caring about them ever sounds like the better trade-off. I don't know how troublesome it's in the CMake sense (but we already do that with proto-generated files in clangd for example).
If you think that's too much work I am also fine with option 3 as you mentioned (this also has the nice side effect of checking the delta to real code after a change to the schema).
As for doc.md, it's unfortunate that we'll need to publish it in a different repository anyways, but I don't think that's a huge burden and we can probably get away with doing that only at branch cuts. Having doc.md and schema.json always available in the repo as source of truth (to aid debugging when things go wrong) sounds like a good plus to me. So I am in favor of having them in.

meta-schema.json

Once I got the tooling set up, having a schema+diagnostics for schema.yaml is pretty nice.
It provides a place to document the structure of the file, and gives a crisp answer to "is this change broken" (albeit one we won't actually have a test for).
OTOH it's not strictly necessary, and yet more stuff in the tree.

I am in favor of having it. this is unlikely to change so not a huge burden for maintenance. I'd still like to have some sort of schema description in the YAML file though (as a comment, both for a place to read without context switches and to serve as a template when introducing a new option).

Enums in ConfigFragment.h

Previously these were strings in ConfigFragment.h, and the enums were defined in Config.h, which I think is where they belong in terms of dep structure.

However once schema.yaml knows about enums, it seems natural to generate the enum definitions and the code to parse them.

So options all have downsides:

1. put them in ConfigFragment.h and parse them in ConfigYAML, with the other generated code. Now Config needs to depend on ConfigFragment
2. generate them into Config.h and generate parsing code in ConfigCompile as today. This means we now need to inject generated code into 4 places instead of 2.
3. don't generate the enums, define & parse them by hand as today (and need to keep that code in sync)

I went with 1 in the code, but I really don't know what's best here.

For me, the biggest downside of the current approach is the need to spell enum names in generated code inside Config.h. but I don't think managing the parser code by hand can be justified just to refer to familiar names in Config.h.
So I think all good here.

Dir structure

With so many extra files, I created config/ and I think moving existing Config* sources to config/* seems like a clear improvement, but want to get an ack on this first as renaming is annoying.

agreed, as discussed in the past, I think we should slowly try to define more fine grained targets for clangd (so that we can better check for layering violations, enable code reuse, enable more caching etc.)

[sammccall]

Add comments to schema.yaml.
Add tests that generated files are up-to-date, and script to regenerate
Rename doc.md -> documentation.md

[sammccall]

Based on offline discussion, doubling down on checking in generated files to make these easy/possible to consume where they're needed.

rebased and addressed high level comments (I think!)

[sammccall]

ping on this one for when you have time
I haven't rebased against latest config yet, it's a bit of a moving target :-)

[nridge]

In D140745#4505829, @sammccall wrote:

ping on this one for when you have time

(Just wanted to double-check, is this ping directed to me or Kadir (or both)? I haven't looked at this because Kadir has done a round of review and it seemed like duplication of work for me to look at it as well; however, if you'd like me to do a round of review, I'm happy to!)

[sammccall]

In D140745#4508559, @nridge wrote:

In D140745#4505829, @sammccall wrote:

ping on this one for when you have time

(Just wanted to double-check, is this ping directed to me or Kadir (or both)? I haven't looked at this because Kadir has done a round of review and it seemed like duplication of work for me to look at it as well; however, if you'd like me to do a round of review, I'm happy to!)

Oops, indeed it was directed at Kadir, we'd also discussed it offline at length a few months ago and I think this is mostly a question of cleaning up the details now.

Always happy to have more feedback or hear concerns, but no need unless you're interested (and this patch isn't that interesting :-D)

clang-tools-extra/clangd/CMakeLists.txt

 endif()
 
 # FIXME(kirillbobyrev): Document this in the LLVM docs once remote index is stable.
 option(CLANGD_ENABLE_REMOTE "Use gRPC library to enable remote index support for Clangd" OFF)
 set(GRPC_INSTALL_PATH "" CACHE PATH "Path to gRPC library manual installation.")
 
 add_subdirectory(index/remote)
 add_subdirectory(index/dex/dexp)
+add_subdirectory(config)

clang-tools-extra/clangd/Config.h

 // of layering problems. Config should be expressed in terms of simple
 // vocabulary types where possible.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_CONFIG_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_CONFIG_H
 
+#include "ConfigFragment.h"
 #include "support/Context.h"
 #include "llvm/ADT/FunctionExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSet.h"
 #include <functional>
 #include <optional>
 #include <string>
 #include <vector>
struct Config {
   struct {
     /// Edits to apply to the compile command, in sequence.
     std::vector<llvm::unique_function<void(std::vector<std::string> &) const>>
         Edits;
     /// Where to search for compilation databases for this file's flags.
     CDBSearchSpec CDBSearch = {CDBSearchSpec::Ancestors, std::nullopt};
   } CompileFlags;
 
-  enum class BackgroundPolicy { Build, Skip };
+  using BackgroundPolicy = config::Fragment::IndexBlock::BackgroundValues;
   /// Describes an external index configuration.
   struct ExternalIndexSpec {
     enum { None, File, Server } Kind = None;
     /// This is one of:
     /// - Address of a clangd-index-server, in the form of "ip:port".
     /// - Absolute path to an index produced by clangd-indexer.
     std::string Location;
     /// Absolute path to source root this index is associated with, uses
     /// forward-slashes.
     std::string MountPoint;
   };
   /// Controls index behavior.
   struct {
     /// Whether this TU should be background-indexed.
     BackgroundPolicy Background = BackgroundPolicy::Build;
     ExternalIndexSpec External;
     bool StandardLibrary = true;
   } Index;
 
-  enum UnusedIncludesPolicy {
-    /// Diagnose unused includes.
-    Strict,
-    None,
-    /// The same as Strict, but using the include-cleaner library.
-    Experiment,
-  };
+  using UnusedIncludesPolicy =
+      config::Fragment::DiagnosticsBlock::UnusedIncludesValues;
   /// Controls warnings and errors when parsing code.
   struct {
     bool SuppressAll = false;
     llvm::StringSet<> Suppress;
 
     /// Configures what clang-tidy checks to run and options to use with them.
     struct {
       // A comma-seperated list of globs specify which clang-tidy checks to run.
       std::string Checks;
       llvm::StringMap<std::string> CheckOptions;
     } ClangTidy;
 
-    UnusedIncludesPolicy UnusedIncludes = None;
+    UnusedIncludesPolicy UnusedIncludes = UnusedIncludesPolicy::None;
 
     /// IncludeCleaner will not diagnose usages of these headers matched by
     /// these regexes.
     struct {
       std::vector<std::function<bool(llvm::StringRef)>> IgnoreHeader;
     } Includes;
   } Diagnostics;
 

clang-tools-extra/clangd/ConfigCompile.cpp

if (FragmentDirectory.empty()) {
       return std::nullopt;
     }
     llvm::SmallString<256> AbsPath = llvm::StringRef(*Path);
     llvm::sys::fs::make_absolute(FragmentDirectory, AbsPath);
     llvm::sys::path::native(AbsPath, Style);
     return AbsPath.str().str();
   }
 
-  // Helper with similar API to StringSwitch, for parsing enum values.
-  template <typename T> class EnumSwitch {
-    FragmentCompiler &Outer;
-    llvm::StringRef EnumName;
-    const Located<std::string> &Input;
-    std::optional<T> Result;
-    llvm::SmallVector<llvm::StringLiteral> ValidValues;
-
-  public:
-    EnumSwitch(llvm::StringRef EnumName, const Located<std::string> &In,
-               FragmentCompiler &Outer)
-        : Outer(Outer), EnumName(EnumName), Input(In) {}
-
-    EnumSwitch &map(llvm::StringLiteral Name, T Value) {
-      assert(!llvm::is_contained(ValidValues, Name) && "Duplicate value!");
-      ValidValues.push_back(Name);
-      if (!Result && *Input == Name)
-        Result = Value;
-      return *this;
-    }
-
-    std::optional<T> value() {
-      if (!Result)
-        Outer.diag(
-            Warning,
-            llvm::formatv("Invalid {0} value '{1}'. Valid values are {2}.",
-                          EnumName, *Input, llvm::join(ValidValues, ", "))
-                .str(),
-            Input.Range);
-      return Result;
-    };
-  };
-
-  // Attempt to parse a specified string into an enum.
-  // Yields std::nullopt and produces a diagnostic on failure.
-  //
-  // std::optional<T> Value = compileEnum<En>("Foo", Frag.Foo)
-  //    .map("Foo", Enum::Foo)
-  //    .map("Bar", Enum::Bar)
-  //    .value();
-  template <typename T>
-  EnumSwitch<T> compileEnum(llvm::StringRef EnumName,
-                            const Located<std::string> &In) {
-    return EnumSwitch<T>(EnumName, In, *this);
-  }
-
   void compile(Fragment &&F) {
     Trusted = F.Source.Trusted;
     if (!F.Source.Directory.empty()) {
       FragmentDirectory = llvm::sys::path::convert_to_slash(F.Source.Directory);
       if (FragmentDirectory.back() != '/')
         FragmentDirectory += '/';
     }
     compile(std::move(F.If));
if (F.CompilationDatabase) {
             [Spec(std::move(*Spec))](const Params &, Config &C) {
               C.CompileFlags.CDBSearch = Spec;
             });
     }
   }
 
   void compile(Fragment::IndexBlock &&F) {
     if (F.Background) {
-      if (auto Val = compileEnum<Config::BackgroundPolicy>("Background",
-                                                           **F.Background)
-                         .map("Build", Config::BackgroundPolicy::Build)
-                         .map("Skip", Config::BackgroundPolicy::Skip)
-                         .value())
-        Out.Apply.push_back(
-            [Val](const Params &, Config &C) { C.Index.Background = *Val; });
+      Out.Apply.push_back([Val(**F.Background)](const Params &, Config &C) {
+        C.Index.Background = Val;
+      });
     }
     if (F.External)
       compile(std::move(**F.External), F.External->Range);
     if (F.StandardLibrary)
       Out.Apply.push_back(
           [Val(**F.StandardLibrary)](const Params &, Config &C) {
             C.Index.StandardLibrary = Val;
           });
if (External.Server) {
       elog("Clangd isn't compiled with remote index support, ignoring Server: "
            "{0}",
            *External.Server);
       External.Server.reset();
     }
 #endif
     // Make sure exactly one of the Sources is set.
     unsigned SourceCount = External.File.has_value() +
-                           External.Server.has_value() + *External.IsNone;
+                           External.Server.has_value() + External.IsNone;
     if (SourceCount != 1) {
       diag(Error, "Exactly one of File, Server or None must be set.",
            BlockRange);
       return;
     }
     Config::ExternalIndexSpec Spec;
     if (External.Server) {
       Spec.Kind = Config::ExternalIndexSpec::Server;
       Spec.Location = std::move(**External.Server);
     } else if (External.File) {
       Spec.Kind = Config::ExternalIndexSpec::File;
       auto AbsPath = makeAbsolute(std::move(*External.File), "File",
                                   llvm::sys::path::Style::native);
       if (!AbsPath)
         return;
       Spec.Location = std::move(*AbsPath);
     } else {
-      assert(*External.IsNone);
+      assert(External.IsNone);
       Spec.Kind = Config::ExternalIndexSpec::None;
     }
     if (Spec.Kind != Config::ExternalIndexSpec::None) {
       // Make sure MountPoint is an absolute path with forward slashes.
       if (!External.MountPoint)
         External.MountPoint.emplace(FragmentDirectory);
       if ((**External.MountPoint).empty()) {
         diag(Error, "A mountpoint is required.", BlockRange);
if (!Normalized.empty())
           [Normalized(std::move(Normalized))](const Params &, Config &C) {
             if (C.Diagnostics.SuppressAll)
               return;
             for (llvm::StringRef N : Normalized)
               C.Diagnostics.Suppress.insert(N);
           });
 
     if (F.UnusedIncludes)
-      if (auto Val =
-              compileEnum<Config::UnusedIncludesPolicy>("UnusedIncludes",
-                                                        **F.UnusedIncludes)
-                  .map("Strict", Config::UnusedIncludesPolicy::Strict)
-                  .map("Experiment", Config::UnusedIncludesPolicy::Experiment)
-                  .map("None", Config::UnusedIncludesPolicy::None)
-                  .value())
-        Out.Apply.push_back([Val](const Params &, Config &C) {
-          C.Diagnostics.UnusedIncludes = *Val;
-        });
+      Out.Apply.push_back([Val(**F.UnusedIncludes)](const Params &, Config &C) {
+        C.Diagnostics.UnusedIncludes = Val;
     compile(std::move(F.Includes));
-
     compile(std::move(F.ClangTidy));
   }
 
   void compile(Fragment::StyleBlock &&F) {
     if (!F.FullyQualifiedNamespaces.empty()) {
       std::vector<std::string> FullyQualifiedNamespaces;
       for (auto &N : F.FullyQualifiedNamespaces) {
         // Normalize the data by dropping both leading and trailing ::

clang-tools-extra/clangd/ConfigFragment.h

template <typename T> struct Located {
   const T *operator->() const { return &Value; }
   T &operator*() { return Value; }
   const T &operator*() const { return Value; }
 
 private:
   T Value;
 };
 
+namespace detail {
+struct IfBase {
+  /// An unrecognized key was found while parsing the condition.
+  /// The condition will evaluate to false.
+  bool HasUnrecognizedCondition = false;
+};
+struct ExternalBase {
+  /// Whether the block is explicitly set to `None`. Can be used to clear
+  /// any external index specified before.
+  bool IsNone = false;
+};
+} // namespace detail
+
 /// A chunk of configuration obtained from a config file, LSP, or elsewhere.
 struct Fragment {
   /// Parses fragments from a YAML file (one from each --- delimited document).
   /// Documents that contained fatal errors are omitted from the results.
   /// BufferName is used for the SourceMgr and diagnostics.
   static std::vector<Fragment> parseYAML(llvm::StringRef YAML,
                                          llvm::StringRef BufferName,
                                          DiagnosticCallback);
struct SourceInfo {
     /// paths mentioned in the fragment are resolved against this.
     std::string Directory;
     /// Whether this fragment is allowed to make critical security/privacy
     /// decisions.
     bool Trusted = false;
   };
   SourceInfo Source;
 
-  /// Conditions in the If block restrict when a Fragment applies.
-  ///
-  /// Each separate condition must match (combined with AND).
-  /// When one condition has multiple values, any may match (combined with OR).
-  /// e.g. `PathMatch: [foo/.*, bar/.*]` matches files in either directory.
-  ///
-  /// Conditions based on a file's path use the following form:
-  /// - if the fragment came from a project directory, the path is relative
-  /// - if the fragment is global (e.g. user config), the path is absolute
-  /// - paths always use forward-slashes (UNIX-style)
-  /// If no file is being processed, these conditions will not match.
-  struct IfBlock {
-    /// The file being processed must fully match a regular expression.
-    std::vector<Located<std::string>> PathMatch;
-    /// The file being processed must *not* fully match a regular expression.
-    std::vector<Located<std::string>> PathExclude;
-
-    /// An unrecognized key was found while parsing the condition.
-    /// The condition will evaluate to false.
-    bool HasUnrecognizedCondition = false;
-  };
-  IfBlock If;
-
-  /// Conditions in the CompileFlags block affect how a file is parsed.
-  ///
-  /// clangd emulates how clang would interpret a file.
-  /// By default, it behaves roughly like `clang $FILENAME`, but real projects
-  /// usually require setting the include path (with the `-I` flag), defining
-  /// preprocessor symbols, configuring warnings etc.
-  /// Often, a compilation database specifies these compile commands. clangd
-  /// searches for compile_commands.json in parents of the source file.
-  ///
-  /// This section modifies how the compile command is constructed.
-  struct CompileFlagsBlock {
-    /// Override the compiler executable name to simulate.
-    ///
-    /// The name can affect how flags are parsed (clang++ vs clang).
-    /// If the executable name is in the --query-driver allowlist, then it will
-    /// be invoked to extract include paths.
-    ///
-    /// (That this simply replaces argv[0], and may mangle commands that use
-    /// more complicated drivers like ccache).
-    std::optional<Located<std::string>> Compiler;
-
-    /// List of flags to append to the compile command.
-    std::vector<Located<std::string>> Add;
-    /// List of flags to remove from the compile command.
-    ///
-    /// - If the value is a recognized clang flag (like "-I") then it will be
-    ///   removed along with any arguments. Synonyms like --include-dir= will
-    ///   also be removed.
-    /// - Otherwise, if the value ends in * (like "-DFOO=*") then any argument
-    ///   with the prefix will be removed.
-    /// - Otherwise any argument exactly matching the value is removed.
-    ///
-    /// In all cases, -Xclang is also removed where needed.
-    ///
-    /// Example:
-    ///   Command: clang++ --include-directory=/usr/include -DFOO=42 foo.cc
-    ///   Remove: [-I, -DFOO=*]
-    ///   Result: clang++ foo.cc
-    ///
-    /// Flags added by the same CompileFlags entry will not be removed.
-    std::vector<Located<std::string>> Remove;
-
-    /// Directory to search for compilation database (compile_commands.json
-    /// etc). Valid values are:
-    /// - A single path to a directory (absolute, or relative to the fragment)
-    /// - Ancestors: search all parent directories (the default)
-    /// - None: do not use a compilation database, just default flags.
-    std::optional<Located<std::string>> CompilationDatabase;
-  };
-  CompileFlagsBlock CompileFlags;
-
-  /// Controls how clangd understands code outside the current file.
-  /// clangd's indexes provide information about symbols that isn't available
-  /// to clang's parser, such as incoming references.
-  struct IndexBlock {
-    /// Whether files are built in the background to produce a project index.
-    /// This is checked for translation units only, not headers they include.
-    /// Legal values are "Build" or "Skip".
-    std::optional<Located<std::string>> Background;
-    /// An external index uses data source outside of clangd itself. This is
-    /// usually prepared using clangd-indexer.
-    /// Exactly one source (File/Server) should be configured.
-    struct ExternalBlock {
-      /// Whether the block is explicitly set to `None`. Can be used to clear
-      /// any external index specified before.
-      Located<bool> IsNone = false;
-      /// Path to an index file generated by clangd-indexer. Relative paths may
-      /// be used, if config fragment is associated with a directory.
-      std::optional<Located<std::string>> File;
-      /// Address and port number for a clangd-index-server. e.g.
-      /// `123.1.1.1:13337`.
-      std::optional<Located<std::string>> Server;
-      /// Source root governed by this index. Default is the directory
-      /// associated with the config fragment. Absolute in case of user config
-      /// and relative otherwise. Should always use forward-slashes.
-      std::optional<Located<std::string>> MountPoint;
-    };
-    std::optional<Located<ExternalBlock>> External;
-    // Whether the standard library visible from this file should be indexed.
-    // This makes all standard library symbols available, included or not.
-    std::optional<Located<bool>> StandardLibrary;
-  };
-  IndexBlock Index;
-
-  /// Controls behavior of diagnostics (errors and warnings).
-  struct DiagnosticsBlock {
-    /// Diagnostic codes that should be suppressed.
-    ///
-    /// Valid values are:
-    /// - *, to disable all diagnostics
-    /// - diagnostic codes exposed by clangd (e.g unknown_type, -Wunused-result)
-    /// - clang internal diagnostic codes (e.g. err_unknown_type)
-    /// - warning categories (e.g. unused-result)
-    /// - clang-tidy check names (e.g. bugprone-narrowing-conversions)
-    ///
-    /// This is a simple filter. Diagnostics can be controlled in other ways
-    /// (e.g. by disabling a clang-tidy check, or the -Wunused compile flag).
-    /// This often has other advantages, such as skipping some analysis.
-    std::vector<Located<std::string>> Suppress;
-
-    /// Controls how clangd will correct "unnecessary #include directives.
-    /// clangd can warn if a header is `#include`d but not used, and suggest
-    /// removing it.
-    //
-    /// Strict means a header is unused if it does not *directly* provide any
-    /// symbol used in the file. Removing it may still break compilation if it
-    /// transitively includes headers that are used. This should be fixed by
-    /// including those headers directly.
-    ///
-    /// Valid values are:
-    /// - Strict
-    /// - None
-    std::optional<Located<std::string>> UnusedIncludes;
-
-    /// Controls IncludeCleaner diagnostics.
-    struct IncludesBlock {
-      /// Regexes that will be used to avoid diagnosing certain includes as
-      /// unused or missing. These can match any suffix of the header file in
-      /// question.
-      std::vector<Located<std::string>> IgnoreHeader;
-    };
-    IncludesBlock Includes;
-
-    /// Controls how clang-tidy will run over the code base.
-    ///
-    /// The settings are merged with any settings found in .clang-tidy
-    /// configuration files with these ones taking precedence.
-    struct ClangTidyBlock {
-      std::vector<Located<std::string>> Add;
-      /// List of checks to disable.
-      /// Takes precedence over Add. To enable all llvm checks except include
-      /// order:
-      ///   Add: llvm-*
-      ///   Remove: llvm-include-order
-      std::vector<Located<std::string>> Remove;
-
-      /// A Key-Value pair list of options to pass to clang-tidy checks
-      /// These take precedence over options specified in clang-tidy
-      /// configuration files. Example:
-      ///   CheckOptions:
-      ///     readability-braces-around-statements.ShortStatementLines: 2
-      std::vector<std::pair<Located<std::string>, Located<std::string>>>
-          CheckOptions;
-    };
-    ClangTidyBlock ClangTidy;
-  };
-  DiagnosticsBlock Diagnostics;
-
-  // Describes the style of the codebase, beyond formatting.
-  struct StyleBlock {
-    // Namespaces that should always be fully qualified, meaning no "using"
-    // declarations, always spell out the whole name (with or without leading
-    // ::). All nested namespaces are affected as well.
-    // Affects availability of the AddUsing tweak.
-    std::vector<Located<std::string>> FullyQualifiedNamespaces;
-  };
-  StyleBlock Style;
-
-  /// Describes code completion preferences.
-  struct CompletionBlock {
-    /// Whether code completion should include suggestions from scopes that are
-    /// not visible. The required scope prefix will be inserted.
-    std::optional<Located<bool>> AllScopes;
-  };
-  CompletionBlock Completion;
-
-  /// Describes hover preferences.
-  struct HoverBlock {
-    /// Whether hover show a.k.a type.
-    std::optional<Located<bool>> ShowAKA;
-  };
-  HoverBlock Hover;
-
-  /// Configures labels shown inline with the code.
-  struct InlayHintsBlock {
-    /// Enables/disables the inlay-hints feature.
-    std::optional<Located<bool>> Enabled;
-
-    /// Show parameter names before function arguments.
-    std::optional<Located<bool>> ParameterNames;
-    /// Show deduced types for `auto`.
-    std::optional<Located<bool>> DeducedTypes;
-    /// Show designators in aggregate initialization.
-    std::optional<Located<bool>> Designators;
-  };
-  InlayHintsBlock InlayHints;
+#include "config/Fragment.inc"
 };
 
 } // namespace config
 } // namespace clangd
 } // namespace clang
 
 #endif

clang-tools-extra/clangd/ConfigYAML.cpp

 //===--- ConfigYAML.cpp - Loading configuration fragments from YAML files -===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #include "ConfigFragment.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/YAMLParser.h"
 #include <optional>
 #include <string>
 #include <system_error>
 
 namespace clang {
for (const auto &AllowedValue : AllowedValues) {
     } else if (EditDistance < MaxEdit) {
       Result = AllowedValue;
       MaxEdit = EditDistance;
     }
   }
   return Result;
 }
 
+std::optional<Located<std::string>> peekScalar(const Node &N) {
+  llvm::SmallString<256> Buf;
+  llvm::StringRef Str;
+  if (auto *S = llvm::dyn_cast<ScalarNode>(&N))
+    Str = S->getValue(Buf);
+  else if (auto *BS = llvm::dyn_cast<BlockScalarNode>(&N))
+    Str = BS->getValue();
+  else
+    return std::nullopt;
+  return Located<std::string>(Str.str(), N.getSourceRange());
+}
+
 class Parser {
   llvm::SourceMgr &SM;
   bool HadError = false;
 
 public:
   Parser(llvm::SourceMgr &SM) : SM(SM) {}
 
   // Tries to parse N into F, returning false if it failed and we couldn't
   // meaningfully recover (YAML syntax error, or hard semantic error).
   bool parse(Fragment &F, Node &N) {
-    DictParser Dict("Config", this);
-    Dict.handle("If", [&](Node &N) { parse(F.If, N); });
-    Dict.handle("CompileFlags", [&](Node &N) { parse(F.CompileFlags, N); });
-    Dict.handle("Index", [&](Node &N) { parse(F.Index, N); });
-    Dict.handle("Style", [&](Node &N) { parse(F.Style, N); });
-    Dict.handle("Diagnostics", [&](Node &N) { parse(F.Diagnostics, N); });
-    Dict.handle("Completion", [&](Node &N) { parse(F.Completion, N); });
-    Dict.handle("Hover", [&](Node &N) { parse(F.Hover, N); });
-    Dict.handle("InlayHints", [&](Node &N) { parse(F.InlayHints, N); });
-    Dict.parse(N);
+    parse(N, "Config", F);
     return !(N.failed() || HadError);
   }
 
 private:
-  void parse(Fragment::IfBlock &F, Node &N) {
-    DictParser Dict("If", this);
-    Dict.unrecognized([&](Located<std::string>, Node &) {
-      F.HasUnrecognizedCondition = true;
-      return true; // Emit a warning for the unrecognized key.
-    });
-    Dict.handle("PathMatch", [&](Node &N) {
-      if (auto Values = scalarValues(N))
-        F.PathMatch = std::move(*Values);
-    });
-    Dict.handle("PathExclude", [&](Node &N) {
-      if (auto Values = scalarValues(N))
-        F.PathExclude = std::move(*Values);
-    });
-    Dict.parse(N);
+  class DictParser;
+  // Parsing is built out of two sets of overloaded functions:
+  //
+  //   parse(yaml::Node&, StringRef Description, T& Out)
+  //   Parses a value out of an arbitrary YAML node.
+  //   On failure it emits warnings, and discards broken parts of the input.
+  //   
+  //   parseScalar(const Located<string>&, StringRef Description, T& Out)
+  //   Parses a value out of a yaml scalar that has already been extracted.
+  //
+  // Parse functions operate on types that can have a "neutral" default value,
+  // like optional<string> or vector<string> rather than string itself.
+  //
+  // To parse a field of type vector<Located<bool>>, we have a call stack like
+  //   parse(..., vector<Located<bool>>&)
+  //   parse(..., optional<Located<bool>>&)
+  //   parse(..., optional<bool>&)
+  //   parseScalar(..., optional<bool>)
+
+  // parse() for blocks and parseScalar() for enums, generated from the schema.
+#include "config/YAML.inc"
+
+  // We can scalar-parse strings and booleans.
+  void parseScalar(const Located<std::string> &S, llvm::StringRef Desc,
+                   std::optional<std::string> &Out) {
+    Out = *S;
+  }
+  void parseScalar(const Located<std::string> &S, llvm::StringRef Desc,
+                   std::optional<bool> &Out) {
+    if (auto Bool = llvm::yaml::parseBool(*S))
+      Out = *Bool;
+    else
+      warning(Desc + " should be a boolean", S.Range);
   }
 
-  void parse(Fragment::CompileFlagsBlock &F, Node &N) {
-    DictParser Dict("CompileFlags", this);
-    Dict.handle("Compiler", [&](Node &N) {
-      if (auto Value = scalarValue(N, "Compiler"))
-        F.Compiler = std::move(*Value);
-    });
-    Dict.handle("Add", [&](Node &N) {
-      if (auto Values = scalarValues(N))
-        F.Add = std::move(*Values);
-    });
-    Dict.handle("Remove", [&](Node &N) {
-      if (auto Values = scalarValues(N))
-        F.Remove = std::move(*Values);
-    });
-    Dict.handle("CompilationDatabase", [&](Node &N) {
-      F.CompilationDatabase = scalarValue(N, "CompilationDatabase");
-    });
-    Dict.parse(N);
+  // Parse optional<T> based on parseScalar(optional<T>).
+  template <typename T>
+  auto parse(Node &N, llvm::StringRef Desc, std::optional<T> &Out)
+      -> decltype(parseScalar(Located<std::string>(""), Desc, Out)) {
+    if (auto Str = peekScalar(N))
+      parseScalar(*Str, Desc, Out);      
+    else
+      warning(Desc + " should be scalar", N);
   }
-
-  void parse(Fragment::StyleBlock &F, Node &N) {
-    DictParser Dict("Style", this);
-    Dict.handle("FullyQualifiedNamespaces", [&](Node &N) {
-      if (auto Values = scalarValues(N))
-        F.FullyQualifiedNamespaces = std::move(*Values);
-    });
-    Dict.parse(N);
+  // Parse optional<T> if we can parse T directly (e.g. optional blocks).
+  template <typename T>
+  auto parse(Node &N, llvm::StringRef Desc, std::optional<T> &Out)
+      -> decltype(parse(N, Desc, *Out)) {
+    Out.emplace();
+    parse(N, Desc, *Out);
+  }
+
+  // Parse optional<Located<T>>: parse optional<T> and attach node location.
+  template <typename T>
+  void parse(Node &N, llvm::StringRef Desc, std::optional<Located<T>> &Out) {
+    std::optional<T> Val;
+    if (parse(N, Desc, Val); Val.has_value())
+      Out = Located<T>(std::move(*Val), N.getSourceRange());
+  }
+
+  // Parse vector<T> by parsing each list element as optional<T>.
+  // We also support providing only a single element.
+  template <typename T>
+  void parse(Node &N, llvm::StringRef Desc, std::vector<T> &Out) {
+    if (auto *S = llvm::dyn_cast<SequenceNode>(&N)) {
+      // We *must* consume all items, even on error, or the parser will assert.
+      for (auto &Child : *S) {
+        std::optional<T> Next;
+        if (parse(Child, Desc, Next); Next.has_value())
+          Out.push_back(std::move(*Next));
       }
-
-  void parse(Fragment::DiagnosticsBlock &F, Node &N) {
-    DictParser Dict("Diagnostics", this);
-    Dict.handle("Suppress", [&](Node &N) {
-      if (auto Values = scalarValues(N))
-        F.Suppress = std::move(*Values);
-    });
-    Dict.handle("UnusedIncludes", [&](Node &N) {
-      F.UnusedIncludes = scalarValue(N, "UnusedIncludes");
-    });
-    Dict.handle("Includes", [&](Node &N) { parse(F.Includes, N); });
-    Dict.handle("ClangTidy", [&](Node &N) { parse(F.ClangTidy, N); });
-    Dict.parse(N);
+    } else {
+      std::optional<T> Only;
+      if (parse(N, Desc, Only); Only.has_value())
+        Out.push_back(std::move(*Only));
     }
-
-  void parse(Fragment::DiagnosticsBlock::ClangTidyBlock &F, Node &N) {
-    DictParser Dict("ClangTidy", this);
-    Dict.handle("Add", [&](Node &N) {
-      if (auto Values = scalarValues(N))
-        F.Add = std::move(*Values);
-    });
-    Dict.handle("Remove", [&](Node &N) {
-      if (auto Values = scalarValues(N))
-        F.Remove = std::move(*Values);
-    });
-    Dict.handle("CheckOptions", [&](Node &N) {
-      DictParser CheckOptDict("CheckOptions", this);
-      CheckOptDict.unrecognized([&](Located<std::string> &&Key, Node &Val) {
-        if (auto Value = scalarValue(Val, *Key))
-          F.CheckOptions.emplace_back(std::move(Key), std::move(*Value));
-        return false; // Don't emit a warning
-      });
-      CheckOptDict.parse(N);
-    });
+  }
+  // Parse "maps" (lists of key-value pairs).
+  // The keys must be Located<string>s, we parse the values as optional<V>.
+  template <typename T>
+  void parse(Node &N, llvm::StringRef Desc,
+             std::vector<std::pair<Located<std::string>, T>> &Out) {
+    DictParser Dict(Desc, this);
+    Dict.unrecognized([&](Located<std::string> Key, Node &Val) {
+      std::optional<T> Next;
+      if (parse(Val, Desc, Next); Next.has_value())
+        Out.emplace_back(std::move(Key), std::move(*Next));
     Dict.parse(N);
   }
 
-  void parse(Fragment::DiagnosticsBlock::IncludesBlock &F, Node &N) {
-    DictParser Dict("Includes", this);
-    Dict.handle("IgnoreHeader", [&](Node &N) {
-      if (auto Values = scalarValues(N))
-        F.IgnoreHeader = std::move(*Values);
+  // Extension point for customizing the DictParser used by generated code.
+  void beforeParsingBlock(DictParser &, void *) {}
+  // When we see an unrecognized If condition, record that so we can
+  // conservatively disable the fragment.
+  void beforeParsingBlock(DictParser &Dict, Fragment::IfBlock *If) {
+    Dict.unrecognized([If](Located<std::string>, Node &) {
+      If->HasUnrecognizedCondition = true;
+      return true; // Emit a warning.
     });
-    Dict.parse(N);
   }
 
-  void parse(Fragment::IndexBlock &F, Node &N) {
-    DictParser Dict("Index", this);
-    Dict.handle("Background",
-                [&](Node &N) { F.Background = scalarValue(N, "Background"); });
-    Dict.handle("External", [&](Node &N) {
-      Fragment::IndexBlock::ExternalBlock External;
-      // External block can either be a mapping or a scalar value. Dispatch
-      // accordingly.
-      if (N.getType() == Node::NK_Mapping) {
-        parse(External, N);
-      } else if (N.getType() == Node::NK_Scalar ||
-                 N.getType() == Node::NK_BlockScalar) {
-        parse(External, *scalarValue(N, "External"));
-      } else {
-        error("External must be either a scalar or a mapping.", N);
-        return;
-      }
-      F.External.emplace(std::move(External));
-      F.External->Range = N.getSourceRange();
-    });
-    Dict.handle("StandardLibrary", [&](Node &N) {
-      if (auto StandardLibrary = boolValue(N, "StandardLibrary"))
-        F.StandardLibrary = *StandardLibrary;
-    });
-    Dict.parse(N);
-  }
-
-  void parse(Fragment::IndexBlock::ExternalBlock &F,
-             Located<std::string> ExternalVal) {
-    if (!llvm::StringRef(*ExternalVal).equals_insensitive("none")) {
-      error("Only scalar value supported for External is 'None'",
-            ExternalVal.Range);
-      return;
-    }
-    F.IsNone = true;
-    F.IsNone.Range = ExternalVal.Range;
-  }
-
-  void parse(Fragment::IndexBlock::ExternalBlock &F, Node &N) {
-    DictParser Dict("External", this);
-    Dict.handle("File", [&](Node &N) { F.File = scalarValue(N, "File"); });
-    Dict.handle("Server",
-                [&](Node &N) { F.Server = scalarValue(N, "Server"); });
-    Dict.handle("MountPoint",
-                [&](Node &N) { F.MountPoint = scalarValue(N, "MountPoint"); });
-    Dict.parse(N);
-  }
-
-  void parse(Fragment::CompletionBlock &F, Node &N) {
-    DictParser Dict("Completion", this);
-    Dict.handle("AllScopes", [&](Node &N) {
-      if (auto AllScopes = boolValue(N, "AllScopes"))
-        F.AllScopes = *AllScopes;
-    });
-    Dict.parse(N);
-  }
-
-  void parse(Fragment::HoverBlock &F, Node &N) {
-    DictParser Dict("Hover", this);
-    Dict.handle("ShowAKA", [&](Node &N) {
-      if (auto ShowAKA = boolValue(N, "ShowAKA"))
-        F.ShowAKA = *ShowAKA;
-    });
-    Dict.parse(N);
-  }
-
-  void parse(Fragment::InlayHintsBlock &F, Node &N) {
-    DictParser Dict("InlayHints", this);
-    Dict.handle("Enabled", [&](Node &N) {
-      if (auto Value = boolValue(N, "Enabled"))
-        F.Enabled = *Value;
-    });
-    Dict.handle("ParameterNames", [&](Node &N) {
-      if (auto Value = boolValue(N, "ParameterNames"))
-        F.ParameterNames = *Value;
-    });
-    Dict.handle("DeducedTypes", [&](Node &N) {
-      if (auto Value = boolValue(N, "DeducedTypes"))
-        F.DeducedTypes = *Value;
-    });
-    Dict.handle("Designators", [&](Node &N) {
-      if (auto Value = boolValue(N, "Designators"))
-        F.Designators = *Value;
-    });
-    Dict.parse(N);
+  // Index.External is usually a block, but can be the scalar "none" instead.
+  void parseScalar(const Located<std::string> &Str, llvm::StringRef Desc,
+                   Fragment::IndexBlock::ExternalBlock &Out) {
+    if (!llvm::StringRef(*Str).equals_insensitive("none")) {
+      error("Only scalar value allowed for " + Desc + " is 'None'", Str.Range);
+    Out.IsNone = true;
   }
 
   // Helper for parsing mapping nodes (dictionaries).
   // We don't use YamlIO as we want to control over unknown keys.
   class DictParser {
     llvm::StringRef Description;
     std::vector<std::pair<llvm::StringRef, std::function<void(Node &)>>> Keys;
     std::function<bool(Located<std::string>, Node &)> UnknownHandler;
public:
     void handle(llvm::StringLiteral Key, std::function<void(Node &)> Parse) {
       for (const auto &Entry : Keys) {
         (void) Entry;
         assert(Entry.first != Key && "duplicate key handler");
       }
       Keys.emplace_back(Key, std::move(Parse));
     }
 
+    template <typename T> void map(llvm::StringLiteral Key, T &Out) {
+      handle(Key, [Key, &Out, this](Node &N) { Outer->parse(N, Key, Out); });
+    }
+
     // Handler is called when a Key is not matched by any handle().
     // If this is unset or the Handler returns true, a warning is emitted for
     // the unknown key.
     void
     unrecognized(std::function<bool(Located<std::string>, Node &)> Handler) {
       UnknownHandler = std::move(Handler);
     }
 
     // Process a mapping node and call handlers for each key/value pair.
     void parse(Node &N) const {
       if (N.getType() != Node::NK_Mapping) {
         Outer->error(Description + " should be a dictionary", N);
         return;
       }
       llvm::SmallSet<std::string, 8> Seen;
       llvm::SmallVector<Located<std::string>, 0> UnknownKeys;
       // We *must* consume all items, even on error, or the parser will assert.
       for (auto &KV : llvm::cast<MappingNode>(N)) {
         auto *K = KV.getKey();
         if (!K) // YAMLParser emitted an error.
           continue;
-        auto Key = Outer->scalarValue(*K, "Dictionary key");
-        if (!Key)
+        auto Key = peekScalar(*K);
+        if (!Key) {
+          Outer->warning("Dictionary key should be scalar!", *K);
           continue;
+        }
         if (!Seen.insert(**Key).second) {
           Outer->warning("Duplicate key " + **Key + " is ignored", *K);
           if (auto *Value = KV.getValue())
             Value->skip();
           continue;
         }
         auto *Value = KV.getValue();
         if (!Value) // YAMLParser emitted an error.
void warnUnknownKeys(llvm::ArrayRef<Located<std::string>> UnknownKeys,
                          UnknownKey.Range);
         else
           Outer->warning("Unknown " + Description + " key '" + *UnknownKey +
                              "'",
                          UnknownKey.Range);
     }
   };
 
-  // Try to parse a single scalar value from the node, warn on failure.
-  std::optional<Located<std::string>> scalarValue(Node &N,
-                                                  llvm::StringRef Desc) {
-    llvm::SmallString<256> Buf;
-    if (auto *S = llvm::dyn_cast<ScalarNode>(&N))
-      return Located<std::string>(S->getValue(Buf).str(), N.getSourceRange());
-    if (auto *BS = llvm::dyn_cast<BlockScalarNode>(&N))
-      return Located<std::string>(BS->getValue().str(), N.getSourceRange());
-    warning(Desc + " should be scalar", N);
-    return std::nullopt;
-  }
-
-  std::optional<Located<bool>> boolValue(Node &N, llvm::StringRef Desc) {
-    if (auto Scalar = scalarValue(N, Desc)) {
-      if (auto Bool = llvm::yaml::parseBool(**Scalar))
-        return Located<bool>(*Bool, Scalar->Range);
-      warning(Desc + " should be a boolean", N);
-    }
-    return std::nullopt;
-  }
+  // Helper with similar API to StringSwitch, for parsing enum values.
+  // Attempt to parse a specified string into an enum.
+  // Yields std::nullopt and produces a diagnostic on failure.
+  //
+  // Optional<T> Value = EnumSwitch<En>("Foo", Frag.Foo, *This)
+  //    .map("Foo", Enum::Foo)
+  //    .map("Bar", Enum::Bar)
+  //    .value();
+  template <typename T> class EnumSwitch {
+    Parser &Outer;
+    llvm::StringRef EnumName;
+    const Located<std::string> &Input;
+    std::optional<T> Result;
+    llvm::SmallVector<llvm::StringLiteral> ValidValues;
 
-  // Try to parse a list of single scalar values, or just a single value.
-  std::optional<std::vector<Located<std::string>>> scalarValues(Node &N) {
-    std::vector<Located<std::string>> Result;
-    if (auto *S = llvm::dyn_cast<ScalarNode>(&N)) {
-      llvm::SmallString<256> Buf;
-      Result.emplace_back(S->getValue(Buf).str(), N.getSourceRange());
-    } else if (auto *S = llvm::dyn_cast<BlockScalarNode>(&N)) {
-      Result.emplace_back(S->getValue().str(), N.getSourceRange());
-    } else if (auto *S = llvm::dyn_cast<SequenceNode>(&N)) {
-      // We *must* consume all items, even on error, or the parser will assert.
-      for (auto &Child : *S) {
-        if (auto Value = scalarValue(Child, "List item"))
-          Result.push_back(std::move(*Value));
-      }
-    } else {
-      warning("Expected scalar or list of scalars", N);
-      return std::nullopt;
-    }
+  public:
+    EnumSwitch(llvm::StringRef EnumName, const Located<std::string> &In,
+               Parser &Outer)
+        : Outer(Outer), EnumName(EnumName), Input(In) {}
+
+    EnumSwitch &map(llvm::StringLiteral Name, T Value) {
+      assert(!llvm::is_contained(ValidValues, Name) && "Duplicate value!");
+      ValidValues.push_back(Name);
+      if (!Result && *Input == Name)
+        Result = Value;
+      return *this;
+    }
+
+    std::optional<T> value() {
+      if (!Result)
+        Outer.warning(
+            llvm::formatv("Invalid {0} value '{1}'. Valid values are {2}.",
+                          EnumName, *Input, llvm::join(ValidValues, ", "))
+                .str(),
+            Input.Range);
       return Result;
-  }
+    };
+  };
 
   // Report a "hard" error, reflecting a config file that can never be valid.
   void error(const llvm::Twine &Msg, llvm::SMRange Range) {
     HadError = true;
     SM.PrintMessage(Range.Start, llvm::SourceMgr::DK_Error, Msg, Range);
   }
   void error(const llvm::Twine &Msg, const Node &N) {
     return error(Msg, N.getSourceRange());

clang-tools-extra/clangd/config/CMakeLists.txt

+add_llvm_utility(clangd-config-generate
+  Generate.cpp
+  )
+
+target_link_libraries(clangd-config-generate PRIVATE LLVMSupport)
 No newline at end of file

clang-tools-extra/clangd/config/Fragment.inc

+/// Conditions in the If block restrict when a Fragment applies.
+/// 
+/// Each separate condition must match (combined with AND).
+/// When one condition has multiple values, any may match (combined with OR).
+/// e.g. `PathMatch: [foo/.*, bar/.*]` matches files in either directory.
+/// 
+/// Conditions based on a file's path use the following form:
+/// 
+/// - if the fragment came from a project directory, the path is relative
+/// - if the fragment is global (e.g. user config), the path is absolute
+/// - paths always use forward-slashes (UNIX-style)
+/// 
+/// If no file is being processed, these conditions will not match.
+struct IfBlock : detail::IfBase {
+  /// The file being processed must fully match a regular expression.
+  std::vector<Located<std::string>> PathMatch;
+  
+  /// The file being processed must *not* fully match a regular expression.
+  std::vector<Located<std::string>> PathExclude;
+  
+};
+IfBlock If;
+
+/// Affects how a file is parsed.
+/// 
+/// clangd emulates how clang would interpret a file.
+/// By default, it behaves roughly like `clang $FILENAME`, but real projects
+/// usually require setting the include path (with the `-I` flag), defining
+/// preprocessor symbols, configuring warnings etc.
+/// 
+/// Often, a compilation database specifies these compile commands. clangd
+/// searches for compile_commands.json in parents of the source file.
+/// 
+/// This section modifies how the compile command is constructed.
+struct CompileFlagsBlock {
+  /// Override the compiler executable name to simulate.
+  /// The name can affect how flags are parsed (clang++ vs clang).
+  /// If the executable name is in the --query-driver allowlist, then it will
+  /// be invoked to extract include paths.
+  /// 
+  /// (This simply replaces argv[0], and may mangle commands that use
+  /// more complicated drivers like ccache).
+  std::optional<Located<std::string>> Compiler;
+  
+  /// List of flags to append to the compile command.
+  std::vector<Located<std::string>> Add;
+  
+  /// List of flags to remove from the compile command.
+  /// 
+  /// - If the value is a recognized clang flag (like `-I`) then it will be
+  ///   removed along with any arguments. Synonyms like `--include-dir=` will
+  ///   also be removed.
+  /// - Otherwise, if the value ends in `*` (like `-DFOO=*`) then any argument
+  ///   with the prefix will be removed.
+  /// - Otherwise any argument exactly matching the value is removed.
+  /// 
+  /// In all cases, `-Xclang` is also removed where needed.
+  /// Flags added by the same CompileFlags entry will not be removed.
+  std::vector<Located<std::string>> Remove;
+  
+  /// Directory to search for compilation database (compile_comands.json etc).
+  /// 
+  /// Valid values are:
+  /// 
+  /// - A single path to a directory (absolute, or relative to the fragment)
+  /// - `Ancestors`: search all parent directories (the default)
+  /// - `None`: do not use a compilation database, just default flags.
+  std::optional<Located<std::string>> CompilationDatabase;
+  
+};
+CompileFlagsBlock CompileFlags;
+
+/// Controls how clangd understands code outside the current file.
+/// 
+/// clangd's indexes provide information about symbols that isn't available
+/// to clang's parser, such as incoming references.
+struct IndexBlock {
+  /// Whether files are built in the background to produce a project index.
+  /// This is checked for translation units only, not headers they include.
+  enum class BackgroundValues {
+    /// Files are indexed as normal. This is the default.
+    Build,
+    /// Files will not be indexed.
+    Skip,
+  };
+  std::optional<Located<BackgroundValues>> Background;
+  
+  /// Used to define an external index source.
+  /// Exactly one of `File` or `Server` should be specified.
+  /// 
+  /// Declaring an `External` index disables background-indexing implicitly for
+  /// files under the `MountPoint`. Users can turn it back on, by explicitly
+  /// specifying `Background: Build`.
+  /// 
+  /// `External: None` will disable a previously-specified external index.
+  struct ExternalBlock : detail::ExternalBase {
+    /// Path to a monolithic index file produced by `clangd-indexer`.
+    std::optional<Located<std::string>> File;
+    
+    /// Address of a [remote index server](/guides/remote-index).
+    std::optional<Located<std::string>> Server;
+    
+    /// Specifies the source root for the index, needed to translate match
+    /// paths in the index to paths on disk.
+    /// Defaults to the location of this config fragment.
+    /// In a project config, this can be a relative path.
+    std::optional<Located<std::string>> MountPoint;
+    
+  };
+  std::optional<Located<ExternalBlock>> External;
+  
+  /// Whether the standard library visible from this file should be indexed.
+  /// This makes all standard library symbols available, included or not.
+  std::optional<Located<bool>> StandardLibrary;
+  
+};
+IndexBlock Index;
+
+/// Describes the style of the codebase, beyond formatting.
+struct StyleBlock {
+  /// Namespaces that should always be fully qualified: no "using" declarations,
+  /// always spell out the whole name (with or without leading `::`).
+  /// All nested namespaces are affected as well.
+  /// Affects availability of the AddUsing tweak.
+  std::vector<Located<std::string>> FullyQualifiedNamespaces;
+  
+};
+StyleBlock Style;
+
+/// Controls behavior of diagnostics (errors and warnings).
+struct DiagnosticsBlock {
+  /// Diagnostic codes that should be suppressed.
+  /// 
+  /// - `*`, to disable all diagnostics
+  /// - diagnostic codes exposed by clangd (e.g `unknown_type`, `-Wunused-result`)
+  /// - clang internal diagnostic codes (e.g. `err_unknown_type`)
+  /// - warning categories (e.g. `unused-result`)
+  /// - clang-tidy check names (e.g. `bugprone-narrowing-conversions`)
+  /// 
+  /// This is a simple filter. Diagnostics can be controlled in other ways
+  /// (e.g. by disabling a clang-tidy check, or the `-Wunused` compile flag).
+  /// This often has other advantages, such as skipping some analysis.
+  std::vector<Located<std::string>> Suppress;
+  
+  /// Controls how clang-tidy will run over the code base.
+  /// 
+  ///       The settings are merged with any settings found in .clang-tidy
+  ///       configuration files, with these ones taking precedence.
+  struct ClangTidyBlock {
+    /// List of [checks](https://clang.llvm.org/extra/clang-tidy/checks/list.html).
+    /// These can be globs, like `bugprone-*`.
+    std::vector<Located<std::string>> Add;
+    
+    /// List of checks to disable, can be globs.
+    /// Takes precedence over Add, which allows enabling all checks in a module
+    /// apart from a specific list.
+    std::vector<Located<std::string>> Remove;
+    
+    /// Key-value pairs list of options to pass to clang-tidy checks.
+    /// Options for all checks can be found [here](https://clang.llvm.org/extra/clang-tidy/checks/list.html).
+    /// These take precedence over options specified in clang-tidy configuration
+    /// files.
+    std::vector<std::pair<Located<std::string>, Located<std::string>>> CheckOptions;
+    
+  };
+  ClangTidyBlock ClangTidy;
+  
+  /// Controls how clangd will correct "unnecessary" #include directives.
+  /// clangd can warn if a header is `#include`d but not used, and suggest
+  /// removing it.
+  enum class UnusedIncludesValues {
+    /// The same as Strict, but using the include-cleaner library.
+    Experiment,
+    /// Unused includes are not reported.
+    None,
+    /// A header is unused if it does not *directly* provide any symbol used
+    /// in the file. Removing it may still break compilation if it transitively
+    /// includes headers that are used. This should be fixed by including those
+    /// headers directly.
+    Strict,
+  };
+  std::optional<Located<UnusedIncludesValues>> UnusedIncludes;
+  
+  /// Controls how headers are diagnosed.
+  struct IncludesBlock {
+    /// Regexes that will be used to avoid diagnosing certain includes as
+    /// unused or missing. These can match any suffix of the header file in
+    /// question.
+    std::vector<Located<std::string>> IgnoreHeader;
+    
+  };
+  IncludesBlock Includes;
+  
+};
+DiagnosticsBlock Diagnostics;
+
+/// Describes code completion preferences.
+struct CompletionBlock {
+  /// Whether code completion should include suggestions from scopes that are
+  /// not visible. The required scope prefix will be inserted.
+  std::optional<Located<bool>> AllScopes;
+  
+};
+CompletionBlock Completion;
+
+/// Configures labels shown inline with the code.
+struct InlayHintsBlock {
+  /// Enables/disables the inlay-hints feature.
+  std::optional<Located<bool>> Enabled;
+  
+  /// Show parameter names before function arguments.
+  std::optional<Located<bool>> ParameterNames;
+  
+  /// Show deduced types for `auto`.
+  std::optional<Located<bool>> DeducedTypes;
+  
+  /// Show designators in aggregate initialization.
+  std::optional<Located<bool>> Designators;
+  
+};
+InlayHintsBlock InlayHints;
+
+/// Configures contents of hover cards.
+struct HoverBlock {
+  /// Controls printing of desugared types, for example:
+  /// `vector<int>::value_type (aka int)`.
+  std::optional<Located<bool>> ShowAKA;
+  
+};
+HoverBlock Hover;
+

clang-tools-extra/clangd/config/Generate.cpp

+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/JSON.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/Signals.h"
+#include "llvm/Support/YAMLTraits.h"
+
+using namespace llvm;
+
+namespace clangd::config {
+namespace {
+using Block = llvm::function_ref<void()>;
+
+struct Node {
+  enum NodeKind { Block, Map, Enum, String, Boolean } Kind;
+  std::string Doc, Example;
+  std::string Scalars;
+  std::string Base;
+  std::optional<bool> Multiple, Nullable;
+
+  std::vector<std::pair<std::string, std::unique_ptr<Node>>> Children;
+  std::vector<std::pair<std::string, std::string>> Enumerators;
+
+  bool scalar() const { return !(Kind == Map || Kind == Block); }
+  std::vector<std::string> Name;
+  uintptr_t SortKey = 0;
+};
+
+void normalize(Node &N) {
+  N.Multiple = N.Multiple.value_or(false);
+  N.Nullable = N.Nullable.value_or(!*N.Multiple && N.scalar());
+  N.Doc.resize(llvm::StringRef(N.Doc).rtrim().size());
+  for (const auto &[Name, Child] : N.Children) {
+    Child->Name = N.Name;
+    Child->Name.push_back(Name);
+    normalize(*Child);
+  }
+}
+
+// Terse helpers for composing types.
+std::string opt(std::string Type, bool Optional = true) {
+  if (!Optional)
+    return Type;
+  return "std::optional<" + Type + ">";
+}
+std::string loc(std::string Type) { return "Located<" + Type + ">"; }
+std::string vec(std::string Type, bool Vec = true) {
+  if (!Vec)
+    return Type;
+  return "std::vector<" + Type + ">";
+}
+std::string pair(std::string TypeA, std::string TypeB) {
+  return "std::pair<" + TypeA + ", " + TypeB + ">";
+}
+
+class JSONSchemaWriter {
+public:
+  JSONSchemaWriter(raw_ostream &OS) : J(OS, /*IndentSize=*/2) {
+    J.objectBegin();
+    J.attribute("$schema", "http://json-schema.org/draft-07/schema");
+  }
+  void write(const Node &Root) { visit(Root); }
+  ~JSONSchemaWriter() { J.objectEnd(); }
+
+private:
+  json::OStream J;
+
+  void visit(const Node &N) {
+    if (!N.Doc.empty()) {
+      J.attribute("description", N.Doc);
+
+      // VSCode extension - our docs are actually markdown, this renders better.
+      std::string MarkdownDescription = N.Doc;
+      if (!N.Example.empty()) {
+        // Tack examples onto the description rather than in the `examples`
+        // field, because that's specified to be JSON objects, and we have YAML.
+        MarkdownDescription += "\n\n```yaml\n";
+        MarkdownDescription += N.Example;
+        MarkdownDescription += "```\n";
+      }
+      J.attribute("markdownDescription", MarkdownDescription);
+    }
+
+    switch (N.Kind) {
+    case Node::Block:
+      J.attribute("type", "object");
+      J.attributeObject("definitions", [&] {
+        for (const auto &C : N.Children)
+          J.attributeObject(C.first, [&] { visit(*C.second); }) ;
+      });
+      J.attributeObject("properties", [&] {
+        for (const auto &C : N.Children)
+          J.attribute(C.first, maybeMultiple(*C.second->Multiple,
+                                             maybeScalars(C.second->Scalars,
+                                                          ref(*C.second))));
+      });
+      if (!N.Scalars.empty())
+        J.attribute("patternProperties", json::Object{{N.Scalars, true}});
+      J.attribute("additionalProperties", false);
+      break;
+    case Node::Map:
+      J.attribute("type", "object");
+      break;
+    case Node::Enum:
+      J.attributeArray("enum", [&] {
+        for (const auto &[Name, Doc] : N.Enumerators)
+          J.value(Name);
+      });
+      // VSCode extension.
+      J.attributeArray("markdownEnumDescriptions", [&] {
+        for (const auto &[Name, Doc] : N.Enumerators)
+          J.value(Doc);
+      });
+      break;
+    case Node::String:
+      J.attribute("type", "string");
+      break;
+    case Node::Boolean:
+      J.attribute("type", "boolean");
+      break;
+    }
+  }
+
+  // Returns a reference to the schema for (one value of) the given node.
+  json::Value ref(const Node &N) {
+    // The schema for values of CompileFlags.Add is at:
+    //   #/definitions/CompileFlags/definitions/Add
+    // Setting anchors seems nicer, but consumers can't handle them.
+    std::string Result = "#";
+    for (llvm::StringRef Part : N.Name) {
+      Result += "/definitions/";
+      Result.append(Part.begin(), Part.end());
+    }
+    return json::Object{{"$ref", std::move(Result)}};
+  }
+
+  json::Value maybeMultiple(bool Multiple, json::Value Target) {
+    if (!Multiple)
+      return Target;
+    return json::Object{{
+        "anyOf",
+        json::Array{Target, json::Object{{"type", "array"}, {"items", Target}}},
+    }};
+  }
+
+  json::Value maybeScalars(llvm::StringRef ScalarPattern, json::Value Target) {
+    if (ScalarPattern.empty())
+      return Target;
+    return json::Object{{
+        "anyOf",
+        json::Array{Target, json::Object{{"type", "string"},
+                                         {"pattern", ScalarPattern}}},
+    }, {"description", "yo"}};
+  }
+};
+
+class CodeWriter {
+  int Indent = 0;
+  raw_ostream &OS;
+
+protected:
+  CodeWriter(raw_ostream &OS) : OS(OS) {}
+  raw_ostream &line() { return OS.indent(Indent); }
+  void indent(int N, Block B) {
+    Indent += N;
+    B();
+    Indent -= N;
+  }
+};
+
+class HeaderWriter : CodeWriter {
+public:
+  HeaderWriter(raw_ostream &OS) : CodeWriter(OS) {}
+
+  void write(const Node &Root) {
+    writeBlockBody(Root);
+  }
+
+private:
+  void visit(const Node &N, llvm::StringRef Name) {
+    // Doc attaches to the type if there is one (block or enum), else the field.
+    writeDoc(N.Doc);
+    switch (N.Kind) {
+    case Node::Block: {
+      std::string Type = (Name + "Block").str();
+      raw_ostream &L = line() << "struct " << Type;
+      if (!N.Base.empty())
+        L << " : " << N.Base;
+      L << " {\n";
+      indent(2, [&] { writeBlockBody(N); });
+      line() << "};\n";
+      // Location info is needed only if presence is significant.
+      if (*N.Nullable)
+        Type = loc(std::move(Type));
+      declare(Name, std::move(Type), N);
+      break;
+    }
+    case Node::Map:
+      declare(Name, vec(pair(loc("std::string"), loc("std::string"))));
+      break;
+    case Node::Enum: {
+      std::string Type = (Name + "Values").str();
+      line() << "enum class " << Type << " {\n";
+      indent(2, [&] {
+        for (const auto &[Enum, Doc] : N.Enumerators) {
+          writeDoc(Doc);
+          line() << Enum << ",\n";
+        }
+      });
+      line() << "};\n";
+      declare(Name, loc(std::move(Type)), N);
+      break;
+    }
+    case Node::String:
+      declare(Name, loc("std::string"), N);
+      break;
+    case Node::Boolean:
+      declare(Name, loc("bool"), N);
+      break;
+    }
+      line() << "\n";
+  }
+
+  void declare(llvm::StringRef Name, std::string Type) {
+    line() << Type << " " << Name << ";\n";
+  }
+  void declare(llvm::StringRef Name, std::string BasicType, const Node &N) {
+    declare(Name, vec(opt(std::move(BasicType), *N.Nullable), *N.Multiple));
+  }
+
+  void writeBlockBody(const Node &N) {
+    for (const auto &[Name, Child] : N.Children)
+      visit(*Child, Name);
+  }
+
+  void writeDoc(llvm::StringRef Doc) {
+    llvm::StringRef Line;
+    while (!Doc.empty()) {
+      std::tie(Line, Doc) = Doc.split('\n');
+      line() << "/// " << Line << "\n";
+    }
+  }
+};
+
+class YAMLParserWriter : CodeWriter {
+public:
+  YAMLParserWriter(raw_ostream &OS) : CodeWriter(OS) {}
+
+  void write(const Node& N) {
+    visit(N);
+    for (const auto &[Name, Child] : N.Children)
+      write(*Child);
+  }
+
+private:
+  std::string scopeName(const Node &N) {
+    std::string Result = "config::Fragment::";
+    return Result;
+  }
+
+  std::string qualType(const Node &N) {
+    std::string Result = "config::Fragment";
+    if (N.Name.empty())
+      return Result;
+    Result += "::";
+    for (const auto &Part : ArrayRef(N.Name).drop_back()) {
+      Result += Part;
+      Result += "Block";
+      Result += "::";
+    }
+    Result += N.Name.back();
+    Result += N.Kind == Node::Block ? "Block" : "Values";
+    return Result;
+  }
+
+  std::string quote(llvm::StringRef Text) {
+    // No escaping needed, since these are all C++ names.
+    return ("\"" + Text + "\"").str();
+  }
+  
+  void visit(const Node &N) {
+    switch (N.Kind) {
+    case Node::Block:
+      line() << "void parse(llvm::yaml::Node &N, llvm::StringRef Desc, "
+             << qualType(N) << " &Out) {\n";
+      indent(2, [&] {
+        if (!N.Scalars.empty()) {
+          line() << "if (auto Str = peekScalar(N))\n";
+          line() << "  return parseScalar(*Str, Desc, Out);\n";
+        }
+        line() << "DictParser Dict(Desc, this);\n";
+        line() << "beforeParsingBlock(Dict, &Out);\n";
+        for (const auto &[Name, Child] : N.Children)
+          line() << "Dict.map(" << quote(Name) << ", Out." << Name << ");\n";
+        line() << "Dict.parse(N);\n";
+      });
+      line() << "}\n\n";
+      break;
+    case Node::Enum:
+      line() << "void parseScalar(const Located<std::string> &In, "
+             << "llvm::StringRef Desc, " << opt(qualType(N)) << " &Out) {\n";
+      indent(2, [&] {
+        line() << "using E = " << qualType(N) << ";\n";
+        line() << "Out = EnumSwitch<E>(Desc, In, *this)\n";
+        for (const auto &[Enum, Doc] : N.Enumerators)
+          line() << "    .map(" << quote(Enum) << ", E::" << Enum << ")\n";
+        line() << "    .value();\n";
+      });
+      line() << "}\n\n";
+      break;
+    default:
+      break;
+    }
+  }
+};
+
+class MarkdownWriter {
+public:
+  MarkdownWriter(raw_ostream &OS) : OS(OS) {}
+
+  void write(const Node &Root) { walkChildren(Root, /*Level=*/2); }
+
+private:
+  void walkChildren(const Node &N, int Level) {
+    for (const auto &[Name, Child] : N.Children) {
+      visit(Name, *Child, Level);
+      walkChildren(*Child, Level + 1);
+    }
+  }
+
+  void visit(llvm::StringRef Name, const Node &N, int Level) {
+    OS << std::string(Level, '#') << " " << Name << "\n\n";
+    if (!N.Doc.empty())
+      OS << N.Doc << "\n\n";
+    if (!N.Example.empty())
+      OS << "```yaml\n" << N.Example << "```\n\n";
+
+    switch (N.Kind) {
+    case Node::Block:
+    case Node::Map:
+      break;
+    case Node::Enum:
+      for (const auto &[Name, Doc] : N.Enumerators)
+        OS << "- `" << Name << "`: " << Doc << "\n";
+      OS << "\n";
+      break;
+    case Node::String:
+    case Node::Boolean:
+      break;
+    }
+  }
+
+  raw_ostream &OS;
+};
+
+} // namespace
+} // namespace clangd::config
+
+// YAML traits to allow parsing schema.yaml into a tree of Node objects.
+namespace llvm::yaml {
+namespace cfg = clangd::config;
+
+template <>
+struct ScalarEnumerationTraits<cfg::Node::NodeKind> {
+  static void enumeration(IO &I, cfg::Node::NodeKind &E) {
+    I.enumCase(E, "block", cfg::Node::Block);
+    I.enumCase(E, "map", cfg::Node::Map);
+    I.enumCase(E, "enum", cfg::Node::Enum);
+    I.enumCase(E, "string", cfg::Node::String);
+    I.enumCase(E, "boolean", cfg::Node::Boolean);
+  }
+};
+
+template <>
+struct MappingTraits<cfg::Node> {
+  static void mapping(IO &I, cfg::Node &N) {
+    I.mapRequired("kind", N.Kind);
+    I.mapOptional("doc", N.Doc);
+    I.mapOptional("example", N.Example);
+    I.mapOptional("base", N.Base);
+    I.mapOptional("scalars", N.Scalars);
+    I.mapOptional("multiple", N.Multiple);
+    I.mapOptional("nullable", N.Nullable);
+
+    assert(!I.outputting() && "Only parsing is supported");
+    // Capture the other attributes: block children and enum enumerators.
+    // These all begin with capital letters.
+    for (StringRef Key : I.keys()) {
+      if (Key.empty() || !std::isupper(Key.front()))
+        continue;
+      if (N.Kind == cfg::Node::Block) {
+        N.Children.emplace_back(Key, std::make_unique<cfg::Node>());
+        I.mapRequired(Key.str().c_str(), *N.Children.back().second);
+      }
+      if (N.Kind == cfg::Node::Enum) {
+        N.Enumerators.emplace_back(Key, "");
+        I.mapRequired(Key.str().c_str(), N.Enumerators.back().second);
+      }
+    }
+    // FIXME: Input::keys() does not preserve input order!
+    // For Nodes, we capture position in the doc and sort Children on that.
+    auto R = static_cast<yaml::Input &>(I).getCurrentNode()->getSourceRange();
+    N.SortKey = reinterpret_cast<uintptr_t>(R.Start.getPointer());
+    llvm::sort(N.Children, [&](auto &L, auto &R) {
+      return L.second->SortKey < R.second->SortKey;
+    });
+    // For Enumerators, we have to live with alphabetical order.
+    llvm::sort(N.Enumerators);
+  }
+};
+
+} // namespace llvm::yaml
+
+static void check(StringRef Description, const std::error_code &V) {
+  if (V) {
+    errs() << Description << ": " << V.message();
+    exit(1);
+  }
+}
+
+int main(int argc, char **argv) {
+  cl::opt<std::string> SchemaFile("schema", cl::Required);
+  cl::opt<std::string> JSONSchemaOut("json-schema-out");
+  cl::opt<std::string> HeaderOut("header-out");
+  cl::opt<std::string> YAMLParserOut("yaml-parser-out");
+  cl::opt<std::string> MarkdownOut("markdown-out");
+
+  sys::PrintStackTraceOnErrorSignal(argv[0]);
+  cl::ParseCommandLineOptions(argc, argv);
+
+  clangd::config::Node Root;
+  {
+    auto Schema = MemoryBuffer::getFileOrSTDIN(SchemaFile);
+    check("schema", Schema.getError());
+    yaml::Input In((*Schema)->getBuffer());
+    In >> Root;
+    check("schema", In.error());
+  }
+  clangd::config::normalize(Root);
+
+  std::error_code EC;
+  if (JSONSchemaOut.getNumOccurrences()) {
+    raw_fd_ostream OS(JSONSchemaOut, EC);
+    check("json schema", EC);
+    clangd::config::JSONSchemaWriter(OS).write(Root);
+  }
+  if (HeaderOut.getNumOccurrences()) {
+    raw_fd_ostream OS(HeaderOut, EC);
+    check("header", EC);
+    clangd::config::HeaderWriter(OS).write(Root);
+  }
+  if (YAMLParserOut.getNumOccurrences()) {
+    raw_fd_ostream OS(YAMLParserOut, EC);
+    check("yaml parser", EC);
+    clangd::config::YAMLParserWriter(OS).write(Root);
+  }
+  if (MarkdownOut.getNumOccurrences()) {
+    raw_fd_ostream OS(MarkdownOut, EC);
+    check("markdown", EC);
+    clangd::config::MarkdownWriter(OS).write(Root);
+  }
+}
 No newline at end of file

clang-tools-extra/clangd/config/YAML.inc

+void parse(llvm::yaml::Node &N, llvm::StringRef Desc, config::Fragment &Out) {
+  DictParser Dict(Desc, this);
+  beforeParsingBlock(Dict, &Out);
+  Dict.map("If", Out.If);
+  Dict.map("CompileFlags", Out.CompileFlags);
+  Dict.map("Index", Out.Index);
+  Dict.map("Style", Out.Style);
+  Dict.map("Diagnostics", Out.Diagnostics);
+  Dict.map("Completion", Out.Completion);
+  Dict.map("InlayHints", Out.InlayHints);
+  Dict.map("Hover", Out.Hover);
+  Dict.parse(N);
+}
+
+void parse(llvm::yaml::Node &N, llvm::StringRef Desc, config::Fragment::IfBlock &Out) {
+  DictParser Dict(Desc, this);
+  beforeParsingBlock(Dict, &Out);
+  Dict.map("PathMatch", Out.PathMatch);
+  Dict.map("PathExclude", Out.PathExclude);
+  Dict.parse(N);
+}
+
+void parse(llvm::yaml::Node &N, llvm::StringRef Desc, config::Fragment::CompileFlagsBlock &Out) {
+  DictParser Dict(Desc, this);
+  beforeParsingBlock(Dict, &Out);
+  Dict.map("Compiler", Out.Compiler);
+  Dict.map("Add", Out.Add);
+  Dict.map("Remove", Out.Remove);
+  Dict.map("CompilationDatabase", Out.CompilationDatabase);
+  Dict.parse(N);
+}
+
+void parse(llvm::yaml::Node &N, llvm::StringRef Desc, config::Fragment::IndexBlock &Out) {
+  DictParser Dict(Desc, this);
+  beforeParsingBlock(Dict, &Out);
+  Dict.map("Background", Out.Background);
+  Dict.map("External", Out.External);
+  Dict.map("StandardLibrary", Out.StandardLibrary);
+  Dict.parse(N);
+}
+
+void parseScalar(const Located<std::string> &In, llvm::StringRef Desc, std::optional<config::Fragment::IndexBlock::BackgroundValues> &Out) {
+  using E = config::Fragment::IndexBlock::BackgroundValues;
+  Out = EnumSwitch<E>(Desc, In, *this)
+      .map("Build", E::Build)
+      .map("Skip", E::Skip)
+      .value();
+}
+
+void parse(llvm::yaml::Node &N, llvm::StringRef Desc, config::Fragment::IndexBlock::ExternalBlock &Out) {
+  if (auto Str = peekScalar(N))
+    return parseScalar(*Str, Desc, Out);
+  DictParser Dict(Desc, this);
+  beforeParsingBlock(Dict, &Out);
+  Dict.map("File", Out.File);
+  Dict.map("Server", Out.Server);
+  Dict.map("MountPoint", Out.MountPoint);
+  Dict.parse(N);
+}
+
+void parse(llvm::yaml::Node &N, llvm::StringRef Desc, config::Fragment::StyleBlock &Out) {
+  DictParser Dict(Desc, this);
+  beforeParsingBlock(Dict, &Out);
+  Dict.map("FullyQualifiedNamespaces", Out.FullyQualifiedNamespaces);
+  Dict.parse(N);
+}
+
+void parse(llvm::yaml::Node &N, llvm::StringRef Desc, config::Fragment::DiagnosticsBlock &Out) {
+  DictParser Dict(Desc, this);
+  beforeParsingBlock(Dict, &Out);
+  Dict.map("Suppress", Out.Suppress);
+  Dict.map("ClangTidy", Out.ClangTidy);
+  Dict.map("UnusedIncludes", Out.UnusedIncludes);
+  Dict.map("Includes", Out.Includes);
+  Dict.parse(N);
+}
+
+void parse(llvm::yaml::Node &N, llvm::StringRef Desc, config::Fragment::DiagnosticsBlock::ClangTidyBlock &Out) {
+  DictParser Dict(Desc, this);
+  beforeParsingBlock(Dict, &Out);
+  Dict.map("Add", Out.Add);
+  Dict.map("Remove", Out.Remove);
+  Dict.map("CheckOptions", Out.CheckOptions);
+  Dict.parse(N);
+}
+
+void parseScalar(const Located<std::string> &In, llvm::StringRef Desc, std::optional<config::Fragment::DiagnosticsBlock::UnusedIncludesValues> &Out) {
+  using E = config::Fragment::DiagnosticsBlock::UnusedIncludesValues;
+  Out = EnumSwitch<E>(Desc, In, *this)
+      .map("Experiment", E::Experiment)
+      .map("None", E::None)
+      .map("Strict", E::Strict)
+      .value();
+}
+
+void parse(llvm::yaml::Node &N, llvm::StringRef Desc, config::Fragment::DiagnosticsBlock::IncludesBlock &Out) {
+  DictParser Dict(Desc, this);
+  beforeParsingBlock(Dict, &Out);
+  Dict.map("IgnoreHeader", Out.IgnoreHeader);
+  Dict.parse(N);
+}
+
+void parse(llvm::yaml::Node &N, llvm::StringRef Desc, config::Fragment::CompletionBlock &Out) {
+  DictParser Dict(Desc, this);
+  beforeParsingBlock(Dict, &Out);
+  Dict.map("AllScopes", Out.AllScopes);
+  Dict.parse(N);
+}
+
+void parse(llvm::yaml::Node &N, llvm::StringRef Desc, config::Fragment::InlayHintsBlock &Out) {
+  DictParser Dict(Desc, this);
+  beforeParsingBlock(Dict, &Out);
+  Dict.map("Enabled", Out.Enabled);
+  Dict.map("ParameterNames", Out.ParameterNames);
+  Dict.map("DeducedTypes", Out.DeducedTypes);
+  Dict.map("Designators", Out.Designators);
+  Dict.parse(N);
+}
+
+void parse(llvm::yaml::Node &N, llvm::StringRef Desc, config::Fragment::HoverBlock &Out) {
+  DictParser Dict(Desc, this);
+  beforeParsingBlock(Dict, &Out);
+  Dict.map("ShowAKA", Out.ShowAKA);
+  Dict.parse(N);
+}
+

clang-tools-extra/clangd/config/documentation.md

+## If
+
+Conditions in the If block restrict when a Fragment applies.
+
+Each separate condition must match (combined with AND).
+When one condition has multiple values, any may match (combined with OR).
+e.g. `PathMatch: [foo/.*, bar/.*]` matches files in either directory.
+
+Conditions based on a file's path use the following form:
+
+- if the fragment came from a project directory, the path is relative
+- if the fragment is global (e.g. user config), the path is absolute
+- paths always use forward-slashes (UNIX-style)
+
+If no file is being processed, these conditions will not match.
+
+```yaml
+If:                               # Apply this config conditionally
+  PathMatch: .*\.h                # to all headers...
+  PathExclude: include/llvm-c/.*  # except those under include/llvm-c/
+```
+
+### PathMatch
+
+The file being processed must fully match a regular expression.
+
+### PathExclude
+
+The file being processed must *not* fully match a regular expression.
+
+## CompileFlags
+
+Affects how a file is parsed.
+
+clangd emulates how clang would interpret a file.
+By default, it behaves roughly like `clang $FILENAME`, but real projects
+usually require setting the include path (with the `-I` flag), defining
+preprocessor symbols, configuring warnings etc.
+
+Often, a compilation database specifies these compile commands. clangd
+searches for compile_commands.json in parents of the source file.
+
+This section modifies how the compile command is constructed.
+
+```yaml
+CompileFlags:                # Tweak the parse settings
+  Add: [-xc++, -Wall]        # treat all files as C++, enable more warnings
+  Remove: -W*                # strip all other warning-related flags
+  Compiler: clang++          # Change argv[0] of compile flags to `clang++`
+```
+
+### Compiler
+
+Override the compiler executable name to simulate.
+The name can affect how flags are parsed (clang++ vs clang).
+If the executable name is in the --query-driver allowlist, then it will
+be invoked to extract include paths.
+
+(This simply replaces argv[0], and may mangle commands that use
+more complicated drivers like ccache).
+
+### Add
+
+List of flags to append to the compile command.
+
+### Remove
+
+List of flags to remove from the compile command.
+
+- If the value is a recognized clang flag (like `-I`) then it will be
+  removed along with any arguments. Synonyms like `--include-dir=` will
+  also be removed.
+- Otherwise, if the value ends in `*` (like `-DFOO=*`) then any argument
+  with the prefix will be removed.
+- Otherwise any argument exactly matching the value is removed.
+
+In all cases, `-Xclang` is also removed where needed.
+Flags added by the same CompileFlags entry will not be removed.
+
+```yaml
+CompileFlags:
+  Remove: [-I, -DFOO=*]
+# Input command: clang++ --include-directory=/usr/include -DFOO=42 foo.cc
+# Final command: clang++ foo.cc
+```
+
+### CompilationDatabase
+
+Directory to search for compilation database (compile_comands.json etc).
+
+Valid values are:
+
+- A single path to a directory (absolute, or relative to the fragment)
+- `Ancestors`: search all parent directories (the default)
+- `None`: do not use a compilation database, just default flags.
+
+## Index
+
+Controls how clangd understands code outside the current file.
+
+clangd's indexes provide information about symbols that isn't available
+to clang's parser, such as incoming references.
+
+### Background
+
+Whether files are built in the background to produce a project index.
+This is checked for translation units only, not headers they include.
+
+```yaml
+Index:
+  Background: Skip     # Disable slow background indexing of these files.
+```
+
+- `Build`: Files are indexed as normal. This is the default.
+- `Skip`: Files will not be indexed.
+
+### External
+
+Used to define an external index source.
+Exactly one of `File` or `Server` should be specified.
+
+Declaring an `External` index disables background-indexing implicitly for
+files under the `MountPoint`. Users can turn it back on, by explicitly
+specifying `Background: Build`.
+
+`External: None` will disable a previously-specified external index.
+
+```yaml
+Index:
+  External:
+    File: /abs/path/to/an/index.idx
+    # OR
+    Server: my.index.server.com:50051
+    MountPoint: /files/under/this/project/
+```
+
+#### File
+
+Path to a monolithic index file produced by `clangd-indexer`.
+
+#### Server
+
+Address of a [remote index server](/guides/remote-index).
+
+#### MountPoint
+
+Specifies the source root for the index, needed to translate match
+paths in the index to paths on disk.
+Defaults to the location of this config fragment.
+In a project config, this can be a relative path.
+
+### StandardLibrary
+
+Whether the standard library visible from this file should be indexed.
+This makes all standard library symbols available, included or not.
+
+```yaml
+Index:
+  StandardLibrary: No
+```
+
+## Style
+
+Describes the style of the codebase, beyond formatting.
+
+### FullyQualifiedNamespaces
+
+Namespaces that should always be fully qualified: no "using" declarations,
+always spell out the whole name (with or without leading `::`).
+All nested namespaces are affected as well.
+Affects availability of the AddUsing tweak.
+
+```yaml
+Style:
+  FullyQualifiedNamespaces: absl::
+```
+
+## Diagnostics
+
+Controls behavior of diagnostics (errors and warnings).
+
+### Suppress
+
+Diagnostic codes that should be suppressed.
+
+- `*`, to disable all diagnostics
+- diagnostic codes exposed by clangd (e.g `unknown_type`, `-Wunused-result`)
+- clang internal diagnostic codes (e.g. `err_unknown_type`)
+- warning categories (e.g. `unused-result`)
+- clang-tidy check names (e.g. `bugprone-narrowing-conversions`)
+
+This is a simple filter. Diagnostics can be controlled in other ways
+(e.g. by disabling a clang-tidy check, or the `-Wunused` compile flag).
+This often has other advantages, such as skipping some analysis.
+
+### ClangTidy
+
+Controls how clang-tidy will run over the code base.
+
+      The settings are merged with any settings found in .clang-tidy
+      configuration files, with these ones taking precedence.
+
+```yaml
+# Use all modernize checks apart from trailing return type:
+Diagnostics:
+  ClangTidy:
+    Add: modernize*
+    Remove: modernize-use-trailing-return-type
+```
+
+#### Add
+
+List of [checks](https://clang.llvm.org/extra/clang-tidy/checks/list.html).
+These can be globs, like `bugprone-*`.
+
+#### Remove
+
+List of checks to disable, can be globs.
+Takes precedence over Add, which allows enabling all checks in a module
+apart from a specific list.
+
+#### CheckOptions
+
+Key-value pairs list of options to pass to clang-tidy checks.
+Options for all checks can be found [here](https://clang.llvm.org/extra/clang-tidy/checks/list.html).
+These take precedence over options specified in clang-tidy configuration
+files.
+
+```yaml
+Diagnostics:
+  ClangTidy:
+    CheckOptions:
+      readability-braces-around-statements.ShortStatementLines: 2
+```
+
+### UnusedIncludes
+
+Controls how clangd will correct "unnecessary" #include directives.
+clangd can warn if a header is `#include`d but not used, and suggest
+removing it.
+
+- `Experiment`: The same as Strict, but using the include-cleaner library.
+- `None`: Unused includes are not reported.
+- `Strict`: A header is unused if it does not *directly* provide any symbol used
+in the file. Removing it may still break compilation if it transitively
+includes headers that are used. This should be fixed by including those
+headers directly.
+
+
+### Includes
+
+Controls how headers are diagnosed.
+
+#### IgnoreHeader
+
+Regexes that will be used to avoid diagnosing certain includes as
+unused or missing. These can match any suffix of the header file in
+question.
+
+## Completion
+
+Describes code completion preferences.
+
+### AllScopes
+
+Whether code completion should include suggestions from scopes that are
+not visible. The required scope prefix will be inserted.
+
+## InlayHints
+
+Configures labels shown inline with the code.
+
+```yaml
+InlayHints:
+  Enabled: Yes
+  ParameterNames: Yes
+  DeducedTypes: Yes
+```
+
+### Enabled
+
+Enables/disables the inlay-hints feature.
+
+### ParameterNames
+
+Show parameter names before function arguments.
+
+### DeducedTypes
+
+Show deduced types for `auto`.
+
+### Designators
+
+Show designators in aggregate initialization.
+
+## Hover
+
+Configures contents of hover cards.
+
+### ShowAKA
+
+Controls printing of desugared types, for example:
+`vector<int>::value_type (aka int)`.
+

clang-tools-extra/clangd/config/generate.sh

+#!/bin/sh -ex
+
+# Regenerates the files generated from config/schema.yaml
+# These are checked in rather than generated at build time, because some of
+# these files are consumed outside LLVM's build system:
+#   - schema.json is referenced from schemastore.org
+#   - doc.md is pulled into the clangd website
+
+CONFIG=$(dirname "$0")
+bin/clangd-config-generate \
+  --schema=$CONFIG/schema.yaml \
+  --json-schema-out=$CONFIG/schema.json \
+  --markdown-out=$CONFIG/documentation.md \
+  --yaml-parser-out=$CONFIG/YAML.inc \
+  --header-out=$CONFIG/YAML.inc

clang-tools-extra/clangd/config/meta-schema.json

+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$ref": "#/$defs/node",
+
+  "$defs": {
+    "node": {
+      "type": "object",
+      "properties": {
+        "kind": {
+          "enum": ["block", "map", "enum", "string", "boolean"],
+          "title": "Option kind",
+          "description": "The type of value this option takes. Can be a simple value or a nested block."
+        },
+        "multiple": {
+          "type": "boolean",
+          "description": "Whether this option may have multiple values. If so it will be parsed into e.g. a vector<string> instead of a string."
+        },
+        "doc": {
+          "type": "string",
+          "title": "Documentation",
+          "description": "Documentation for this config option, in markdown syntax."
+        },
+        "example": {
+          "type": "string",
+          "title": "Example",
+          "description": "Example of this setting, in YAML syntax."
+        },
+        "nullable": {
+          "type": "boolean",
+          "title": "Nullable",
+          "description": "Whether the presence/absence of this property is significant. (Parsed as optional<string> instead of string). Defaults to true for scalars and false for blocks."
+        }
+      },
+      "required": ["kind"],
+      "allOf": [
+        {
+          "if": { "type": "object", "properties": { "kind": { "const": "block" } } },
+          "then": { "$ref": "#/$defs/block" }
+        },
+        {
+          "if": { "type": "object", "properties": { "kind": { "anyOf": [{"const": "string"},{"const": "boolean"}] } } },
+          "then": { "$ref": "#/$defs/string" }
+        },
+        {
+          "if": { "type": "object", "properties": { "kind": { "const": "enum" } } },
+          "then": { "$ref": "#/$defs/enum" }
+        },
+        {
+          "if": { "type": "object", "properties": { "kind": { "const": "map" } } },
+          "then": { "$ref": "#/$defs/map" }
+        }
+      ]
+    },
+    "block": {
+      "type": "object",
+      "title": "Block",
+      "description": "A group of related config options",
+      "properties": {
+        "kind": true, "doc": true, "example": true, "multiple": false, "nullable": true,
+        "scalars": {
+          "type": "string",
+          "description": "Rather than specifying the whole block, a user may provide a string as a shortcut. This anchored regex matches such strings."
+        },
+        "base": {
+          "type": "string",
+          "description": "Define a base class for this block. This allows adding fields not defined in the schema."
+        }
+      },
+      "patternProperties": {
+        "^[A-Z]": { "$ref": "#/$defs/node" }
+      },
+      "additionalProperties": false
+    },
+    "string": {
+      "type": "object",
+      "title": "Scalar",
+      "description": "A config option that takes a simple value",
+      "properties": {
+        "kind": true, "doc": true, "example": true, "multiple": true, "nullable": true
+      },
+      "additionalProperties": false
+    },
+    "enum": {
+      "type": "object",
+      "title": "Enumeration",
+      "description": "A config option that can take a fixed set of values",
+      "properties": {
+        "kind": true, "doc": true, "example": true, "multiple": true, "nullable": true
+      },
+      "patternProperties": {
+        "^[A-Z]": {
+          "type": "string",
+          "title": "Enum value",
+          "description": "The key is the enumerator, the value is its documentation string"
+        }
+      },
+      "additionalProperties": false
+    },
+    "map": {
+      "type": "object",
+      "title": "Map",
+      "description": "A config option that lists key-value pairs",
+      "properties": {
+        "kind": true, "doc": true, "example": true, "multiple": false, "nullable": true
+      },
+      "additionalProperties": false
+    }
+  }
+}

clang-tools-extra/clangd/config/schema.json

+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "type": "object",
+  "definitions": {
+    "If": {
+      "description": "Conditions in the If block restrict when a Fragment applies.\n\nEach separate condition must match (combined with AND).\nWhen one condition has multiple values, any may match (combined with OR).\ne.g. `PathMatch: [foo/.*, bar/.*]` matches files in either directory.\n\nConditions based on a file's path use the following form:\n\n- if the fragment came from a project directory, the path is relative\n- if the fragment is global (e.g. user config), the path is absolute\n- paths always use forward-slashes (UNIX-style)\n\nIf no file is being processed, these conditions will not match.",
+      "markdownDescription": "Conditions in the If block restrict when a Fragment applies.\n\nEach separate condition must match (combined with AND).\nWhen one condition has multiple values, any may match (combined with OR).\ne.g. `PathMatch: [foo/.*, bar/.*]` matches files in either directory.\n\nConditions based on a file's path use the following form:\n\n- if the fragment came from a project directory, the path is relative\n- if the fragment is global (e.g. user config), the path is absolute\n- paths always use forward-slashes (UNIX-style)\n\nIf no file is being processed, these conditions will not match.\n\n```yaml\nIf:                               # Apply this config conditionally\n  PathMatch: .*\\.h                # to all headers...\n  PathExclude: include/llvm-c/.*  # except those under include/llvm-c/\n```\n",
+      "type": "object",
+      "definitions": {
+        "PathMatch": {
+          "description": "The file being processed must fully match a regular expression.",
+          "markdownDescription": "The file being processed must fully match a regular expression.",
+          "type": "string"
+        },
+        "PathExclude": {
+          "description": "The file being processed must *not* fully match a regular expression.",
+          "markdownDescription": "The file being processed must *not* fully match a regular expression.",
+          "type": "string"
+        }
+      },
+      "properties": {
+        "PathMatch": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/If/definitions/PathMatch"
+            },
+            {
+              "items": {
+                "$ref": "#/definitions/If/definitions/PathMatch"
+              },
+              "type": "array"
+            }
+          ]
+        },
+        "PathExclude": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/If/definitions/PathExclude"
+            },
+            {
+              "items": {
+                "$ref": "#/definitions/If/definitions/PathExclude"
+              },
+              "type": "array"
+            }
+          ]
+        }
+      },
+      "additionalProperties": false
+    },
+    "CompileFlags": {
+      "description": "Affects how a file is parsed.\n\nclangd emulates how clang would interpret a file.\nBy default, it behaves roughly like `clang $FILENAME`, but real projects\nusually require setting the include path (with the `-I` flag), defining\npreprocessor symbols, configuring warnings etc.\n\nOften, a compilation database specifies these compile commands. clangd\nsearches for compile_commands.json in parents of the source file.\n\nThis section modifies how the compile command is constructed.",
+      "markdownDescription": "Affects how a file is parsed.\n\nclangd emulates how clang would interpret a file.\nBy default, it behaves roughly like `clang $FILENAME`, but real projects\nusually require setting the include path (with the `-I` flag), defining\npreprocessor symbols, configuring warnings etc.\n\nOften, a compilation database specifies these compile commands. clangd\nsearches for compile_commands.json in parents of the source file.\n\nThis section modifies how the compile command is constructed.\n\n```yaml\nCompileFlags:                # Tweak the parse settings\n  Add: [-xc++, -Wall]        # treat all files as C++, enable more warnings\n  Remove: -W*                # strip all other warning-related flags\n  Compiler: clang++          # Change argv[0] of compile flags to `clang++`\n```\n",
+      "type": "object",
+      "definitions": {
+        "Compiler": {
+          "description": "Override the compiler executable name to simulate.\nThe name can affect how flags are parsed (clang++ vs clang).\nIf the executable name is in the --query-driver allowlist, then it will\nbe invoked to extract include paths.\n\n(This simply replaces argv[0], and may mangle commands that use\nmore complicated drivers like ccache).",
+          "markdownDescription": "Override the compiler executable name to simulate.\nThe name can affect how flags are parsed (clang++ vs clang).\nIf the executable name is in the --query-driver allowlist, then it will\nbe invoked to extract include paths.\n\n(This simply replaces argv[0], and may mangle commands that use\nmore complicated drivers like ccache).",
+          "type": "string"
+        },
+        "Add": {
+          "description": "List of flags to append to the compile command.",
+          "markdownDescription": "List of flags to append to the compile command.",
+          "type": "string"
+        },
+        "Remove": {
+          "description": "List of flags to remove from the compile command.\n\n- If the value is a recognized clang flag (like `-I`) then it will be\n  removed along with any arguments. Synonyms like `--include-dir=` will\n  also be removed.\n- Otherwise, if the value ends in `*` (like `-DFOO=*`) then any argument\n  with the prefix will be removed.\n- Otherwise any argument exactly matching the value is removed.\n\nIn all cases, `-Xclang` is also removed where needed.\nFlags added by the same CompileFlags entry will not be removed.",
+          "markdownDescription": "List of flags to remove from the compile command.\n\n- If the value is a recognized clang flag (like `-I`) then it will be\n  removed along with any arguments. Synonyms like `--include-dir=` will\n  also be removed.\n- Otherwise, if the value ends in `*` (like `-DFOO=*`) then any argument\n  with the prefix will be removed.\n- Otherwise any argument exactly matching the value is removed.\n\nIn all cases, `-Xclang` is also removed where needed.\nFlags added by the same CompileFlags entry will not be removed.\n\n```yaml\nCompileFlags:\n  Remove: [-I, -DFOO=*]\n# Input command: clang++ --include-directory=/usr/include -DFOO=42 foo.cc\n# Final command: clang++ foo.cc\n```\n",
+          "type": "string"
+        },
+        "CompilationDatabase": {
+          "description": "Directory to search for compilation database (compile_comands.json etc).\n\nValid values are:\n\n- A single path to a directory (absolute, or relative to the fragment)\n- `Ancestors`: search all parent directories (the default)\n- `None`: do not use a compilation database, just default flags.",
+          "markdownDescription": "Directory to search for compilation database (compile_comands.json etc).\n\nValid values are:\n\n- A single path to a directory (absolute, or relative to the fragment)\n- `Ancestors`: search all parent directories (the default)\n- `None`: do not use a compilation database, just default flags.",
+          "type": "string"
+        }
+      },
+      "properties": {
+        "Compiler": {
+          "$ref": "#/definitions/CompileFlags/definitions/Compiler"
+        },
+        "Add": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/CompileFlags/definitions/Add"
+            },
+            {
+              "items": {
+                "$ref": "#/definitions/CompileFlags/definitions/Add"
+              },
+              "type": "array"
+            }
+          ]
+        },
+        "Remove": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/CompileFlags/definitions/Remove"
+            },
+            {
+              "items": {
+                "$ref": "#/definitions/CompileFlags/definitions/Remove"
+              },
+              "type": "array"
+            }
+          ]
+        },
+        "CompilationDatabase": {
+          "$ref": "#/definitions/CompileFlags/definitions/CompilationDatabase"
+        }
+      },
+      "additionalProperties": false
+    },
+    "Index": {
+      "description": "Controls how clangd understands code outside the current file.\n\nclangd's indexes provide information about symbols that isn't available\nto clang's parser, such as incoming references.",
+      "markdownDescription": "Controls how clangd understands code outside the current file.\n\nclangd's indexes provide information about symbols that isn't available\nto clang's parser, such as incoming references.",
+      "type": "object",
+      "definitions": {
+        "Background": {
+          "description": "Whether files are built in the background to produce a project index.\nThis is checked for translation units only, not headers they include.",
+          "markdownDescription": "Whether files are built in the background to produce a project index.\nThis is checked for translation units only, not headers they include.\n\n```yaml\nIndex:\n  Background: Skip     # Disable slow background indexing of these files.\n```\n",
+          "enum": [
+            "Build",
+            "Skip"
+          ],
+          "markdownEnumDescriptions": [
+            "Files are indexed as normal. This is the default.",
+            "Files will not be indexed."
+          ]
+        },
+        "External": {
+          "description": "Used to define an external index source.\nExactly one of `File` or `Server` should be specified.\n\nDeclaring an `External` index disables background-indexing implicitly for\nfiles under the `MountPoint`. Users can turn it back on, by explicitly\nspecifying `Background: Build`.\n\n`External: None` will disable a previously-specified external index.",
+          "markdownDescription": "Used to define an external index source.\nExactly one of `File` or `Server` should be specified.\n\nDeclaring an `External` index disables background-indexing implicitly for\nfiles under the `MountPoint`. Users can turn it back on, by explicitly\nspecifying `Background: Build`.\n\n`External: None` will disable a previously-specified external index.\n\n```yaml\nIndex:\n  External:\n    File: /abs/path/to/an/index.idx\n    # OR\n    Server: my.index.server.com:50051\n    MountPoint: /files/under/this/project/\n```\n",
+          "type": "object",
+          "definitions": {
+            "File": {
+              "description": "Path to a monolithic index file produced by `clangd-indexer`.",
+              "markdownDescription": "Path to a monolithic index file produced by `clangd-indexer`.",
+              "type": "string"
+            },
+            "Server": {
+              "description": "Address of a [remote index server](/guides/remote-index).",
+              "markdownDescription": "Address of a [remote index server](/guides/remote-index).",
+              "type": "string"
+            },
+            "MountPoint": {
+              "description": "Specifies the source root for the index, needed to translate match\npaths in the index to paths on disk.\nDefaults to the location of this config fragment.\nIn a project config, this can be a relative path.",
+              "markdownDescription": "Specifies the source root for the index, needed to translate match\npaths in the index to paths on disk.\nDefaults to the location of this config fragment.\nIn a project config, this can be a relative path.",
+              "type": "string"
+            }
+          },
+          "properties": {
+            "File": {
+              "$ref": "#/definitions/Index/definitions/External/definitions/File"
+            },
+            "Server": {
+              "$ref": "#/definitions/Index/definitions/External/definitions/Server"
+            },
+            "MountPoint": {
+              "$ref": "#/definitions/Index/definitions/External/definitions/MountPoint"
+            }
+          },
+          "patternProperties": {
+            "^[Nn]one$": true
+          },
+          "additionalProperties": false
+        },
+        "StandardLibrary": {
+          "description": "Whether the standard library visible from this file should be indexed.\nThis makes all standard library symbols available, included or not.",
+          "markdownDescription": "Whether the standard library visible from this file should be indexed.\nThis makes all standard library symbols available, included or not.\n\n```yaml\nIndex:\n  StandardLibrary: No\n```\n",
+          "type": "boolean"
+        }
+      },
+      "properties": {
+        "Background": {
+          "$ref": "#/definitions/Index/definitions/Background"
+        },
+        "External": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/Index/definitions/External"
+            },
+            {
+              "pattern": "^[Nn]one$",
+              "type": "string"
+            }
+          ],
+          "description": "yo"
+        },
+        "StandardLibrary": {
+          "$ref": "#/definitions/Index/definitions/StandardLibrary"
+        }
+      },
+      "additionalProperties": false
+    },
+    "Style": {
+      "description": "Describes the style of the codebase, beyond formatting.",
+      "markdownDescription": "Describes the style of the codebase, beyond formatting.",
+      "type": "object",
+      "definitions": {
+        "FullyQualifiedNamespaces": {
+          "description": "Namespaces that should always be fully qualified: no \"using\" declarations,\nalways spell out the whole name (with or without leading `::`).\nAll nested namespaces are affected as well.\nAffects availability of the AddUsing tweak.",
+          "markdownDescription": "Namespaces that should always be fully qualified: no \"using\" declarations,\nalways spell out the whole name (with or without leading `::`).\nAll nested namespaces are affected as well.\nAffects availability of the AddUsing tweak.\n\n```yaml\nStyle:\n  FullyQualifiedNamespaces: absl::\n```\n",
+          "type": "string"
+        }
+      },
+      "properties": {
+        "FullyQualifiedNamespaces": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/Style/definitions/FullyQualifiedNamespaces"
+            },
+            {
+              "items": {
+                "$ref": "#/definitions/Style/definitions/FullyQualifiedNamespaces"
+              },
+              "type": "array"
+            }
+          ]
+        }
+      },
+      "additionalProperties": false
+    },
+    "Diagnostics": {
+      "description": "Controls behavior of diagnostics (errors and warnings).",
+      "markdownDescription": "Controls behavior of diagnostics (errors and warnings).",
+      "type": "object",
+      "definitions": {
+        "Suppress": {
+          "description": "Diagnostic codes that should be suppressed.\n\n- `*`, to disable all diagnostics\n- diagnostic codes exposed by clangd (e.g `unknown_type`, `-Wunused-result`)\n- clang internal diagnostic codes (e.g. `err_unknown_type`)\n- warning categories (e.g. `unused-result`)\n- clang-tidy check names (e.g. `bugprone-narrowing-conversions`)\n\nThis is a simple filter. Diagnostics can be controlled in other ways\n(e.g. by disabling a clang-tidy check, or the `-Wunused` compile flag).\nThis often has other advantages, such as skipping some analysis.",
+          "markdownDescription": "Diagnostic codes that should be suppressed.\n\n- `*`, to disable all diagnostics\n- diagnostic codes exposed by clangd (e.g `unknown_type`, `-Wunused-result`)\n- clang internal diagnostic codes (e.g. `err_unknown_type`)\n- warning categories (e.g. `unused-result`)\n- clang-tidy check names (e.g. `bugprone-narrowing-conversions`)\n\nThis is a simple filter. Diagnostics can be controlled in other ways\n(e.g. by disabling a clang-tidy check, or the `-Wunused` compile flag).\nThis often has other advantages, such as skipping some analysis.",
+          "type": "string"
+        },
+        "ClangTidy": {
+          "description": "Controls how clang-tidy will run over the code base.\n\n      The settings are merged with any settings found in .clang-tidy\n      configuration files, with these ones taking precedence.",
+          "markdownDescription": "Controls how clang-tidy will run over the code base.\n\n      The settings are merged with any settings found in .clang-tidy\n      configuration files, with these ones taking precedence.\n\n```yaml\n# Use all modernize checks apart from trailing return type:\nDiagnostics:\n  ClangTidy:\n    Add: modernize*\n    Remove: modernize-use-trailing-return-type\n```\n",
+          "type": "object",
+          "definitions": {
+            "Add": {
+              "description": "List of [checks](https://clang.llvm.org/extra/clang-tidy/checks/list.html).\nThese can be globs, like `bugprone-*`.",
+              "markdownDescription": "List of [checks](https://clang.llvm.org/extra/clang-tidy/checks/list.html).\nThese can be globs, like `bugprone-*`.",
+              "type": "string"
+            },
+            "Remove": {
+              "description": "List of checks to disable, can be globs.\nTakes precedence over Add, which allows enabling all checks in a module\napart from a specific list.",
+              "markdownDescription": "List of checks to disable, can be globs.\nTakes precedence over Add, which allows enabling all checks in a module\napart from a specific list.",
+              "type": "string"
+            },
+            "CheckOptions": {
+              "description": "Key-value pairs list of options to pass to clang-tidy checks.\nOptions for all checks can be found [here](https://clang.llvm.org/extra/clang-tidy/checks/list.html).\nThese take precedence over options specified in clang-tidy configuration\nfiles.",
+              "markdownDescription": "Key-value pairs list of options to pass to clang-tidy checks.\nOptions for all checks can be found [here](https://clang.llvm.org/extra/clang-tidy/checks/list.html).\nThese take precedence over options specified in clang-tidy configuration\nfiles.\n\n```yaml\nDiagnostics:\n  ClangTidy:\n    CheckOptions:\n      readability-braces-around-statements.ShortStatementLines: 2\n```\n",
+              "type": "object"
+            }
+          },
+          "properties": {
+            "Add": {
+              "anyOf": [
+                {
+                  "$ref": "#/definitions/Diagnostics/definitions/ClangTidy/definitions/Add"
+                },
+                {
+                  "items": {
+                    "$ref": "#/definitions/Diagnostics/definitions/ClangTidy/definitions/Add"
+                  },
+                  "type": "array"
+                }
+              ]
+            },
+            "Remove": {
+              "anyOf": [
+                {
+                  "$ref": "#/definitions/Diagnostics/definitions/ClangTidy/definitions/Remove"
+                },
+                {
+                  "items": {
+                    "$ref": "#/definitions/Diagnostics/definitions/ClangTidy/definitions/Remove"
+                  },
+                  "type": "array"
+                }
+              ]
+            },
+            "CheckOptions": {
+              "$ref": "#/definitions/Diagnostics/definitions/ClangTidy/definitions/CheckOptions"
+            }
+          },
+          "additionalProperties": false
+        },
+        "UnusedIncludes": {
+          "description": "Controls how clangd will correct \"unnecessary\" #include directives.\nclangd can warn if a header is `#include`d but not used, and suggest\nremoving it.",
+          "markdownDescription": "Controls how clangd will correct \"unnecessary\" #include directives.\nclangd can warn if a header is `#include`d but not used, and suggest\nremoving it.",
+          "enum": [
+            "Experiment",
+            "None",
+            "Strict"
+          ],
+          "markdownEnumDescriptions": [
+            "The same as Strict, but using the include-cleaner library.",
+            "Unused includes are not reported.",
+            "A header is unused if it does not *directly* provide any symbol used\nin the file. Removing it may still break compilation if it transitively\nincludes headers that are used. This should be fixed by including those\nheaders directly.\n"
+          ]
+        },
+        "Includes": {
+          "description": "Controls how headers are diagnosed.",
+          "markdownDescription": "Controls how headers are diagnosed.",
+          "type": "object",
+          "definitions": {
+            "IgnoreHeader": {
+              "description": "Regexes that will be used to avoid diagnosing certain includes as\nunused or missing. These can match any suffix of the header file in\nquestion.",
+              "markdownDescription": "Regexes that will be used to avoid diagnosing certain includes as\nunused or missing. These can match any suffix of the header file in\nquestion.",
+              "type": "string"
+            }
+          },
+          "properties": {
+            "IgnoreHeader": {
+              "anyOf": [
+                {
+                  "$ref": "#/definitions/Diagnostics/definitions/Includes/definitions/IgnoreHeader"
+                },
+                {
+                  "items": {
+                    "$ref": "#/definitions/Diagnostics/definitions/Includes/definitions/IgnoreHeader"
+                  },
+                  "type": "array"
+                }
+              ]
+            }
+          },
+          "additionalProperties": false
+        }
+      },
+      "properties": {
+        "Suppress": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/Diagnostics/definitions/Suppress"
+            },
+            {
+              "items": {
+                "$ref": "#/definitions/Diagnostics/definitions/Suppress"
+              },
+              "type": "array"
+            }
+          ]
+        },
+        "ClangTidy": {
+          "$ref": "#/definitions/Diagnostics/definitions/ClangTidy"
+        },
+        "UnusedIncludes": {
+          "$ref": "#/definitions/Diagnostics/definitions/UnusedIncludes"
+        },
+        "Includes": {
+          "$ref": "#/definitions/Diagnostics/definitions/Includes"
+        }
+      },
+      "additionalProperties": false
+    },
+    "Completion": {
+      "description": "Describes code completion preferences.",
+      "markdownDescription": "Describes code completion preferences.",
+      "type": "object",
+      "definitions": {
+        "AllScopes": {
+          "description": "Whether code completion should include suggestions from scopes that are\nnot visible. The required scope prefix will be inserted.",
+          "markdownDescription": "Whether code completion should include suggestions from scopes that are\nnot visible. The required scope prefix will be inserted.",
+          "type": "boolean"
+        }
+      },
+      "properties": {
+        "AllScopes": {
+          "$ref": "#/definitions/Completion/definitions/AllScopes"
+        }
+      },
+      "additionalProperties": false
+    },
+    "InlayHints": {
+      "description": "Configures labels shown inline with the code.",
+      "markdownDescription": "Configures labels shown inline with the code.\n\n```yaml\nInlayHints:\n  Enabled: Yes\n  ParameterNames: Yes\n  DeducedTypes: Yes\n```\n",
+      "type": "object",
+      "definitions": {
+        "Enabled": {
+          "description": "Enables/disables the inlay-hints feature.",
+          "markdownDescription": "Enables/disables the inlay-hints feature.",
+          "type": "boolean"
+        },
+        "ParameterNames": {
+          "description": "Show parameter names before function arguments.",
+          "markdownDescription": "Show parameter names before function arguments.",
+          "type": "boolean"
+        },
+        "DeducedTypes": {
+          "description": "Show deduced types for `auto`.",
+          "markdownDescription": "Show deduced types for `auto`.",
+          "type": "boolean"
+        },
+        "Designators": {
+          "description": "Show designators in aggregate initialization.",
+          "markdownDescription": "Show designators in aggregate initialization.",
+          "type": "boolean"
+        }
+      },
+      "properties": {
+        "Enabled": {
+          "$ref": "#/definitions/InlayHints/definitions/Enabled"
+        },
+        "ParameterNames": {
+          "$ref": "#/definitions/InlayHints/definitions/ParameterNames"
+        },
+        "DeducedTypes": {
+          "$ref": "#/definitions/InlayHints/definitions/DeducedTypes"
+        },
+        "Designators": {
+          "$ref": "#/definitions/InlayHints/definitions/Designators"
+        }
+      },
+      "additionalProperties": false
+    },
+    "Hover": {
+      "description": "Configures contents of hover cards.",
+      "markdownDescription": "Configures contents of hover cards.",
+      "type": "object",
+      "definitions": {
+        "ShowAKA": {
+          "description": "Controls printing of desugared types, for example:\n`vector<int>::value_type (aka int)`.",
+          "markdownDescription": "Controls printing of desugared types, for example:\n`vector<int>::value_type (aka int)`.",
+          "type": "boolean"
+        }
+      },
+      "properties": {
+        "ShowAKA": {
+          "$ref": "#/definitions/Hover/definitions/ShowAKA"
+        }
+      },
+      "additionalProperties": false
+    }
+  },
+  "properties": {
+    "If": {
+      "$ref": "#/definitions/If"
+    },
+    "CompileFlags": {
+      "$ref": "#/definitions/CompileFlags"
+    },
+    "Index": {
+      "$ref": "#/definitions/Index"
+    },
+    "Style": {
+      "$ref": "#/definitions/Style"
+    },
+    "Diagnostics": {
+      "$ref": "#/definitions/Diagnostics"
+    },
+    "Completion": {
+      "$ref": "#/definitions/Completion"
+    },
+    "InlayHints": {
+      "$ref": "#/definitions/InlayHints"
+    },
+    "Hover": {
+      "$ref": "#/definitions/Hover"
+    }
+  },
+  "additionalProperties": false
+}
 No newline at end of file

clang-tools-extra/clangd/config/schema.yaml

+# yaml-language-server: $schema=./meta-schema.json
+#
+# This defines the clangd config file format, see https://clangd.llvm.org/config
+#
+# The config is a YAML file containing named blocks.
+# Blocks may have children, which may be settings or nested blocks.
+#
+# In this file, nodes (i.e. blocks or settings) have these properties:
+#   kind: block/enum/string/map
+#   doc: a markdown fragment describing this block or setting
+#   example: a YAML fragment showing a sample of this setting
+#   multiple: whether the user can provide an array of values for this setting
+#   nullable: whether the presence/absence of this field is significant
+#             (defaults to true for single values, false for blocks and lists)
+# For blocks only:
+#   scalars: A regular expression.
+#            Matching strings are accepted as "shorthand" values for this block.
+#   base: Names a C++ class that the generated config struct will inherit from.
+#         This can be used to add extra fields.
+#   Foo: a nested setting or block named `Foo` (must start with uppercase)
+# For enums only:
+#   Foo: "Bar": defines an enumarator Foo whose documentation text is Bar.
+
+
+kind: block
+If:
+  kind: block
+  doc: |
+    Conditions in the If block restrict when a Fragment applies.
+
+    Each separate condition must match (combined with AND).
+    When one condition has multiple values, any may match (combined with OR).
+    e.g. `PathMatch: [foo/.*, bar/.*]` matches files in either directory.
+
+    Conditions based on a file's path use the following form:
+
+    - if the fragment came from a project directory, the path is relative
+    - if the fragment is global (e.g. user config), the path is absolute
+    - paths always use forward-slashes (UNIX-style)
+
+    If no file is being processed, these conditions will not match.
+  example: |
+    If:                               # Apply this config conditionally
+      PathMatch: .*\.h                # to all headers...
+      PathExclude: include/llvm-c/.*  # except those under include/llvm-c/
+  base: detail::IfBase
+  PathMatch:
+    doc: The file being processed must fully match a regular expression.
+    kind: string
+    multiple: true
+  PathExclude:
+    doc: The file being processed must *not* fully match a regular expression.
+    kind: string
+    multiple: true
+
+CompileFlags:
+  kind: block
+  doc: |
+    Affects how a file is parsed.
+
+    clangd emulates how clang would interpret a file.
+    By default, it behaves roughly like `clang $FILENAME`, but real projects
+    usually require setting the include path (with the `-I` flag), defining
+    preprocessor symbols, configuring warnings etc.
+
+    Often, a compilation database specifies these compile commands. clangd
+    searches for compile_commands.json in parents of the source file.
+
+    This section modifies how the compile command is constructed.
+  example: |
+    CompileFlags:                # Tweak the parse settings
+      Add: [-xc++, -Wall]        # treat all files as C++, enable more warnings
+      Remove: -W*                # strip all other warning-related flags
+      Compiler: clang++          # Change argv[0] of compile flags to `clang++`
+  Compiler:
+    kind: string
+    doc: |
+      Override the compiler executable name to simulate.
+      The name can affect how flags are parsed (clang++ vs clang).
+      If the executable name is in the --query-driver allowlist, then it will
+      be invoked to extract include paths.
+
+      (This simply replaces argv[0], and may mangle commands that use
+      more complicated drivers like ccache).
+  Add:
+    kind: string
+    multiple: true
+    doc: List of flags to append to the compile command.
+  Remove:
+    kind: string
+    multiple: true
+    doc: |
+      List of flags to remove from the compile command.
+
+      - If the value is a recognized clang flag (like `-I`) then it will be
+        removed along with any arguments. Synonyms like `--include-dir=` will
+        also be removed.
+      - Otherwise, if the value ends in `*` (like `-DFOO=*`) then any argument
+        with the prefix will be removed.
+      - Otherwise any argument exactly matching the value is removed.
+
+      In all cases, `-Xclang` is also removed where needed.
+      Flags added by the same CompileFlags entry will not be removed.
+    example: |
+      CompileFlags:
+        Remove: [-I, -DFOO=*]
+      # Input command: clang++ --include-directory=/usr/include -DFOO=42 foo.cc
+      # Final command: clang++ foo.cc
+  CompilationDatabase:
+    kind: string
+    doc: |
+      Directory to search for compilation database (compile_comands.json etc).
+
+      Valid values are:
+
+      - A single path to a directory (absolute, or relative to the fragment)
+      - `Ancestors`: search all parent directories (the default)
+      - `None`: do not use a compilation database, just default flags.
+
+Index:
+  kind: block
+  doc: |
+    Controls how clangd understands code outside the current file.
+
+    clangd's indexes provide information about symbols that isn't available
+    to clang's parser, such as incoming references.
+  Background:
+    kind: enum
+    doc: |
+      Whether files are built in the background to produce a project index.
+      This is checked for translation units only, not headers they include.
+    example: |
+      Index:
+        Background: Skip     # Disable slow background indexing of these files.
+    Build: Files are indexed as normal. This is the default.
+    Skip: Files will not be indexed.
+  External:
+    kind: block
+    nullable: true
+    scalars: ^[Nn]one$
+    doc: |
+      Used to define an external index source.
+      Exactly one of `File` or `Server` should be specified.
+
+      Declaring an `External` index disables background-indexing implicitly for
+      files under the `MountPoint`. Users can turn it back on, by explicitly
+      specifying `Background: Build`.
+
+      `External: None` will disable a previously-specified external index.
+    example: |
+      Index:
+        External:
+          File: /abs/path/to/an/index.idx
+          # OR
+          Server: my.index.server.com:50051
+          MountPoint: /files/under/this/project/
+    base: detail::ExternalBase
+    File:
+      kind: string
+      doc: Path to a monolithic index file produced by `clangd-indexer`.
+    Server:
+      kind: string
+      doc: Address of a [remote index server](/guides/remote-index).
+    MountPoint:
+      kind: string
+      doc: |
+        Specifies the source root for the index, needed to translate match
+        paths in the index to paths on disk.
+        Defaults to the location of this config fragment.
+        In a project config, this can be a relative path.
+  StandardLibrary:
+    kind: boolean
+    example: |
+      Index:
+        StandardLibrary: No
+    doc: |
+      Whether the standard library visible from this file should be indexed.
+      This makes all standard library symbols available, included or not.
+
+Style:
+  kind: block
+  doc: Describes the style of the codebase, beyond formatting.
+  FullyQualifiedNamespaces:
+    kind: string
+    multiple: true
+    doc: |
+      Namespaces that should always be fully qualified: no "using" declarations,
+      always spell out the whole name (with or without leading `::`).
+      All nested namespaces are affected as well.
+      Affects availability of the AddUsing tweak.
+    example: |
+      Style:
+        FullyQualifiedNamespaces: absl::
+
+Diagnostics:
+  kind: block
+  doc: Controls behavior of diagnostics (errors and warnings).
+  Suppress:
+    kind: string
+    multiple: true
+    doc: |
+      Diagnostic codes that should be suppressed.
+
+      - `*`, to disable all diagnostics
+      - diagnostic codes exposed by clangd (e.g `unknown_type`, `-Wunused-result`)
+      - clang internal diagnostic codes (e.g. `err_unknown_type`)
+      - warning categories (e.g. `unused-result`)
+      - clang-tidy check names (e.g. `bugprone-narrowing-conversions`)
+
+      This is a simple filter. Diagnostics can be controlled in other ways
+      (e.g. by disabling a clang-tidy check, or the `-Wunused` compile flag).
+      This often has other advantages, such as skipping some analysis.
+  ClangTidy:
+    kind: block
+    doc: Controls how clang-tidy will run over the code base.
+
+      The settings are merged with any settings found in .clang-tidy
+      configuration files, with these ones taking precedence.
+    example: |
+      # Use all modernize checks apart from trailing return type:
+      Diagnostics:
+        ClangTidy:
+          Add: modernize*
+          Remove: modernize-use-trailing-return-type
+    Add:
+      doc: |
+        List of [checks](https://clang.llvm.org/extra/clang-tidy/checks/list.html).
+        These can be globs, like `bugprone-*`.
+      kind: string
+      multiple: true
+    Remove:
+      kind: string
+      multiple: true
+      doc: |
+        List of checks to disable, can be globs.
+        Takes precedence over Add, which allows enabling all checks in a module
+        apart from a specific list.
+    CheckOptions:
+      kind: map
+      doc: |
+        Key-value pairs list of options to pass to clang-tidy checks.
+        Options for all checks can be found [here](https://clang.llvm.org/extra/clang-tidy/checks/list.html).
+        These take precedence over options specified in clang-tidy configuration
+        files.
+      example: |
+        Diagnostics:
+          ClangTidy:
+            CheckOptions:
+              readability-braces-around-statements.ShortStatementLines: 2
+  UnusedIncludes:
+    kind: enum
+    doc: |
+      Controls how clangd will correct "unnecessary" #include directives.
+      clangd can warn if a header is `#include`d but not used, and suggest
+      removing it.
+    Strict: |
+      A header is unused if it does not *directly* provide any symbol used
+      in the file. Removing it may still break compilation if it transitively
+      includes headers that are used. This should be fixed by including those
+      headers directly.
+    Experiment: The same as Strict, but using the include-cleaner library.
+    None: Unused includes are not reported.
+  Includes:
+    kind: block
+    doc: Controls how headers are diagnosed.
+    IgnoreHeader:
+      kind: string
+      multiple: true
+      doc: |
+        Regexes that will be used to avoid diagnosing certain includes as
+        unused or missing. These can match any suffix of the header file in
+        question.
+
+Completion:
+  kind: block
+  doc: Describes code completion preferences.
+  AllScopes:
+    kind: boolean
+    doc: |
+      Whether code completion should include suggestions from scopes that are
+      not visible. The required scope prefix will be inserted.
+
+InlayHints:
+  kind: block
+  doc: Configures labels shown inline with the code.
+  example: |
+    InlayHints:
+      Enabled: Yes
+      ParameterNames: Yes
+      DeducedTypes: Yes
+  Enabled:
+    kind: boolean
+    doc: Enables/disables the inlay-hints feature.
+  ParameterNames:
+    kind: boolean
+    doc: Show parameter names before function arguments.
+  DeducedTypes:
+    kind: boolean
+    doc: Show deduced types for `auto`.
+  Designators:
+    kind: boolean
+    doc: Show designators in aggregate initialization.
+
+Hover:
+  kind: block
+  doc: Configures contents of hover cards.
+  ShowAKA:
+    kind: boolean
+    doc: |
+      Controls printing of desugared types, for example:
+      `vector<int>::value_type (aka int)`.

clang-tools-extra/clangd/test/config-generator.test

+# When this test fails, run clang-tools-extra/clangd/config/generate.sh (from your build directory)
+
+RUN: clangd-config-generate --schema=%S/../config/schema.yaml --header-out=- | diff %S/../config/Fragment.inc -
+RUN: clangd-config-generate --schema=%S/../config/schema.yaml --json-schema-out=- | diff %S/../config/schema.json -
+RUN: clangd-config-generate --schema=%S/../config/schema.yaml --yaml-parser-out=- | diff %S/../config/YAML.inc -
+RUN: clangd-config-generate --schema=%S/../config/schema.yaml --markdown-out=- | diff %S/../config/documentation.md -

clang-tools-extra/clangd/unittests/ConfigCompileTests.cpp

TEST_F(ConfigCompileTests, CompilationDatabase) {
   EXPECT_TRUE(compileAndApply());
   EXPECT_EQ(Conf.CompileFlags.CDBSearch.Policy,
             Config::CDBSearchSpec::FixedDir);
   EXPECT_EQ(Conf.CompileFlags.CDBSearch.FixedCDBPath, testPath("Something2"));
   EXPECT_THAT(Diags.Diagnostics, IsEmpty());
 }
 
 TEST_F(ConfigCompileTests, Index) {
-  Frag.Index.Background.emplace("Skip");
+  Frag.Index.Background = Fragment::IndexBlock::BackgroundValues::Skip;
   EXPECT_TRUE(compileAndApply());
   EXPECT_EQ(Conf.Index.Background, Config::BackgroundPolicy::Skip);
 
+  #if FIXME
   Frag = {};
   Frag.Index.Background.emplace("Foo");
   EXPECT_TRUE(compileAndApply());
   EXPECT_EQ(Conf.Index.Background, Config::BackgroundPolicy::Build)
       << "by default";
   EXPECT_THAT(
       Diags.Diagnostics,
       ElementsAre(diagMessage(
           "Invalid Background value 'Foo'. Valid values are Build, Skip.")));
+  #endif
 }
 
 TEST_F(ConfigCompileTests, PathSpecMatch) {
   auto BarPath = llvm::sys::path::convert_to_slash(testPath("foo/bar.h"));
   Parm.Path = BarPath;
 
   struct {
     std::string Directory;

 }
 
 TEST_F(ConfigCompileTests, DiagnosticsIncludeCleaner) {
   // Defaults to None.
   EXPECT_TRUE(compileAndApply());
   EXPECT_EQ(Conf.Diagnostics.UnusedIncludes,
             Config::UnusedIncludesPolicy::None);
 
+  #if FIXME
   Frag = {};
   Frag.Diagnostics.UnusedIncludes.emplace("None");
   EXPECT_TRUE(compileAndApply());
   EXPECT_EQ(Conf.Diagnostics.UnusedIncludes,
             Config::UnusedIncludesPolicy::None);
 
   Frag = {};
   Frag.Diagnostics.UnusedIncludes.emplace("Strict");
   EXPECT_TRUE(compileAndApply());
   EXPECT_EQ(Conf.Diagnostics.UnusedIncludes,
             Config::UnusedIncludesPolicy::Strict);
+  #endif
 
   Frag = {};
   EXPECT_TRUE(Conf.Diagnostics.Includes.IgnoreHeader.empty())
       << Conf.Diagnostics.Includes.IgnoreHeader.size();
   Frag.Diagnostics.Includes.IgnoreHeader.push_back(
       Located<std::string>("foo.h"));
   Frag.Diagnostics.Includes.IgnoreHeader.push_back(
       Located<std::string>(".*inc"));
EXPECT_THAT(
       Contains(
           AllOf(diagMessage("Exactly one of File, Server or None must be set."),
                 diagKind(llvm::SourceMgr::DK_Error))));
 }
 
 TEST_F(ConfigCompileTests, ExternalBlockDisablesBackgroundIndex) {
   auto BazPath = testPath("foo/bar/baz.h", llvm::sys::path::Style::posix);
   Parm.Path = BazPath;
-  Frag.Index.Background.emplace("Build");
+  Frag.Index.Background = Fragment::IndexBlock::BackgroundValues::Build;
   Fragment::IndexBlock::ExternalBlock External;
   External.File.emplace(testPath("foo"));
   External.MountPoint.emplace(
       testPath("foo/bar", llvm::sys::path::Style::posix));
   Frag.Index.External = std::move(External);
   compileAndApply();
   EXPECT_EQ(Conf.Index.Background, Config::BackgroundPolicy::Skip);
 }

clang-tools-extra/clangd/unittests/ConfigYAMLTests.cpp

Diagnostics:
   ASSERT_EQ(Results.size(), 4u);
   EXPECT_FALSE(Results[0].If.HasUnrecognizedCondition);
   EXPECT_THAT(Results[0].If.PathMatch, ElementsAre(val("abc")));
   EXPECT_THAT(Results[0].CompileFlags.Add, ElementsAre(val("foo"), val("bar")));
 
   EXPECT_THAT(Results[1].CompileFlags.Add, ElementsAre(val("b\naz\n")));
 
   ASSERT_TRUE(Results[2].Index.Background);
-  EXPECT_EQ("Skip", **Results[2].Index.Background);
+  EXPECT_EQ(Fragment::IndexBlock::BackgroundValues::Skip,
+            **Results[2].Index.Background);
   EXPECT_THAT(Results[3].Diagnostics.ClangTidy.CheckOptions,
               ElementsAre(PairVal("IgnoreMacros", "true"),
                           PairVal("example-check.ExampleOption", "0")));
   EXPECT_TRUE(Results[3].Diagnostics.UnusedIncludes);
-  EXPECT_EQ("Strict", **Results[3].Diagnostics.UnusedIncludes);
+  EXPECT_EQ(Fragment::DiagnosticsBlock::UnusedIncludesValues::Strict,
+            **Results[3].Diagnostics.UnusedIncludes);
 }
 
 TEST(ParseYAML, Locations) {
   CapturedDiags Diags;
   Annotations YAML(R"yaml(
 If:
   PathMatch: [['???bad***regex(((']]
   )yaml");
Index:
   auto Results =
       Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback());
   ASSERT_THAT(Diags.Diagnostics, IsEmpty());
   ASSERT_EQ(Results.size(), 1u);
   ASSERT_TRUE(Results[0].Index.External);
   EXPECT_FALSE((*Results[0].Index.External)->File.has_value());
   EXPECT_FALSE((*Results[0].Index.External)->MountPoint.has_value());
   EXPECT_FALSE((*Results[0].Index.External)->Server.has_value());
-  EXPECT_THAT(*(*Results[0].Index.External)->IsNone, testing::Eq(true));
+  EXPECT_TRUE((*Results[0].Index.External)->IsNone);
 }
 
 TEST(ParseYAML, ExternalBlock) {
   CapturedDiags Diags;
   Annotations YAML(R"yaml(
 Index:
   External:
     File: "foo"

clang-tools-extra/clangd/unittests/IncludeCleanerTests.cpp

TEST(IncludeCleaner, IWYUPragmas) {
   TU.AdditionalFiles["behind_keep.h"] = guard("");
   TU.AdditionalFiles["exported.h"] = guard("");
   TU.AdditionalFiles["public.h"] = guard("#include \"private.h\"");
   TU.AdditionalFiles["private.h"] = guard(R"cpp(
     // IWYU pragma: private, include "public.h"
     void foo() {}
   )cpp");
   Config Cfg;
-  Cfg.Diagnostics.UnusedIncludes = Config::Experiment;
+  Cfg.Diagnostics.UnusedIncludes = Config::UnusedIncludesPolicy::Experiment;
   WithContextValue Ctx(Config::Key, std::move(Cfg));
   ParsedAST AST = TU.build();
 
   auto ReferencedFiles = findReferencedFiles(
       findReferencedLocations(AST), AST.getIncludeStructure(),
       AST.getCanonicalIncludes(), AST.getSourceManager());
   EXPECT_EQ(ReferencedFiles.SpelledUmbrellas.size(), 1u);
   EXPECT_EQ(ReferencedFiles.SpelledUmbrellas.begin()->getKey(), "\"public.h\"");
TU.AdditionalFiles["foo.h"] = R"cpp(
     #ifndef FOO_H
     #define FOO_H
 
     #endif
   )cpp";
   TU.ExtraArgs.emplace_back("-xobjective-c");
 
   Config Cfg;
-  Cfg.Diagnostics.UnusedIncludes = Config::Strict;
+  Cfg.Diagnostics.UnusedIncludes = Config::UnusedIncludesPolicy::Strict;
   WithContextValue Ctx(Config::Key, std::move(Cfg));
   ParsedAST AST = TU.build();
   EXPECT_THAT(AST.getDiagnostics(), llvm::ValueIs(IsEmpty()));
 }
 } // namespace
 } // namespace clangd
 } // namespace clang