[clangd] Handle absolute/relative path specifications in Config

[kadircet]

Summary

This introduces a mechanism for providers to interpret paths specified
in a fragment either as absolute or relative to fragment location.
This information should be used during compile stage to handle blocks correctly.

[sammccall]

Thanks for doing this!

Main points:

• I think we should have one high-level concept of "the optional associated directory" rather than two low-level ones of "the location of the config file" and "should we use the location to form relative paths"
• We need to be careful about windows vs posix paths

clang-tools-extra/clangd/ConfigCompile.cpp

289

passing a reference to part of this and then separately this by rvalue when the reference is live feels... fragile.

Maybe have compile() assign to a member stringref instead? Or even a string and do the path normalization at that point...

clang-tools-extra/clangd/ConfigFragment.h

94

directory the fragment is associated with? At this level, I don't think we should care whether it's actually a file that lives there, and I don't see why the global config would want to set this.

We should also say what this is for: "Relative paths mentioned the fragment are resolved against this directory."

95

Paths in a fragment are conventionally Posix paths, so this dir should be one too before we can use string prefixes. It's also more convenient if it has a trailing slash (current code has a bug where /foo matches /foo2).

This could be handled by the creator of SourceInfo, or we could accept native paths here (with/without slashes) and normalize at the start of compilation. Latter is probably slightly less error-prone.

96

Not sure "Fragment" adds anything here - Directory is a little vaguer than ideal but FragmentDirectory just seems... longer.

98

Why is this separate from FragmentDirectory?

(i.e. when would is it not FragmentDirectory.empty() ? Absolute : Relative)

clang-tools-extra/clangd/ConfigProvider.cpp

37

the associated directory is invariant, like the path - consider making it a member set at construction time instead of plumbing it through all the functions

123

this seems like a surprising place to encode this choice (why is fromYAMLFile coupled to the idea that it's a global config file not associated with any dir?)

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

126

can we use a slightly less degenerate example to verify that we're applying the regex to the correct string?

127

please use testPath() to generate fake paths.

I think this would have caught path-handling bugs on windows.

150

can we fold this into the test above? it seems pretty duplicative.

[kadircet]

• Drop PathSpec, deduce it from emptyness of FragmentDirectory.
• Make tests more homogenous.
• Add path cannonicalization to compile stage.

clang-tools-extra/clangd/ConfigProvider.cpp

123

It was mostly because the only user of fromYAMLFile was user-config provider. Would you rather have this as an additional parameter instead?

I can't see any other way of updating that information directly from the user, apart from changing the interface of Provider to have some sort of setPathSpec method.

[sammccall]

clang-tools-extra/clangd/ConfigCompile.cpp

87

nit: associated with again (or just "normalized Fragment::SourceInfo::Directory")

173

maybe pull out a method Optional<StringRef> configRelative(StringRef)?
This would avoid the duplication

179

not needed as you've ensured FragmentDir ends with a slash

clang-tools-extra/clangd/ConfigProvider.cpp

67

nit: Directory matching Fragment.Source.Directory?
(the abbreviation isn't terrible but consistency is nice)

123

Yes, I'd prefer this to be a parameter (I suppose the dir seems slightly cleaner than a boolean).
The fact that user-config is the only user seems like a coincidence, I'd rather express the decision at that level.

(On the other hand, the fact that RelFileProvider *does* set Dir isn't a coincidence, it seems OK to hardcode that)

[kadircet]

• Make Directory a parameter of fromYAMLFile.
• Factor out configRelative logic to a helper.

[kadircet]

clang-tools-extra/clangd/ConfigCompile.cpp

173

Went with just StringRef as otuput and made empty imply a missmatch (i.e. being out-of-tree)

[sammccall]

clang-tools-extra/clangd/ConfigCompile.cpp

51

not that if Path == FragmentDir you're going to return "" which means "not under".
I don't think this can happen yet, but it's a trap for the future...

You might want the last line to be "return FragmentDir.empty() ? "." : Path".

[kadircet]

• Return "." if Path == FragmentDir in conifgRelative.

clang-tools-extra/clangd/ConfigCompile.cpp

51

i think you meant Path.empty() ? "." : Path, right?

[sammccall]

Still LG but a few more nits

clang-tools-extra/clangd/ConfigCompile.cpp

46

you should document+verify what this does if FragmentDir is empty, since we are triggering that case

51

oops, no I think I meant (Path.empty() && !FragmentDir.empty() ? "." : Path.
You don't want configRelative("","") to be ".".

So either that or handle the FragmentDir-is-empty case upfront.

170

nit: why the rename rather than just capturing?

[kadircet]

clang-tools-extra/clangd/ConfigCompile.cpp

170

because it is actually a member of FragmentCompiler and not a scoped variable :/

[kadircet]

• Explicitly handle FragmentDir.empty() case by returning Path as-is.

clang-tools-extra/clangd/ConfigCompile.cpp

 //  - it's more efficient, as the work done in stage 1 must only be done once
 //  - problems can be reported in stage 1, in stage 2 we must silently recover
 //
 //===----------------------------------------------------------------------===//
 
 #include "CompileCommands.h"
 #include "Config.h"
 #include "ConfigFragment.h"
+#include "ConfigProvider.h"
 #include "support/Logger.h"
 #include "support/Trace.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
+#include "llvm/Support/Path.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Support/SMLoc.h"
 #include "llvm/Support/SourceMgr.h"
+#include <string>
 
 namespace clang {
 namespace clangd {
 namespace config {
 namespace {
 
+// Returns an empty stringref if Path is not under FragmentDir.
+llvm::StringRef configRelative(llvm::StringRef Path,
+                               llvm::StringRef FragmentDir) {
+  if (!Path.consume_front(FragmentDir))
+    return llvm::StringRef();
+  return Path.empty() ? "." : Path;
+}
+
 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.
bool operator()(const Params &P, Config &C) const {
     for (const auto &A : Apply)
       A(C);
     return true;
   }
 };
 
 // Wrapper around condition compile() functions to reduce arg-passing.
 struct FragmentCompiler {
+  FragmentCompiler(CompiledFragmentImpl &Out, DiagnosticCallback D,
+                   llvm::SourceMgr *SM)
+      : Out(Out), Diagnostic(D), SourceMgr(SM) {}
   CompiledFragmentImpl &Out;
   DiagnosticCallback Diagnostic;
   llvm::SourceMgr *SourceMgr;
+  // Normalized Fragment::SourceInfo::Directory.
+  std::string FragmentDirectory;
 
   llvm::Optional<llvm::Regex> compileRegex(const Located<std::string> &Text) {
     std::string Anchored = "^(" + *Text + ")$";
     llvm::Regex Result(Anchored);
     std::string RegexError;
     if (!Result.isValid(RegexError)) {
       diag(Error, "Invalid regex " + Anchored + ": " + RegexError, Text.Range);
       return llvm::None;
struct FragmentCompiler {
   //    .value();
   template <typename T>
   EnumSwitch<T> compileEnum(llvm::StringRef EnumName,
                             const Located<std::string> &In) {
     return EnumSwitch<T>(EnumName, In, *this);
   }
 
   void compile(Fragment &&F) {
+    if (!F.Source.Directory.empty()) {
+      FragmentDirectory = llvm::sys::path::convert_to_slash(F.Source.Directory);
+      if (FragmentDirectory.back() != '/')
+        FragmentDirectory += '/';
+    }
     compile(std::move(F.If));
     compile(std::move(F.CompileFlags));
     compile(std::move(F.Index));
   }
 
   void compile(Fragment::IfBlock &&F) {
     if (F.HasUnrecognizedCondition)
       Out.Conditions.push_back([&](const Params &) { return false; });
 
     auto PathMatch = std::make_unique<std::vector<llvm::Regex>>();
     for (auto &Entry : F.PathMatch) {
       if (auto RE = compileRegex(Entry))
         PathMatch->push_back(std::move(*RE));
     }
     if (!PathMatch->empty()) {
       Out.Conditions.push_back(
-          [PathMatch(std::move(PathMatch))](const Params &P) {
+          [PathMatch(std::move(PathMatch)),
+           FragmentDir(FragmentDirectory)](const Params &P) {
             if (P.Path.empty())
               return false;
+            llvm::StringRef Path = configRelative(P.Path, FragmentDir);
+            // Ignore the file if it is not nested under Fragment.
+            if (Path.empty())
+              return false;
             return llvm::any_of(*PathMatch, [&](const llvm::Regex &RE) {
-              return RE.match(P.Path);
+              return RE.match(Path);
             });
           });
     }
 
     auto PathExclude = std::make_unique<std::vector<llvm::Regex>>();
     for (auto &Entry : F.PathExclude) {
       if (auto RE = compileRegex(Entry))
         PathExclude->push_back(std::move(*RE));
     }
     if (!PathExclude->empty()) {
       Out.Conditions.push_back(
-          [PathExclude(std::move(PathExclude))](const Params &P) {
+          [PathExclude(std::move(PathExclude)),
+           FragmentDir(FragmentDirectory)](const Params &P) {
             if (P.Path.empty())
               return false;
+            llvm::StringRef Path = configRelative(P.Path, FragmentDir);
+            // Ignore the file if it is not nested under Fragment.
+            if (Path.empty())
+              return true;
             return llvm::none_of(*PathExclude, [&](const llvm::Regex &RE) {
-              return RE.match(P.Path);
+              return RE.match(Path);
             });
           });
     }
   }
 
   void compile(Fragment::CompileFlagsBlock &&F) {
     if (!F.Remove.empty()) {
       auto Remove = std::make_shared<ArgStripper>();
if (auto *SM = Source.Manager.get()) {
     ConfigFile = SM->getBufferInfo(BufID).Buffer->getBufferIdentifier();
   }
   trace::Span Tracer("ConfigCompile");
   SPAN_ATTACH(Tracer, "ConfigFile", ConfigFile);
   auto Result = std::make_shared<CompiledFragmentImpl>();
   vlog("Config fragment: compiling {0}:{1} -> {2}", ConfigFile, LineCol.first,
        Result.get());
 
   FragmentCompiler{*Result, D, Source.Manager.get()}.compile(std::move(*this));
   // Return as cheaply-copyable wrapper.
   return [Result(std::move(Result))](const Params &P, Config &C) {
     return (*Result)(P, C);
   };
 }
 
 } // namespace config
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/ConfigFragment.h

struct SourceInfo {
     /// Retains a buffer of the original source this fragment was parsed from.
     /// Locations within Located<T> objects point into this SourceMgr.
     /// Shared because multiple fragments are often parsed from one (YAML) file.
     /// May be null, then all locations should be ignored.
     std::shared_ptr<llvm::SourceMgr> Manager;
     /// The start of the original source for this fragment.
     /// Only valid if SourceManager is set.
     llvm::SMLoc Location;
+    /// Absolute path to directory the fragment is associated with. Relative
+    /// paths mentioned in the fragment are resolved against this.
+    std::string Directory;
   };
   SourceInfo Source;
 
   /// Conditions in the If block restrict when a Fragment applies.
   ///
   /// Each separate condition must match (combined with AND).
   /// When one condition has multiple values, any may match (combined with OR).
   /// e.g. `PathMatch: [foo/.*, bar/.*]` matches files in either directory.
   ///
   /// Conditions based on a file's path use the following form:

clang-tools-extra/clangd/ConfigProvider.h

 // This file defines the structures used for this, that produce a Config.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_CONFIGPROVIDER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_CONFIGPROVIDER_H
 
 #include "llvm/ADT/FunctionExtras.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/SMLoc.h"
 #include "llvm/Support/SourceMgr.h"
 #include <chrono>
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace clangd {

 /// A source of configuration fragments.
 /// Generally these providers reflect a fixed policy for obtaining config,
 /// but return different concrete configuration over time.
 /// e.g. a provider that reads config from files is responsive to file changes.
 class Provider {
 public:
   virtual ~Provider() = default;
 
-  // Reads fragments from a single YAML file with a fixed path.
-  static std::unique_ptr<Provider> fromYAMLFile(llvm::StringRef AbsPathPath,
+  /// Reads fragments from a single YAML file with a fixed path. If non-empty,
+  /// Directory will be used to resolve relative paths in the fragments.
+  static std::unique_ptr<Provider> fromYAMLFile(llvm::StringRef AbsPath,
+                                                llvm::StringRef Directory,
                                                 const ThreadsafeFS &);
   // Reads fragments from YAML files found relative to ancestors of Params.Path.
   //
   // All fragments that exist are returned, starting from distant ancestors.
   // For instance, given RelPath of ".clangd", then for source file /foo/bar.cc,
   // the searched fragments are [/.clangd, /foo/.clangd].
   //
   // If Params does not specify a path, no fragments are returned.

clang-tools-extra/clangd/ConfigProvider.cpp

 //===--- ConfigProvider.cpp - Loading of user configuration ---------------===//
 //
 // 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 "ConfigProvider.h"
 #include "Config.h"
 #include "ConfigFragment.h"
 #include "support/ThreadsafeFS.h"
 #include "support/Trace.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Path.h"
 #include <chrono>
 #include <mutex>
+#include <string>
 
 namespace clang {
 namespace clangd {
 namespace config {
 
 // Threadsafe cache around reading a YAML config file from disk.
 class FileConfigCache {
   std::mutex Mu;
   std::chrono::steady_clock::time_point ValidTime = {};
   llvm::SmallVector<CompiledFragment, 1> CachedValue;
   llvm::sys::TimePoint<> MTime = {};
   unsigned Size = -1;
 
   // Called once we are sure we want to read the file.
   // REQUIRES: Cache keys are set. Mutex must be held.
   void fillCacheFromDisk(llvm::vfs::FileSystem &FS, DiagnosticCallback DC) {
     CachedValue.clear();
 
     auto Buf = FS.getBufferForFile(Path);
     // If we failed to read (but stat succeeded), don't cache failure.
     if (!Buf) {
       Size = -1;
       MTime = {};
       return;
     }
 
     // If file changed between stat and open, we don't know its mtime.
     // For simplicity, don't cache the value in this case (use a bad key).
     if (Buf->get()->getBufferSize() != Size) {
       Size = -1;
       MTime = {};
     }
 
     // Finally parse and compile the actual fragments.
     for (auto &Fragment :
-         Fragment::parseYAML(Buf->get()->getBuffer(), Path, DC))
+         Fragment::parseYAML(Buf->get()->getBuffer(), Path, DC)) {
+      Fragment.Source.Directory = Directory;
       CachedValue.push_back(std::move(Fragment).compile(DC));
     }
+  }
 
 public:
   // Must be set before the cache is used. Not a constructor param to allow
   // computing ancestor-relative paths to be deferred.
   std::string Path;
+  // Directory associated with this fragment.
+  std::string Directory;
 
   // Retrieves up-to-date config fragments from disk.
   // A cached result may be reused if the mtime and size are unchanged.
   // (But several concurrent read()s can miss the cache after a single change).
   // Future performance ideas:
   // - allow caches to be reused based on short elapsed walltime
   // - allow latency-sensitive operations to skip revalidating the cache
   void read(const ThreadsafeFS &TFS, DiagnosticCallback DC,
void read(const ThreadsafeFS &TFS, DiagnosticCallback DC,
     // OK, the file has actually changed. Update cache key, compute new value.
     Size = Stat->getSize();
     MTime = Stat->getLastModificationTime();
     fillCacheFromDisk(*FS, DC);
   }
 };
 
 std::unique_ptr<Provider> Provider::fromYAMLFile(llvm::StringRef AbsPath,
+                                                 llvm::StringRef Directory,
                                                  const ThreadsafeFS &FS) {
   class AbsFileProvider : public Provider {
     mutable FileConfigCache Cache; // threadsafe
     const ThreadsafeFS &FS;
 
     std::vector<CompiledFragment>
     getFragments(const Params &P, DiagnosticCallback DC) const override {
       std::vector<CompiledFragment> Result;
       Cache.read(FS, DC, P.FreshTime, Result);
       return Result;
     };
 
   public:
-    AbsFileProvider(llvm::StringRef Path, const ThreadsafeFS &FS) : FS(FS) {
+    AbsFileProvider(llvm::StringRef Path, llvm::StringRef Directory,
+                    const ThreadsafeFS &FS)
+        : FS(FS) {
       assert(llvm::sys::path::is_absolute(Path));
       Cache.Path = Path.str();
+      Cache.Directory = Directory.str();
     }
   };
 
-  return std::make_unique<AbsFileProvider>(AbsPath, FS);
+  return std::make_unique<AbsFileProvider>(AbsPath, Directory, FS);
 }
 
 std::unique_ptr<Provider>
 Provider::fromAncestorRelativeYAMLFiles(llvm::StringRef RelPath,
                                         const ThreadsafeFS &FS) {
   class RelFileProvider : public Provider {
     std::string RelPath;
     const ThreadsafeFS &FS;
getFragments(const Params &P, DiagnosticCallback DC) const override {
         std::lock_guard<std::mutex> Lock(Mu);
         for (llvm::StringRef Ancestor : Ancestors) {
           auto R = Cache.try_emplace(Ancestor);
           // Assemble the actual config file path only once.
           if (R.second) {
             llvm::SmallString<256> ConfigPath = Ancestor;
             path::append(ConfigPath, RelPath);
             R.first->second.Path = ConfigPath.str().str();
+            R.first->second.Directory = Ancestor.str();
           }
           Caches.push_back(&R.first->second);
         }
       }
       // Finally query each individual file.
       // This will take a (per-file) lock for each file that actually exists.
       std::vector<CompiledFragment> Result;
-      for (FileConfigCache *Cache : Caches)
+      for (FileConfigCache *Cache : Caches) {
         Cache->read(FS, DC, P.FreshTime, Result);
+      }
       return Result;
     };
 
   public:
     RelFileProvider(llvm::StringRef RelPath, const ThreadsafeFS &FS)
         : RelPath(RelPath), FS(FS) {
       assert(llvm::sys::path::is_relative(RelPath));
     }

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

#endif
   std::unique_ptr<config::Provider> Config;
   if (EnableConfig) {
     ProviderStack.push_back(
         config::Provider::fromAncestorRelativeYAMLFiles(".clangd", TFS));
     llvm::SmallString<256> UserConfig;
     if (llvm::sys::path::user_config_directory(UserConfig)) {
       llvm::sys::path::append(UserConfig, "clangd", "config.yaml");
       vlog("User config file is {0}", UserConfig);
-      ProviderStack.push_back(config::Provider::fromYAMLFile(UserConfig, TFS));
+      ProviderStack.push_back(
+          config::Provider::fromYAMLFile(UserConfig, /*Directory=*/"", TFS));
     } else {
       elog("Couldn't determine user config file, not loading");
     }
     std::vector<const config::Provider *> ProviderPointers;
     for (const auto &P : ProviderStack)
       ProviderPointers.push_back(P.get());
     Config = config::Provider::combine(std::move(ProviderPointers));
     Opts.ConfigProvider = Config.get();

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

 //===-- ConfigCompileTests.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 "Config.h"
 #include "ConfigFragment.h"
 #include "ConfigTesting.h"
+#include "TestFS.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Path.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
+#include <string>
 
 namespace clang {
 namespace clangd {
 namespace config {
 namespace {
 using ::testing::ElementsAre;
 using ::testing::IsEmpty;
 using ::testing::SizeIs;
TEST_F(ConfigCompileTests, Index) {
   EXPECT_EQ(Conf.Index.Background, Config::BackgroundPolicy::Build)
       << "by default";
   EXPECT_THAT(
       Diags.Diagnostics,
       ElementsAre(DiagMessage(
           "Invalid Background value 'Foo'. Valid values are Build, Skip.")));
 }
 
+TEST_F(ConfigCompileTests, PathSpecMatch) {
+  auto BarPath = llvm::sys::path::convert_to_slash(testPath("foo/bar.h"));
+  Parm.Path = BarPath;
+
+  struct {
+    std::string Directory;
+    std::string PathSpec;
+    bool ShouldMatch;
+  } Cases[] = {
+      {
+          // Absolute path matches.
+          "",
+          llvm::sys::path::convert_to_slash(testPath("foo/bar.h")),
+          true,
+      },
+      {
+          // Absolute path fails.
+          "",
+          llvm::sys::path::convert_to_slash(testPath("bar/bar.h")),
+          false,
+      },
+      {
+          // Relative should fail to match as /foo/bar.h doesn't reside under
+          // /baz/.
+          testPath("baz"),
+          "bar\\.h",
+          false,
+      },
+      {
+          // Relative should pass with /foo as directory.
+          testPath("foo"),
+          "bar\\.h",
+          true,
+      },
+  };
+
+  // PathMatch
+  for (const auto &Case : Cases) {
+    Frag = {};
+    Frag.If.PathMatch.emplace_back(Case.PathSpec);
+    Frag.Source.Directory = Case.Directory;
+    EXPECT_EQ(compileAndApply(), Case.ShouldMatch);
+    ASSERT_THAT(Diags.Diagnostics, IsEmpty());
+  }
+
+  // PathEclude
+  for (const auto &Case : Cases) {
+    SCOPED_TRACE(Case.Directory);
+    SCOPED_TRACE(Case.PathSpec);
+    Frag = {};
+    Frag.If.PathExclude.emplace_back(Case.PathSpec);
+    Frag.Source.Directory = Case.Directory;
+    EXPECT_NE(compileAndApply(), Case.ShouldMatch);
+    ASSERT_THAT(Diags.Diagnostics, IsEmpty());
+  }
+}
 } // namespace
 } // namespace config
 } // namespace clangd
 } // namespace clang

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

 //===-- ConfigProviderTests.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 "Config.h"
 #include "ConfigProvider.h"
 #include "ConfigTesting.h"
 #include "TestFS.h"
+#include "llvm/Support/Path.h"
 #include "llvm/Support/SourceMgr.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <atomic>
 #include <chrono>
 
 namespace clang {
 namespace clangd {
CompileFlags:
   Add: baz
 )yaml";
 
 TEST(ProviderTest, FromYAMLFile) {
   MockFS FS;
   FS.Files["foo.yaml"] = AddFooWithErr;
 
   CapturedDiags Diags;
-  auto P = Provider::fromYAMLFile(testPath("foo.yaml"), FS);
+  auto P = Provider::fromYAMLFile(testPath("foo.yaml"), /*Directory=*/"", FS);
   auto Cfg = P->getConfig(Params(), Diags.callback());
   EXPECT_THAT(Diags.Diagnostics,
               ElementsAre(DiagMessage("Unknown CompileFlags key Unknown")));
   EXPECT_THAT(getAddedArgs(Cfg), ElementsAre("foo"));
   Diags.Diagnostics.clear();
 
   Cfg = P->getConfig(Params(), Diags.callback());
   EXPECT_THAT(Diags.Diagnostics, IsEmpty()) << "Cached, not re-parsed";
TEST(ProviderTest, Staleness) {
   MockFS FS;
 
   auto StartTime = std::chrono::steady_clock::now();
   Params StaleOK;
   StaleOK.FreshTime = StartTime;
   Params MustBeFresh;
   MustBeFresh.FreshTime = StartTime + std::chrono::hours(1);
   CapturedDiags Diags;
-  auto P = Provider::fromYAMLFile(testPath("foo.yaml"), FS);
+  auto P = Provider::fromYAMLFile(testPath("foo.yaml"), /*Directory=*/"", FS);
 
   // Initial query always reads, regardless of policy.
   FS.Files["foo.yaml"] = AddFooWithErr;
   auto Cfg = P->getConfig(StaleOK, Diags.callback());
   EXPECT_THAT(Diags.Diagnostics,
               ElementsAre(DiagMessage("Unknown CompileFlags key Unknown")));
   EXPECT_THAT(getAddedArgs(Cfg), ElementsAre("foo"));
   Diags.Diagnostics.clear();
TEST(ProviderTest, Staleness) {
 
   // Cache revalidated by (default) policy.
   FS.Files.erase("foo.yaml");
   Cfg = P->getConfig(Params(), Diags.callback());
   EXPECT_THAT(Diags.Diagnostics, IsEmpty());
   EXPECT_THAT(getAddedArgs(Cfg), IsEmpty());
 }
 
+TEST(ProviderTest, SourceInfo) {
+  MockFS FS;
+
+  FS.Files["baz/foo.yaml"] = R"yaml(
+If:
+  PathMatch: .*
+  PathExclude: bar.h
+CompileFlags:
+  Add: bar
+)yaml";
+  const auto BarPath = testPath("baz/bar.h", llvm::sys::path::Style::posix);
+  CapturedDiags Diags;
+  Params Bar;
+  Bar.Path = BarPath;
+
+  // This should be an absolute match/exclude hence baz/bar.h should not be
+  // excluded.
+  auto P =
+      Provider::fromYAMLFile(testPath("baz/foo.yaml"), /*Directory=*/"", FS);
+  auto Cfg = P->getConfig(Bar, Diags.callback());
+  ASSERT_THAT(Diags.Diagnostics, IsEmpty());
+  EXPECT_THAT(getAddedArgs(Cfg), ElementsAre("bar"));
+  Diags.Diagnostics.clear();
+
+  // This should be a relative match/exclude hence baz/bar.h should be excluded.
+  P = Provider::fromAncestorRelativeYAMLFiles("foo.yaml", FS);
+  Cfg = P->getConfig(Bar, Diags.callback());
+  ASSERT_THAT(Diags.Diagnostics, IsEmpty());
+  EXPECT_THAT(getAddedArgs(Cfg), IsEmpty());
+  Diags.Diagnostics.clear();
+}
 } // namespace
 } // namespace config
 } // namespace clangd
 } // namespace clang