[clangd] Add fallbackFlags initialization extension.

[sammccall]

Summary

This allows customizing the flags used when no compile database is
available. It addresses some uses of the old extraFlags extension.

[ilya-biryukov]

This feels like a configuration option that might be changed in the course of running clangd.
Are there any strong reasons to make it work only upon initialization? My guess is that it keeps the code simpler, but if we approached it purely from the UX perspective, changing it while running clangd seems to make sense. WDYT?

[sammccall]

In D53688#1275586, @ilya-biryukov wrote:

This feels like a configuration option that might be changed in the course of running clangd.
Are there any strong reasons to make it work only upon initialization? My guess is that it keeps the code simpler, but if we approached it purely from the UX perspective, changing it while running clangd seems to make sense. WDYT?

It's hard to reason about UX outside of concrete tools - the only use I know of (atom-ide-cpp) never needs to change it, and I'm having a hard time imagining when you'd want to change this, but still have it global to clangd. (I can imagine it being scoped to a subtree a la compile commands, but that's a whole different thing..)

And yes, there are significant implementation concerns with making it mutable: ultimately we're going to want to have a CDB -> clangd compile command invalidation mechanism that can drive reindexing, reloading diagnostics etc. If the fallback command is mutable, such a mechanism needs to handle wildcards (or accept that this is a case it will get wrong, there are others).

[ilya-biryukov]

In D53688#1275793, @sammccall wrote:

It's hard to reason about UX outside of concrete tools - the only use I know of (atom-ide-cpp) never needs to change it, and I'm having a hard time imagining when you'd want to change this, but still have it global to clangd. (I can imagine it being scoped to a subtree a la compile commands, but that's a whole different thing..)

And yes, there are significant implementation concerns with making it mutable: ultimately we're going to want to have a CDB -> clangd compile command invalidation mechanism that can drive reindexing, reloading diagnostics etc. If the fallback command is mutable, such a mechanism needs to handle wildcards (or accept that this is a case it will get wrong, there are others).

Whatever the tool is, the choices for it are to allow changing some configuration at the init time or while running. Just realized that we're removing the compileCommandsDir for that specific reason, sorry for being out of context here.

The atom-ide-cpp use case is somewhat special anyway, since it ends up reading a file in a format we already support, albeit having a different name from the one clangd would expect (correct me if I'm wrong on this one).
In the long-run it seems better to communicate to the users that they should rename the file to make clangd work rather than add this (a bit different and more powerful?) extension to clangd.

We're aiming to allow users change their compile flags while running clangd anyway (assuming we're gonna get the file watches in at some point), so, again, in the long-run I don't see why that would complicate things. But sympathetic to keeping the code simpler anyway.

LGTM

clangd/ClangdLSPServer.cpp

void ClangdLSPServer::onInitialize(const InitializeParams &Params,
   if (Server)
     return Reply(make_error<LSPError>("server already initialized",
                                       ErrorCode::InvalidRequest));
   if (const auto &Dir = Params.initializationOptions.compilationDatabasePath)
     CompileCommandsDir = Dir;
   if (UseDirBasedCDB)
     BaseCDB = llvm::make_unique<DirectoryBasedGlobalCompilationDatabase>(
         CompileCommandsDir);
-  CDB.emplace(BaseCDB.get());
+  CDB.emplace(BaseCDB.get(), Params.initializationOptions.fallbackFlags);
   Server.emplace(*CDB, FSProvider, static_cast<DiagnosticsConsumer &>(*this),
                  ClangdServerOpts);
   applyConfiguration(Params.initializationOptions.ConfigSettings);
 
   CCOpts.EnableSnippets = Params.capabilities.CompletionSnippets;
   DiagOpts.EmbedFixesInDiagnostics = Params.capabilities.DiagnosticFixes;
   DiagOpts.SendDiagnosticCategory = Params.capabilities.DiagnosticCategory;
   if (Params.capabilities.WorkspaceSymbolKinds)
for (auto &Entry : Settings.compilationDatabaseChanges) {
     /// The opened files need to be reparsed only when some existing
     /// entries are changed.
     PathRef File = Entry.first;
     auto Old = CDB->getCompileCommand(File);
     auto New =
         tooling::CompileCommand(std::move(Entry.second.workingDirectory), File,
                                 std::move(Entry.second.compilationCommand),
                                 /*Output=*/"");
-    if (Old != New)
+    if (Old != New) {
       CDB->setCompileCommand(File, std::move(New));
       ShouldReparseOpenFiles = true;
     }
+  }
   if (ShouldReparseOpenFiles)
     reparseOpenedFiles();
 }
 
 // FIXME: This function needs to be properly tested.
 void ClangdLSPServer::onChangeConfiguration(
     const DidChangeConfigurationParams &Params) {
   applyConfiguration(Params.settings);

clangd/Protocol.h

 /// Clangd extension: parameters configurable at `initialize` time.
 /// LSP defines this type as `any`.
 struct InitializationOptions {
   // What we can change throught the didChangeConfiguration request, we can
   // also set through the initialize request (initializationOptions field).
   ConfigurationSettings ConfigSettings;
 
   llvm::Optional<std::string> compilationDatabasePath;
+  // Additional flags to be included in the "fallback command" used when
+  // the compilation database doesn't describe an opened file.
+  // The command used will be approximately `clang $FILE $fallbackFlags`.
+  std::vector<std::string> fallbackFlags;
 };
 bool fromJSON(const llvm::json::Value &, InitializationOptions &);
 
 struct InitializeParams {
   /// The process Id of the parent process that started
   /// the server. Is null if the process has not been started by another
   /// process. If the parent process is not alive then the server should exit
   /// (see exit notification) its process.

clangd/Protocol.cpp

 
 bool fromJSON(const json::Value &Params, InitializationOptions &Opts) {
   json::ObjectMapper O(Params);
   if (!O)
     return true; // 'any' type in LSP.
 
   fromJSON(Params, Opts.ConfigSettings);
   O.map("compilationDatabasePath", Opts.compilationDatabasePath);
+  O.map("fallbackFlags", Opts.fallbackFlags);
   return true;
 }
 
 bool fromJSON(const json::Value &Params, ReferenceParams &R) {
   TextDocumentPositionParams &Base = R;
   return fromJSON(Params, Base);
 }
 
 } // namespace clangd
 } // namespace clang