[clangd] Support include paths relative to .clangd config file

[freqmod]

Summary

This addresses the use case in https://github.com/clangd/clangd/issues/1038 where
a user wants to make a .clangd file that is applicable for several subdirectories with
relative paths to the .clangd file (instead of the individual c-files). It does this by
replacing any occurrances of ${CURRENT_FILE_PATH} with the directory of the .clangd file.

The syntax for the text to be replaced is up for discussion.

clang-tools-extra/clangd/ConfigFragment.h

private:
   T Value;
 };
 
 /// A chunk of configuration obtained from a config file, LSP, or elsewhere.
 struct Fragment {
   /// Parses fragments from a YAML file (one from each --- delimited document).
   /// Documents that contained fatal errors are omitted from the results.
   /// BufferName is used for the SourceMgr and diagnostics.
-  static std::vector<Fragment> parseYAML(llvm::StringRef YAML,
-                                         llvm::StringRef BufferName,
-                                         DiagnosticCallback);
+  /// configFilePath is used for variable replacement in the configuration if
+  /// present, otherwise it is treated as ""
+  static std::vector<Fragment>
+  parseYAML(llvm::StringRef YAML, llvm::StringRef BufferName,
+            std::optional<llvm::StringRef> configFilePath,
+            DiagnosticCallback Diags);
 
   /// Analyzes and consumes this fragment, possibly yielding more diagnostics.
   /// This always produces a usable result (errors are recovered).
   ///
   /// Typically, providers will compile a Fragment once when it's first loaded,
   /// caching the result for reuse.
   /// Like a compiled program, this is good for performance and also encourages
   /// errors to be reported early and only once.

clang-tools-extra/clangd/ConfigProvider.cpp

public:
   void get(const ThreadsafeFS &TFS, DiagnosticCallback DC,
            std::chrono::steady_clock::time_point FreshTime, bool Trusted,
            std::vector<CompiledFragment> &Out) const {
     read(
         TFS, FreshTime,
         [&](std::optional<llvm::StringRef> Data) {
           CachedValue.clear();
           if (Data)
-            for (auto &Fragment : Fragment::parseYAML(*Data, path(), DC)) {
+            for (auto &Fragment :
+                 Fragment::parseYAML(*Data, path(), Directory, DC)) {
               Fragment.Source.Directory = Directory;
               Fragment.Source.Trusted = Trusted;
               CachedValue.push_back(std::move(Fragment).compile(DC));
             }
         },
         [&]() { llvm::copy(CachedValue, std::back_inserter(Out)); });
   }
 };

clang-tools-extra/clangd/ConfigYAML.cpp

for (const auto &AllowedValue : AllowedValues) {
     } else if (EditDistance < MaxEdit) {
       Result = AllowedValue;
       MaxEdit = EditDistance;
     }
   }
   return Result;
 }
 
+// Copied from OpDefinitionsGen
+// Replaces all occurrences of `match` in `str` with `substitute`.
+static std::string replaceAllSubstrs(std::string str, const std::string &match,
+                                     const std::string &substitute) {
+  std::string::size_type scanLoc = 0, matchLoc = std::string::npos;
+  while ((matchLoc = str.find(match, scanLoc)) != std::string::npos) {
+    str = str.replace(matchLoc, match.size(), substitute);
+    scanLoc = matchLoc + substitute.size();
+  }
+  return str;
+}
+
 class Parser {
   llvm::SourceMgr &SM;
   bool HadError = false;
+  std::optional<llvm::StringRef> ConfigFilePath;
 
 public:
-  Parser(llvm::SourceMgr &SM) : SM(SM) {}
+  Parser(llvm::SourceMgr &SM, std::optional<llvm::StringRef> configFilePath)
+      : SM(SM), ConfigFilePath(configFilePath) {}
 
   // Tries to parse N into F, returning false if it failed and we couldn't
   // meaningfully recover (YAML syntax error, or hard semantic error).
   bool parse(Fragment &F, Node &N) {
     DictParser Dict("Config", this);
     Dict.handle("If", [&](Node &N) { parse(F.If, N); });
     Dict.handle("CompileFlags", [&](Node &N) { parse(F.CompileFlags, N); });
     Dict.handle("Index", [&](Node &N) { parse(F.Index, N); });
void warnUnknownKeys(llvm::ArrayRef<Located<std::string>> UnknownKeys,
                          UnknownKey.Range);
         else
           Outer->warning("Unknown " + Description + " key '" + *UnknownKey +
                              "'",
                          UnknownKey.Range);
     }
   };
 
+  std::string keywordReplace(std::string value) {
+    return replaceAllSubstrs(
+        value, "${CURRENT_FILE_PATH}",
+        this->ConfigFilePath.value_or(llvm::StringRef()).str());
+  }
   // Try to parse a single scalar value from the node, warn on failure.
   std::optional<Located<std::string>> scalarValue(Node &N,
                                                   llvm::StringRef Desc) {
     llvm::SmallString<256> Buf;
-    if (auto *S = llvm::dyn_cast<ScalarNode>(&N))
-      return Located<std::string>(S->getValue(Buf).str(), N.getSourceRange());
-    if (auto *BS = llvm::dyn_cast<BlockScalarNode>(&N))
-      return Located<std::string>(BS->getValue().str(), N.getSourceRange());
+    if (auto *S = llvm::dyn_cast<ScalarNode>(&N)) {
+      return Located<std::string>(keywordReplace(S->getValue(Buf).str()),
+                                  N.getSourceRange());
+    }
+    if (auto *BS = llvm::dyn_cast<BlockScalarNode>(&N)) {
+      return Located<std::string>(keywordReplace(BS->getValue().str()),
+                                  N.getSourceRange());
+    }
     warning(Desc + " should be scalar", N);
     return std::nullopt;
   }
 
   std::optional<Located<bool>> boolValue(Node &N, llvm::StringRef Desc) {
     if (auto Scalar = scalarValue(N, Desc)) {
       if (auto Bool = llvm::yaml::parseBool(**Scalar))
         return Located<bool>(*Bool, Scalar->Range);
private:
   }
   void warning(const llvm::Twine &Msg, const Node &N) {
     return warning(Msg, N.getSourceRange());
   }
 };
 
 } // namespace
 
-std::vector<Fragment> Fragment::parseYAML(llvm::StringRef YAML,
-                                          llvm::StringRef BufferName,
-                                          DiagnosticCallback Diags) {
+std::vector<Fragment>
+Fragment::parseYAML(llvm::StringRef YAML, llvm::StringRef BufferName,
+                    std::optional<llvm::StringRef> configFilePath,
   // The YAML document may contain multiple conditional fragments.
   // The SourceManager is shared for all of them.
   auto SM = std::make_shared<llvm::SourceMgr>();
   auto Buf = llvm::MemoryBuffer::getMemBufferCopy(YAML, BufferName);
   // Adapt DiagnosticCallback to function-pointer interface.
   // Callback receives both errors we emit and those from the YAML parser.
   SM->setDiagHandler(
       [](const llvm::SMDiagnostic &Diag, void *Ctx) {
         (*reinterpret_cast<DiagnosticCallback *>(Ctx))(Diag);
       },
       &Diags);
   std::vector<Fragment> Result;
   for (auto &Doc : llvm::yaml::Stream(*Buf, *SM)) {
     if (Node *N = Doc.getRoot()) {
       Fragment Fragment;
       Fragment.Source.Manager = SM;
       Fragment.Source.Location = N->getSourceRange().Start;
       SM->PrintMessage(Fragment.Source.Location, llvm::SourceMgr::DK_Note,
                        "Parsing config fragment");
-      if (Parser(*SM).parse(Fragment, *N))
+      if (Parser(*SM, configFilePath).parse(Fragment, *N))
         Result.push_back(std::move(Fragment));
     }
   }
   SM->PrintMessage(SM->FindLocForLineAndColumn(SM->getMainFileID(), 0, 0),
                    llvm::SourceMgr::DK_Note,
                    "Parsed " + llvm::Twine(Result.size()) +
                        " fragments from file");
   // Hack: stash the buffer in the SourceMgr to keep it alive.
   // SM has two entries: "main" non-owning buffer, and ignored owning buffer.
   SM->AddNewSourceBuffer(std::move(Buf), llvm::SMLoc());
   return Result;
 }
 
 } // namespace config
 } // namespace clangd
 } // namespace clang

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

 ---
 Diagnostics:
   ClangTidy:
     CheckOptions:
       IgnoreMacros: true
       example-check.ExampleOption: 0
   UnusedIncludes: Strict
   )yaml";
-  auto Results = Fragment::parseYAML(YAML, "config.yaml", Diags.callback());
+  auto Results = Fragment::parseYAML(YAML, "config.yaml", "", Diags.callback());
   EXPECT_THAT(Diags.Diagnostics, IsEmpty());
   EXPECT_THAT(Diags.Files, ElementsAre("config.yaml"));
   ASSERT_EQ(Results.size(), 4u);
   EXPECT_FALSE(Results[0].If.HasUnrecognizedCondition);
   EXPECT_THAT(Results[0].If.PathMatch, ElementsAre(val("abc")));
   EXPECT_THAT(Results[0].CompileFlags.Add, ElementsAre(val("foo"), val("bar")));
 
   EXPECT_THAT(Results[1].CompileFlags.Add, ElementsAre(val("b\naz\n")));
 
   ASSERT_TRUE(Results[2].Index.Background);
   EXPECT_EQ("Skip", **Results[2].Index.Background);
   EXPECT_THAT(Results[3].Diagnostics.ClangTidy.CheckOptions,
               ElementsAre(PairVal("IgnoreMacros", "true"),
                           PairVal("example-check.ExampleOption", "0")));
   EXPECT_TRUE(Results[3].Diagnostics.UnusedIncludes);
   EXPECT_EQ("Strict", **Results[3].Diagnostics.UnusedIncludes);
 }
 
+TEST(ParseYAML, IncludesFileRelative) {
+  CapturedDiags Diags;
+  /* Annotations cannot be used here as it interprets the $ and {} special
+   * characters */
+  StringRef RawYAML(R"yaml(
+  CompileFlags:
+    Add: ["-I${CURRENT_FILE_PATH}test.h"]
+  )yaml");
+  auto Results = Fragment::parseYAML(RawYAML, "config.yaml", "/tmp/testpath/",
+                                     Diags.callback());
+  ASSERT_THAT(Diags.Diagnostics, IsEmpty());
+  ASSERT_EQ(Results.size(), 1u);
+  EXPECT_THAT(Results[0].CompileFlags.Add,
+              ElementsAre(val("-I/tmp/testpath/test.h")));
+}
+
 TEST(ParseYAML, Locations) {
   CapturedDiags Diags;
   Annotations YAML(R"yaml(
 If:
   PathMatch: [['???bad***regex(((']]
   )yaml");
   auto Results =
-      Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback());
+      Fragment::parseYAML(YAML.code(), "config.yaml", "", Diags.callback());
   EXPECT_THAT(Diags.Diagnostics, IsEmpty());
   ASSERT_EQ(Results.size(), 1u);
   ASSERT_NE(Results.front().Source.Manager, nullptr);
   EXPECT_EQ(toRange(Results.front().If.PathMatch.front().Range,
                     *Results.front().Source.Manager),
             YAML.range());
 }
 
 TEST(ParseYAML, ConfigDiagnostics) {
   CapturedDiags Diags;
   Annotations YAML(R"yaml(
 If:
   $unknown[[UnknownCondition]]: "foo"
 CompileFlags:
   Add: 'first'
 ---
 CompileFlags: {$unexpected^
 )yaml");
   auto Results =
-      Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback());
+      Fragment::parseYAML(YAML.code(), "config.yaml", "", Diags.callback());
 
   ASSERT_THAT(
       Diags.Diagnostics,
       ElementsAre(AllOf(diagMessage("Unknown If key 'UnknownCondition'"),
                         diagKind(llvm::SourceMgr::DK_Warning),
                         diagPos(YAML.range("unknown").start),
                         diagRange(YAML.range("unknown"))),
                   AllOf(diagMessage("Unexpected token. Expected Key, Flow "
TEST(ParseYAML, Invalid) {
   CapturedDiags Diags;
   const char *YAML = R"yaml(
 If:
 
 horrible
 ---
 - 1
   )yaml";
-  auto Results = Fragment::parseYAML(YAML, "config.yaml", Diags.callback());
+  auto Results = Fragment::parseYAML(YAML, "config.yaml", "", Diags.callback());
   EXPECT_THAT(Diags.Diagnostics,
               ElementsAre(diagMessage("If should be a dictionary"),
                           diagMessage("Config should be a dictionary")));
   ASSERT_THAT(Results, IsEmpty());
 }
 
 TEST(ParseYAML, ExternalBlockNone) {
   CapturedDiags Diags;
   Annotations YAML(R"yaml(
 Index:
   External: None
   )yaml");
   auto Results =
-      Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback());
+      Fragment::parseYAML(YAML.code(), "config.yaml", "", Diags.callback());
   ASSERT_THAT(Diags.Diagnostics, IsEmpty());
   ASSERT_EQ(Results.size(), 1u);
   ASSERT_TRUE(Results[0].Index.External);
   EXPECT_FALSE((*Results[0].Index.External)->File.has_value());
   EXPECT_FALSE((*Results[0].Index.External)->MountPoint.has_value());
   EXPECT_FALSE((*Results[0].Index.External)->Server.has_value());
   EXPECT_THAT(*(*Results[0].Index.External)->IsNone, testing::Eq(true));
 }
 
 TEST(ParseYAML, ExternalBlock) {
   CapturedDiags Diags;
   Annotations YAML(R"yaml(
 Index:
   External:
     File: "foo"
     Server: ^"bar"
     MountPoint: "baz"
   )yaml");
   auto Results =
-      Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback());
+      Fragment::parseYAML(YAML.code(), "config.yaml", "", Diags.callback());
   ASSERT_EQ(Results.size(), 1u);
   ASSERT_TRUE(Results[0].Index.External);
   EXPECT_THAT(*(*Results[0].Index.External)->File, val("foo"));
   EXPECT_THAT(*(*Results[0].Index.External)->MountPoint, val("baz"));
   ASSERT_THAT(Diags.Diagnostics, IsEmpty());
   EXPECT_THAT(*(*Results[0].Index.External)->Server, val("bar"));
 }
 
 TEST(ParseYAML, AllScopes) {
   CapturedDiags Diags;
   Annotations YAML(R"yaml(
 Completion:
   AllScopes: True
   )yaml");
   auto Results =
-      Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback());
+      Fragment::parseYAML(YAML.code(), "config.yaml", "", Diags.callback());
   ASSERT_THAT(Diags.Diagnostics, IsEmpty());
   ASSERT_EQ(Results.size(), 1u);
   EXPECT_THAT(Results[0].Completion.AllScopes, llvm::ValueIs(val(true)));
 }
 
 TEST(ParseYAML, AllScopesWarn) {
   CapturedDiags Diags;
   Annotations YAML(R"yaml(
 Completion:
   AllScopes: $diagrange[[Truex]]
   )yaml");
   auto Results =
-      Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback());
+      Fragment::parseYAML(YAML.code(), "config.yaml", "", Diags.callback());
   EXPECT_THAT(Diags.Diagnostics,
               ElementsAre(AllOf(diagMessage("AllScopes should be a boolean"),
                                 diagKind(llvm::SourceMgr::DK_Warning),
                                 diagPos(YAML.range("diagrange").start),
                                 diagRange(YAML.range("diagrange")))));
   ASSERT_EQ(Results.size(), 1u);
   EXPECT_THAT(Results[0].Completion.AllScopes, testing::Eq(std::nullopt));
 }
 
 TEST(ParseYAML, ShowAKA) {
   CapturedDiags Diags;
   Annotations YAML(R"yaml(
 Hover:
   ShowAKA: True
   )yaml");
   auto Results =
-      Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback());
+      Fragment::parseYAML(YAML.code(), "config.yaml", "", Diags.callback());
   ASSERT_THAT(Diags.Diagnostics, IsEmpty());
   ASSERT_EQ(Results.size(), 1u);
   EXPECT_THAT(Results[0].Hover.ShowAKA, llvm::ValueIs(val(true)));
 }
 
 TEST(ParseYAML, InlayHints) {
   CapturedDiags Diags;
   Annotations YAML(R"yaml(
 InlayHints:
   Enabled: No
   ParameterNames: Yes
   )yaml");
   auto Results =
-      Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback());
+      Fragment::parseYAML(YAML.code(), "config.yaml", "", Diags.callback());
   ASSERT_THAT(Diags.Diagnostics, IsEmpty());
   ASSERT_EQ(Results.size(), 1u);
   EXPECT_THAT(Results[0].InlayHints.Enabled, llvm::ValueIs(val(false)));
   EXPECT_THAT(Results[0].InlayHints.ParameterNames, llvm::ValueIs(val(true)));
   EXPECT_EQ(Results[0].InlayHints.DeducedTypes, std::nullopt);
 }
 
 TEST(ParseYAML, IncludesIgnoreHeader) {
   CapturedDiags Diags;
   Annotations YAML(R"yaml(
 Diagnostics:
   Includes:
     IgnoreHeader: [foo, bar]
   )yaml");
   auto Results =
-      Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback());
+      Fragment::parseYAML(YAML.code(), "config.yaml", "", Diags.callback());
   ASSERT_THAT(Diags.Diagnostics, IsEmpty());
   ASSERT_EQ(Results.size(), 1u);
   EXPECT_THAT(Results[0].Diagnostics.Includes.IgnoreHeader,
               ElementsAre(val("foo"), val("bar")));
 }
 
 TEST(ParseYAML, Style) {
   CapturedDiags Diags;
   Annotations YAML(R"yaml(
 Style:
   FullyQualifiedNamespaces: [foo, bar])yaml");
   auto Results =
-      Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback());
+      Fragment::parseYAML(YAML.code(), "config.yaml", "", Diags.callback());
   ASSERT_THAT(Diags.Diagnostics, IsEmpty());
   ASSERT_EQ(Results.size(), 1u);
   EXPECT_THAT(Results[0].Style.FullyQualifiedNamespaces,
               ElementsAre(val("foo"), val("bar")));
 }
 } // namespace
 } // namespace config
 } // namespace clangd
 } // namespace clang