[clangd] Add clang-tidy options to config

[njames93]

Summary

First step of implementing clang-tidy configuration into clangd config.
This is just adding support for reading and verifying the clang tidy options from the config fragments.
No support is added for actually using the options within clang-tidy yet.

That will be added in a follow up as its a little more involved.

[njames93]

clang-tools-extra/clangd/ConfigCompile.cpp

236–237

Is this the direction we want to go, the first draft paper on this seems to suggest so.

clang-tools-extra/clangd/ConfigTidyProvider.cpp

38–41

This definitely isn't right, but I'm unsure of the correct way to get the config for the specified file.
Is it better to not have this class share the interface of ClangTidyOptionsProvider and instead have it take an interface that takes a Config and a Filename and works from there instead?

[njames93]

Added unittests for reading and compiling config and fixed the bugs causing said unittests to fail.

[njames93]

Rename Tidy to ClangTidy in Fragment
Extract CheckOptions logic into a new class DynamicDictParser, this should help if config is extended to load other dictionaries where keys are unknown strings.e

[njames93]

Removed support for using clang-tidy that will happen in a follow up as its a more involved change.

[njames93]

Rebase and make apply take reference to Params.
Fix fragments checks being applied on top of each other instead of overwriting the current config checks.

[sammccall]

Thank you!

This design looks really good, just have some nits on comments, possible simplifications etc.

(Sorry about the delay getting to these, on it now!)

clang-tools-extra/clangd/ConfigCompile.cpp

231

nit: method name is confusing because it uses "check" as a noun where you'd expect it to be a verb (this method validates Adjuster)

Maybe appendTidyCheckSpec?

235

nit: I think this code is going to too much trouble to produce a precise error message

• not sure "Add check item can't start with '-'" is clearer than without the word "add". Errors show the error location/range.
• "check name" would be clearer than "check item" (even if wildcards are allowed, IMO)
• it feels a bit weird to be really specific about - and , - these are references to a fixed list of checks, so all that really matters is that it's not the name of a check. I'd consider just returning fixed "Invalid clang-tidy check name" for both cases

236–237

Yeah it looks like a good solution to me. It's not as powerful as an ordered list of globs, but it's simple and consistent with the other settings we have. .clang-tidy is still the right thing for full control.

238

Str.startswith("-") - we haven't checked that it's empty (and shouldn't bother IMO)

264

nit: I'd suggest *including" the leading comma in these
e.g. Checks is ",foo,bar". (Maybe call it ChecksSuffix)

Then when applying,
C.ClangTidy.Checks.append(Checks, C.ClangTidy.Checks.empty() ? /*skip comma*/1 : 0);

advantages:

• marginally simplifies checkAdjuster (no need to conditionally add the comma)
• the Apply step (which is somewhat performance-sensitive) is at most a single allocation (which is awkward to achieve otherwise)

clang-tools-extra/clangd/ConfigFragment.h

175

nit: drop "this section" and add trailing period, consistent with other sections.

I think "code" would be clearer than codebase.

180

I wonder if it's worth having this when we support Remove: *.

technically this does something slightly different:

• it still runs the machinery just with no actual checks
• you can enable: true later to override it, without losing the previously configured list of checks

Is one of these important? Is there some other benefit?
(I'm not opposed to having this if you want it, but I'm curious)

181

nit: we should document each separately.

e.g. "/// List of checks to enable - can be wildcards like "readability-*".

182

nit: "get ran" is confusing - this doesn't affect the order in which checks *run*, just which overrrides which.
And this text/example could probably be a little more compact.

I'd suggest:

List of checks to disable.
Takes precedence over Add. To enable all llvm checks except include order:
  Add: llvm-*
  Remove: llvm-include-onder

185

should this be llvm-*?

clang-tools-extra/clangd/ConfigYAML.cpp

206

instead of adding a second class for this, can we reuse DictParser, and change unrecognized() so:

• the callback gets access to the key location and the value
• the callback is responsible for emitting the "unknown key" error if it wants one

i.e. the default unrecognized handler is:

[this](Located<std::string> Key, Node &Value) { Outer->warning("Unknown " + Description + " key " + *Key); }

and we replace it for parsing CheckOptions

253

can we implement this on top of scalarValue? seems like it would avoid a bunch of repetition and the efficiency doesn't seem that important

257

not sure why we're trimming here

264

Technically we're probably supposed to accept
y|Y|yes|Yes|YES|n|N|no|No|NO|true|True|TRUE|false|False|FALSE|on|On|ON|off|Off|OFF
(https://yaml.org/type/bool.html)

I'd be happy accepting y/n/yes/no/true/false/on/off case-insensitively though :-)

269

conversely, not sure why we'd accept a number here

[njames93]

clang-tools-extra/clangd/ConfigFragment.h

180

I'm not 100% sure what you are asking here.

clang-tools-extra/clangd/ConfigYAML.cpp

206

Not sure I'm a huge fan of that approach. I can't imagine a use case where the 2 dictionary modes will be used at the same time so there isn't a need for it to support both.
By that I mean you wont have a dictionary where its expected to have both known and unknown keys.

DictParser could well be implemented as a a specialisation of DynamicDictParser but not much would be gained from that.

[njames93]

Address comments

[sammccall]

Thanks! Just some simplifications and doc nits left, then please go ahead and land

clang-tools-extra/clangd/Config.h

74

nit: we're using triple slash comments for these...

77

Enable is trivial enough to go without documentation, but the format of Checks certainly needs to be documented.

78

I think this should be a StringMap<string>

It makes sense to use a vector-of-pairs in ConfigFragment to preserve the Located information for keys, but we don't need to do that in Config.

clang-tools-extra/clangd/ConfigFragment.h

180

I'm asking whether we really need Enable, or whether we should remove it and recommend Remove: * to disable the checks.

If there isn't a clear reason we need it, my preference is to omit it for simplicity (we can add more setting later, but it's harder to remove them).

I don't feel strongly though, this is up to you.

clang-tools-extra/clangd/ConfigYAML.cpp

206

Yes, they're being used for different purposes, so using the same class isn't the most expressive.
But this isn't a public API, it's a local helper. The implementation is nontrivial and almost identical. This is just about reducing the implementation complexity.

253

You've extracted a common getScalar function here instead, I think to avoid scalarValue copying the string?
But this isn't a hot path, and all the legal values for this string are in SSO range anyway - can we avoid this extra complexity?

[njames93]

clang-tools-extra/clangd/Config.h

78

If we do use a StringMap<string>, whats the policy when multiple fragments specify the same option.
Currently at the Fragment level there is logic that ignores duplicated keys, but when compiling the fragments, should we give priority to keys declared in earlier or later fragments. In any case would it also be wise to warn about that.

clang-tools-extra/clangd/ConfigFragment.h

180

If we use Remove: * when it comes to actually implementing this, it would be wise to disable running clang-tidy if there are no checks enabled. But yes, I do agree that it could be removed at first, then added at a later date if needs must.

clang-tools-extra/clangd/ConfigYAML.cpp

206

Ok I'll update it.

253

It's not about that, I'd prefer the warning message to explicitly say it needs a boolean even if they pass something that's not a scalar. Reusing scalarValue will give a warning saying SomeKey should be scalar. What we actually want is a warning saying SomeKey should be a boolean

[sammccall]

clang-tools-extra/clangd/Config.h

78

We merge with the later fragments taking priority. So in this case each fragment writes its keys into the single stringmap, replacing whatever is there.

(Most common case of later fragments is subdirectory overriding parent, or user config overriding in-tree).

I don't think we need to warn for this - does clang-tidy warn if there are multiple options sources configured and one overrides a setting from another? This is the same thing.

clang-tools-extra/clangd/ConfigFragment.h

180

This sounds like a good idea to me. This would happen in ParsedAST::build.
If the loop through CTChecks never actually manages to call registerPPCallbacks/Matchers, then we can skip the matchAST call.

I'll send a patch.

[njames93]

Removed Enable.
Removed the scalarBool parser as it was only needed by Enable.
Removed DynamicDictParser in favour of reworking DictParser to get better control of how to handle unknown keys.
Use a StringMap to store the CheckOptions in the Config.

[njames93]

Fix the unit tests.

clang-tools-extra/clangd/CMakeLists.txt

add_clang_library(clangDaemon
   ClangdServer.cpp
   CodeComplete.cpp
   CodeCompletionStrings.cpp
   CollectMacros.cpp
   CompileCommands.cpp
   Compiler.cpp
   Config.cpp
   ConfigCompile.cpp
+  ConfigTidyProvider.cpp
   ConfigProvider.cpp
   ConfigYAML.cpp
   Diagnostics.cpp
   DraftStore.cpp
   ExpectedTypes.cpp
   FindSymbols.cpp
   FindTarget.cpp
   FileDistance.cpp

clang-tools-extra/clangd/Config.h

struct Config {
 
   /// Style of the codebase.
   struct {
     // 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.
     std::vector<std::string> FullyQualifiedNamespaces;
   } Style;
+
+  // Configures what clang-tidy checks to run and options to use with them.
+  struct {
+    bool Enable;
+    std::string Checks;
+    std::vector<std::pair<std::string, std::string>> CheckOptions;
+  } ClangTidy;
 };
 
 } // namespace clangd
 } // namespace clang
 
 #endif

clang-tools-extra/clangd/ConfigCompile.cpp

EnumSwitch<T> compileEnum(llvm::StringRef EnumName,
                             const Located<std::string> &In) {
     return EnumSwitch<T>(EnumName, In, *this);
   }
 
   void compile(Fragment &&F) {
     compile(std::move(F.If));
     compile(std::move(F.CompileFlags));
     compile(std::move(F.Index));
+    compile(std::move(F.Tidy));
   }
 
   void compile(Fragment::IfBlock &&F) {
     if (F.HasUnrecognizedCondition)
       Out.Conditions.push_back([&](const Params &) { return false; });
 
     auto PathMatch = std::make_unique<std::vector<llvm::Regex>>();
     for (auto &Entry : F.PathMatch) {
if (!F.FullyQualifiedNamespaces.empty()) {
                               std::move(FullyQualifiedNamespaces))](Config &C) {
         C.Style.FullyQualifiedNamespaces.insert(
             C.Style.FullyQualifiedNamespaces.begin(),
             FullyQualifiedNamespaces.begin(), FullyQualifiedNamespaces.end());
       });
     }
   }
 
+  void checkAdjuster(std::string &Adjuster, const Located<std::string> &Arg,
+                     bool IsPositive) {
+    SmallString<64> DiagBuffer;
+    StringRef Str = *Arg;
+    StringRef Type(IsPositive ? "Add" : "Remove");
+    // Don't support negating here, its handled if the item is in the Add or
+    // Remove list.
+    if (Str[0] == '-') {
+      diag(Error,
+           (Type + " check item can't start with '-'").toStringRef(DiagBuffer),
+           Arg.Range);
+      return;
+    }
+    if (Str.contains(',')) {
+      diag(Error,
+           ("Invalid character ',' found in " + Type + " check item")
+               .toStringRef(DiagBuffer),
+           Arg.Range);
+      return;
+    }
+    if (!IsPositive)
+      Adjuster += '-';
+    Adjuster += Str;
+  }
+
+  void compile(Fragment::TidyBlock &&F) {
+    if (F.Enable)
+      Out.Apply.push_back(
+          [Enable = **F.Enable](Config &C) { C.ClangTidy.Enable = Enable; });
+
+    std::string Checks;
+    if (!F.Add.empty())
+      llvm::for_each(F.Add, std::bind(&FragmentCompiler::checkAdjuster, this,
+                                      Checks, std::placeholders::_1, true));
+
+    if (!F.Remove.empty())
+      llvm::for_each(F.Remove, std::bind(&FragmentCompiler::checkAdjuster, this,
+                                         Checks, std::placeholders::_1, false));
+
+    if (!Checks.empty())
+      Out.Apply.push_back([Checks = std::move(Checks)](Config &C) {
+        C.ClangTidy.Checks = std::move(Checks);
+      });
+    if (!F.CheckOptions.empty()) {
+      std::vector<std::pair<std::string, std::string>> CheckOptions;
+      for (auto &Opt : F.CheckOptions)
+        CheckOptions.push_back(std::move(*Opt));
+      Out.Apply.push_back([CheckOptions = std::move(CheckOptions)](Config &C) {
+        C.ClangTidy.CheckOptions.insert(
+            C.ClangTidy.CheckOptions.end(),
+            std::make_move_iterator(CheckOptions.begin()),
+            std::make_move_iterator(CheckOptions.end()));
+      });
+    }
+  }
+
   constexpr static llvm::SourceMgr::DiagKind Error = llvm::SourceMgr::DK_Error;
   constexpr static llvm::SourceMgr::DiagKind Warning =
       llvm::SourceMgr::DK_Warning;
   void diag(llvm::SourceMgr::DiagKind Kind, llvm::StringRef Message,
             llvm::SMRange Range) {
     if (Range.isValid() && SourceMgr != nullptr)
       Diagnostic(SourceMgr->GetMessage(Range.Start, Kind, Message, Range));
     else

clang-tools-extra/clangd/ConfigFragment.h

struct Fragment {
   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;
+
+  /// This section controls how clang-tidy will run over the code base
+  ///
+  /// The settings are merged with any settings found in .clang-tidy
+  /// configiration files with these ones taking precedence.
+  struct TidyBlock {
+    llvm::Optional<Located<bool>> Enable;
+    /// List of checks to enable or disable, can use wildcards.
+    /// \ref Add checks get ran first, then \ref Remove checks. This lets you
+    /// enable all checks from a module apart from a few specific checks,
+    /// Example:
+    ///   Add: llvm-
+    ///   Remove: llvm-include-order
+    /// This will enable all checks from the llvm module apart from
+    /// llvm-include-order.
+    std::vector<Located<std::string>> Add;
+    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<Located<std::pair<std::string, std::string>>> CheckOptions;
+  };
+  TidyBlock Tidy;
 };
 
 } // namespace config
 } // namespace clangd
 } // namespace clang
 
 #endif

clang-tools-extra/clangd/ConfigTidyProvider.h

+//===--- ConfigTidyProvider.h ------------------------------------*- C++-*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Creates a ClangTidyOptionsProvider that merges a users clangd config with
+// .clang-tidy files
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_CONFIGTIDYPROVIDER_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_CONFIGTIDYPROVIDER_H
+
+#include "../clang-tidy/ClangTidyOptions.h"
+
+namespace clang {
+namespace clangd {
+namespace config {
+class Provider;
+} // namespace config
+
+class ConfigTidyOptionsProvider : public tidy::FileOptionsBaseProvider {
+public:
+  ConfigTidyOptionsProvider(
+      const tidy::ClangTidyGlobalOptions &GlobalOptions,
+      const tidy::ClangTidyOptions &DefaultOptions,
+      config::Provider &ConfigProvider,
+      const tidy::ClangTidyOptions &OverrideOptions,
+      llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS = nullptr);
+
+  std::vector<OptionsSource> getRawOptions(llvm::StringRef FileName) override;
+
+private:
+  config::Provider &ConfigProvider;
+};
+
+} // namespace clangd
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_CONFIGTIDYPROVIDER_H
 No newline at end of file

clang-tools-extra/clangd/ConfigTidyProvider.cpp

+//===--- ConfigTidyProvider.cpp ----------------------------------*- C++-*-===//
+//
+// 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 "ConfigTidyProvider.h"
+#include "../clang-tidy/ClangTidyOptions.h"
+#include "Config.h"
+#include "ConfigProvider.h"
+
+namespace clang {
+namespace clangd {
+ConfigTidyOptionsProvider::ConfigTidyOptionsProvider(
+    const tidy::ClangTidyGlobalOptions &GlobalOptions,
+    const tidy::ClangTidyOptions &DefaultOptions,
+    config::Provider &ConfigProvider,
+    const tidy::ClangTidyOptions &OverrideOptions,
+    llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS)
+    : tidy::FileOptionsBaseProvider(GlobalOptions, DefaultOptions,
+                                    OverrideOptions, FS),
+      ConfigProvider(ConfigProvider) {}
+
+std::vector<tidy::ClangTidyOptionsProvider::OptionsSource>
+ConfigTidyOptionsProvider::getRawOptions(llvm::StringRef FileName) {
+  std::vector<OptionsSource> RawOptions =
+      DefaultOptionsProvider::getRawOptions(FileName);
+  assert(FS && "FS must be set.");
+
+  llvm::SmallString<128> AbsoluteFilePath(FileName);
+
+  if (!FS->makeAbsolute(AbsoluteFilePath)) {
+    addRawFileOptions(AbsoluteFilePath, RawOptions);
+  }
+
+  config::Params P;
+  P.Path = AbsoluteFilePath;
+  auto IgnoreDiag = [](const llvm::SMDiagnostic &) {};
+  Config C = ConfigProvider.getConfig(P, IgnoreDiag);
+
+  tidy::ClangTidyOptions ConfigOptions;
+
+  if (!C.ClangTidy.Checks.empty())
+    ConfigOptions.Checks = C.ClangTidy.Checks;
+  for (auto &Item : C.ClangTidy.CheckOptions)
+    ConfigOptions.CheckOptions.try_emplace(Item.first, Item.second);
+
+  RawOptions.emplace_back(ConfigOptions, ".clangd config");
+
+  RawOptions.emplace_back(OverrideOptions,
+                          "command-line option '-clang-tidy-checks'");
+  return RawOptions;
+}
+} // namespace clangd
+} // namespace clang

clang-tools-extra/clangd/ConfigYAML.cpp

public:
   // 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("Tidy", [&](Node &N) { parse(F.Tidy, N); });
     Dict.parse(N);
     return !(N.failed() || HadError);
   }
 
 private:
   void parse(Fragment::IfBlock &F, Node &N) {
     DictParser Dict("If", this);
     Dict.unrecognized(
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);
   }
 
+  void parse(Fragment::TidyBlock &F, Node &N) {
+    DictParser Dict("Tidy", this);
+    Dict.handle("Enable", [&](Node &N) {
+      if (auto Value = scalarBool(N, "Enable"))
+        F.Enable = *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("CheckOptions", [&](Node &N) {
+      if (N.getType() != Node::NK_Mapping) {
+        this->error("CheckOptions should be a dictionary", N);
+        return;
+      }
+      llvm::SmallSet<std::string, 8> Seen;
+
+      for (auto &KV : llvm::cast<MappingNode>(N)) {
+        auto *K = KV.getKey();
+        if (!K) // YAMLParser emitted an error.
+          continue;
+        auto Key = this->scalarValue(*K, "CheckOption Key");
+        if (!Key)
+          continue;
+        if (!Seen.insert(**Key).second) {
+          this->warning("Duplicate CheckOption " + **Key + " is ignored", *K);
+          continue;
+        }
+        auto *V = KV.getValue();
+        if (!V) // YAMLParser emitted an error.
+          continue;
+        auto Value = this->scalarValue(*V, **Key);
+        if (!Value) // Couldn't parse V as a String
+          continue;
+        F.CheckOptions.emplace_back(
+            std::make_pair(std::move(**Key), std::move(**Value)),
+            N.getSourceRange());
+      }
+    });
+  }
+
   void parse(Fragment::IndexBlock &F, Node &N) {
     DictParser Dict("Index", this);
     Dict.handle("Background",
                 [&](Node &N) { F.Background = scalarValue(N, "Background"); });
     Dict.parse(N);
   }
 
   // Helper for parsing mapping nodes (dictionaries).
void parse(Node &N) const {
           Outer->warning("Unknown " + Description + " key " + **Key, *K);
           if (Unknown)
             Unknown(**Key);
         }
       }
     }
   };
 
+  // Try to parse a single boolean value from the node, warn on failure.
+  llvm::Optional<Located<bool>> scalarBool(Node &N, llvm::StringRef Desc) {
+    llvm::SmallString<256> Buf;
+    llvm::StringRef Str;
+    if (auto *S = llvm::dyn_cast<ScalarNode>(&N))
+      Str = S->getValue(Buf).trim();
+    else if (auto *BS = llvm::dyn_cast<BlockScalarNode>(&N))
+      Str = BS->getValue().trim();
+    else {
+      warning(Desc + " should be a boolean", N);
+      return llvm::None;
+    }
+    if (Str.equals_lower("true"))
+      return Located<bool>(true, N.getSourceRange());
+    if (Str.equals_lower("false"))
+      return Located<bool>(false, N.getSourceRange());
+    bool Result;
+    if (!Str.getAsInteger(10, Result))
+      return Located<bool>(Result, N.getSourceRange());
+    warning("Couldn't parse '" + Str + "' as a boolean for " + Desc, N);
+    return llvm::None;
+  }
+
   // Try to parse a single scalar value from the node, warn on failure.
   llvm::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 llvm::None;
   }
 
   // Try to parse a list of single scalar values, or just a single value.
   llvm::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 llvm::None;
     }
     return Result;
   }
 
   // Report a "hard" error, reflecting a config file that can never be valid.
   void error(const llvm::Twine &Msg, const Node &N) {
     HadError = true;
     SM.PrintMessage(N.getSourceRange().Start, llvm::SourceMgr::DK_Error, Msg,
                     N.getSourceRange());
   }
 
   // Report a "soft" error that could be caused by e.g. version skew.
   void warning(const llvm::Twine &Msg, const Node &N) {
     SM.PrintMessage(N.getSourceRange().Start, llvm::SourceMgr::DK_Warning, Msg,
                     N.getSourceRange());
   }
 };
 
 } // namespace
 

clang-tools-extra/clangd/tool/ClangdMain.cpp

 //===--- ClangdMain.cpp - clangd server loop ------------------------------===//
 //
 // 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 "ClangdLSPServer.h"
 #include "CodeComplete.h"
+#include "ConfigTidyProvider.h"
 #include "Features.inc"
 #include "PathMapping.h"
 #include "Protocol.h"
 #include "Transport.h"
 #include "index/Background.h"
 #include "index/Serialization.h"
 #include "index/remote/Client.h"
 #include "refactor/Rename.h"
#endif
   std::unique_ptr<tidy::ClangTidyOptionsProvider>
       ClangTidyOptProvider; /*GUARDED_BY(ClangTidyOptMu)*/
   if (EnableClangTidy) {
     auto EmptyDefaults = tidy::ClangTidyOptions::getDefaults();
     EmptyDefaults.Checks.reset(); // So we can tell if checks were ever set.
     tidy::ClangTidyOptions OverrideClangTidyOptions;
     if (!ClangTidyChecks.empty())
       OverrideClangTidyOptions.Checks = ClangTidyChecks;
+    if (Opts.ConfigProvider)
+      ClangTidyOptProvider = std::make_unique<ConfigTidyOptionsProvider>(
+          tidy::ClangTidyGlobalOptions(),
+          /* Default */ EmptyDefaults, *Opts.ConfigProvider,
+          /* Override */ OverrideClangTidyOptions,
+          TFS.view(/*CWD=*/llvm::None));
+    else
       ClangTidyOptProvider = std::make_unique<tidy::FileOptionsProvider>(
           tidy::ClangTidyGlobalOptions(),
           /* Default */ EmptyDefaults,
-        /* Override */ OverrideClangTidyOptions, TFS.view(/*CWD=*/llvm::None));
+          /* Override */ OverrideClangTidyOptions,
+          TFS.view(/*CWD=*/llvm::None));
     Opts.GetClangTidyOptions = [&](llvm::vfs::FileSystem &,
                                    llvm::StringRef File) {
       // This function must be thread-safe and tidy option providers are not.
       tidy::ClangTidyOptions Opts;
       {
         std::lock_guard<std::mutex> Lock(ClangTidyOptMu);
         // FIXME: use the FS provided to the function.
         Opts = ClangTidyOptProvider->getOptions(File);