[clangd] Add caching behaviour for clang-format config

[njames93]

Summary

Create a clang format configuration provider to be used when getting the FormatStyle for any features which require formatting behaviour.
Create a provider that searches the directory for configuration files, according to how clang-format searches, and stores the parsed styles in a cache.
Create a provider that just returns the LLVM style designed for use in tests where directory based formatting isn't required.

[njames93]

Refactor alot of the implementation.

[njames93]

Tests pass on my machine, rebasing on main and trigger a fresh rebuild.

[njames93]

Hopefully fix the build failing. ASAN said it was a use-after-scope issue which seemed suspicious.

[njames93]

Small fix

[njames93]

Ping?

[njames93]

Add unittests for provider.

[njames93]

Update to support inheriting configurations from D93844

clang-tools-extra/clangd/CMakeLists.txt

add_clang_library(clangDaemon
   Diagnostics.cpp
   DraftStore.cpp
   DumpAST.cpp
   ExpectedTypes.cpp
   FindSymbols.cpp
   FindTarget.cpp
   FileDistance.cpp
   Format.cpp
+  FormatProvider.cpp
   FS.cpp
   FuzzyMatch.cpp
   GlobalCompilationDatabase.cpp
   Headers.cpp
   HeaderSourceSwitch.cpp
   Hover.cpp
   IncludeFixer.cpp
   JSONTransport.cpp

clang-tools-extra/clangd/ClangdServer.h

 //===--- ClangdServer.h - Main clangd server code ----------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_CLANGDSERVER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_CLANGDSERVER_H
 
 #include "../clang-tidy/ClangTidyOptions.h"
 #include "CodeComplete.h"
 #include "ConfigProvider.h"
+#include "FormatProvider.h"
 #include "GlobalCompilationDatabase.h"
 #include "Hover.h"
 #include "Protocol.h"
 #include "SemanticHighlighting.h"
 #include "TUScheduler.h"
 #include "XRefs.h"
 #include "index/Background.h"
 #include "index/FileIndex.h"
struct Options {
 
     /// If set, queried to obtain the configuration to handle each request.
     config::Provider *ConfigProvider = nullptr;
 
     /// The Options provider to use when running clang-tidy. If null, clang-tidy
     /// checks will be disabled.
     TidyProviderRef ClangTidyProvider;
 
+    FormatProviderRef ClangFormatProvider;
+
     /// 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:
   // 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.
   TidyProviderRef ClangTidyProvider;
 
+  // When set, provides clang-format options for a specific file.
+  FormatProviderRef ClangFormatProvider;
+
   // 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.
   bool PreserveRecoveryASTType = false;

clang-tools-extra/clangd/ClangdServer.cpp

ClangdServer::ClangdServer(const GlobalCompilationDatabase &CDB,
                            const ThreadsafeFS &TFS, const Options &Opts,
                            Callbacks *Callbacks)
     : ConfigProvider(Opts.ConfigProvider), TFS(TFS), ServerCallbacks(Callbacks),
       DynamicIdx(Opts.BuildDynamicSymbolIndex
                      ? new FileIndex(Opts.HeavyweightDynamicSymbolIndex,
                                      Opts.CollectMainFileRefs)
                      : nullptr),
       ClangTidyProvider(Opts.ClangTidyProvider),
+      ClangFormatProvider(Opts.ClangFormatProvider),
       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
void ClangdServer::addDocument(PathRef File, llvm::StringRef Contents,
   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.ClangFormatProvider = ClangFormatProvider;
   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);
 }
 
if (!IP->Preamble) {
               CachedCompletionFuzzyFindRequestByFile[File];
         }
       }
     }
     ParseInputs ParseInput{IP->Command, &TFS, IP->Contents.str()};
     ParseInput.Index = Index;
     ParseInput.Opts.BuildRecoveryAST = BuildRecoveryAST;
     ParseInput.Opts.PreserveRecoveryASTType = PreserveRecoveryASTType;
+    ParseInput.ClangFormatProvider = ClangFormatProvider;
 
     // FIXME(ibiryukov): even if Preamble is non-null, we may want to check
     // both the old and the new version in case only one of them matches.
     CodeCompleteResult Result = clangd::codeComplete(
         File, Pos, IP->Preamble, ParseInput, CodeCompleteOpts,
         SpecFuzzyFind ? SpecFuzzyFind.getPointer() : nullptr);
     {
       clang::clangd::trace::Span Tracer("Completion results callback");
void ClangdServer::formatOnType(PathRef File, llvm::StringRef Code,
                                 Position Pos, StringRef TriggerText,
                                 Callback<std::vector<TextEdit>> CB) {
   llvm::Expected<size_t> CursorPos = positionToOffset(Code, Pos);
   if (!CursorPos)
     return CB(CursorPos.takeError());
   auto Action = [File = File.str(), Code = Code.str(),
                  TriggerText = TriggerText.str(), CursorPos = *CursorPos,
                  CB = std::move(CB), this]() mutable {
-    auto Style = format::getStyle(format::DefaultFormatStyle, File,
-                                  format::DefaultFallbackStyle, Code,
-                                  TFS.view(/*CWD=*/llvm::None).get());
-    if (!Style)
-      return CB(Style.takeError());
+    auto Style = ClangFormatProvider(File, Code);
+    assert(Style && "Provider should always return a valid style");
 
     std::vector<TextEdit> Result;
     for (const tooling::Replacement &R :
          formatIncremental(Code, CursorPos, TriggerText, *Style))
       Result.push_back(replacementToEdit(Code, R));
     return CB(Result);
   };
   WorkScheduler.run("FormatOnType", File, std::move(Action));
auto GetDirtyBuffer =
       return It->second;
     };
     auto R = clangd::rename(
         {Pos, NewName, InpAST->AST, File, Index, Opts, GetDirtyBuffer});
     if (!R)
       return CB(R.takeError());
 
     if (Opts.WantFormat) {
-      auto Style = getFormatStyleForFile(File, InpAST->Inputs.Contents,
-                                         *InpAST->Inputs.TFS);
+      auto Style = ClangFormatProvider(File, InpAST->Inputs.Contents);
       llvm::Error Err = llvm::Error::success();
       for (auto &E : R->GlobalChanges)
-        Err =
-            llvm::joinErrors(reformatEdit(E.getValue(), Style), std::move(Err));
+        Err = llvm::joinErrors(reformatEdit(E.getValue(), *Style),
+                               std::move(Err));
 
       if (Err)
         return CB(std::move(Err));
     }
     RenameFiles.record(R->GlobalChanges.size());
     return CB(*R);
   };
   WorkScheduler.runWithAST("Rename", File, std::move(Action));
for (const auto &Selection : *Selections) {
       }
       Effect = T.takeError();
     }
     assert(Effect.hasValue() && "Expected at least one selection");
     if (*Effect) {
       // Tweaks don't apply clang-format, do that centrally here.
       for (auto &It : (*Effect)->ApplyEdits) {
         Edit &E = It.second;
-        format::FormatStyle Style =
-            getFormatStyleForFile(File, E.InitialCode, TFS);
-        if (llvm::Error Err = reformatEdit(E, Style))
+        auto Style = ClangFormatProvider(File, E.InitialCode);
+        if (llvm::Error Err = reformatEdit(E, *Style))
           elog("Failed to format {0}: {1}", It.first(), std::move(Err));
       }
     } else {
       TweakFailed.record(1, TweakID);
     }
     return CB(std::move(*Effect));
   };
   WorkScheduler.runWithAST("ApplyTweak", File, std::move(Action));

 }
 
 void ClangdServer::formatCode(PathRef File, llvm::StringRef Code,
                               llvm::ArrayRef<tooling::Range> Ranges,
                               Callback<tooling::Replacements> CB) {
   // Call clang-format.
   auto Action = [File = File.str(), Code = Code.str(), Ranges = Ranges.vec(),
                  CB = std::move(CB), this]() mutable {
-    format::FormatStyle Style = getFormatStyleForFile(File, Code, TFS);
+    auto Style = ClangFormatProvider(File, Code);
     tooling::Replacements IncludeReplaces =
-        format::sortIncludes(Style, Code, Ranges, File);
+        format::sortIncludes(*Style, Code, Ranges, File);
     auto Changed = tooling::applyAllReplacements(Code, IncludeReplaces);
     if (!Changed)
       return CB(Changed.takeError());
 
     CB(IncludeReplaces.merge(format::reformat(
-        Style, *Changed,
+        *Style, *Changed,
         tooling::calculateRangesAfterReplacements(IncludeReplaces, Ranges),
         File)));
   };
   WorkScheduler.run("Format", File, std::move(Action));
 }
 
 void ClangdServer::findDocumentHighlights(
     PathRef File, Position Pos, Callback<std::vector<DocumentHighlight>> CB) {

 }
 
 void ClangdServer::findHover(PathRef File, Position Pos,
                              Callback<llvm::Optional<HoverInfo>> CB) {
   auto Action = [File = File.str(), Pos, CB = std::move(CB),
                  this](llvm::Expected<InputsAndAST> InpAST) mutable {
     if (!InpAST)
       return CB(InpAST.takeError());
-    format::FormatStyle Style = getFormatStyleForFile(
-        File, InpAST->Inputs.Contents, *InpAST->Inputs.TFS);
-    CB(clangd::getHover(InpAST->AST, Pos, std::move(Style), Index));
+    auto Style = ClangFormatProvider(File, InpAST->Inputs.Contents);
+    CB(clangd::getHover(InpAST->AST, Pos, Style, Index));
   };
 
   WorkScheduler.runWithAST("Hover", File, std::move(Action),
                            TUScheduler::InvalidateOnUpdate);
 }
 
 void ClangdServer::typeHierarchy(PathRef File, Position Pos, int Resolve,
                                  TypeHierarchyDirection Direction,

clang-tools-extra/clangd/CodeComplete.cpp

 
 #include "CodeComplete.h"
 #include "AST.h"
 #include "CodeCompletionStrings.h"
 #include "Compiler.h"
 #include "Diagnostics.h"
 #include "ExpectedTypes.h"
 #include "FileDistance.h"
+#include "FormatProvider.h"
 #include "FuzzyMatch.h"
 #include "Headers.h"
 #include "Hover.h"
 #include "Preamble.h"
 #include "Protocol.h"
 #include "Quality.h"
 #include "SourceCode.h"
 #include "TUScheduler.h"
class CodeCompleteFlow {
   llvm::Optional<IncludeInserter> Inserter;  // Available during runWithSema.
   llvm::Optional<URIDistance> FileProximity; // Initialized once Sema runs.
   /// Speculative request based on the cached request and the filter text before
   /// the cursor.
   /// Initialized right before sema run. This is only set if `SpecFuzzyFind` is
   /// set and contains a cached request.
   llvm::Optional<FuzzyFindRequest> SpecReq;
 
+  FormatProviderRef FormatProvider;
+
 public:
   // A CodeCompleteFlow object is only useful for calling run() exactly once.
   CodeCompleteFlow(PathRef FileName, const IncludeStructure &Includes,
                    SpeculativeFuzzyFind *SpecFuzzyFind,
-                   const CodeCompleteOptions &Opts)
+                   const CodeCompleteOptions &Opts,
+                   FormatProviderRef FormatProvider)
       : FileName(FileName), Includes(Includes), SpecFuzzyFind(SpecFuzzyFind),
-        Opts(Opts) {}
+        Opts(Opts), FormatProvider(FormatProvider) {}
 
   CodeCompleteResult run(const SemaCompleteInput &SemaCCInput) && {
     trace::Span Tracer("CodeCompleteFlow");
     HeuristicPrefix = guessCompletionPrefix(SemaCCInput.ParseInput.Contents,
                                             SemaCCInput.Offset);
     populateContextWords(SemaCCInput.ParseInput.Contents);
     if (Opts.Index && SpecFuzzyFind && SpecFuzzyFind->CachedReq.hasValue()) {
       assert(!SpecFuzzyFind->Result.valid());
       SpecReq = speculativeFuzzyFindRequestForCompletion(
           *SpecFuzzyFind->CachedReq, HeuristicPrefix);
       SpecFuzzyFind->Result = startAsyncFuzzyFind(*Opts.Index, *SpecReq);
     }
 
     // We run Sema code completion first. It builds an AST and calculates:
     //   - completion results based on the AST.
     //   - partial identifier and context. We need these for the index query.
     CodeCompleteResult Output;
     auto RecorderOwner = std::make_unique<CompletionRecorder>(Opts, [&]() {
       assert(Recorder && "Recorder is not set");
       CCContextKind = Recorder->CCContext.getKind();
       IsUsingDeclaration = Recorder->CCContext.isUsingDeclaration();
-      auto Style = getFormatStyleForFile(SemaCCInput.FileName,
-                                         SemaCCInput.ParseInput.Contents,
-                                         *SemaCCInput.ParseInput.TFS);
+      auto Style =
+          FormatProvider(SemaCCInput.FileName, SemaCCInput.ParseInput.Contents);
       const auto NextToken = Lexer::findNextToken(
           Recorder->CCSema->getPreprocessor().getCodeCompletionLoc(),
           Recorder->CCSema->getSourceManager(), Recorder->CCSema->LangOpts);
       if (NextToken)
         NextTokenKind = NextToken->getKind();
       // If preprocessor was run, inclusions from preprocessor callback should
       // already be added to Includes.
       Inserter.emplace(
-          SemaCCInput.FileName, SemaCCInput.ParseInput.Contents, Style,
+          SemaCCInput.FileName, SemaCCInput.ParseInput.Contents, *Style,
           SemaCCInput.ParseInput.CompileCommand.Directory,
           &Recorder->CCSema->getPreprocessor().getHeaderSearchInfo());
       for (const auto &Inc : Includes.MainFileIncludes)
         Inserter->addExisting(Inc);
 
       // Most of the cost of file proximity is in initializing the FileDistance
       // structures based on the observed includes, once per query. Conceptually
       // that happens here (though the per-URI-scheme initialization is lazy).
CodeCompleteResult runWithoutSema(llvm::StringRef Content, size_t Offset,
     auto Pos = offsetToPosition(Content, Offset);
     ReplacedRange.start = ReplacedRange.end = Pos;
     ReplacedRange.start.character -= HeuristicPrefix.Name.size();
 
     llvm::StringMap<SourceParams> ProxSources;
     ProxSources[FileName].Cost = 0;
     FileProximity.emplace(ProxSources);
 
-    auto Style = getFormatStyleForFile(FileName, Content, TFS);
+    auto Style = FormatProvider(FileName, Content);
     // This will only insert verbatim headers.
-    Inserter.emplace(FileName, Content, Style,
+    Inserter.emplace(FileName, Content, *Style,
                      /*BuildDir=*/"", /*HeaderSearchInfo=*/nullptr);
 
-    auto Identifiers = collectIdentifiers(Content, Style);
+    auto Identifiers = collectIdentifiers(Content, *Style);
     std::vector<RawIdentifier> IdentifierResults;
     for (const auto &IDAndCount : Identifiers) {
       RawIdentifier ID;
       ID.Name = IDAndCount.first();
       ID.References = IDAndCount.second;
       // Avoid treating typed filter as an identifier.
       if (ID.Name == HeuristicPrefix.Name)
         --ID.References;
       if (ID.References > 0)
         IdentifierResults.push_back(std::move(ID));
     }
 
     // Simplified version of getQueryScopes():
     //  - accessible scopes are determined heuristically.
     //  - all-scopes query if no qualifier was typed (and it's allowed).
     SpecifiedScope Scopes;
     Scopes.AccessibleScopes = visibleNamespaces(
-        Content.take_front(Offset), format::getFormattingLangOpts(Style));
+        Content.take_front(Offset), format::getFormattingLangOpts(*Style));
     for (std::string &S : Scopes.AccessibleScopes)
       if (!S.empty())
         S.append("::"); // visibleNamespaces doesn't include trailing ::.
     if (HeuristicPrefix.Qualifier.empty())
       AllScopes = Opts.AllScopes;
     else if (HeuristicPrefix.Qualifier.startswith("::")) {
       Scopes.AccessibleScopes = {""};
       Scopes.UnresolvedQualifier =
CodeCompleteResult codeComplete(PathRef FileName, Position Pos,
                                 SpeculativeFuzzyFind *SpecFuzzyFind) {
   auto Offset = positionToOffset(ParseInput.Contents, Pos);
   if (!Offset) {
     elog("Code completion position was invalid {0}", Offset.takeError());
     return CodeCompleteResult();
   }
   auto Flow = CodeCompleteFlow(
       FileName, Preamble ? Preamble->Includes : IncludeStructure(),
-      SpecFuzzyFind, Opts);
+      SpecFuzzyFind, Opts, ParseInput.ClangFormatProvider);
   return (!Preamble || Opts.RunParser == CodeCompleteOptions::NeverParse)
              ? std::move(Flow).runWithoutSema(ParseInput.Contents, *Offset,
                                               *ParseInput.TFS)
              : std::move(Flow).run({FileName, *Offset, *Preamble,
                                     // We want to serve code completions with
                                     // low latency, so don't bother patching.
                                     /*PreamblePatch=*/llvm::None, ParseInput});
 }

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 "FormatProvider.h"
 #include "GlobalCompilationDatabase.h"
 #include "TidyProvider.h"
 #include "index/Index.h"
 #include "support/ThreadsafeFS.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/PrecompiledPreamble.h"
 #include "clang/Tooling/CompilationDatabase.h"
 
struct ParseInputs {
   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();
   TidyProviderRef ClangTidyProvider = {};
+  FormatProviderRef ClangFormatProvider = {};
 };
 
 /// 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/FormatProvider.h

+//===--- FormatProvider.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
+//
+//===----------------------------------------------------------------------===//
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_FORMATPROVIDER_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_FORMATPROVIDER_H
+
+#include "support/Path.h"
+#include "support/ThreadsafeFS.h"
+#include "clang/Format/Format.h"
+#include "llvm/ADT/FunctionExtras.h"
+
+namespace clang {
+namespace clangd {
+using FormatProvider =
+    llvm::unique_function<std::shared_ptr<const format::FormatStyle>(
+        PathRef, llvm::StringRef) const>;
+using FormatProviderRef =
+    llvm::function_ref<std::shared_ptr<const format::FormatStyle>(
+        PathRef, llvm::StringRef)>;
+
+FormatProvider getClangFormatProvider(ThreadsafeFS &TFS,
+                                      StringRef FallbackStyle);
+
+} // namespace clangd
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_FORMATPROVIDER_H

clang-tools-extra/clangd/FormatProvider.cpp

+//===--- FormatProvider.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 "FormatProvider.h"
+#include "support/FileCache.h"
+#include "support/Logger.h"
+#include "clang/Format/Format.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/MemoryBufferRef.h"
+#include <memory>
+#include <tuple>
+#include <utility>
+
+namespace clang {
+namespace clangd {
+
+namespace {
+// Access to config from a clang format configuration file, caching IO and
+// parsing.
+using LanguageKind = format::FormatStyle::LanguageKind;
+class ClangFormatCache : private FileCache {
+  mutable std::shared_ptr<format::FormatStyle> Value;
+  const LanguageKind Lang;
+
+public:
+  ClangFormatCache(PathRef Path, LanguageKind Lang)
+      : FileCache(Path), Lang(Lang) {}
+
+  std::shared_ptr<const format::FormatStyle>
+  get(const ThreadsafeFS &TFS,
+      std::chrono::steady_clock::time_point FreshTime) const {
+    std::shared_ptr<const format::FormatStyle> Result;
+    read(
+        TFS, FreshTime,
+        [this](llvm::Optional<llvm::StringRef> Data) {
+          // Clear any stale config if one exists.
+          Value.reset();
+          if (!Data || !Data->empty())
+            return;
+          format::FormatStyle Style = format::getLLVMStyle(Lang);
+          if (auto EC = format::parseConfiguration(
+                  llvm::MemoryBufferRef(*Data, path()), &Style,
+                  /*AllowUnknownOptions=*/true))
+            elog("clang-format style parsing error: {0}", EC.message());
+          else
+            Value = std::make_shared<format::FormatStyle>(std::move(Style));
+        },
+        [&]() { Result = Value; });
+    return Result;
+  }
+};
+
+// Clang-Format checks for ".clang-format" then "_clang-format" in each
+// directory, so this wraps those 2 caches into one.
+struct ClangFormatCachePair {
+private:
+  SmallString<256> appendDir(StringRef Dir, StringRef Tail) {
+    SmallString<256> Res(Dir);
+    llvm::sys::path::append(Res, Tail);
+    return Res;
+  }
+
+public:
+  ClangFormatCache Dot;
+  ClangFormatCache Underscore;
+
+  explicit ClangFormatCachePair(StringRef Dir, LanguageKind Lang)
+      : Dot(appendDir(Dir, ".clang-format"), Lang),
+        Underscore(appendDir(Dir, "_clang-format"), Lang) {}
+};
+
+class ClangFormatConfigTree {
+  struct CacheMapAndFallback {
+  private:
+    static std::shared_ptr<format::FormatStyle> getFallback(StringRef Fallback,
+                                                            LanguageKind Lang) {
+      auto Result = std::make_shared<format::FormatStyle>(format::getNoStyle());
+      if (!format::getPredefinedStyle(Fallback, Lang, &*Result)) {
+        StringRef PrettyStyle;
+        if (Lang == LanguageKind::LK_Cpp)
+          PrettyStyle = "C/C++";
+        else if (Lang == LanguageKind::LK_ObjC)
+          PrettyStyle = "Objective-C/Objective-C++";
+        else
+          llvm_unreachable("Unsupported language kind");
+        elog("error: Couldn't get fallback style for '{0}', using LLVM Style",
+             PrettyStyle);
+        *Result = format::getLLVMStyle(Lang);
+      }
+      return Result;
+    }
+
+  public:
+    CacheMapAndFallback(StringRef FallbackStyle, LanguageKind Lang)
+        : Fallback(getFallback(FallbackStyle, Lang)) {}
+
+    llvm::StringMap<ClangFormatCachePair> Map;
+    const std::shared_ptr<const format::FormatStyle> Fallback;
+  };
+
+  const ThreadsafeFS &FS;
+  std::chrono::steady_clock::duration MaxStaleness;
+  mutable std::mutex Mu;
+
+  CacheMapAndFallback CPPConfig, ObjCConfig;
+
+public:
+  ClangFormatConfigTree(const ThreadsafeFS &FS, StringRef FallbackStyle)
+      : FS(FS), MaxStaleness(std::chrono::seconds(5)),
+        CPPConfig(FallbackStyle, LanguageKind::LK_Cpp),
+        ObjCConfig(FallbackStyle, LanguageKind::LK_Cpp) {}
+
+  std::shared_ptr<const format::FormatStyle> get(PathRef AbsPath,
+                                                 LanguageKind Lang) {
+    CacheMapAndFallback *MapFallback;
+
+    switch (Lang) {
+    case LanguageKind::LK_Cpp:
+      MapFallback = &CPPConfig;
+      break;
+    case LanguageKind::LK_ObjC:
+      MapFallback = &ObjCConfig;
+      break;
+    default:
+      llvm_unreachable("Unsupported language kind");
+    }
+    namespace path = llvm::sys::path;
+    assert(path::is_absolute(AbsPath));
+
+    // Compute absolute paths to all ancestors (substrings of P.Path).
+    // Ensure cache entries for each ancestor exist in the map.
+    llvm::StringRef Parent = path::parent_path(AbsPath);
+    llvm::SmallVector<ClangFormatCachePair *> Caches;
+    {
+      std::lock_guard<std::mutex> Lock(Mu);
+      for (auto I = path::begin(Parent), E = path::end(Parent); I != E; ++I) {
+        assert(I->end() >= Parent.begin() && I->end() <= Parent.end() &&
+               "Canonical path components should be substrings");
+        llvm::StringRef Ancestor(Parent.begin(), I->end() - Parent.begin());
+#ifdef _WIN32
+        // C:\ is an ancestor, but skip its (relative!) parent C:.
+        if (Ancestor.size() == 2 && Ancestor.back() == ':')
+          continue;
+#endif
+        assert(path::is_absolute(Ancestor));
+
+        auto It = MapFallback->Map.find(Ancestor);
+
+        // Assemble the actual config file path only if needed.
+        if (It == MapFallback->Map.end()) {
+          It = MapFallback->Map.try_emplace(Ancestor, Ancestor, Lang).first;
+        }
+        Caches.push_back(&It->second);
+      }
+    }
+    // Finally query each individual file.
+    // This will take a (per-file) lock for each file that actually exists.
+    std::chrono::steady_clock::time_point FreshTime =
+        std::chrono::steady_clock::now() - MaxStaleness;
+    for (const ClangFormatCachePair *Cache : Caches) {
+      // Check the .clang-format file.
+      if (auto Config = Cache->Dot.get(FS, FreshTime))
+        return Config;
+      // Check the _clang-format file.
+      if (auto Config = Cache->Underscore.get(FS, FreshTime))
+        return Config;
+    }
+    return MapFallback->Fallback;
+  }
+};
+
+} // namespace
+FormatProvider getClangFormatProvider(ThreadsafeFS &TFS,
+                                      StringRef FallbackStyle) {
+  return [Tree = std::make_unique<ClangFormatConfigTree>(TFS, FallbackStyle)](
+             PathRef Filename, StringRef Contents) {
+    LanguageKind Lang = format::guessLanguage(Filename, Contents);
+    return Tree->get(Filename, Lang);
+  };
+}
+} // namespace clangd
+} // namespace clang

clang-tools-extra/clangd/Hover.h

 llvm::raw_ostream &operator<<(llvm::raw_ostream &, const HoverInfo::Param &);
 inline bool operator==(const HoverInfo::Param &LHS,
                        const HoverInfo::Param &RHS) {
   return std::tie(LHS.Type, LHS.Name, LHS.Default) ==
          std::tie(RHS.Type, RHS.Name, RHS.Default);
 }
 
 /// Get the hover information when hovering at \p Pos.
-llvm::Optional<HoverInfo> getHover(ParsedAST &AST, Position Pos,
-                                   format::FormatStyle Style,
-                                   const SymbolIndex *Index);
+llvm::Optional<HoverInfo>
+getHover(ParsedAST &AST, Position Pos,
+         std::shared_ptr<const format::FormatStyle> Style,
 
 } // namespace clangd
 } // namespace clang
 
 #endif

clang-tools-extra/clangd/Hover.cpp

for (auto *CastNode = N->Parent;
     }
   }
 
   HI.CallPassType.emplace(PassType);
 }
 
 } // namespace
 
-llvm::Optional<HoverInfo> getHover(ParsedAST &AST, Position Pos,
-                                   format::FormatStyle Style,
-                                   const SymbolIndex *Index) {
+llvm::Optional<HoverInfo>
+getHover(ParsedAST &AST, Position Pos,
+         std::shared_ptr<const format::FormatStyle> Style,
   PrintingPolicy PP =
       getPrintingPolicy(AST.getASTContext().getPrintingPolicy());
   const SourceManager &SM = AST.getSourceManager();
   auto CurLoc = sourceLocationInMainFile(SM, Pos);
   if (!CurLoc) {
     llvm::consumeError(CurLoc.takeError());
     return llvm::None;
   }
if (const SelectionTree::Node *N = ST.commonAncestor()) {
       //  - built-in types
     }
   }
 
   if (!HI)
     return llvm::None;
 
   auto Replacements = format::reformat(
-      Style, HI->Definition, tooling::Range(0, HI->Definition.size()));
+      *Style, HI->Definition, tooling::Range(0, HI->Definition.size()));
   if (auto Formatted =
           tooling::applyAllReplacements(HI->Definition, Replacements))
     HI->Definition = *Formatted;
   HI->SymRange = halfOpenToRange(SM, HighlightRange);
 
   return HI;
 }
 

clang-tools-extra/clangd/ParsedAST.cpp

ParsedAST::build(llvm::StringRef Filename, const ParseInputs &Inputs,
   }
 
   // Add IncludeFixer which can recover diagnostics caused by missing includes
   // (e.g. incomplete type) and attach include insertion fixes to diagnostics.
   llvm::Optional<IncludeFixer> FixIncludes;
   auto BuildDir = VFS->getCurrentWorkingDirectory();
   if (Inputs.Opts.SuggestMissingIncludes && Inputs.Index &&
       !BuildDir.getError()) {
-    auto Style = getFormatStyleForFile(Filename, Inputs.Contents, *Inputs.TFS);
+    auto Style = Inputs.ClangFormatProvider(Filename, Inputs.Contents);
     auto Inserter = std::make_shared<IncludeInserter>(
-        Filename, Inputs.Contents, Style, BuildDir.get(),
+        Filename, Inputs.Contents, *Style, BuildDir.get(),
         &Clang->getPreprocessor().getHeaderSearchInfo());
     if (Preamble) {
       for (const auto &Inc : Preamble->Includes.MainFileIncludes)
         Inserter->addExisting(Inc);
     }
     FixIncludes.emplace(Filename, Inserter, *Inputs.Index,
                         /*IndexRequestLimit=*/5);
     ASTDiags.contributeFixes([&FixIncludes](DiagnosticsEngine::Level DiagLevl,

clang-tools-extra/clangd/SourceCode.h

 ///   - No duplicate or trailing directory separator
 ///
 /// This function should be used when paths needs to be used outside the
 /// component that generate it, so that paths are normalized as much as
 /// possible.
 llvm::Optional<std::string> getCanonicalPath(const FileEntry *F,
                                              const SourceManager &SourceMgr);
 
-/// Choose the clang-format style we should apply to a certain file.
-/// This will usually use FS to look for .clang-format directories.
-/// FIXME: should we be caching the .clang-format file search?
-/// This uses format::DefaultFormatStyle and format::DefaultFallbackStyle,
-/// though the latter may have been overridden in main()!
-format::FormatStyle getFormatStyleForFile(llvm::StringRef File,
-                                          llvm::StringRef Content,
-                                          const ThreadsafeFS &TFS);
-
 /// Cleanup and format the given replacements.
 llvm::Expected<tooling::Replacements>
 cleanupAndFormat(StringRef Code, const tooling::Replacements &Replaces,
                  const format::FormatStyle &Style);
 
 /// A set of edits generated for a single file. Can verify whether it is safe to
 /// apply these edits to a code block.
 struct Edit {

clang-tools-extra/clangd/SourceCode.cpp

 llvm::Optional<FileDigest> digestFile(const SourceManager &SM, FileID FID) {
   bool Invalid = false;
   llvm::StringRef Content = SM.getBufferData(FID, &Invalid);
   if (Invalid)
     return None;
   return digest(Content);
 }
 
-format::FormatStyle getFormatStyleForFile(llvm::StringRef File,
-                                          llvm::StringRef Content,
-                                          const ThreadsafeFS &TFS) {
-  auto Style = format::getStyle(format::DefaultFormatStyle, File,
-                                format::DefaultFallbackStyle, Content,
-                                TFS.view(/*CWD=*/llvm::None).get());
-  if (!Style) {
-    log("getStyle() failed for file {0}: {1}. Fallback is LLVM style.", File,
-        Style.takeError());
-    return format::getLLVMStyle();
-  }
-  return *Style;
-}
-
 llvm::Expected<tooling::Replacements>
 cleanupAndFormat(StringRef Code, const tooling::Replacements &Replaces,
                  const format::FormatStyle &Style) {
   auto CleanReplaces = cleanupAroundReplacements(Code, Replaces, Style);
   if (!CleanReplaces)
     return CleanReplaces;
   return formatReplacements(Code, std::move(*CleanReplaces), Style);
 }

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

class Checker {
   // from constructor
   std::string File;
   ClangdLSPServer::Options Opts;
   // from buildCommand
   tooling::CompileCommand Cmd;
   // from buildInvocation
   ParseInputs Inputs;
   std::unique_ptr<CompilerInvocation> Invocation;
-  format::FormatStyle Style;
+  std::shared_ptr<const format::FormatStyle> Style;
   // from buildAST
   std::shared_ptr<const PreambleData> Preamble;
   llvm::Optional<ParsedAST> AST;
   FileIndex Index;
 
 public:
   // Number of non-fatal errors seen.
   unsigned ErrCount = 0;
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.ClangFormatProvider = Opts.ClangFormatProvider;
     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");
       return false;
     }
 
     // FIXME: Check that resource-dir/built-in-headers exist?
 
-    Style = getFormatStyleForFile(File, Inputs.Contents, TFS);
+    Style = Inputs.ClangFormatProvider(File, Inputs.Contents);
 
     return true;
   }
 
   // Build preamble and AST, and index them.
   bool buildAST() {
     log("Building preamble...");
     Preamble =

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 "FormatProvider.h"
 #include "PathMapping.h"
 #include "Protocol.h"
 #include "TidyProvider.h"
 #include "Transport.h"
 #include "index/Background.h"
 #include "index/Index.h"
 #include "index/Merge.h"
 #include "index/ProjectAware.h"
if (EnableClangTidy) {
     if (!ClangTidyChecks.empty())
       Providers.push_back(addTidyChecks(ClangTidyChecks));
     else
       Providers.push_back(provideDefaultChecks());
     Providers.push_back(disableUnusableChecks());
     ClangTidyOptProvider = combine(std::move(Providers));
     Opts.ClangTidyProvider = ClangTidyOptProvider;
   }
+  FormatProvider ClangFormatOptProvider =
+      getClangFormatProvider(TFS, FallbackStyle);
+  Opts.ClangFormatProvider = ClangFormatOptProvider;
   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())
       return llvm::is_contained(TweakList, T.id());

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

 //===-- ClangdTests.cpp - Clangd unit tests ---------------------*- 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 "ClangdLSPServer.h"
 #include "ClangdServer.h"
 #include "CodeComplete.h"
 #include "ConfigFragment.h"
+#include "FormatProvider.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"
)cpp";
   ASSERT_TRUE(Server.blockUntilIdleForTest());
   EXPECT_THAT(Server.fileStats(), IsEmpty());
 }
 
 TEST(ClangdServerTest, InvalidCompileCommand) {
   MockFS FS;
   ErrorCheckingCallbacks DiagConsumer;
   MockCompilationDatabase CDB;
+  FormatProvider Format =
+      getClangFormatProvider(FS, format::DefaultFallbackStyle);
+  ClangdServer::Options ServerOpts = ClangdServer::optsForTest();
+  ServerOpts.ClangFormatProvider = Format;
 
-  ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &DiagConsumer);
+  ClangdServer Server(CDB, FS, ServerOpts, &DiagConsumer);
 
   auto FooCpp = testPath("foo.cpp");
   // clang cannot create CompilerInvocation if we pass two files in the
   // CompileCommand. We pass the file in ExtraFlags once and CDB adds another
   // one in getCompileCommand().
   CDB.ExtraClangFlags.push_back(FooCpp);
 
   // Clang can't parse command args in that case, but we shouldn't crash.
)cpp";
   std::vector<RequestStats> ReqStats;
   ReqStats.reserve(FilesCount);
   for (unsigned FileIndex = 0; FileIndex < FilesCount; ++FileIndex)
     ReqStats.emplace_back();
 
   TestDiagConsumer DiagConsumer;
   {
     MockCompilationDatabase CDB;
-    ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &DiagConsumer);
+    FormatProvider Format =
+        getClangFormatProvider(FS, format::DefaultFallbackStyle);
+    ClangdServer::Options ServerOpts = ClangdServer::optsForTest();
+    ServerOpts.ClangFormatProvider = Format;
+
+    ClangdServer Server(CDB, FS, ServerOpts, &DiagConsumer);
 
     // Prepare some random distributions for the test.
     std::random_device RandGen;
 
     std::uniform_int_distribution<unsigned> FileIndexDist(0, FilesCount - 1);
     // Pass a text that contains compiler errors to addDocument in about 20% of
     // all requests.
     std::bernoulli_distribution ShouldHaveErrorsDist(0.2);
)cpp";
   ASSERT_TRUE(Server.blockUntilIdleForTest()) << "Waiting for diagnostics";
   ASSERT_EQ(DiagConsumer.Count, 2); // Sanity check - we actually ran both?
 }
 
 TEST(ClangdServerTest, FormatCode) {
   MockFS FS;
   ErrorCheckingCallbacks DiagConsumer;
   MockCompilationDatabase CDB;
-  ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &DiagConsumer);
+  FormatProvider Format =
+      getClangFormatProvider(FS, format::DefaultFallbackStyle);
+  ClangdServer::Options ServerOpts = ClangdServer::optsForTest();
+  ServerOpts.ClangFormatProvider = Format;
+
+  ClangdServer Server(CDB, FS, ServerOpts, &DiagConsumer);
 
   auto Path = testPath("foo.cpp");
   std::string Code = R"cpp(
 #include "x.h"
 #include "y.h"
 
 void f(  )  {}
 )cpp";
)cpp";
   EXPECT_TRUE(static_cast<bool>(Changed));
   EXPECT_EQ(Expected, *Changed);
 }
 
 TEST(ClangdServerTest, ChangedHeaderFromISystem) {
   MockFS FS;
   ErrorCheckingCallbacks DiagConsumer;
   MockCompilationDatabase CDB;
-  ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &DiagConsumer);
+  FormatProvider Format =
+      getClangFormatProvider(FS, format::DefaultFallbackStyle);
+  ClangdServer::Options ServerOpts = ClangdServer::optsForTest();
+  ServerOpts.ClangFormatProvider = Format;
+
+  ClangdServer Server(CDB, FS, ServerOpts, &DiagConsumer);
 
   auto SourcePath = testPath("source/foo.cpp");
   auto HeaderPath = testPath("headers/foo.h");
   FS.Files[HeaderPath] = "struct X { int bar; };";
   Annotations Code(R"cpp(
     #include "foo.h"
 
     int main() {
IntrusiveRefCntPtr<llvm::vfs::FileSystem> viewImpl() const override {
           new StatRecordingVFS(buildTestFS(Files), CountStats));
     }
   };
 
   llvm::StringMap<unsigned> CountStats;
   StatRecordingFS FS(CountStats);
   ErrorCheckingCallbacks DiagConsumer;
   MockCompilationDatabase CDB;
-  ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &DiagConsumer);
+  FormatProvider Format =
+      getClangFormatProvider(FS, format::DefaultFallbackStyle);
+  ClangdServer::Options ServerOpts = ClangdServer::optsForTest();
+  ServerOpts.ClangFormatProvider = Format;
+
+  ClangdServer Server(CDB, FS, ServerOpts, &DiagConsumer);
 
   auto SourcePath = testPath("foo.cpp");
   auto HeaderPath = testPath("foo.h");
   FS.Files[HeaderPath] = "struct TestSym {};";
   Annotations Code(R"cpp(
     #include "foo.h"
 
     int main() {
EXPECT_THAT(Completions,
               ElementsAre(Field(&CodeCompletion::Name, "TestSym")));
 }
 #endif
 
 TEST(ClangdServerTest, FallbackWhenPreambleIsNotReady) {
   MockFS FS;
   ErrorCheckingCallbacks DiagConsumer;
   MockCompilationDatabase CDB;
-  ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &DiagConsumer);
+  FormatProvider Format =
+      getClangFormatProvider(FS, format::DefaultFallbackStyle);
+  ClangdServer::Options ServerOpts = ClangdServer::optsForTest();
+  ServerOpts.ClangFormatProvider = Format;
+
+  ClangdServer Server(CDB, FS, ServerOpts, &DiagConsumer);
 
   auto FooCpp = testPath("foo.cpp");
   Annotations Code(R"cpp(
     namespace ns { int xyz; }
     using namespace ns;
     int main() {
        xy^
     })cpp");
public:
     std::vector<std::string> ExtraClangFlags;
 
   private:
     Notification &CanReturnCommand;
   };
 
   Notification CanReturnCommand;
   DelayedCompilationDatabase CDB(CanReturnCommand);
-  ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &DiagConsumer);
+  FormatProvider Format =
+      getClangFormatProvider(FS, format::DefaultFallbackStyle);
+  ClangdServer::Options ServerOpts = ClangdServer::optsForTest();
+  ServerOpts.ClangFormatProvider = Format;
+
+  ClangdServer Server(CDB, FS, ServerOpts, &DiagConsumer);
 
   auto FooCpp = testPath("foo.cpp");
   Annotations Code(R"cpp(
     namespace ns { int xyz; }
     using namespace ns;
     int main() {
        xy^
     })cpp");

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

 //===-- CodeCompleteTests.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 "ClangdServer.h"
 #include "CodeComplete.h"
 #include "Compiler.h"
+#include "FormatProvider.h"
 #include "Matchers.h"
 #include "Protocol.h"
 #include "Quality.h"
 #include "SourceCode.h"
 #include "SyncAPI.h"
 #include "TestFS.h"
 #include "TestIndex.h"
 #include "TestTU.h"
CodeCompleteResult completions(llvm::StringRef Text,
   return completions(TU, Test.point(), std::move(IndexSymbols),
                      std::move(Opts));
 }
 
 // Runs code completion without the clang parser.
 CodeCompleteResult completionsNoCompile(llvm::StringRef Text,
                                         std::vector<Symbol> IndexSymbols = {},
                                         clangd::CodeCompleteOptions Opts = {},
-                                        PathRef FilePath = "foo.cpp") {
+                                        PathRef FilePath = "/foo.cpp") {
   std::unique_ptr<SymbolIndex> OverrideIndex;
   if (!IndexSymbols.empty()) {
     assert(!Opts.Index && "both Index and IndexSymbols given!");
     OverrideIndex = memIndex(std::move(IndexSymbols));
     Opts.Index = OverrideIndex.get();
   }
 
   MockFS FS;
+  FormatProvider Format =
+      getClangFormatProvider(FS, format::DefaultFallbackStyle);
   Annotations Test(Text);
   ParseInputs ParseInput{tooling::CompileCommand(), &FS, Test.code().str()};
+  ParseInput.ClangFormatProvider = Format;
   return codeComplete(FilePath, Test.point(), /*Preamble=*/nullptr, ParseInput,
                       Opts);
 }
 
 Symbol withReferences(int N, Symbol S) {
   S.References = N;
   return S;
 }
TEST(CompletionTest, CompletionRecoveryASTType) {
   EXPECT_THAT(Results, ElementsAre(Named("member")));
 }
 
 TEST(CompletionTest, DynamicIndexIncludeInsertion) {
   MockFS FS;
   MockCompilationDatabase CDB;
   ClangdServer::Options Opts = ClangdServer::optsForTest();
   Opts.BuildDynamicSymbolIndex = true;
+  FormatProvider Format =
+      getClangFormatProvider(FS, format::DefaultFallbackStyle);
+  Opts.ClangFormatProvider = Format;
   ClangdServer Server(CDB, FS, Opts);
 
   FS.Files[testPath("foo_header.h")] = R"cpp(
     #pragma once
     struct Foo {
        // Member doc
        int foo();
     };
EXPECT_THAT(CompletionList.Completions,
                                 InsertInclude())));
 }
 
 TEST(CompletionTest, DynamicIndexMultiFile) {
   MockFS FS;
   MockCompilationDatabase CDB;
   auto Opts = ClangdServer::optsForTest();
   Opts.BuildDynamicSymbolIndex = true;
+  FormatProvider Format =
+      getClangFormatProvider(FS, format::DefaultFallbackStyle);
+  Opts.ClangFormatProvider = Format;
   ClangdServer Server(CDB, FS, Opts);
 
   FS.Files[testPath("foo.h")] = R"cpp(
       namespace ns { class XYZ {}; void foo(int x) {} }
   )cpp";
   runAddDocument(Server, testPath("foo.cpp"), R"cpp(
       #include "foo.h"
   )cpp");

 }
 
 TEST(CompletionTest, CommentsFromSystemHeaders) {
   MockFS FS;
   MockCompilationDatabase CDB;
 
   auto Opts = ClangdServer::optsForTest();
   Opts.BuildDynamicSymbolIndex = true;
+  FormatProvider Format =
+      getClangFormatProvider(FS, format::DefaultFallbackStyle);
+  Opts.ClangFormatProvider = Format;
 
   ClangdServer Server(CDB, FS, Opts);
 
   FS.Files[testPath("foo.h")] = R"cpp(
     #pragma GCC system_header
 
     // This comment should be retained!
     int foo();
TEST(CompletionTest, DocumentationFromChangedFileCrash) {
   auto FooCpp = testPath("foo.cpp");
   FS.Files[FooH] = R"cpp(
     // this is my documentation comment.
     int func();
   )cpp";
   FS.Files[FooCpp] = "";
 
   MockCompilationDatabase CDB;
-  ClangdServer Server(CDB, FS, ClangdServer::optsForTest());
+  ClangdServer::Options ServerOpts = ClangdServer::optsForTest();
+  FormatProvider Format =
+      getClangFormatProvider(FS, format::DefaultFallbackStyle);
+  ServerOpts.ClangFormatProvider = Format;
+  ClangdServer Server(CDB, FS, ServerOpts);
 
   Annotations Source(R"cpp(
     #include "foo.h"
     int func() {
       // This makes sure we have func from header in the AST.
     }
     int a = fun^
   )cpp");

 
 TEST(CompletionTest, CompleteOnInvalidLine) {
   auto FooCpp = testPath("foo.cpp");
 
   MockCompilationDatabase CDB;
   MockFS FS;
   FS.Files[FooCpp] = "// empty file";
 
-  ClangdServer Server(CDB, FS, ClangdServer::optsForTest());
+  ClangdServer::Options ServerOpts = ClangdServer::optsForTest();
+  FormatProvider Format =
+      getClangFormatProvider(FS, format::DefaultFallbackStyle);
+  ServerOpts.ClangFormatProvider = Format;
+  ClangdServer Server(CDB, FS, ServerOpts);
   // Run completion outside the file range.
   Position Pos;
   Pos.line = 100;
   Pos.character = 0;
   EXPECT_THAT_EXPECTED(
       runCodeComplete(Server, FooCpp, Pos, clangd::CodeCompleteOptions()),
       Failed());
 }
EXPECT_THAT(
           AllOf(Sig("foo([[int]], [[int]]) -> int"), SigDoc("Doc from sema"))));
 }
 
 TEST(SignatureHelpTest, DynamicIndexDocumentation) {
   MockFS FS;
   MockCompilationDatabase CDB;
   ClangdServer::Options Opts = ClangdServer::optsForTest();
   Opts.BuildDynamicSymbolIndex = true;
+  FormatProvider Format =
+      getClangFormatProvider(FS, format::DefaultFallbackStyle);
+  Opts.ClangFormatProvider = Format;
   ClangdServer Server(CDB, FS, Opts);
 
   FS.Files[testPath("foo.h")] = R"cpp(
     struct Foo {
        // Member doc
        int foo();
     };
   )cpp";
for (llvm::StringRef Case : {
     EXPECT_EQ(WantName, Prefix.Name) << Case;
     EXPECT_EQ(WantName.begin(), Prefix.Name.begin()) << Case;
   }
 }
 
 TEST(CompletionTest, EnableSpeculativeIndexRequest) {
   MockFS FS;
   MockCompilationDatabase CDB;
-  ClangdServer Server(CDB, FS, ClangdServer::optsForTest());
+  ClangdServer::Options ServerOpts = ClangdServer::optsForTest();
+  FormatProvider Format =
+      getClangFormatProvider(FS, format::DefaultFallbackStyle);
+  ServerOpts.ClangFormatProvider = Format;
+  ClangdServer Server(CDB, FS, ServerOpts);
 
   auto File = testPath("foo.cpp");
   Annotations Test(R"cpp(
       namespace ns1 { int abc; }
       namespace ns2 { int abc; }
       void f() { ns1::ab$1^; ns1::ab$2^; }
       void f2() { ns2::ab$3^; }
   )cpp");

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

for (const auto &Case : Cases) {
     Annotations T(Case.Code);
     TestTU TU = TestTU::withCode(T.code());
     TU.ExtraArgs.push_back("-std=c++17");
     // Types might be different depending on the target triplet, we chose a
     // fixed one to make sure tests passes on different platform.
     TU.ExtraArgs.push_back("--target=x86_64-pc-linux-gnu");
     auto AST = TU.build();
 
-    auto H = getHover(AST, T.point(), format::getLLVMStyle(), nullptr);
+    auto H = getHover(
+        AST, T.point(),
+        std::make_shared<format::FormatStyle>(format::getLLVMStyle()), nullptr);
     ASSERT_TRUE(H);
     HoverInfo Expected;
     Expected.SymRange = T.range();
     Case.ExpectedBuilder(Expected);
 
     EXPECT_EQ(H->NamespaceScope, Expected.NamespaceScope);
     EXPECT_EQ(H->LocalScope, Expected.LocalScope);
     EXPECT_EQ(H->Name, Expected.Name);
)cpp";
   for (const auto &Test : Tests) {
     SCOPED_TRACE(Test.Code);
 
     const auto Code = (CodePrefix + Test.Code + CodeSuffix).str();
     Annotations T(Code);
     TestTU TU = TestTU::withCode(T.code());
     TU.ExtraArgs.push_back("-std=c++17");
     auto AST = TU.build();
-    auto H = getHover(AST, T.point(), format::getLLVMStyle(), nullptr);
+    auto H = getHover(
+        AST, T.point(),
+        std::make_shared<format::FormatStyle>(format::getLLVMStyle()), nullptr);
     ASSERT_TRUE(H);
     EXPECT_EQ(H->CallPassType->PassBy, Test.PassBy);
     EXPECT_EQ(H->CallPassType->Converted, Test.Converted);
   }
 }
 
 TEST(Hover, NoHover) {
   llvm::StringRef Tests[] = {
TEST(Hover, NoHover) {
 
   for (const auto &Test : Tests) {
     SCOPED_TRACE(Test);
 
     Annotations T(Test);
     TestTU TU = TestTU::withCode(T.code());
     TU.ExtraArgs.push_back("-std=c++17");
     auto AST = TU.build();
-    auto H = getHover(AST, T.point(), format::getLLVMStyle(), nullptr);
+    auto H = getHover(
+        AST, T.point(),
+        std::make_shared<format::FormatStyle>(format::getLLVMStyle()), nullptr);
     ASSERT_FALSE(H);
   }
 }
 
 TEST(Hover, All) {
   struct {
     const char *const Code;
     const std::function<void(HoverInfo &)> ExpectedBuilder;
for (const auto &Case : Cases) {
     TU.ExtraArgs.push_back("-xobjective-c++");
 
     TU.ExtraArgs.push_back("-Wno-gnu-designator");
     // Types might be different depending on the target triplet, we chose a
     // fixed one to make sure tests passes on different platform.
     TU.ExtraArgs.push_back("--target=x86_64-pc-linux-gnu");
     auto AST = TU.build();
 
-    auto H = getHover(AST, T.point(), format::getLLVMStyle(), Index.get());
+    auto H =
+        getHover(AST, T.point(),
+                 std::make_shared<format::FormatStyle>(format::getLLVMStyle()),
+                 Index.get());
     ASSERT_TRUE(H);
     HoverInfo Expected;
     Expected.SymRange = T.range();
     Case.ExpectedBuilder(Expected);
 
     SCOPED_TRACE(H->present().asPlainText());
     EXPECT_EQ(H->NamespaceScope, Expected.NamespaceScope);
     EXPECT_EQ(H->LocalScope, Expected.LocalScope);
TEST(Hover, DocsFromIndex) {
   IndexSym.ID = getSymbolID(&findDecl(AST, "X"));
   IndexSym.Documentation = "comment from index";
   SymbolSlab::Builder Symbols;
   Symbols.insert(IndexSym);
   auto Index =
       MemIndex::build(std::move(Symbols).build(), RefSlab(), RelationSlab());
 
   for (const auto &P : T.points()) {
-    auto H = getHover(AST, P, format::getLLVMStyle(), Index.get());
+    auto H = getHover(
+        AST, P, std::make_shared<format::FormatStyle>(format::getLLVMStyle()),
+        Index.get());
     ASSERT_TRUE(H);
     EXPECT_EQ(H->Documentation, IndexSym.Documentation);
   }
 }
 
 TEST(Hover, DocsFromAST) {
   Annotations T(R"cpp(
   // doc
   template <typename T> class X {};
   // doc
   template <typename T> void bar() {}
   // doc
   template <typename T> T baz;
   void foo() {
     au^to t = X<int>();
     X^<int>();
     b^ar<int>();
     au^to T = ba^z<X<int>>;
     ba^z<int> = 0;
   })cpp");
 
   TestTU TU = TestTU::withCode(T.code());
   auto AST = TU.build();
   for (const auto &P : T.points()) {
-    auto H = getHover(AST, P, format::getLLVMStyle(), nullptr);
+    auto H = getHover(
+        AST, P, std::make_shared<format::FormatStyle>(format::getLLVMStyle()),
+        nullptr);
     ASSERT_TRUE(H);
     EXPECT_EQ(H->Documentation, "doc");
   }
 }
 
 TEST(Hover, DocsFromMostSpecial) {
   Annotations T(R"cpp(
   // doc1
   template <typename T> class $doc1^X {};
   // doc2
   template <> class $doc2^X<int> {};
   // doc3
   template <typename T> class $doc3^X<T*> {};
   void foo() {
     X$doc1^<char>();
     X$doc2^<int>();
     X$doc3^<int*>();
   })cpp");
 
   TestTU TU = TestTU::withCode(T.code());
   auto AST = TU.build();
   for (auto Comment : {"doc1", "doc2", "doc3"}) {
     for (const auto &P : T.points(Comment)) {
-      auto H = getHover(AST, P, format::getLLVMStyle(), nullptr);
+      auto H = getHover(
+          AST, P, std::make_shared<format::FormatStyle>(format::getLLVMStyle()),
+          nullptr);
       ASSERT_TRUE(H);
       EXPECT_EQ(H->Documentation, Comment);
     }
   }
 }
 
 TEST(Hover, Present) {
   struct {

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

TEST(PreamblePatchTest, LocateMacroAtDeletion) {
     const auto &SM = AST->getSourceManager();
     auto *MacroTok = AST->getTokens().spelledTokenAt(
         SM.getComposedLoc(SM.getMainFileID(), Modified.point()));
     ASSERT_TRUE(MacroTok);
 
     auto FoundMacro = locateMacroAt(*MacroTok, AST->getPreprocessor());
     ASSERT_TRUE(FoundMacro);
     EXPECT_THAT(FoundMacro->Name, "FOO");
-    auto HI =
-        getHover(*AST, offsetToPosition(Modified.code(), Modified.point()),
-                 format::getLLVMStyle(), nullptr);
+    auto HI = getHover(
+        *AST, offsetToPosition(Modified.code(), Modified.point()),
+        std::make_shared<format::FormatStyle>(format::getLLVMStyle()), nullptr);
     ASSERT_TRUE(HI);
     EXPECT_THAT(HI->Definition, testing::IsEmpty());
   }
 
   {
     // Offset is valid, but underlying text is different.
     llvm::StringLiteral Baseline = "#define FOO";
     Annotations Modified(R"cpp(#define BAR
     ^FOO")cpp");
 
     auto AST = createPatchedAST(Baseline, Modified.code());
     ASSERT_TRUE(AST);
 
-    auto HI = getHover(*AST, Modified.point(), format::getLLVMStyle(), nullptr);
+    auto HI = getHover(
+        *AST, Modified.point(),
+        std::make_shared<format::FormatStyle>(format::getLLVMStyle()), nullptr);
     ASSERT_TRUE(HI);
     EXPECT_THAT(HI->Definition, "#define BAR");
   }
 }
 
 TEST(PreamblePatchTest, RefsToMacros) {
   struct {
     const char *const Baseline;

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

 //
 //===---------------------------------------------------------------------===//
 
 #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 "FormatProvider.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>
 #include <utility>
struct TestTU {
 
   // Name and contents of each file.
   llvm::StringMap<std::string> AdditionalFiles;
 
   // Extra arguments for the compiler invocation.
   std::vector<std::string> ExtraArgs;
 
   TidyProvider ClangTidyProvider = {};
+
+  mutable FormatProvider ClangFormatProvider = {};
   // 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

 //===--- TestTU.cpp - Scratch source files for testing --------------------===//
 //
 // 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 "TestTU.h"
 #include "Compiler.h"
 #include "Diagnostics.h"
+#include "FormatProvider.h"
 #include "TestFS.h"
 #include "index/FileIndex.h"
 #include "index/MemIndex.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Frontend/Utils.h"
 #include "llvm/ADT/ScopeExit.h"
ParseInputs TestTU::inputs(MockFS &FS) const {
   Inputs.CompileCommand.Directory = testRoot();
   Inputs.Contents = Code;
   if (OverlayRealFileSystemForModules)
     FS.OverlayRealFileSystemForModules = true;
   Inputs.TFS = &FS;
   Inputs.Opts = ParseOptions();
   if (ClangTidyProvider)
     Inputs.ClangTidyProvider = ClangTidyProvider;
+  ClangFormatProvider =
+      getClangFormatProvider(FS, format::DefaultFallbackStyle);
+  Inputs.ClangFormatProvider = ClangFormatProvider;
   Inputs.Index = ExternalIndex;
   if (Inputs.Index)
     Inputs.Opts.SuggestMissingIncludes = true;
   return Inputs;
 }
 
 void initializeModuleCache(CompilerInvocation &CI) {
   llvm::SmallString<128> ModuleCachePath;