[clangd] Pass parameters to config apply functions

[kadircet]

Summary

This will enable some fragments to apply their features selectively.

Depends on D90270.

clang-tools-extra/clangd/ConfigCompile.cpp

struct CompiledFragmentImpl {
   // The independent conditions to check before using settings from this config.
   // The following fragment has *two* conditions:
   //   If: { Platform: [mac, linux], PathMatch: foo/.* }
   // All of them must be satisfied: the platform and path conditions are ANDed.
   // The OR logic for the platform condition is implemented inside the function.
   std::vector<llvm::unique_function<bool(const Params &) const>> Conditions;
   // Mutations that this fragment will apply to the configuration.
   // These are invoked only if the conditions are satisfied.
-  std::vector<llvm::unique_function<void(Config &) const>> Apply;
+  std::vector<llvm::unique_function<void(const Params &, Config &) const>>
+      Apply;
 
   bool operator()(const Params &P, Config &C) const {
     for (const auto &C : Conditions) {
       if (!C(P)) {
         dlog("Config fragment {0}: condition not met", this);
         return false;
       }
     }
     dlog("Config fragment {0}: applying {1} rules", this, Apply.size());
     for (const auto &A : Apply)
-      A(C);
+      A(P, C);
     return true;
   }
 };
 
 // Wrapper around condition compile() functions to reduce arg-passing.
 struct FragmentCompiler {
   FragmentCompiler(CompiledFragmentImpl &Out, DiagnosticCallback D,
                    llvm::SourceMgr *SM)
struct FragmentCompiler {
   }
 
   void compile(Fragment::CompileFlagsBlock &&F) {
     if (!F.Remove.empty()) {
       auto Remove = std::make_shared<ArgStripper>();
       for (auto &A : F.Remove)
         Remove->strip(*A);
       Out.Apply.push_back([Remove(std::shared_ptr<const ArgStripper>(
-                              std::move(Remove)))](Config &C) {
+                              std::move(Remove)))](const Params &, Config &C) {
         C.CompileFlags.Edits.push_back(
             [Remove](std::vector<std::string> &Args) {
               Remove->process(Args);
             });
       });
     }
 
     if (!F.Add.empty()) {
       std::vector<std::string> Add;
       for (auto &A : F.Add)
         Add.push_back(std::move(*A));
-      Out.Apply.push_back([Add(std::move(Add))](Config &C) {
+      Out.Apply.push_back([Add(std::move(Add))](const Params &, Config &C) {
         C.CompileFlags.Edits.push_back([Add](std::vector<std::string> &Args) {
           Args.insert(Args.end(), Add.begin(), Add.end());
         });
       });
     }
   }
 
   void compile(Fragment::IndexBlock &&F) {
     if (F.Background) {
       if (auto Val = compileEnum<Config::BackgroundPolicy>("Background",
                                                            **F.Background)
                          .map("Build", Config::BackgroundPolicy::Build)
                          .map("Skip", Config::BackgroundPolicy::Skip)
                          .value())
-        Out.Apply.push_back([Val](Config &C) { C.Index.Background = *Val; });
+        Out.Apply.push_back(
+            [Val](const Params &, Config &C) { C.Index.Background = *Val; });
     }
   }
 
   void compile(Fragment::StyleBlock &&F) {
     if (!F.FullyQualifiedNamespaces.empty()) {
       std::vector<std::string> FullyQualifiedNamespaces;
       for (auto &N : F.FullyQualifiedNamespaces) {
         // Normalize the data by dropping both leading and trailing ::
         StringRef Namespace(*N);
         Namespace.consume_front("::");
         Namespace.consume_back("::");
         FullyQualifiedNamespaces.push_back(Namespace.str());
       }
       Out.Apply.push_back([FullyQualifiedNamespaces(
-                              std::move(FullyQualifiedNamespaces))](Config &C) {
+                              std::move(FullyQualifiedNamespaces))](
+                              const Params &, Config &C) {
         C.Style.FullyQualifiedNamespaces.insert(
             C.Style.FullyQualifiedNamespaces.begin(),
             FullyQualifiedNamespaces.begin(), FullyQualifiedNamespaces.end());
       });
     }
   }
 
   constexpr static llvm::SourceMgr::DiagKind Error = llvm::SourceMgr::DK_Error;