[clangd] Implement clang-tidy options from config

[njames93]

Summary

Added some new ClangTidyOptionsProvider like classes designed for clangd work flow.
These providers are designed to source the options on the worker thread but in a thread safe manner.
This is done through making the options getter take a pointer to the filesystem used by the worker thread which natuarally is from a ThreadsafeFS.
Internal caching in the providers is also guarded.

The providers don't inherit from ClangTidyOptionsProvider instead they share a base class which is able to create a provider for the ClangTidyContext using a specific FileSystem.
This approach means one provider can be used for multiple contexts even though ClangTidyContext owns its provider.

Depends on D90531

[njames93]

Fix potential race when updating cache in FileTidyProvider.

[njames93]

Fix compile errors.

[njames93]

Fix last compile error, check-clangd ran without a hitch. Testing the binary in another project seems to work ok.

[njames93]

• Fix compile error for gcc 5.3.
• Add back logging configuration when creating CTContext.

[sammccall]

Thanks for working on this!

I think the scope of this patch is probably bigger than we need, at least initially:

• it adds a new TidyProvider system with a lot of flexibility. But our config needs are quite static. The only flexibility we need initially is being able to swap out reading .clang-tidy for a different strategy, and the ability to replace the whole thing with a fixed config (for -checks)
• the clangd::Config based check configuration probably does need depend on some refactoring of how ClangTidyOptions are created, but it doesn't need to land in the same patch
• it adds caching around the file IO, which may be nice to have but is complicated and unrelated and shouldn't be mixed with the refactoring

Do you want to take a shot at scoping this down? Is it useful if I sketch what I mean for the refactoring part?

clang-tools-extra/clangd/ClangdServer.h

367

new comment doesn't really say anything, revert to the old one?

clang-tools-extra/clangd/ParsedAST.cpp

250

why this change?

310

nit: move a few lines above to after the options-initialization if-stmt?

clang-tools-extra/clangd/TidyProvider.h

20

Any reason to pass in a VFS to get a ClangTidyOptionsProvider here, rather than having the subclass take a ThreadsafeFS in its constructor if it needs one?

This interface seems a bit strange, because not all implementations of ClangTidyProvider would necessarily get their config from a VFS.

(Moreover, it seems like ClangTidyProvider could just be a ClangTidyOptionsProvider with a threadsafety guarantee, if it weren't for the fact that ClangTidyContext wants to take ownership of the optionsprovider, which doesn't make a lot of sense - maybe we should fix that instead?)

21

we don't usually use a "Clangd" prefix in the clangd namespace. (Clangd[LSP]Server being notable and very old exceptions)

40

how is the cache invalidated? (AFAICT currently it never is)

41

We don't have a way to guarantee this, the vfs::FileSystems provided by ThreadsafeFS are arbitrary (ThreadsafeFS is an extension point) and don't have to be threadsafe.

If you need a filesystem that's threadsafe, that's what ThreadsafeFS is for.

74

reader-writer locks are a nice model but very commonly perform equal or worse to plain mutexes in practice.
I think we should have evidence this is an improvement before using it.

85

Using a deep inheritance hierarchy here parallel to the hierarchy of ClangTidyOptionsProvider is IMO too much complexity for the problem being solved. Most of these classes want to be functions.

85

in this design, we don't have a good way to use the check-adjustment together with a non-file source of configs.

(At google we use this capability to support a different project configuration format that's used instead of .clang-tidy files)

[njames93]

Reworked large chunks of this:

• Renamed ClangdTidyProvider->TidyProvider.
• Removed the obselete interface mirroring ClangTidyOptionsProvider, it wasn't needed.
• Incorporated the ThreadsafeFS inside the provider.
• Removed some unnecessary changes.
• Removed the internal caching of the ThreadsafeFileTidyProvider.
• Trimmed down inheritance hierarchy.

[njames93]

Thanks for the comments, I agree it was a little too much. Likely due in part to how I first tried to mirror the interface of ClangTidyOptionsProvider.

clang-tools-extra/clangd/ParsedAST.cpp

250

So we can use the same VFS a bit further down. However as thats not a thing now it can be reverted.

310

The options for the context are only sourced once the currentFile has been set

[njames93]

• Small tweaks

[sammccall]

Thanks, this looks massively simpler.
It seems clear that we get config by applying a sequence of strategies in order, and these strategies (e.g. .clang-tidy files, config, disabled checks) are mostly independent.
So I have a suggestion for expressing this composition more directly in clangdmain, details in the comments.

clang-tools-extra/clangd/TidyProvider.cpp

35

it'd be nice if this class could focus on a single responsibility (adapting between interfaces) rather than also trying to apply defaults.

clang-tools-extra/clangd/TidyProvider.h

21

we're using inheritance for a couple of purposes here.

First, giving a common interface to the various types of provider.
This makes sense, though we use unique_function<ClangTidyOptions(StringRef)> for this as the type as it's essentially just one function.
This would give us the option of using lambdas instead of having TestClangTidyProvider...

The other purpose is composition: ConfigTidyProvider inherits from ThreadSafeFileTidyProvider in order to provide both sets of config.
This is awkward and constraining, e.g. we can't now enable config but not .clang-tidy (which is the desired config inside google), and more immediately the handling of overrides is awkward.
It seems more natural to have several units and compose them explicitly. The most simple way to compose them is have them be functions that mutate a ClangTidyOptions, instead of producing one.

So in its minimal form this could look like:

using TidyProvider = unique_function<void(ClangTidyOptions&, /*Filename*/llvm::StringRef)>;
TidyProvider combine(vector<TidyProvider>); 
ClangTidyOptionsProvider asClangTidyOptionsProvider(TidyProvider);

TidyProvider provideEnvironment();
TidyProvider provideDefaultChecks();
TidyProvider disableUnusableChecks(ArrayRef<std::string> OverrideChecks={});
TidyProvider provideClangdConfig();
TidyProvider provideClangTidyFiles(ThreadsafeFS&);

// In ClangdMain:
TidyProvider Tidy = combine({provideEnvironment(), provideClangTidyFiles(FS), provideClangdConfig(), provideDefaultChecks(), disableUnusableChecks());

What do you think?

25

This is just adapting this interface to another one, it doesn't need to be virtual (and in fact could be a free function...).

Maybe call it asClangTidyOptionsProvider or so? The current name makes it sound like some kind of singleton.

33

these subclasses are only constructed and used through the TidyProvider interface. I think they can be moved into the impl file and just expose factories.

46

It'd be nice to be able to customize the set of checks that are disabled. In our hosted environment, when we find a check that is crashing in production, we disable it with a command-line flag (but without a new release). This flag needs to be propagated through here somehow...

Of course if tidy providers are easy to compose, we can just add our own for this.

clang-tools-extra/clangd/unittests/TestTidyProvider.h

16

(I think it's reasonable to put this trivial implementation into TidyProvider.h as FixedTidyProvider or so, to avoid the extra test-only files: the implementation is trivial and there's it does *make sense* as a production provider)

[njames93]

Reworked everything.

[njames93]

Messed up branches, fixed that

[njames93]

clang-tools-extra/clangd/TidyProvider.h

21

That is a much nicer interface

[njames93]

Fix ChecksToDisable to actually disable the checks.

[njames93]

Fix assertion in provideDefaultChecks

[njames93]

Added PathRef to TidyProvider, this handles finding clang-tidy files when the compile command directory isn't the project root.
Use elog for reporting errors instead of llvm::errs - It was an artefact from the code in ClangTidyOptions.cpp.

[njames93]

Small tweaks

[sammccall]

OK this looks really great, thanks so much for persisting with this.

Comments are mostly simple nits/simplifications, with the exception of Order which is a... slightly trickier simplification, but seems worth doing.

Tomorrow I'll adapt our internal clang-tidy config bits to work with this interface...

clang-tools-extra/clangd/ParsedAST.cpp

241

or just use fixedTidyProvider("-*")

clang-tools-extra/clangd/TidyProvider.cpp

75

I'm not sure if this applies anymore - it's going to be the bottom of the stack, and nullopt is the default

76

nit: hoist the getenv out of the lambda?

76

seems like we can just assign to Opts.User directly?

100

nit: = seems clearer than emplace

111

I think should just be assignment rather than merge (same with WarningsAsErrors).
The name suggests that it always returns the same set of checks.

(Failing that, maybe call it addTidyChecks)

168

(as noted elsewhere, the path is always absolute in clangd and we should make this an interface requiremnet)

171

I don't think we need to try to stat the directory here.

FileOptionsProvider does, but looking at the history, this seems related to some combination of:

• arg validation (the parameter there is a directory name, rather than a filename)
• trying to return an appropriate error_code (original return type was ErrorOr<Options>)
• iterating over multiple possible config files
• maybe caching

182

can you add a FIXME to add caching here?

I hadn't realized FileOptionsProvider *was* actually doing caching.

(I don't think this is a big problem in the short term, and I don't think we should solve it inline in this patch, rather I should land D88172 and use that, which doesn't have the annoying "cache forever" behavior)

195

This order business is a real tangle, and looks like legacy to me (qualified vs unqualified names).

I don't really think we want to use/expose it beyond the requirement that we don't change the meaning of existing sets of .clang-tidy config files.
And I don't think we want to bother teaching clangd's config system about it.

So I'd suggest a hack/simplification:

• we remove the order parameter from TidyProvider
• here in provideClangTidyFiles, we just use a local Order which counts up from 1. This preserves the relative precedence of .clang-tidy files
• in provideClangdConfig, we always set the order to max_uint (always wins)
• if we ever add checkoptions to any other providers, we set the order to 0 (always loses)
• combine() doesn't touch order

This *does* duplicate the fact that .clangd config is stacked on top of .clang-tidy in ClangdMain, but in a way that only matters with disputes between qualified/unqualified names.

210

nit: "adapter" may be clearer than "instance", up to you

clang-tools-extra/clangd/TidyProvider.h

26

we should always be passing an absolute path, so CWD shouldn't be needed.

I'm a bit surprised that ParsedAST::build doesn't assert that (though it calls PreamblePatch::create, which does). Feel free to add it!

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

162

ah, sorry, I led you astray here... I don't think we actually need a flag to control this in ClangdMain.cpp, just that the layering allows one :-)

Google's production deployment of clangd has a different entrypoint (not ClangdMain.cpp) which has a flag to disable checks. A previous version of this patch buried the list of disabled checks very deeply so that it couldn't be changed, but building the TidyProvider stack in clangdmain addresses this (our bizarro_clangd_main.cpp can do its own version making use of its flag).

You can keep this if you like, but I don't think it's necessary (for debugging we can just use -clang-tidy-checks, and for users working around bugs we can use clangd config).

822

if -clang-tidy-checks is provided, we don't want to parse .clang-tidy files, respect clangd config, or disable unusable checks - just environment + the flag.
The main purpose of that flag is to debug e.g. isolate crashes down to individual checks, so full control is best.

(I believe this matches the old behavior, but it's really hard to tell from the code - the new code is much nicer!)

825

I think the condition is backwards

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

1226

This is confusing... I think these are now disabled twice (by disableUnusableChecks(), and via provideClangTidyFiles).

(I've got no objection to checking that elements of the standard tidy config stack work together properly, but I don't think that's what's happening in this test)

1229

I think we probably don't want the environment here, if it does anything at all it probably makes the test non-hermetic

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

133–134

We sholudn't need -* here and elsewhere. This is the whole config provider, nothing could be turning any checks on.

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

62

I think the condition is not needed

clang-tools-extra/clangd/unittests/TestTU.h

62

mutable here smells funny, can we do using TidyProvider = unique_function<void(args) const> instead? (so it's const-callable)

[njames93]

clang-tools-extra/clangd/ParsedAST.cpp

241

Issue with that approach is fixedTidyProvider has state so that would need a stable storage when passing to asClangTidyOptionsProvider.

clang-tools-extra/clangd/TidyProvider.cpp

75

This is just incase ClangTidyOptions::getDefaults() ever changes.

76

We can't as EmptyDefaults also contains the Options clang tidy modules may want to set.

168

See previous comment about clang-tidy checks not adhering to this requirement.

171

Ditto

195

That approach is a simplification but it only makes sense in how we are using the providers in clangd. Downstream someone may want to add another provider that may get ran after .clangd providers. Forcing .clangd to have the highest priority will result in unexpected behaviour in that instance.
I'm happy to go with your approach if you don't see it as a blocking issue.

clang-tools-extra/clangd/TidyProvider.h

26

While clangd may always use absolute paths, clang-tidy may not. Checks are able to query the context and get options for other files.
When I put asserts on the Filename being absolute, things started failing.

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

822

The old behaviour, and the behaviour of the -checks option in clang-tidy is to append the checks specified on the command line to whats found in .clang-tidy files. This is so that the checks will respect other fields in the configuration.

825

Yes it was, good spot.

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

1226

provideClangTidyFiles here will enable use-after-move/header-guard but disable all other checks, which is what we want.
Hopefully disableUnusableChecks will then disable those 2 checks and all will work well.

1229

I agree, can trim this down a little.

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

62

I think it is, the operator= for function_ref doesn't seem to correctly handle the case when the argument doesn't hold a callable. Well asserts were failing before I added the condition, may be a bug somewhere else.

clang-tools-extra/clangd/unittests/TestTU.h

62

I was debating between the two but that does look a little nicer.

[njames93]

Address (most of the) comments.

[sammccall]

clang-tools-extra/clangd/ParsedAST.cpp

299–306

do you think we should just directly/eagerly create the clang-tidy config here, and wrap it in a provider that always returns it?
(with a check that the requested filename matches, see other comment)

Now that I understand why CTContext is lazy, I'm not sure we're benefitting from it.

clang-tools-extra/clangd/TidyProvider.cpp

76

Oh, I missed how ClangTidyOptions::getDefaults was being used here.

This makes sense but rather than merging the defaults using a TidyProvider, I think getDefaults should be the base object that the TidyProviders mutate. I.e. in TidyProviderAdapter, when we add the single OptionsSource, it should be initialized to ClangTidyOptions::getDefaults() before having the TidyProvider applied to it.

195

Any arbitrary fixed number seems like it should work here - we could have .clangd use priority 10000 and then people could use a range higher or lower if they want to support this.

Mostly it seems like this is probably a theoretical issue only and we shouldn't let it dominate the design. Customizing check options is somewhat rare, config inheritance is rare, getLocalOrGlobal is rare, downstream modifications are rare, etc. I'd rather have the simple version and add the complexity if it causes practical problems.

(If we really need to solve this at some point, we can probably do it non-intrusively by having combine() lower the priority of all config options by a bunch after each step. We'd need to make priority signed though...)

clang-tools-extra/clangd/TidyProvider.h

26

Ah, learn something new and horrifying every day!

AFAICT the only thing that actually does this is is readability/IdentifierNamingCheck, which looks like it uses the style of the file where an identifier is declared to check its name.
Our intent is very much that we're running clang-tidy strictly limited to the current file. The clangd config certainly doesn't support querying config for other files.

I think we should really only expose the current file config, and return empty config when asked for any other file.
We can have the TidyConfigAdapter do this, I think.
(Slight catch: we want getConfigForFile("rel/path/to/current/file.cpp") to work, for IdentifierNamingCheck. I think if it's a relative path, we can just check whether the basename matches - shouldn't have too many matches)

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

822

Oops... this wasn't the intent - see the docstring for the flag.

In any case, fine to leave as is, we can change this separately.

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

62

Oh, of course, the RHS is a "callable" type that's null at runtime, and nothing checks for that and converts to a null function_ref.
Feature request for function_ref, I suppose!

[njames93]

clang-tools-extra/clangd/ParsedAST.cpp

299–306

Kind of how it is set already out with a DefaultOptionsProvider?

clang-tools-extra/clangd/TidyProvider.h

26

That option in IdentifierNamingCheck is itself controlled by an option, we could just subvert that option in disableUnusableChecks as a, somewhat dirty, fix.

[njames93]

Getting closer.

[njames93]

clang-tools-extra/clangd/TidyProvider.cpp

195

(If we really need to solve this at some point, we can probably do it non-intrusively by having combine() lower the priority of all config options by a bunch after each step. We'd need to make priority signed though...)

Or just give everything a high priority as default

[njames93]

Tweak disableUnusableChecks to take an ArrayRef over a vector.

[njames93]

.

[sammccall]

OK, I would love to get this landed.
I think the simplest thing is to compute the config eagerly and load it in with DefaultOptionsProvider as you mentioned.

I might fiddle with checking the filename afterwards, but I don't think this is blocking.
Similarly I want to add the IO caching after this lands.

clang-tools-extra/clangd/ParsedAST.cpp

299–306

Right! The only wrinkle would be the use of empty options vs same options when requesting config for a different file.
But happy to go with DefaultOptionsProvider in to get this landed!

clang-tools-extra/clangd/TidyProvider.h

26

Yeah, that has slightly different behavior though: it means that it will assume every other file has the same config as the current file. (i.e. the check *is* enabled for those files, and the style is the same).
Returning an empty config seems more principled, and more likely to do the right thing if other such checks get added.

[njames93]

Use DefaultOptionsProvider for initializing ClangTidyContext.

[njames93]

clang-tools-extra/clangd/TidyProvider.h

26

and more likely to do the right thing if other such checks get added.

I'm going to change the identifier-naming option to make it a global. I can think of other checks in clang-tidy land that would benefit from it.

[sammccall]

Thanks, this LG!

(The change to global makes sense but doesn't block us I think)

clang-tools-extra/clangd/TidyProvider.h

26

CWD is now effectively unused and can be dropped

[njames93]

Removed duplicated logging of options.

[njames93]

clang-tools-extra/clangd/TidyProvider.h

26

So I tried removing CWD and it leads to assertions failing in the tests(the ones with the extension .test).
I do know that the TFS has some issues in those tests anyway:

[build] E[16:04:40.948] VFS: failed to set CWD to /clangd-test: No such file or directory.

I could remove the CWD but not have assertions, instead just bail out if we encounter those cases, maybe with a log. WDYT?

[sammccall]

clang-tools-extra/clangd/TidyProvider.h

26

It's a bit hard to say without more details - what assertions/cases?

AFAICT:

• Filename now only ever has the value passed from ParsedAST::build().
• That should always be absolute
• CWD is only used for the filesystem examining Filename and its parents, and if they're absolute it should be irrelevant

One of these is clearly not true, though :-)

[sammccall]

clang-tools-extra/clangd/TidyProvider.h

26

(FWIW I patched in the latest revision of this patch, deleted CWD and check-clangd passed without assertion failures)

[njames93]

clang-tools-extra/clangd/TidyProvider.h

26

Oh I added some assertions to ensure that it was a directory, those are the ones that failed. The ones ensuring its absolute ran without a hitch.

[njames93]

Removed CWD references.
Added some fixme comments about function_ref<->unique_function and null values.
Added asserts in provideClangTidyFiles ensuring path is absolute.

[sammccall]

Hooray, ship it!

[njames93]

Whoops, probably should've updated the summary before pushing, ah well.

clang-tools-extra/clangd/CMakeLists.txt

add_clang_library(clangDaemon
   ParsedAST.cpp
   Preamble.cpp
   RIFF.cpp
   Selection.cpp
   SemanticHighlighting.cpp
   SemanticSelection.cpp
   SourceCode.cpp
   QueryDriverDatabase.cpp
+  TidyProvider.cpp
   TUScheduler.cpp
   URI.cpp
   XRefs.cpp
   ${CMAKE_CURRENT_BINARY_DIR}/CompletionModel.cpp
 
   index/Background.cpp
   index/BackgroundIndexLoader.cpp
   index/BackgroundIndexStorage.cpp

clang-tools-extra/clangd/ClangdServer.h

 #include <functional>
 #include <future>
 #include <string>
 #include <type_traits>
 #include <utility>
 
 namespace clang {
 namespace clangd {
-
-/// When set, used by ClangdServer to get clang-tidy options for each particular
-/// file. Must be thread-safe. We use this instead of ClangTidyOptionsProvider
-/// to allow reading tidy configs from the VFS used for parsing.
-using ClangTidyOptionsBuilder = std::function<tidy::ClangTidyOptions(
-    llvm::vfs::FileSystem &, llvm::StringRef /*File*/)>;
-
+class ClangdTidyProvider;
 /// Manages a collection of source files and derived data (ASTs, indexes),
 /// and provides language-aware features such as code completion.
 ///
 /// The primary client is ClangdLSPServer which exposes these features via
 /// the Language Server protocol. ClangdServer may also be embedded directly,
 /// though its API is not stable over time.
 ///
 /// ClangdServer should be used from a single thread. Many potentially-slow
struct Options {
     bool CollectMainFileRefs = false;
 
     /// If set, use this index to augment code completion results.
     SymbolIndex *StaticIndex = nullptr;
 
     /// If set, queried to obtain the configuration to handle each request.
     config::Provider *ConfigProvider = nullptr;
 
-    /// If set, enable clang-tidy in clangd and use to it get clang-tidy
-    /// configurations for a particular file.
-    /// Clangd supports only a small subset of ClangTidyOptions, these options
-    /// (Checks, CheckOptions) are about which clang-tidy checks will be
-    /// enabled.
-    ClangTidyOptionsBuilder GetClangTidyOptions;
+    /// The Options provider to use when running clang-tidy. If null, clang-tidy
+    /// checks will be disabled.
+    ClangdTidyProvider *ClangTidyProvider = nullptr;
 
     /// If true, force -frecovery-ast flag.
     /// If false, respect the value in clang.
     bool BuildRecoveryAST = false;
 
     /// If true, force -frecovery-ast-type flag.
     /// If false, respect the value in clang.
     bool PreserveRecoveryASTType = false;
private:
   const SymbolIndex *Index = nullptr;
   // If present, an index of symbols in open files. Read via *Index.
   std::unique_ptr<FileIndex> DynamicIdx;
   // If present, the new "auto-index" maintained in background threads.
   std::unique_ptr<BackgroundIndex> BackgroundIdx;
   // Storage for merged views of the various indexes.
   std::vector<std::unique_ptr<SymbolIndex>> MergedIdx;
 
-  // When set, provides clang-tidy options for a specific file.
-  ClangTidyOptionsBuilder GetClangTidyOptions;
+  // OptionsPrivder for clang-tidy.
+  ClangdTidyProvider *ClangTidyProvider = nullptr;
 
   // If this is true, suggest include insertion fixes for diagnostic errors that
   // can be caused by missing includes (e.g. member access in incomplete type).
   bool SuggestMissingIncludes = false;
 
   // If true, preserve expressions in AST for broken code.
   bool BuildRecoveryAST = true;
   // If true, preserve the type for recovery AST.

clang-tools-extra/clangd/ClangdServer.cpp

struct UpdateIndexCallbacks : public ParsingCallbacks {
   }
 
 private:
   FileIndex *FIndex;
   ClangdServer::Callbacks *ServerCallbacks;
   bool TheiaSemanticHighlighting;
 };
 
-// Set of clang-tidy checks that don't work well in clangd, either due to
-// crashes or false positives.
-// Returns a clang-tidy filter string: -check1,-check2.
-llvm::StringRef getUnusableTidyChecks() {
-  static const std::string FalsePositives =
-      llvm::join_items(", ",
-                       // Check relies on seeing ifndef/define/endif directives,
-                       // clangd doesn't replay those when using a preamble.
-                       "-llvm-header-guard");
-  static const std::string CrashingChecks =
-      llvm::join_items(", ",
-                       // Check can choke on invalid (intermediate) c++ code,
-                       // which is often the case when clangd tries to build an
-                       // AST.
-                       "-bugprone-use-after-move");
-  static const std::string UnusableTidyChecks =
-      llvm::join_items(", ", FalsePositives, CrashingChecks);
-  return UnusableTidyChecks;
-}
-
-// Returns a clang-tidy options string: check1,check2.
-llvm::StringRef getDefaultTidyChecks() {
-  // These default checks are chosen for:
-  //  - low false-positive rate
-  //  - providing a lot of value
-  //  - being reasonably efficient
-  static const std::string DefaultChecks = llvm::join_items(
-      ",", "readability-misleading-indentation", "readability-deleted-default",
-      "bugprone-integer-division", "bugprone-sizeof-expression",
-      "bugprone-suspicious-missing-comma", "bugprone-unused-raii",
-      "bugprone-unused-return-value", "misc-unused-using-decls",
-      "misc-unused-alias-decls", "misc-definitions-in-headers");
-  return DefaultChecks;
-}
 } // namespace
 
 ClangdServer::Options ClangdServer::optsForTest() {
   ClangdServer::Options Opts;
   Opts.UpdateDebounce = DebouncePolicy::fixed(/*zero*/ {});
   Opts.StorePreamblesInMemory = true;
   Opts.AsyncThreadsCount = 4; // Consistent!
   Opts.TheiaSemanticHighlighting = true;

 ClangdServer::ClangdServer(const GlobalCompilationDatabase &CDB,
                            const ThreadsafeFS &TFS, const Options &Opts,
                            Callbacks *Callbacks)
     : ConfigProvider(Opts.ConfigProvider), TFS(TFS),
       DynamicIdx(Opts.BuildDynamicSymbolIndex
                      ? new FileIndex(Opts.HeavyweightDynamicSymbolIndex,
                                      Opts.CollectMainFileRefs)
                      : nullptr),
-      GetClangTidyOptions(Opts.GetClangTidyOptions),
+      ClangTidyProvider(Opts.ClangTidyProvider),
       SuggestMissingIncludes(Opts.SuggestMissingIncludes),
       BuildRecoveryAST(Opts.BuildRecoveryAST),
       PreserveRecoveryASTType(Opts.PreserveRecoveryASTType),
       WorkspaceRoot(Opts.WorkspaceRoot),
       // Pass a callback into `WorkScheduler` to extract symbols from a newly
       // parsed file and rebuild the file index synchronously each time an AST
       // is parsed.
       // FIXME(ioeric): this can be slow and we may be able to index on less
ClangdServer::ClangdServer(const GlobalCompilationDatabase &CDB,
   if (DynamicIdx)
     AddIndex(DynamicIdx.get());
 }
 
 void ClangdServer::addDocument(PathRef File, llvm::StringRef Contents,
                                llvm::StringRef Version,
                                WantDiagnostics WantDiags, bool ForceRebuild) {
   ParseOptions Opts;
-  Opts.ClangTidyOpts = tidy::ClangTidyOptions::getDefaults();
-  // FIXME: call tidy options builder on the worker thread, it can do IO.
-  if (GetClangTidyOptions)
-    Opts.ClangTidyOpts =
-        GetClangTidyOptions(*TFS.view(/*CWD=*/llvm::None), File);
-  if (Opts.ClangTidyOpts.Checks.hasValue()) {
-    // If the set of checks was configured, make sure clangd incompatible ones
-    // are disabled.
-    Opts.ClangTidyOpts.Checks = llvm::join_items(
-        ", ", *Opts.ClangTidyOpts.Checks, getUnusableTidyChecks());
-  } else {
-    // Otherwise provide a nice set of defaults.
-    Opts.ClangTidyOpts.Checks = getDefaultTidyChecks().str();
-  }
   Opts.SuggestMissingIncludes = SuggestMissingIncludes;
 
   // Compile command is set asynchronously during update, as it can be slow.
   ParseInputs Inputs;
   Inputs.TFS = &TFS;
   Inputs.Contents = std::string(Contents);
   Inputs.Version = Version.str();
   Inputs.ForceRebuild = ForceRebuild;
   Inputs.Opts = std::move(Opts);
   Inputs.Index = Index;
+  Inputs.ClangTidyProvider = ClangTidyProvider;
   Inputs.Opts.BuildRecoveryAST = BuildRecoveryAST;
   Inputs.Opts.PreserveRecoveryASTType = PreserveRecoveryASTType;
   bool NewFile = WorkScheduler.update(File, Inputs, WantDiags);
   // If we loaded Foo.h, we want to make sure Foo.cpp is indexed.
   if (NewFile && BackgroundIdx)
     BackgroundIdx->boostRelated(File);
 }
 

clang-tools-extra/clangd/Compiler.h

 // Most callers will use this through Preamble/ParsedAST, but some features like
 // CodeComplete run their own compile actions that share these low-level pieces.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_COMPILER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_COMPILER_H
 
-#include "../clang-tidy/ClangTidyOptions.h"
 #include "GlobalCompilationDatabase.h"
 #include "index/Index.h"
 #include "support/ThreadsafeFS.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/PrecompiledPreamble.h"
 #include "clang/Tooling/CompilationDatabase.h"
 
 namespace clang {
 namespace clangd {
 
+class ClangdTidyProvider;
+
 class IgnoreDiagnostics : public DiagnosticConsumer {
 public:
   static void log(DiagnosticsEngine::Level DiagLevel,
                   const clang::Diagnostic &Info);
 
   void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
                         const clang::Diagnostic &Info) override;
 };
 
 // Options to run clang e.g. when parsing AST.
 struct ParseOptions {
-  tidy::ClangTidyOptions ClangTidyOpts;
   bool SuggestMissingIncludes = false;
   bool BuildRecoveryAST = false;
   bool PreserveRecoveryASTType = false;
 };
 
 /// Information required to run clang, e.g. to parse AST or do code completion.
 struct ParseInputs {
   tooling::CompileCommand CompileCommand;
   const ThreadsafeFS *TFS;
   std::string Contents;
   // Version identifier for Contents, provided by the client and opaque to us.
   std::string Version = "null";
   // Prevent reuse of the cached preamble/AST. Slow! Useful to workaround
   // clangd's assumption that missing header files will stay missing.
   bool ForceRebuild = false;
   // Used to recover from diagnostics (e.g. find missing includes for symbol).
   const SymbolIndex *Index = nullptr;
   ParseOptions Opts = ParseOptions();
+  ClangdTidyProvider *ClangTidyProvider = nullptr;
 };
 
 /// Builds compiler invocation that could be used to build AST or preamble.
 std::unique_ptr<CompilerInvocation>
 buildCompilerInvocation(const ParseInputs &Inputs, clang::DiagnosticConsumer &D,
                         std::vector<std::string> *CC1Args = nullptr);
 
 /// Creates a compiler instance, configured so that:

clang-tools-extra/clangd/ParsedAST.cpp

 #include "../clang-tidy/ClangTidyModuleRegistry.h"
 #include "AST.h"
 #include "Compiler.h"
 #include "Diagnostics.h"
 #include "Headers.h"
 #include "IncludeFixer.h"
 #include "Preamble.h"
 #include "SourceCode.h"
+#include "TidyProvider.h"
 #include "index/CanonicalIncludes.h"
 #include "index/Index.h"
 #include "support/Logger.h"
 #include "support/Trace.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/SourceLocation.h"
private:
   const SourceManager &SM;
   Preprocessor &PP;
   std::vector<syntax::Token> MainFileTokens;
 };
 
 } // namespace
 
 llvm::Optional<ParsedAST>
 ParsedAST::build(llvm::StringRef Filename, const ParseInputs &Inputs,
                  std::unique_ptr<clang::CompilerInvocation> CI,
                  llvm::ArrayRef<Diag> CompilerInvocationDiags,
                  std::shared_ptr<const PreambleData> Preamble) {
   trace::Span Tracer("BuildAST");
   SPAN_ATTACH(Tracer, "File", Filename);
 
   auto VFS = Inputs.TFS->view(Inputs.CompileCommand.Directory);
   if (Preamble && Preamble->StatCache)
-    VFS = Preamble->StatCache->getConsumingFS(std::move(VFS));
+    VFS = Preamble->StatCache->getConsumingFS(VFS.get());
 
   assert(CI);
   // Command-line parsing sets DisableFree to true by default, but we don't want
   // to leak memory in clangd.
   CI->getFrontendOpts().DisableFree = false;
   const PrecompiledPreamble *PreamblePCH =
       Preamble ? &Preamble->Preamble : nullptr;
 
ParsedAST::build(llvm::StringRef Filename, const ParseInputs &Inputs,
   //  - matchers run only over the main-file top-level decls (and can't see
   //    ancestors outside this scope).
   // In practice almost all checks work well without modifications.
   std::vector<std::unique_ptr<tidy::ClangTidyCheck>> CTChecks;
   ast_matchers::MatchFinder CTFinder;
   llvm::Optional<tidy::ClangTidyContext> CTContext;
   {
     trace::Span Tracer("ClangTidyInit");
-    dlog("ClangTidy configuration for file {0}: {1}", Filename,
-         tidy::configurationAsText(Inputs.Opts.ClangTidyOpts));
     tidy::ClangTidyCheckFactories CTFactories;
     for (const auto &E : tidy::ClangTidyModuleRegistry::entries())
       E.instantiate()->addCheckFactories(CTFactories);
+    if (Inputs.ClangTidyProvider) {
+      CTContext.emplace(Inputs.ClangTidyProvider->getInstance(VFS.get()));
+    } else {
+      // This OptionsProvider will have no checks enabled, essentially disabling
+      // clang-tidy.
       CTContext.emplace(std::make_unique<tidy::DefaultOptionsProvider>(
-        tidy::ClangTidyGlobalOptions(), Inputs.Opts.ClangTidyOpts));
+          tidy::ClangTidyGlobalOptions(), tidy::ClangTidyOptions()));
+    }
     CTContext->setDiagnosticsEngine(&Clang->getDiagnostics());
     CTContext->setASTContext(&Clang->getASTContext());
     CTContext->setCurrentFile(Filename);
+    dlog("ClangTidy configuration for file {0}: {1}", Filename,
+         tidy::configurationAsText(CTContext->getOptions()));
     CTChecks = CTFactories.createChecks(CTContext.getPointer());
     llvm::erase_if(CTChecks, [&](const auto &Check) {
       return !Check->isLanguageVersionSupported(CTContext->getLangOpts());
     });
     Preprocessor *PP = &Clang->getPreprocessor();
     for (const auto &Check : CTChecks) {
       Check->registerPPCallbacks(Clang->getSourceManager(), PP, PP);
       Check->registerMatchers(&CTFinder);

clang-tools-extra/clangd/TidyProvider.h

+//===--- TidyProvider.h - create options for running clang-tidy------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_TIDYPROVIDER_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_TIDYPROVIDER_H
+
+#include "../clang-tidy/ClangTidyOptions.h"
+#include "llvm/Support/VirtualFileSystem.h"
+#include <shared_mutex>
+
+namespace clang {
+namespace clangd {
+
+/// The base class of all clang-tidy config providers for clangd. The option
+/// getters take a pointer to a Filesystem that should be used for any file IO.
+class ClangdTidyProvider {
+public:
+  using OptionsSource = tidy::ClangTidyOptionsProvider::OptionsSource;
+
+  /// Returns a provider than can be passed directly to the constructor of \ref
+  /// ClangTidyContext which delegates its option sourcing to this class.
+  virtual std::unique_ptr<tidy::ClangTidyOptionsProvider>
+  getInstance(llvm::vfs::FileSystem *FS);
+
+  virtual const tidy::ClangTidyGlobalOptions &
+  getGlobalOptions(llvm::vfs::FileSystem *) = 0;
+
+  virtual std::vector<OptionsSource>
+  getRawOptions(llvm::vfs::FileSystem *FS, llvm::StringRef FileName) = 0;
+
+  virtual ~ClangdTidyProvider() = default;
+};
+
+/// A Provider that will mimic the behaviour of tidy::FileOptionsProvider but
+/// it caches options retrieved in a thread safe manner. To be completely thread
+/// safe it must be passed a thread safe filesystem when reading files.
+class FileTidyProvider : public ClangdTidyProvider {
+public:
+  FileTidyProvider(tidy::ClangTidyGlobalOptions GlobalOptions,
+                   tidy::ClangTidyOptions DefaultOptions,
+                   tidy::ClangTidyOptions OverrideOptions)
+      : GlobalOpts(std::move(GlobalOptions)),
+        DefaultOpts(std::move(DefaultOptions)),
+        OverrideOpts(std::move(OverrideOptions)) {}
+  const tidy::ClangTidyGlobalOptions &
+  getGlobalOptions(llvm::vfs::FileSystem * /*unused*/) override;
+
+  std::vector<OptionsSource> getRawOptions(llvm::vfs::FileSystem *FS,
+                                           llvm::StringRef FileName) override;
+
+protected:
+  /// Loads .clang-tidy config files into \p CurOptions from the filesystem \p
+  /// FS found in parent directories of \p FileName.
+  void addFileOptions(llvm::vfs::FileSystem *FS, llvm::StringRef FileName,
+                      std::vector<OptionsSource> &CurOptions);
+
+private:
+  /// Tries to read and parse a configuration file located in \p Directory.
+  llvm::Optional<OptionsSource> tryReadConfigFile(llvm::vfs::FileSystem *FS,
+                                                  llvm::StringRef Directory);
+
+  /// Trys to get a OptionsSource from \p Directory, returns the OptionsSource
+  /// and a flag indicating if the value was read from the cache.
+  llvm::Optional<std::pair<OptionsSource, bool>>
+  tryGetConfig(llvm::vfs::FileSystem *FS, llvm::StringRef Directory);
+
+  // Using a shared mutex lets different threads read the cache at the same
+  // time, while preventing any thread updating the cache.
+  std::shared_timed_mutex CacheGuard;
+  llvm::StringMap<OptionsSource> CachedOptions;
+
+  const tidy::ClangTidyGlobalOptions GlobalOpts;
+  const tidy::ClangTidyOptions DefaultOpts;
+  const tidy::ClangTidyOptions OverrideOpts;
+};
+
+/// A FileTidyProvider that will adjust its checks for clangd.
+/// Either by assigning a nice default set of checks if none are specified or
+/// removing checks known to cause issues in clang-tidy.
+class CheckAdjustingTidyProvider : public FileTidyProvider {
+public:
+  using FileTidyProvider::FileTidyProvider;
+  std::vector<OptionsSource> getRawOptions(llvm::vfs::FileSystem *FS,
+                                           llvm::StringRef FileName) override;
+
+protected:
+  /// Appends an OptionsSource that will set default checks if no checks exists,
+  /// or disable checks known to cause issue when ran in clangd.
+  void adjustChecks(std::vector<OptionsSource> &RawOptions);
+};
+
+/// A ClangdTidyProvider that will use clangd::config when building its options.
+class ConfigTidyProvider : public CheckAdjustingTidyProvider {
+public:
+  using CheckAdjustingTidyProvider::CheckAdjustingTidyProvider;
+
+  std::vector<OptionsSource> getRawOptions(llvm::vfs::FileSystem *FS,
+                                           llvm::StringRef FileName) override;
+};
+
+// Set of clang-tidy checks that don't work well in clangd, either due to
+// crashes or false positives.
+// Returns a clang-tidy filter string: -check1,-check2.
+llvm::StringRef getUnusableTidyChecks();
+
+// Set of nice checks to enable by default if no checks are specified.
+// Returns a clang-tidy options string: check1,check2.
+llvm::StringRef getDefaultTidyChecks();
+
+} // namespace clangd
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_TIDYPROVIDER_H

clang-tools-extra/clangd/TidyProvider.cpp

+//===--- TidyProvider.cpp - create options for running clang-tidy----------===//
+//
+// 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 "TidyProvider.h"
+#include "Config.h"
+#include "clang/Basic/LLVM.h"
+#include "llvm/Support/VirtualFileSystem.h"
+
+namespace clang {
+namespace clangd {
+
+namespace {
+
+class ProxyFSTidyOptionsProvider : public tidy::ClangTidyOptionsProvider {
+public:
+  ProxyFSTidyOptionsProvider(ClangdTidyProvider &Provider,
+                             llvm::vfs::FileSystem *FS)
+      : Provider(Provider), TFSView(FS) {}
+
+  const tidy::ClangTidyGlobalOptions &getGlobalOptions() override {
+    return Provider.getGlobalOptions(TFSView.get());
+  }
+  std::vector<OptionsSource> getRawOptions(llvm::StringRef FileName) override {
+    return Provider.getRawOptions(TFSView.get(), FileName);
+  }
+
+private:
+  ClangdTidyProvider &Provider;
+  llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> TFSView;
+};
+
+} // namespace
+
+StringRef getUnusableTidyChecks() {
+  static const std::string FalsePositives =
+      llvm::join_items(", ",
+                       // Check relies on seeing ifndef/define/endif directives,
+                       // clangd doesn't replay those when using a preamble.
+                       "-llvm-header-guard");
+  static const std::string CrashingChecks =
+      llvm::join_items(", ",
+                       // Check can choke on invalid (intermediate) c++ code,
+                       // which is often the case when clangd tries to build an
+                       // AST.
+                       "-bugprone-use-after-move");
+  static const std::string UnusableTidyChecks =
+      llvm::join_items(", ", FalsePositives, CrashingChecks);
+  return UnusableTidyChecks;
+}
+
+StringRef getDefaultTidyChecks() {
+  // These default checks are chosen for:
+  //  - low false-positive rate
+  //  - providing a lot of value
+  //  - being reasonably efficient
+  static const std::string DefaultChecks = llvm::join_items(
+      ",", "readability-misleading-indentation", "readability-deleted-default",
+      "bugprone-integer-division", "bugprone-sizeof-expression",
+      "bugprone-suspicious-missing-comma", "bugprone-unused-raii",
+      "bugprone-unused-return-value", "misc-unused-using-decls",
+      "misc-unused-alias-decls", "misc-definitions-in-headers");
+  return DefaultChecks;
+}
+
+std::unique_ptr<tidy::ClangTidyOptionsProvider>
+ClangdTidyProvider::getInstance(llvm::vfs::FileSystem *FS) {
+  return std::make_unique<ProxyFSTidyOptionsProvider>(*this, FS);
+}
+
+const tidy::ClangTidyGlobalOptions &
+FileTidyProvider::getGlobalOptions(llvm::vfs::FileSystem * /*unused*/) {
+  return GlobalOpts;
+}
+
+std::vector<ClangdTidyProvider::OptionsSource>
+FileTidyProvider::getRawOptions(llvm::vfs::FileSystem *FS,
+                                llvm::StringRef FileName) {
+  std::vector<OptionsSource> RawOptions;
+  RawOptions.emplace_back(this->DefaultOpts, "clangd: default options");
+  addFileOptions(FS, FileName, RawOptions);
+
+  RawOptions.emplace_back(OverrideOpts, "command-line: -clang-tidy-checks");
+
+  return RawOptions;
+}
+
+void FileTidyProvider::addFileOptions(llvm::vfs::FileSystem *FS,
+                                      StringRef FileName,
+                                      std::vector<OptionsSource> &CurOptions) {
+
+  llvm::SmallString<128> AbsolutePath(FileName);
+
+  if (FS->makeAbsolute(AbsolutePath))
+    return;
+
+  auto CurSize = CurOptions.size();
+
+  // Look for a suitable configuration file in all parent directories of the
+  // file. Start with the immediate parent directory and move up.
+  StringRef Path = llvm::sys::path::parent_path(AbsolutePath);
+  for (StringRef CurrentPath = Path; !CurrentPath.empty();
+       CurrentPath = llvm::sys::path::parent_path(CurrentPath)) {
+    auto SourceAndFromCache = tryGetConfig(FS, CurrentPath);
+
+    if (!SourceAndFromCache)
+      continue; // No config found for this directory
+
+    OptionsSource &OptionsAndSource = SourceAndFromCache->first;
+
+    if (!SourceAndFromCache->second) {
+      // Require exclusive access while we update the CachedOptions.
+      std::unique_lock<std::shared_timed_mutex> ExclusiveGuard(CacheGuard);
+      CachedOptions.insert(std::make_pair(Path, OptionsAndSource));
+    }
+
+    if (Path != CurrentPath) {
+      // Defer locking until we are sure we need to update the cache.
+      std::unique_lock<std::shared_timed_mutex> ExclusiveGuard(
+          CacheGuard, std::defer_lock_t{});
+
+      // Acquire this lock now as it's needed to read the cache.
+      // If we ever need to update the cache, this will be released.
+      std::shared_lock<std::shared_timed_mutex> SharedGuard(CacheGuard);
+
+      // Store cached value for all intermediate directories.
+      while (Path != CurrentPath) {
+        if (CachedOptions.count(Path) == 0) {
+          // Release the shared access and gain exclusive access if we don't
+          // already have it.
+          if (!ExclusiveGuard.owns_lock()) {
+            assert(SharedGuard.owns_lock());
+            SharedGuard.unlock();
+            ExclusiveGuard.lock();
+          }
+          CachedOptions.insert(std::make_pair(Path, OptionsAndSource));
+        }
+        Path = llvm::sys::path::parent_path(Path);
+      }
+    }
+
+    CurOptions.push_back(std::move(OptionsAndSource));
+
+    if (!CurOptions.back().first.InheritParentConfig.getValueOr(false))
+      break;
+    // We need to inherit from the directory where the options were found.
+    // dir1/
+    //   .clang-tidy
+    //   dir2/
+    //     .clang-tidy
+    //     dir3/
+    //       dir4/
+    //         <FileName>
+    // If search at dir4/FileName and dir2/.clang-tidy is in the cache, the
+    // cache will also contain an entry for dir4 that is a copy of dir2.
+    // Likewise so will dir3. If we don't adjust the search path we'll look for
+    // the parent config in dir3 which will be a copy of whats in dir4. Where as
+    // if we adjust the search path to start from dir2 parent we'll search in
+    // dir1 and find the config we actually need.
+    AbsolutePath.assign(CurOptions.back().second);
+    if (FS->makeAbsolute(AbsolutePath))
+      break;
+    Path = llvm::sys::path::parent_path(AbsolutePath);
+    CurrentPath = Path;
+  }
+  // Reverse order of file configs because closer configs should have higher
+  // priority.
+  std::reverse(CurOptions.begin() + CurSize, CurOptions.end());
+}
+
+llvm::Optional<std::pair<ClangdTidyProvider::OptionsSource, bool>>
+FileTidyProvider::tryGetConfig(llvm::vfs::FileSystem *FS,
+                               llvm::StringRef Directory) {
+  {
+    // Only require shared control when reading. This lets multiple threads
+    // query the cache at the same time so long as no one is updating it.
+    std::shared_lock<std::shared_timed_mutex> Guard(CacheGuard);
+    auto Iter = CachedOptions.find(Directory);
+    if (Iter != CachedOptions.end())
+      return std::make_pair(Iter->getValue(), true);
+  }
+
+  if (auto Res = tryReadConfigFile(FS, Directory))
+    return std::make_pair(std::move(*Res), false);
+  return llvm::None;
+}
+
+llvm::Optional<ClangdTidyProvider::OptionsSource>
+FileTidyProvider::tryReadConfigFile(llvm::vfs::FileSystem *FS,
+                                    llvm::StringRef Directory) {
+  assert(!Directory.empty());
+
+  llvm::ErrorOr<llvm::vfs::Status> DirectoryStatus = FS->status(Directory);
+
+  if (!DirectoryStatus || !DirectoryStatus->isDirectory()) {
+    llvm::errs() << "Error reading configuration from " << Directory
+                 << ": directory doesn't exist.\n";
+    return llvm::None;
+  }
+
+  SmallString<128> ConfigFile(Directory);
+  llvm::sys::path::append(ConfigFile, ".clang-tidy");
+
+  llvm::ErrorOr<llvm::vfs::Status> FileStatus = FS->status(ConfigFile);
+
+  if (!FileStatus || !FileStatus->isRegularFile())
+    return llvm::None;
+
+  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Text =
+      FS->getBufferForFile(ConfigFile);
+  if (std::error_code EC = Text.getError()) {
+    llvm::errs() << "Can't read " << ConfigFile << ": " << EC.message() << "\n";
+    return llvm::None;
+  }
+
+  // Skip empty files, e.g. files opened for writing via shell output
+  // redirection.
+  if ((*Text)->getBuffer().empty())
+    return llvm::None;
+  llvm::ErrorOr<tidy::ClangTidyOptions> ParsedOptions =
+      tidy::parseConfiguration((*Text)->getBuffer());
+  if (!ParsedOptions) {
+    if (ParsedOptions.getError())
+      llvm::errs() << "Error parsing " << ConfigFile << ": "
+                   << ParsedOptions.getError().message() << "\n";
+    return llvm::None;
+  }
+  return OptionsSource(std::move(*ParsedOptions), std::string(ConfigFile));
+}
+
+std::vector<ClangdTidyProvider::OptionsSource>
+CheckAdjustingTidyProvider::getRawOptions(llvm::vfs::FileSystem *FS,
+                                          llvm::StringRef FileName) {
+  std::vector<OptionsSource> Opts =
+      FileTidyProvider::getRawOptions(FS, FileName);
+  adjustChecks(Opts);
+  return Opts;
+}
+
+void CheckAdjustingTidyProvider::adjustChecks(
+    std::vector<ClangdTidyProvider::OptionsSource> &RawOptions) {
+  if (llvm::all_of(RawOptions, [](OptionsSource &Source) {
+        return !Source.first.Checks.hasValue() || Source.first.Checks->empty();
+      })) {
+    tidy::ClangTidyOptions DefaultChecks;
+    DefaultChecks.Checks.emplace(getDefaultTidyChecks());
+    RawOptions.emplace_back(DefaultChecks, "clangd: default checks");
+  } else {
+    tidy::ClangTidyOptions RemoveIncompatiableChecks;
+    RemoveIncompatiableChecks.Checks.emplace(getUnusableTidyChecks());
+    RawOptions.emplace_back(RemoveIncompatiableChecks,
+                            "clangd: incompatible checks");
+  }
+}
+
+std::vector<ClangdTidyProvider::OptionsSource>
+ConfigTidyProvider::getRawOptions(llvm::vfs::FileSystem *FS,
+                                  llvm::StringRef FileName) {
+
+  const auto &CurTidyConfig = Config::current().ClangTidy;
+
+  // If the config doesn't contain any clang-tidy options, fall back to the
+  // CheckAdjustingTidyProvider.
+  if (CurTidyConfig.Checks.empty() && CurTidyConfig.CheckOptions.empty())
+    return CheckAdjustingTidyProvider::getRawOptions(FS, FileName);
+
+  std::vector<OptionsSource> OptionSources =
+      FileTidyProvider::getRawOptions(FS, FileName);
+
+  tidy::ClangTidyOptions ConfigOpts;
+
+  if (!CurTidyConfig.Checks.empty())
+    ConfigOpts.Checks.emplace(CurTidyConfig.Checks);
+
+  for (const auto &CheckOption : CurTidyConfig.CheckOptions)
+    ConfigOpts.CheckOptions.insert_or_assign(
+        CheckOption.getKey(),
+        tidy::ClangTidyOptions::ClangTidyValue(CheckOption.getValue()));
+
+  OptionSources.insert(OptionSources.end() - 1,
+                       OptionsSource(ConfigOpts, "clangd-config"));
+
+  adjustChecks(OptionSources);
+  return OptionSources;
+}
+
+} // namespace clangd
+} // namespace clang

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

bool buildInvocation(const ThreadsafeFS &TFS,
     } else {
       if (auto Contents = TFS.view(llvm::None)->getBufferForFile(File)) {
         Inputs.Contents = Contents->get()->getBuffer().str();
       } else {
         elog("Couldn't read {0}: {1}", File, Contents.getError().message());
         return false;
       }
     }
-    Inputs.Opts.ClangTidyOpts =
-        Opts.GetClangTidyOptions(*TFS.view(llvm::None), File);
     log("Parsing command...");
     Invocation =
         buildCompilerInvocation(Inputs, CaptureInvocationDiags, &CC1Args);
     auto InvocationDiags = CaptureInvocationDiags.take();
     ErrCount += showErrors(InvocationDiags);
     log("internal (cc1) args are: {0}", llvm::join(CC1Args, " "));
     if (!Invocation) {
       elog("Failed to parse command line");

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 "Features.inc"
 #include "PathMapping.h"
 #include "Protocol.h"
+#include "TidyProvider.h"
 #include "Transport.h"
 #include "index/Background.h"
 #include "index/Serialization.h"
 #include "index/remote/Client.h"
 #include "refactor/Rename.h"
 #include "support/Path.h"
 #include "support/Shutdown.h"
 #include "support/ThreadsafeFS.h"

 opt<std::string> ClangTidyChecks{
     "clang-tidy-checks",
     cat(Features),
     desc("List of clang-tidy checks to run (this will override "
          ".clang-tidy files). Only meaningful when -clang-tidy flag is on"),
     init(""),
 };
 
 opt<CodeCompleteOptions::CodeCompletionParse> CodeCompletionParse{
     "completion-parse",
     cat(Features),
     desc("Whether the clang-parser is used for code-completion"),
     values(clEnumValN(CodeCompleteOptions::AlwaysParse, "always",
                       "Block until the parser can be used"),
            clEnumValN(CodeCompleteOptions::ParseIfReady, "auto",
                       "Use text-based completion if the parser "
                       "is not ready"),
if (EnableConfig) {
     std::vector<const config::Provider *> ProviderPointers;
     for (const auto &P : ProviderStack)
       ProviderPointers.push_back(P.get());
     Config = config::Provider::combine(std::move(ProviderPointers));
     Opts.ConfigProvider = Config.get();
   }
 
   // Create an empty clang-tidy option.
-  std::mutex ClangTidyOptMu;
-  std::unique_ptr<tidy::ClangTidyOptionsProvider>
-      ClangTidyOptProvider; /*GUARDED_BY(ClangTidyOptMu)*/
+  std::unique_ptr<ClangdTidyProvider> ClangTidyOptProvider;
   if (EnableClangTidy) {
     auto EmptyDefaults = tidy::ClangTidyOptions::getDefaults();
     EmptyDefaults.Checks.reset(); // So we can tell if checks were ever set.
     EmptyDefaults.User = llvm::sys::Process::GetEnv("USER");
 #ifdef _WIN32
     if (!EmptyDefaults.User)
       EmptyDefaults.User = llvm::sys::Process::GetEnv("USERNAME");
 #endif
     tidy::ClangTidyOptions OverrideClangTidyOptions;
     if (!ClangTidyChecks.empty())
       OverrideClangTidyOptions.Checks = ClangTidyChecks;
-    ClangTidyOptProvider = std::make_unique<tidy::FileOptionsProvider>(
-        tidy::ClangTidyGlobalOptions(),
-        /* Default */ EmptyDefaults,
-        /* 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);
-      }
-      return Opts;
-    };
+    if (EnableConfig)
+      ClangTidyOptProvider = std::make_unique<ConfigTidyProvider>(
+          tidy::ClangTidyGlobalOptions(), std::move(EmptyDefaults),
+          std::move(OverrideClangTidyOptions));
+    else
+      ClangTidyOptProvider = std::make_unique<CheckAdjustingTidyProvider>(
+          tidy::ClangTidyGlobalOptions(), std::move(EmptyDefaults),
+          std::move(OverrideClangTidyOptions));
+    Opts.ClangTidyProvider = ClangTidyOptProvider.get();
   }
   Opts.AsyncPreambleBuilds = AsyncPreamble;
   Opts.SuggestMissingIncludes = SuggestMissingIncludes;
   Opts.QueryDriverGlobs = std::move(QueryDriverGlobs);
   Opts.TweakFilter = [&](const Tweak &T) {
     if (T.hidden() && !HiddenFeatures)
       return false;
     if (TweakList.getNumOccurrences())

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

add_unittest(ClangdUnitTests ClangdTests
   SerializationTests.cpp
   SourceCodeTests.cpp
   SymbolCollectorTests.cpp
   SymbolInfoTests.cpp
   SyncAPI.cpp
   TUSchedulerTests.cpp
   TestFS.cpp
   TestIndex.cpp
+  TestTidyProvider.cpp
   TestTU.cpp
   TestWorkspace.cpp
   TypeHierarchyTests.cpp
   TweakTests.cpp
   TweakTesting.cpp
   URITests.cpp
   XRefsTests.cpp
   ${CMAKE_CURRENT_BINARY_DIR}/DecisionForestRuntimeTest.cpp

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

 #include "ClangdServer.h"
 #include "CodeComplete.h"
 #include "ConfigFragment.h"
 #include "GlobalCompilationDatabase.h"
 #include "Matchers.h"
 #include "SyncAPI.h"
 #include "TestFS.h"
 #include "TestTU.h"
+#include "TidyProvider.h"
 #include "URI.h"
 #include "support/MemoryTree.h"
 #include "support/Path.h"
 #include "support/Threading.h"
 #include "clang/Config/config.h"
 #include "clang/Sema/CodeCompleteConsumer.h"
 #include "clang/Tooling/ArgumentsAdjusters.h"
 #include "llvm/ADT/None.h"
void onDiagnosticsReady(PathRef File, llvm::StringRef Version,
       std::lock_guard<std::mutex> Lock(Mutex);
       HadDiagsInLastCallback = !Diagnostics.empty();
     }
 
     std::mutex Mutex;
     bool HadDiagsInLastCallback = false;
   } DiagConsumer;
 
+  // We need to use the actual options provider here as we're interested in
+  // making sure those providers correctly disable problematic checks.
+  // As an added bonus it demonstrates the provider is capable of handling the
+  // ThreadsafeFS.
+
   MockFS FS;
+  FS.Files[testPath(".clang-tidy")] = R"(
+    Checks: -*,bugprone-use-after-move,llvm-header-guard
+  )";
   MockCompilationDatabase CDB;
+  CheckAdjustingTidyProvider Provider({}, {}, {});
   CDB.ExtraClangFlags = {"-xc++"};
   auto Opts = ClangdServer::optsForTest();
-  Opts.GetClangTidyOptions = [](llvm::vfs::FileSystem &, llvm::StringRef) {
-    auto Opts = tidy::ClangTidyOptions::getDefaults();
-    // These checks don't work well in clangd, even if configured they shouldn't
-    // run.
-    Opts.Checks = "bugprone-use-after-move,llvm-header-guard";
-    return Opts;
-  };
+  Opts.ClangTidyProvider = &Provider;
   ClangdServer Server(CDB, FS, Opts, &DiagConsumer);
   const char *SourceContents = R"cpp(
     struct Foo { Foo(); Foo(Foo&); Foo(Foo&&); };
     namespace std { Foo&& move(Foo&); }
     void foo() {
       Foo x;
       Foo y = std::move(x);
       Foo z = x;

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

 //===--- DiagnosticsTests.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 "Annotations.h"
 #include "Diagnostics.h"
 #include "ParsedAST.h"
 #include "Protocol.h"
 #include "SourceCode.h"
 #include "TestFS.h"
 #include "TestIndex.h"
 #include "TestTU.h"
+#include "TestTidyProvider.h"
 #include "index/MemIndex.h"
 #include "support/Path.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticSema.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/TargetSelect.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
o]]();
       double $type[[bar]] = "foo";
       struct Foo { int x; }; Foo a;
       a.$nomember[[y]];
       test::$nomembernamespace[[test]];
       $macro[[ID($macroarg[[fod]])]]();
     }
   )cpp");
   auto TU = TestTU::withCode(Test.code());
-  TU.ClangTidyChecks = "-*,google-explicit-constructor";
+  TU.ClangTidyProvider =
+      std::make_unique<TestClangTidyProvider>("-*,google-explicit-constructor");
   EXPECT_THAT(
       TU.build().getDiagnostics(),
       ElementsAre(
           // This range spans lines.
           AllOf(Diag(Test.range("typo"),
                      "use of undeclared identifier 'goo'; did you mean 'foo'?"),
                 DiagSource(Diag::Clang), DiagName("undeclared_var_use_suggest"),
                 WithFix(

 
 TEST(DiagnosticsTest, DeduplicatedClangTidyDiagnostics) {
   Annotations Test(R"cpp(
     float foo = [[0.1f]];
   )cpp");
   auto TU = TestTU::withCode(Test.code());
   // Enable alias clang-tidy checks, these check emits the same diagnostics
   // (except the check name).
-  TU.ClangTidyChecks = "-*, readability-uppercase-literal-suffix, "
-                       "hicpp-uppercase-literal-suffix";
+  TU.ClangTidyProvider = std::make_unique<TestClangTidyProvider>(
+      "-*, readability-uppercase-literal-suffix, "
+      "hicpp-uppercase-literal-suffix");
   // Verify that we filter out the duplicated diagnostic message.
   EXPECT_THAT(
       TU.build().getDiagnostics(),
       UnorderedElementsAre(::testing::AllOf(
           Diag(Test.range(),
                "floating point literal has suffix 'f', which is not uppercase"),
           DiagSource(Diag::ClangTidy))));
 
Annotations Test(R"cpp(
     int $main[[main]]() {
       int y = 4;
       return SQUARE($macroarg[[++]]y);
       return $doubled[[sizeof]](sizeof(int));
     }
   )cpp");
   auto TU = TestTU::withCode(Test.code());
   TU.HeaderFilename = "assert.h"; // Suppress "not found" error.
-  TU.ClangTidyChecks =
+  TU.ClangTidyProvider = std::make_unique<TestClangTidyProvider>(
       "-*, bugprone-sizeof-expression, bugprone-macro-repeated-side-effects, "
-      "modernize-deprecated-headers, modernize-use-trailing-return-type";
+      "modernize-deprecated-headers, modernize-use-trailing-return-type");
   EXPECT_THAT(
       TU.build().getDiagnostics(),
       UnorderedElementsAre(
           AllOf(Diag(Test.range("deprecated"),
                      "inclusion of deprecated C++ header 'assert.h'; consider "
                      "using 'cassert' instead"),
                 DiagSource(Diag::ClangTidy),
                 DiagName("modernize-deprecated-headers"),
TEST(DiagnosticsTest, ClangTidyEOF) {
   // clang-format off
   Annotations Test(R"cpp(
   [[#]]include <b.h>
   #include "a.h")cpp");
   // clang-format on
   auto TU = TestTU::withCode(Test.code());
   TU.ExtraArgs = {"-isystem."};
   TU.AdditionalFiles["a.h"] = TU.AdditionalFiles["b.h"] = "";
-  TU.ClangTidyChecks = "-*, llvm-include-order";
+  TU.ClangTidyProvider =
+      std::make_unique<TestClangTidyProvider>("-*, llvm-include-order");
   EXPECT_THAT(
       TU.build().getDiagnostics(),
       Contains(AllOf(Diag(Test.range(), "#includes are not sorted properly"),
                      DiagSource(Diag::ClangTidy),
                      DiagName("llvm-include-order"))));
 }
 
 TEST(DiagnosticTest, TemplatesInHeaders) {
Annotations Main(R"cpp(
     void f() {
       Foo<LabelInfo> label_info_map;
       [[for]] (auto it = label_info_map.begin(); it != label_info_map.end(); ++it) {
         auto S = *it;
       }
     }
   )cpp");
   TestTU TU = TestTU::withCode(Main.code());
-  TU.ClangTidyChecks = "modernize-loop-convert";
+  TU.ClangTidyProvider =
+      std::make_unique<TestClangTidyProvider>("modernize-loop-convert");
   EXPECT_THAT(
       TU.build().getDiagnostics(),
       UnorderedElementsAre(::testing::AllOf(
           Diag(Main.range(), "use range-based for loop instead"),
           DiagSource(Diag::ClangTidy), DiagName("modernize-loop-convert"))));
 }
 
 TEST(DiagnosticTest, ClangTidySuppressionComment) {
   Annotations Main(R"cpp(
     int main() {
       int i = 3;
       double d = 8 / i;  // NOLINT
       // NOLINTNEXTLINE
       double e = 8 / i;
       #define BAD 8 / i
       double f = BAD;  // NOLINT
       double g = [[8]] / i;
       #define BAD2 BAD
       double h = BAD2;  // NOLINT
     }
   )cpp");
   TestTU TU = TestTU::withCode(Main.code());
-  TU.ClangTidyChecks = "bugprone-integer-division";
+  TU.ClangTidyProvider =
+      std::make_unique<TestClangTidyProvider>("bugprone-integer-division");
   EXPECT_THAT(
       TU.build().getDiagnostics(),
       UnorderedElementsAre(::testing::AllOf(
           Diag(Main.range(), "result of integer division used in a floating "
                              "point context; possible loss of precision"),
           DiagSource(Diag::ClangTidy), DiagName("bugprone-integer-division"))));
 }
 
 TEST(DiagnosticTest, ClangTidyWarningAsError) {
   Annotations Main(R"cpp(
     int main() {
       int i = 3;
       double f = [[8]] / i; // error-ok
     }
   )cpp");
   TestTU TU = TestTU::withCode(Main.code());
-  TU.ClangTidyChecks = "bugprone-integer-division";
-  TU.ClangTidyWarningsAsErrors = "bugprone-integer-division";
+  TU.ClangTidyProvider = std::make_unique<TestClangTidyProvider>(
+      "bugprone-integer-division", "bugprone-integer-division");
   EXPECT_THAT(
       TU.build().getDiagnostics(),
       UnorderedElementsAre(::testing::AllOf(
           Diag(Main.range(), "result of integer division used in a floating "
                              "point context; possible loss of precision"),
           DiagSource(Diag::ClangTidy), DiagName("bugprone-integer-division"),
           DiagSeverity(DiagnosticsEngine::Error))));
 }

 TEST(DiagnosticTest, ClangTidySuppressionCommentTrumpsWarningAsError) {
   Annotations Main(R"cpp(
     int main() {
       int i = 3;
       double f = [[8]] / i;  // NOLINT
     }
   )cpp");
   TestTU TU = TestTU::withCode(Main.code());
-  TU.ClangTidyChecks = "bugprone-integer-division";
-  TU.ClangTidyWarningsAsErrors = "bugprone-integer-division";
+  TU.ClangTidyProvider = std::make_unique<TestClangTidyProvider>(
+      "bugprone-integer-division", "bugprone-integer-division");
   EXPECT_THAT(TU.build().getDiagnostics(), UnorderedElementsAre());
 }
 
 TEST(DiagnosticTest, ClangTidyNoLiteralDataInMacroToken) {
   Annotations Main(R"cpp(
     #define SIGTERM 15
     using pthread_t = int;
     int pthread_kill(pthread_t thread, int sig);
     int func() {
       pthread_t thread;
       return pthread_kill(thread, 0);
     }
   )cpp");
   TestTU TU = TestTU::withCode(Main.code());
-  TU.ClangTidyChecks = "-*,bugprone-bad-signal-to-kill-thread";
+  TU.ClangTidyProvider = std::make_unique<TestClangTidyProvider>(
+      "-*,bugprone-bad-signal-to-kill-thread");
   EXPECT_THAT(TU.build().getDiagnostics(), UnorderedElementsAre()); // no-crash
 }
 
 TEST(DiagnosticsTest, Preprocessor) {
   // This looks like a preamble, but there's an #else in the middle!
   // Check that:
   //  - the #else doesn't generate diagnostics (we had this bug)
   //  - we get diagnostics from the taken branch

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

 #include "Compiler.h"
 #include "Diagnostics.h"
 #include "Headers.h"
 #include "ParsedAST.h"
 #include "Preamble.h"
 #include "SourceCode.h"
 #include "TestFS.h"
 #include "TestTU.h"
+#include "TestTidyProvider.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TokenKinds.h"
 #include "clang/Lex/PPCallbacks.h"
 #include "clang/Lex/Token.h"
 #include "clang/Tooling/Syntax/Tokens.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "gmock/gmock-matchers.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
+#include <memory>
 
 namespace clang {
 namespace clangd {
 namespace {
 
 using ::testing::AllOf;
 using ::testing::ElementsAre;
 using ::testing::ElementsAreArray;
)cpp";
   EXPECT_EQ(Spelled.front().kind(), tok::hash);
   EXPECT_EQ(Spelled.back().text(SM), "last_token");
 }
 
 TEST(ParsedASTTest, NoCrashOnTokensWithTidyCheck) {
   TestTU TU;
   // this check runs the preprocessor, we need to make sure it does not break
   // our recording logic.
-  TU.ClangTidyChecks = "modernize-use-trailing-return-type";
+  TU.ClangTidyProvider = std::make_unique<TestClangTidyProvider>(
+      "modernize-use-trailing-return-type");
   TU.Code = "inline int foo() {}";
 
   auto AST = TU.build();
   const syntax::TokenBuffer &T = AST.getTokens();
   const auto &SM = AST.getSourceManager();
 
   ASSERT_GT(T.expandedTokens().size(), 7u);
   // Check first token after the preamble.
addCheckFactories(tidy::ClangTidyCheckFactories &CheckFactories) override {
           "replay-preamble-check");
     }
   };
 
   static tidy::ClangTidyModuleRegistry::Add<ReplayPreambleModule> X(
       "replay-preamble-module", "");
   TestTU TU;
   // This check records inclusion directives replayed by clangd.
-  TU.ClangTidyChecks = "replay-preamble-check";
+  TU.ClangTidyProvider =
+      std::make_unique<TestClangTidyProvider>("replay-preamble-check");
   llvm::Annotations Test(R"cpp(
     $hash^#$include[[import]] $filebegin^"$filerange[[bar.h]]"
     $hash^#$include[[include_next]] $filebegin^"$filerange[[baz.h]]"
     $hash^#$include[[include]] $filebegin^<$filerange[[a.h]]>)cpp");
   llvm::StringRef Code = Test.code();
   TU.Code = Code.str();
   TU.AdditionalFiles["bar.h"] = "";
   TU.AdditionalFiles["baz.h"] = "";

clang-tools-extra/clangd/unittests/TestTU.h

 // the mechanics of VFS and compiler interactions, and then easily grab the
 // AST, particular symbols, etc.
 //
 //===---------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_TESTTU_H
 #define LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_TESTTU_H
 
+#include "../TidyProvider.h"
 #include "Compiler.h"
 #include "ParsedAST.h"
 #include "TestFS.h"
 #include "index/Index.h"
 #include "support/Path.h"
 #include "llvm/ADT/StringMap.h"
 #include "gtest/gtest.h"
 #include <string>
struct TestTU {
   std::string HeaderFilename = "TestTU.h";
 
   // Name and contents of each file.
   llvm::StringMap<std::string> AdditionalFiles;
 
   // Extra arguments for the compiler invocation.
   std::vector<std::string> ExtraArgs;
 
-  llvm::Optional<std::string> ClangTidyChecks;
-  llvm::Optional<std::string> ClangTidyWarningsAsErrors;
+  std::unique_ptr<ClangdTidyProvider> ClangTidyProvider;
   // Index to use when building AST.
   const SymbolIndex *ExternalIndex = nullptr;
 
   // Simulate a header guard of the header (using an #import directive).
   bool ImplicitHeaderGuard = true;
 
   // Whether to use overlay the TestFS over the real filesystem. This is
   // required for use of implicit modules.where the module file is written to

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

ParseInputs TestTU::inputs(MockFS &FS) const {
   Argv.push_back(FullFilename);
   Inputs.CompileCommand.Filename = FullFilename;
   Inputs.CompileCommand.Directory = testRoot();
   Inputs.Contents = Code;
   if (OverlayRealFileSystemForModules)
     FS.OverlayRealFileSystemForModules = true;
   Inputs.TFS = &FS;
   Inputs.Opts = ParseOptions();
-  Inputs.Opts.ClangTidyOpts.Checks = ClangTidyChecks;
-  Inputs.Opts.ClangTidyOpts.WarningsAsErrors = ClangTidyWarningsAsErrors;
+  Inputs.ClangTidyProvider = ClangTidyProvider.get();
   Inputs.Index = ExternalIndex;
   if (Inputs.Index)
     Inputs.Opts.SuggestMissingIncludes = true;
   return Inputs;
 }
 
 void initializeModuleCache(CompilerInvocation &CI) {
   llvm::SmallString<128> ModuleCachePath;

clang-tools-extra/clangd/unittests/TestTidyProvider.h

+//===-- TestTidyProvider.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
+//
+//===----------------------------------------------------------------------===//
+
+#include "../TidyProvider.h"
+#include "llvm/Support/VirtualFileSystem.h"
+
+namespace clang {
+namespace clangd {
+
+class TestClangTidyProvider : public ClangdTidyProvider {
+public:
+  /// Convienence method for creating a provider that just uses \p Checks and \p
+  /// WarningsAsErrors
+  TestClangTidyProvider(llvm::StringRef Checks,
+                        llvm::StringRef WarningsAsErrors = {});
+  TestClangTidyProvider(const tidy::ClangTidyGlobalOptions &GlobalOptions,
+                        const tidy::ClangTidyOptions &Options);
+  std::vector<OptionsSource> getRawOptions(llvm::vfs::FileSystem * /*unused*/,
+                                           llvm::StringRef FileName) override;
+  const tidy::ClangTidyGlobalOptions &
+  getGlobalOptions(llvm::vfs::FileSystem * /*unused*/) override;
+
+private:
+  tidy::ClangTidyGlobalOptions GlobalOpts;
+  tidy::ClangTidyOptions Opts;
+};
+
+} // namespace clangd
+} // namespace clang

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

+//===-- TestTidyProvider.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 "TestTidyProvider.h"
+
+namespace clang {
+
+using namespace tidy;
+
+namespace clangd {
+
+TestClangTidyProvider::TestClangTidyProvider(llvm::StringRef Checks,
+                                             llvm::StringRef WarningsAsErrors) {
+  if (Checks.empty())
+    Opts.Checks.emplace(getDefaultTidyChecks());
+  else
+    Opts.Checks.emplace((Checks + "," + getUnusableTidyChecks()).str());
+  if (!WarningsAsErrors.empty())
+    Opts.WarningsAsErrors.emplace(WarningsAsErrors);
+}
+
+TestClangTidyProvider::TestClangTidyProvider(
+    const ClangTidyGlobalOptions &GlobalOptions,
+    const ClangTidyOptions &Options)
+    : GlobalOpts(GlobalOptions), Opts(Options) {
+  if (!Opts.Checks.hasValue() || Opts.Checks->empty())
+    Opts.Checks = getDefaultTidyChecks().str();
+  else
+    Opts.Checks->append(("," + getUnusableTidyChecks().str()));
+}
+
+std::vector<ClangTidyOptionsProvider::OptionsSource>
+TestClangTidyProvider::getRawOptions(llvm::vfs::FileSystem * /*unused*/,
+                                     llvm::StringRef FileName) {
+  std::vector<OptionsSource> RawOpts;
+  RawOpts.emplace_back(Opts, "mock-options");
+  return RawOpts;
+}
+
+const ClangTidyGlobalOptions &
+TestClangTidyProvider::getGlobalOptions(llvm::vfs::FileSystem * /*unused*/) {
+  return GlobalOpts;
+}
+} // namespace clangd
+} // namespace clang