[clangd] Config: If.PathExclude

[hokein]

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

73

IIUC the semantic is: we only process the file if (PathMatch("bar", "b.*") && !PathExclude("bar", ".*r")), PathExclude is true here, so we won't process the file.

[sammccall]

BTW I'm not planning to add Suffix/SuffixExclude in the immediate future, at least for clangd 11 people will have to use PathMatch: '.*\.h' or so. Sound OK?

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

73

Exactly. Added a small message to the assertion to clarify the intent.

[hokein]

In D83511#2143803, @sammccall wrote:

BTW I'm not planning to add Suffix/SuffixExclude in the immediate future, at least for clangd 11 people will have to use PathMatch: '.*\.h' or so. Sound OK?

yeah, that sounds good to me.

clang-tools-extra/clangd/ConfigCompile.cpp

if (!PathMatch->empty()) {
           [PathMatch(std::move(PathMatch))](const Params &P) {
             if (P.Path.empty())
               return false;
             return llvm::any_of(*PathMatch, [&](const llvm::Regex &RE) {
               return RE.match(P.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) {
+            if (P.Path.empty())
+              return false;
+            return llvm::none_of(*PathExclude, [&](const llvm::Regex &RE) {
+              return RE.match(P.Path);
+            });
+          });
+    }
   }
 
   void compile(Fragment::CompileFlagsBlock &&F) {
     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) {

clang-tools-extra/clangd/ConfigFragment.h

struct Fragment {
   /// Conditions based on a file's path use the following form:
   /// - if the fragment came from a project directory, the path is relative
   /// - if the fragment is global (e.g. user config), the path is absolute
   /// - paths always use forward-slashes (UNIX-style)
   /// If no file is being processed, these conditions will not match.
   struct IfBlock {
     /// The file being processed must fully match a regular expression.
     std::vector<Located<std::string>> PathMatch;
+    /// The file being processed must *not* fully match a regular expression.
+    std::vector<Located<std::string>> PathExclude;
+
     /// An unrecognized key was found while parsing the condition.
     /// The condition will evaluate to false.
     bool HasUnrecognizedCondition = false;
   };
   IfBlock If;
 
   struct CompileFlagsBlock {
     std::vector<Located<std::string>> Add;
   } CompileFlags;
 };
 
 } // namespace config
 } // namespace clangd
 } // namespace clang
 
 #endif

clang-tools-extra/clangd/ConfigYAML.cpp

private:
   void parse(Fragment::IfBlock &F, Node &N) {
     DictParser Dict("If", this);
     Dict.unrecognized(
         [&](llvm::StringRef) { F.HasUnrecognizedCondition = true; });
     Dict.handle("PathMatch", [&](Node &N) {
       if (auto Values = scalarValues(N))
         F.PathMatch = std::move(*Values);
     });
+    Dict.handle("PathExclude", [&](Node &N) {
+      if (auto Values = scalarValues(N))
+        F.PathExclude = std::move(*Values);
+    });
     Dict.parse(N);
   }
 
   void parse(Fragment::CompileFlagsBlock &F, Node &N) {
     DictParser Dict("CompileFlags", this);
     Dict.handle("Add", [&](Node &N) {
       if (auto Values = scalarValues(N))
         F.Add = std::move(*Values);

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

TEST_F(ConfigCompileTests, Condition) {
 
   // Matching regex.
   Frag = {};
   Frag.If.PathMatch.emplace_back("fo*");
   Frag.If.PathMatch.emplace_back("ba*r");
   EXPECT_TRUE(compileAndApply());
   EXPECT_THAT(Diags.Diagnostics, IsEmpty());
 
+  // Excluded regex.
+  Frag = {};
+  Frag.If.PathMatch.emplace_back("b.*");
+  Frag.If.PathExclude.emplace_back(".*r");
+  EXPECT_FALSE(compileAndApply()) << "Included but also excluded";
+  EXPECT_THAT(Diags.Diagnostics, IsEmpty());
+
   // Invalid regex.
   Frag = {};
   Frag.If.PathMatch.emplace_back("**]@theu");
   EXPECT_TRUE(compileAndApply());
   EXPECT_THAT(Diags.Diagnostics, SizeIs(1));
   EXPECT_THAT(Diags.Diagnostics.front().Message, StartsWith("Invalid regex"));
 
   // Valid regex and unknown key.