[clangd] Add config support for ResourceDir

[hokein]

The code looks good, but I don't have a very strong opinion of making the resource-dir as a config option. Do we have a motivation (e.g. user request?) now?

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

381

looks like removing the eof is an accident change?

clang-tools-extra/clangd/CompileCommands.cpp

void CommandMangler::adjust(std::vector<std::string> &Cmd) const {
   // requested on the command line.
   Cmd = tooling::getClangStripDependencyFileAdjuster()(Cmd, "");
   // Strip plugin related command line arguments. Clangd does
   // not support plugins currently. Therefore it breaks if
   // compiler tries to load plugins.
   Cmd = tooling::getStripPluginsAdjuster()(Cmd, "");
   Cmd = tooling::getClangSyntaxOnlyAdjuster()(Cmd, "");
 
-  if (ResourceDir && !Has("-resource-dir"))
-    Cmd.push_back(("-resource-dir=" + *ResourceDir));
+  if (!Has("-resource-dir")) {
+    // Prefer specified resource-dir over the one in config.
+    auto RDir =
+        ResourceDir ? *ResourceDir : Config::current().CompileFlags.ResourceDir;
+    if (!RDir.empty())
+      Cmd.push_back(("-resource-dir=" + RDir));
+  }
 
   // Don't set `-isysroot` if it is already set or if `--sysroot` is set.
   // `--sysroot` is a superset of the `-isysroot` argument.
   if (Sysroot && !Has("-isysroot") && !Has("--sysroot")) {
     Cmd.push_back("-isysroot");
     Cmd.push_back(*Sysroot);
   }
 
if (matchingRule(Args[Read], CurrentMode, ArgCount)) {
         Args[Write] = std::move(Args[Read]);
       ++Write;
     }
     ++Read;
   }
   Args.resize(Write);
 }
 
-
 std::string printArgv(llvm::ArrayRef<llvm::StringRef> Args) {
   std::string Buf;
   llvm::raw_string_ostream OS(Buf);
   bool Sep = false;
   for (llvm::StringRef Arg : Args) {
     if (Sep)
       OS << ' ';
     Sep = true;

clang-tools-extra/clangd/Config.h

struct Config {
 
   /// Controls how the compile command for the current file is determined.
   struct {
     /// Edits to apply to the compile command, in sequence.
     std::vector<llvm::unique_function<void(std::vector<std::string> &) const>>
         Edits;
     /// Where to search for compilation databases for this file's flags.
     CDBSearchSpec CDBSearch = {CDBSearchSpec::Ancestors, llvm::None};
+    /// Directory to look for internal headers.
+    std::string ResourceDir;
   } CompileFlags;
 
   enum class BackgroundPolicy { Build, Skip };
   /// Describes an external index configuration.
   struct ExternalIndexSpec {
     enum { File, Server } Kind;
     /// This is one of:
     /// - Address of a clangd-index-server, in the form of "ip:port".

clang-tools-extra/clangd/ConfigCompile.cpp

if (F.CompilationDatabase) {
         }
       }
       if (Spec)
         Out.Apply.push_back(
             [Spec(std::move(*Spec))](const Params &, Config &C) {
               C.CompileFlags.CDBSearch = Spec;
             });
     }
+
+    if (F.ResourceDir) {
+      if (auto Path = makeAbsolute(*F.ResourceDir, "ResourceDir",
+                                   llvm::sys::path::Style::native)) {
+        Out.Apply.push_back(
+            [Path(std::move(*Path))](const Params &, Config &C) {
+              C.CompileFlags.ResourceDir = Path;
+            });
+      }
+    }
   }
 
   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)

clang-tools-extra/clangd/ConfigFragment.h

struct CompileFlagsBlock {
     std::vector<Located<std::string>> Remove;
 
     /// Directory to search for compilation database (compile_comands.json etc).
     /// Valid values are:
     /// - A single path to a directory (absolute, or relative to the fragment)
     /// - Ancestors: search all parent directories (the default)
     /// - None: do not use a compilation database, just default flags.
     llvm::Optional<Located<std::string>> CompilationDatabase;
+
+    /// Path to a directory on user's machine, that'll be used to search for
+    /// built-in headers. Relative paths may be used, if config fragment is
+    /// associated with a directory.
+    llvm::Optional<Located<std::string>> ResourceDir;
   };
   CompileFlagsBlock CompileFlags;
 
   /// Controls how clangd understands code outside the current file.
   /// clangd's indexes provide information about symbols that isn't available
   /// to clang's parser, such as incoming references.
   struct IndexBlock {
     /// Whether files are built in the background to produce a project index.

clang-tools-extra/clangd/ConfigYAML.cpp

void parse(Fragment::CompileFlagsBlock &F, Node &N) {
     });
     Dict.handle("Remove", [&](Node &N) {
       if (auto Values = scalarValues(N))
         F.Remove = std::move(*Values);
     });
     Dict.handle("CompilationDatabase", [&](Node &N) {
       F.CompilationDatabase = scalarValue(N, "CompilationDatabase");
     });
+    Dict.handle("ResourceDir", [&](Node &N) {
+      F.ResourceDir = scalarValue(N, "ResourceDir");
+    });
     Dict.parse(N);
   }
 
   void parse(Fragment::StyleBlock &F, Node &N) {
     DictParser Dict("Style", this);
     Dict.handle("FullyQualifiedNamespaces", [&](Node &N) {
       if (auto Values = scalarValues(N))
         F.FullyQualifiedNamespaces = std::move(*Values);

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

TEST(CommandMangler, Everything) {
   EXPECT_THAT(Cmd, ElementsAre(testPath("fake/clang++"), "foo.cc",
                                "-fsyntax-only",
                                "-resource-dir=" + testPath("fake/resources"),
                                "-isysroot", testPath("fake/sysroot")));
 }
 
 TEST(CommandMangler, ResourceDir) {
   auto Mangler = CommandMangler::forTests();
-  Mangler.ResourceDir = testPath("fake/resources");
+
+  // Check config works.
+  Config Cfg;
+  auto ResourceDir = testPath("config/resources");
+  Cfg.CompileFlags.ResourceDir = ResourceDir;
+  WithContextValue WithConfig(Config::Key, std::move(Cfg));
   std::vector<std::string> Cmd = {"clang++", "foo.cc"};
   Mangler.adjust(Cmd);
-  EXPECT_THAT(Cmd, Contains("-resource-dir=" + testPath("fake/resources")));
+  EXPECT_THAT(Cmd, Contains("-resource-dir=" + ResourceDir));
+
+  // Check that explicit option overrides config.
+  ResourceDir = testPath("explicit/resources");
+  Mangler.ResourceDir = ResourceDir;
+  Cmd = {"clang++", "foo.cc"};
+  Mangler.adjust(Cmd);
+  EXPECT_THAT(Cmd, Contains("-resource-dir=" + ResourceDir));
 }
 
 TEST(CommandMangler, Sysroot) {
   auto Mangler = CommandMangler::forTests();
   Mangler.Sysroot = testPath("fake/sysroot");
 
   std::vector<std::string> Cmd = {"clang++", "foo.cc"};
   Mangler.adjust(Cmd);
TEST(PrintArgvTest, All) {
   };
   const char *Expected = R"(one two "thr ee" "f\"o\"ur" "fi\\ve" $)";
   EXPECT_EQ(Expected, printArgv(Args));
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang
-

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

TEST_F(ConfigCompileTests, CompilationDatabase) {
   Frag.CompileFlags.CompilationDatabase.emplace(testPath("Something2"));
   EXPECT_TRUE(compileAndApply());
   EXPECT_EQ(Conf.CompileFlags.CDBSearch.Policy,
             Config::CDBSearchSpec::FixedDir);
   EXPECT_EQ(Conf.CompileFlags.CDBSearch.FixedCDBPath, testPath("Something2"));
   EXPECT_THAT(Diags.Diagnostics, IsEmpty());
 }
 
+TEST_F(ConfigCompileTests, ResourceDir) {
+  EXPECT_TRUE(compileAndApply());
+  EXPECT_TRUE(Conf.CompileFlags.ResourceDir.empty());
+
+  auto ResourceDir = testPath("foo");
+  Frag.CompileFlags.ResourceDir.emplace(ResourceDir);
+  EXPECT_TRUE(compileAndApply());
+  EXPECT_EQ(Conf.CompileFlags.ResourceDir, ResourceDir);
+
+  ResourceDir = "foo";
+  Frag.Source.Directory = testRoot();
+  Frag.CompileFlags.ResourceDir.emplace(ResourceDir);
+  EXPECT_TRUE(compileAndApply());
+  EXPECT_EQ(Conf.CompileFlags.ResourceDir, testPath("foo"));
+}
+
 TEST_F(ConfigCompileTests, Index) {
   Frag.Index.Background.emplace("Skip");
   EXPECT_TRUE(compileAndApply());
   EXPECT_EQ(Conf.Index.Background, Config::BackgroundPolicy::Skip);
 
   Frag = {};
   Frag.Index.Background.emplace("Foo");
   EXPECT_TRUE(compileAndApply());

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

 //===-- ConfigYAMLTests.cpp -----------------------------------------------===//
 //
 // 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 "ConfigFragment.h"
 #include "ConfigTesting.h"
 #include "Protocol.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/SMLoc.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/SourceMgr.h"
+#include "llvm/Testing/Support/SupportHelpers.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 namespace clang {
 namespace clangd {
 namespace config {
 template <typename T> void PrintTo(const Located<T> &V, std::ostream *OS) {
   *OS << ::testing::PrintToString(*V);
Index:
   ASSERT_EQ(Results.size(), 1u);
   ASSERT_TRUE(Results[0].Index.External);
   EXPECT_THAT(*Results[0].Index.External.getValue()->File, Val("foo"));
   EXPECT_THAT(*Results[0].Index.External.getValue()->MountPoint, Val("baz"));
   ASSERT_THAT(Diags.Diagnostics, IsEmpty());
   EXPECT_THAT(*Results[0].Index.External.getValue()->Server, Val("bar"));
 }
 
+TEST(ParseYAML, ResourceDir) {
+  CapturedDiags Diags;
+  Annotations YAML(R"yaml(
+CompileFlags:
+  ResourceDir: "foo")yaml");
+  auto Results =
+      Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback());
+  ASSERT_EQ(Results.size(), 1u);
+  ASSERT_THAT(Diags.Diagnostics, IsEmpty());
+  EXPECT_THAT(Results[0].CompileFlags.ResourceDir, llvm::ValueIs(Val("foo")));
+}
 } // namespace
 } // namespace config
 } // namespace clangd
 } // namespace clang