[clangd] Enable configuring include insertions

[njames93]

Summary

See https://github.com/clangd/clangd/issues/1367

[sammccall]

The replacement rules design is just too complicated I'm afraid.
It's unclear that it solves a widespread problem, and even when there is one and the solution applies, the result is still difficult to use.

Angles vs quotes is something we've had multiple reports on, though, and may be narrow enough to find a simple solution.

• maybe something config-based like Style: { IncludeAngled: 'match/a/suffix/.*' }
• or something based on seeing how the header is included and storing this in the index. This is nice as it avoids config, but seems complicated in other ways (unpredictable, relies on complete index, can go wrong, may regress existing behavior)

clang-tools-extra/clangd/CMakeLists.txt

add_clang_library(clangDaemon
   FuzzyMatch.cpp
   GlobalCompilationDatabase.cpp
   Headers.cpp
   HeaderSourceSwitch.cpp
   HeuristicResolver.cpp
   Hover.cpp
   IncludeCleaner.cpp
   IncludeFixer.cpp
+  IncludeRenamer.cpp
   InlayHints.cpp
   JSONTransport.cpp
   PathMapping.cpp
   Protocol.cpp
   Quality.cpp
   ParsedAST.cpp
   Preamble.cpp
   RIFF.cpp

clang-tools-extra/clangd/ClangdServer.cpp

auto Task = [Pos, CodeCompleteOpts, File = File.str(), CB = std::move(CB),
     // FIXME: Add traling new line if there is none at eof, workaround a crash,
     // see https://github.com/clangd/clangd/issues/332
     if (!IP->Contents.endswith("\n"))
       ParseInput.Contents.append("\n");
     ParseInput.Index = Index;
 
     CodeCompleteOpts.MainFileSignals = IP->Signals;
     CodeCompleteOpts.AllScopes = Config::current().Completion.AllScopes;
+    CodeCompleteOpts.IncludeRenamer = Config::current().IncludeRules;
     // FIXME(ibiryukov): even if Preamble is non-null, we may want to check
     // both the old and the new version in case only one of them matches.
     CodeCompleteResult Result = clangd::codeComplete(
         File, Pos, IP->Preamble, ParseInput, CodeCompleteOpts,
         SpecFuzzyFind ? SpecFuzzyFind.getPointer() : nullptr);
     {
       clang::clangd::trace::Span Tracer("Completion results callback");
       CB(std::move(Result));

clang-tools-extra/clangd/CodeComplete.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_CODECOMPLETE_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_CODECOMPLETE_H
 
 #include "ASTSignals.h"
 #include "Compiler.h"
+#include "Config.h"
+#include "IncludeRenamer.h"
 #include "Protocol.h"
 #include "Quality.h"
 #include "index/Index.h"
 #include "index/Symbol.h"
 #include "index/SymbolOrigin.h"
 #include "support/Markup.h"
 #include "support/Path.h"
 #include "clang/Sema/CodeCompleteConsumer.h"
 #include "clang/Sema/CodeCompleteOptions.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include <functional>
 #include <future>
+#include <memory>
 #include <utility>
 
 namespace clang {
 class NamedDecl;
 namespace clangd {
 struct PreambleData;
 struct CodeCompletion;
 
struct CodeCompleteOptions {
   /// CompletionScore is NameMatch * pow(Base, Prediction).
   /// The optimal value of Base largely depends on the semantics of the model
   /// and prediction score (e.g. algorithm used during training, number of
   /// trees, etc.). Usually if the range of Prediction is [-20, 20] then a Base
   /// in [1.2, 1.7] works fine.
   /// Semantics: E.g. For Base = 1.3, if the Prediction score reduces by 2.6
   /// points then completion score reduces by 50% or 1.3^(-2.6).
   float DecisionForestBase = 1.3f;
+
+  std::shared_ptr<const IncludeRenamer> IncludeRenamer;
 };
 
 // Semi-structured representation of a code-complete suggestion for our C++ API.
 // We don't use the LSP structures here (unlike most features) as we want
 // to expose more data to allow for more precise testing and evaluation.
 struct CodeCompletion {
   // The unqualified name of the symbol or other completion item.
   std::string Name;

clang-tools-extra/clangd/CodeComplete.cpp

 // it's purely AST-based, and there are few candidates.
 //
 //===----------------------------------------------------------------------===//
 
 #include "CodeComplete.h"
 #include "AST.h"
 #include "CodeCompletionStrings.h"
 #include "Compiler.h"
+#include "Config.h"
 #include "ExpectedTypes.h"
 #include "FileDistance.h"
 #include "FuzzyMatch.h"
 #include "Headers.h"
 #include "Hover.h"
 #include "Preamble.h"
 #include "Protocol.h"
 #include "Quality.h"
auto Inserted = [&](llvm::StringRef Header)
           std::move(*Spelled),
           Includes.shouldInsertInclude(*ResolvedDeclaring, *ResolvedInserted));
     };
     bool ShouldInsert = C.headerToInsertIfAllowed(Opts).has_value();
     // Calculate include paths and edits for all possible headers.
     for (const auto &Inc : C.RankedIncludeHeaders) {
       if (auto ToInclude = Inserted(Inc)) {
         CodeCompletion::IncludeCandidate Include;
-        Include.Header = ToInclude->first;
+        if (Optional<std::string> MappedInclude =
+                Opts.IncludeRenamer
+                    ? Opts.IncludeRenamer->processInclude(ToInclude->first)
+                    : ToInclude->first) {
+          Include.Header = *MappedInclude;
           if (ToInclude->second && ShouldInsert)
-          Include.Insertion = Includes.insert(ToInclude->first);
+            Include.Insertion = Includes.insert(*MappedInclude);
           Completion.Includes.push_back(std::move(Include));
+        }
       } else
         log("Failed to generate include insertion edits for adding header "
             "(FileURI='{0}', IncludeHeader='{1}') into {2}: {3}",
             C.IndexResult->CanonicalDeclaration.FileURI, Inc, FileName,
             ToInclude.takeError());
     }
     // Prefer includes that do not need edits (i.e. already exist).
     std::stable_partition(Completion.Includes.begin(),

clang-tools-extra/clangd/Config.h

 // of layering problems. Config should be expressed in terms of simple
 // vocabulary types where possible.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_CONFIG_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_CONFIG_H
 
+#include "IncludeRenamer.h"
 #include "support/Context.h"
 #include "llvm/ADT/FunctionExtras.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSet.h"
+#include "llvm/Support/Regex.h"
 #include <functional>
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace clangd {
 
 /// Settings that express user/project preferences and control clangd behavior.
struct {
     /// If false, inlay hints are completely disabled.
     bool Enabled = true;
 
     // Whether specific categories of hints are enabled.
     bool Parameters = true;
     bool DeducedTypes = true;
     bool Designators = true;
   } InlayHints;
+
+  /// Rules for configuring include insertions.
+  std::shared_ptr<IncludeRenamer> IncludeRules =
+      std::make_shared<IncludeRenamer>();
 };
 
 } // namespace clangd
 } // namespace clang
 
 namespace llvm {
 template <> struct DenseMapInfo<clang::clangd::Config::ExternalIndexSpec> {
   using ExternalIndexSpec = clang::clangd::Config::ExternalIndexSpec;

clang-tools-extra/clangd/ConfigCompile.cpp

 //===----------------------------------------------------------------------===//
 
 #include "CompileCommands.h"
 #include "Config.h"
 #include "ConfigFragment.h"
 #include "ConfigProvider.h"
 #include "Diagnostics.h"
 #include "Feature.h"
+#include "IncludeRenamer.h"
 #include "TidyProvider.h"
 #include "support/Logger.h"
 #include "support/Path.h"
 #include "support/Trace.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
void compile(Fragment &&F) {
     compile(std::move(F.If));
     compile(std::move(F.CompileFlags));
     compile(std::move(F.Index));
     compile(std::move(F.Diagnostics));
     compile(std::move(F.Completion));
     compile(std::move(F.Hover));
     compile(std::move(F.InlayHints));
     compile(std::move(F.Style));
+    compile(std::move(F.IncludeRules));
   }
 
   void compile(Fragment::IfBlock &&F) {
     if (F.HasUnrecognizedCondition)
       Out.Conditions.push_back([&](const Params &) { return false; });
 
 #ifdef CLANGD_PATH_CASE_INSENSITIVE
     llvm::Regex::RegexFlags Flags = llvm::Regex::IgnoreCase;
if (F.DeducedTypes)
         C.InlayHints.DeducedTypes = Value;
       });
     if (F.Designators)
       Out.Apply.push_back([Value(**F.Designators)](const Params &, Config &C) {
         C.InlayHints.Designators = Value;
       });
   }
 
+  void compile(std::vector<Located<Fragment::IncludeRuleBlock>> &&F) {
+#ifdef CLANGD_PATH_CASE_INSENSITIVE
+    static llvm::Regex::RegexFlags Flags = llvm::Regex::IgnoreCase;
+#else
+    static llvm::Regex::RegexFlags Flags = llvm::Regex::NoFlags;
+#endif
+    std::vector<IncludeRule> Rules;
+    for (auto &Item : F) {
+      std::shared_ptr<llvm::Regex> Regex;
+      if (!Item->PathMatch) {
+        diag(Error, "Include block must contain 'PathMatch'", Item.Range);
+      } else {
+        Regex = std::make_shared<llvm::Regex>(**Item->PathMatch, Flags);
+        // Don't anchor these regexes
+        std::string RegexError;
+        if (!Regex->isValid(RegexError)) {
+          diag(Error,
+               llvm::formatv("Invalid regular expression '{0}': {1}",
+                             **Item->PathMatch, RegexError)
+                   .str(),
+               Item->PathMatch->Range);
+          Regex.reset();
+        }
+      }
+      llvm::Optional<IncludeRule::Type> Type;
+      if (Item->Type) {
+        if (auto Value = compileEnum<IncludeRule::Type>("Type", *Item->Type)
+                             .map("Quoted", IncludeRule::Type::Quoted)
+                             .map("Angled", IncludeRule::Type::Angled)
+                             .map("Disabled", IncludeRule::Type::Disabled)
+                             .value()) {
+          Type = Value;
+        }
+      }
+      if (Regex) {
+        llvm::Optional<std::string> Replace;
+        if (Item->Replace)
+          Replace = std::move(**Item->Replace);
+        Rules.emplace_back(std::move(Regex), std::move(Type),
+                           std::move(Replace));
+      }
+    }
+    if (!Rules.empty()) {
+      Out.Apply.push_back([Rules(std::move(Rules))](const Params &, Config &C) {
+        C.IncludeRules->addRules(Rules);
+      });
+    }
+  }
+
   constexpr static llvm::SourceMgr::DiagKind Error = llvm::SourceMgr::DK_Error;
   constexpr static llvm::SourceMgr::DiagKind Warning =
       llvm::SourceMgr::DK_Warning;
   void diag(llvm::SourceMgr::DiagKind Kind, llvm::StringRef Message,
             llvm::SMRange Range) {
     if (Range.isValid() && SourceMgr != nullptr)
       Diagnostic(SourceMgr->GetMessage(Range.Start, Kind, Message, Range));
     else

clang-tools-extra/clangd/ConfigFragment.h

struct InlayHintsBlock {
     /// Show parameter names before function arguments.
     llvm::Optional<Located<bool>> ParameterNames;
     /// Show deduced types for `auto`.
     llvm::Optional<Located<bool>> DeducedTypes;
     /// Show designators in aggregate initialization.
     llvm::Optional<Located<bool>> Designators;
   };
   InlayHintsBlock InlayHints;
+
+  struct IncludeRuleBlock {
+    /// A regex that must be matched for this rule to take effect.
+    /// Only partial matching is needed so:
+    /// {PathMatch: '^foo/'} will match all includes under the foo directory
+    llvm::Optional<Located<std::string>> PathMatch;
+
+    /// What type of include we should generate.
+    ///
+    /// Valid values are:
+    /// - Quoted: insert a "double_quoted" include.
+    /// - Angled: insert an <angle_bracket> include.
+    /// - Disabled: don't emit an include for this item
+    llvm::Optional<Located<std::string>> Type;
+
+    /// A regex replacement string to transform the matched path.
+    /// For example with this config:
+    /// PathMatch: '^foo/'
+    /// Replace: 'my_foo/'
+    ///
+    /// The include: `<foo/impl.h>` would be changed to:
+    /// `<my_foo/impl.h>`
+    /// Note only the first regex match is replaced, therefor given a regex
+    /// 'foo/' and a replace 'my_foo', the include: `<foo/foo/impl.h>` would be
+    /// changed to: `<my_foo/foo/impl.h>`
+    llvm::Optional<Located<std::string>> Replace;
+  };
+
+  /// A list of @c IncludeRuleBlock`s. This list is traversed in order and stops
+  /// being processed once the first rule matches.
+  std::vector<Located<IncludeRuleBlock>> IncludeRules;
 };
 
 } // namespace config
 } // namespace clangd
 } // namespace clang
 
 #endif

clang-tools-extra/clangd/ConfigYAML.cpp

bool parse(Fragment &F, Node &N) {
     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); });
     Dict.handle("Style", [&](Node &N) { parse(F.Style, N); });
     Dict.handle("Diagnostics", [&](Node &N) { parse(F.Diagnostics, N); });
     Dict.handle("Completion", [&](Node &N) { parse(F.Completion, N); });
     Dict.handle("Hover", [&](Node &N) { parse(F.Hover, N); });
     Dict.handle("InlayHints", [&](Node &N) { parse(F.InlayHints, N); });
+    Dict.handle("IncludeRules", [&](Node &N) { parse(F.IncludeRules, N); });
     Dict.parse(N);
     return !(N.failed() || HadError);
   }
 
 private:
   void parse(Fragment::IfBlock &F, Node &N) {
     DictParser Dict("If", this);
     Dict.unrecognized([&](Located<std::string>, Node &) {
void parse(Fragment::InlayHintsBlock &F, Node &N) {
     });
     Dict.handle("Designators", [&](Node &N) {
       if (auto Value = boolValue(N, "Designators"))
         F.Designators = *Value;
     });
     Dict.parse(N);
   }
 
+  llvm::Optional<Located<Fragment::IncludeRuleBlock>>
+  parseIncludeRule(Node &N) {
+    Fragment::IncludeRuleBlock Result;
+    DictParser Dict("IncludeRule", this);
+    Dict.handle("PathMatch", [&](Node &N) {
+      if (auto Value = scalarValue(N, "PathMatch"))
+        Result.PathMatch = *Value;
+    });
+    Dict.handle("Type", [&](Node &N) {
+      if (auto Value = scalarValue(N, "Type"))
+        Result.Type = *Value;
+    });
+    Dict.handle("Replace", [&](Node &N) {
+      if (auto Value = scalarValue(N, "Replace"))
+        Result.Replace = *Value;
+    });
+    Dict.parse(N);
+    if (this->HadError)
+      return llvm::None;
+    return Located<Fragment::IncludeRuleBlock>(std::move(Result),
+                                               N.getSourceRange());
+  }
+
+  void parse(std::vector<Located<Fragment::IncludeRuleBlock>> &F, Node &N) {
+    if (auto *S = llvm::dyn_cast<SequenceNode>(&N)) {
+      llvm::Optional<Fragment::IncludeRuleBlock> Result;
+      DictParser Dict("IncludeRule", this);
+      Dict.handle("PathMatch", [&](Node &N) {
+        if (auto Value = scalarValue(N, "PathMatch"))
+          Result->PathMatch = *Value;
+      });
+      Dict.handle("Type", [&](Node &N) {
+        if (auto Value = scalarValue(N, "Type"))
+          Result->Type = *Value;
+      });
+      Dict.handle("Replace", [&](Node &N) {
+        if (auto Value = scalarValue(N, "Replace"))
+          Result->Replace = *Value;
+      });
+      for (auto &Child : *S) {
+        Result.emplace();
+        Dict.parse(Child);
+        if (!this->HadError)
+          F.emplace_back(std::move(*Result), Child.getSourceRange());
+        Result.emplace();
+      }
+    } else {
+      N.skip();
+      error("Expected list of Input Rules", N);
+    }
+  }
+
   // Helper for parsing mapping nodes (dictionaries).
   // We don't use YamlIO as we want to control over unknown keys.
   class DictParser {
     llvm::StringRef Description;
     std::vector<std::pair<llvm::StringRef, std::function<void(Node &)>>> Keys;
     std::function<bool(Located<std::string>, Node &)> UnknownHandler;
     Parser *Outer;
 

clang-tools-extra/clangd/IncludeFixer.h

 //===--- IncludeFixer.h ------------------------------------------*- C++-*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_INCLUDEFIXER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INCLUDEFIXER_H
 
 #include "Diagnostics.h"
 #include "Headers.h"
+#include "IncludeRenamer.h"
 #include "index/Index.h"
 #include "index/Symbol.h"
 #include "clang/AST/Type.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Sema/ExternalSemaSource.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include <memory>
 
 namespace clang {
 namespace clangd {
 
 /// Attempts to recover from error diagnostics by suggesting include insertion
 /// fixes. For example, member access into incomplete type can be fixes by
 /// include headers with the definition.
 class IncludeFixer {
 public:
   IncludeFixer(llvm::StringRef File, std::shared_ptr<IncludeInserter> Inserter,
-               const SymbolIndex &Index, unsigned IndexRequestLimit)
+               const SymbolIndex &Index, unsigned IndexRequestLimit,
+               std::shared_ptr<const IncludeRenamer> Renamer)
       : File(File), Inserter(std::move(Inserter)), Index(Index),
-        IndexRequestLimit(IndexRequestLimit) {}
+        IndexRequestLimit(IndexRequestLimit), Renamer(Renamer) {}
 
   /// Returns include insertions that can potentially recover the diagnostic.
   /// If Info is a note and fixes are returned, they should *replace* the note.
   std::vector<Fix> fix(DiagnosticsEngine::Level DiagLevel,
                        const clang::Diagnostic &Info) const;
 
   /// Returns an ExternalSemaSource that records failed name lookups in Sema.
   /// This allows IncludeFixer to suggest inserting headers that define those
private:
   // copy-and-pasted without #includes. We cache the index results based on
   // index requests.
   mutable llvm::StringMap<SymbolSlab> FuzzyFindCache;
   mutable llvm::DenseMap<SymbolID, SymbolSlab> LookupCache;
   // Returns None if the number of index requests has reached the limit.
   llvm::Optional<const SymbolSlab *>
   fuzzyFindCached(const FuzzyFindRequest &Req) const;
   llvm::Optional<const SymbolSlab *> lookupCached(const SymbolID &ID) const;
+
+  std::shared_ptr<const IncludeRenamer> Renamer;
 };
 
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INCLUDEFIXER_H

clang-tools-extra/clangd/IncludeFixer.cpp

std::vector<Fix> IncludeFixer::fixesForSymbols(const SymbolSlab &Syms) const {
   // Deduplicate fixes by include headers. This doesn't distinguish symbols in
   // different scopes from the same header, but this case should be rare and is
   // thus ignored.
   llvm::StringSet<> InsertedHeaders;
   for (const auto &Sym : Syms) {
     for (const auto &Inc : getRankedIncludes(Sym)) {
       if (auto ToInclude = Inserted(Sym, Inc)) {
         if (ToInclude->second) {
-          if (!InsertedHeaders.try_emplace(ToInclude->first).second)
+          if (auto MappedInclude = Renamer->processInclude(ToInclude->first)) {
+            if (!InsertedHeaders.try_emplace(*MappedInclude).second)
               continue;
             if (auto Fix =
-                  insertHeader(ToInclude->first, (Sym.Scope + Sym.Name).str()))
+                    insertHeader(*MappedInclude, (Sym.Scope + Sym.Name).str()))
               Fixes.push_back(std::move(*Fix));
           }
+        }
       } else {
         vlog("Failed to calculate include insertion for {0} into {1}: {2}", Inc,
              File, ToInclude.takeError());
       }
     }
   }
   return Fixes;
 }

clang-tools-extra/clangd/IncludeRenamer.h

+//===--- IncludeRenamed.h-----------------------------------------*- C++-*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_INCLUDERENAMED_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INCLUDERENAMED_H
+
+#include "clang/Basic/LLVM.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Regex.h"
+#include <memory>
+#include <mutex>
+#include <vector>
+namespace clang::clangd {
+
+class IncludeRule {
+  friend class IncludeRenamer;
+
+public:
+  enum class Type { Angled, Quoted, Disabled };
+
+  IncludeRule(std::shared_ptr<llvm::Regex> Match, Optional<Type> IncludeType,
+              Optional<std::string> Replace)
+      : Match(std::move(Match)), IncludeType(IncludeType),
+        Replace(std::move(Replace)) {}
+
+private:
+  std::shared_ptr<llvm::Regex> Match;
+  Optional<Type> IncludeType;
+  Optional<std::string> Replace;
+};
+
+class IncludeRenamer {
+public:
+  Optional<std::string> processInclude(StringRef Include) const;
+
+  void addRule(IncludeRule &&Rule);
+
+  void addRules(ArrayRef<IncludeRule> Rules);
+
+  bool empty() const;
+
+  size_t size() const;
+
+private:
+  mutable std::mutex Guard;
+  std::vector<IncludeRule> Rules;
+};
+
+} // namespace clang::clangd
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INCLUDERENAMED_H
 No newline at end of file

clang-tools-extra/clangd/IncludeRenamer.cpp

+//===--- IncludeRenamed.cpp---------------------------------------*- C++-*-===//
+//
+// 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 "IncludeRenamer.h"
+#include "support/Logger.h"
+#include "llvm/ADT/None.h"
+#include <mutex>
+
+namespace clang::clangd {
+
+llvm::Optional<std::string>
+IncludeRenamer::processInclude(llvm::StringRef Include) const {
+  std::lock_guard<std::mutex> Lock(Guard);
+  if (Include.empty())
+    return llvm::None;
+  if (Rules.empty())
+    return Include.str();
+  llvm::StringRef Hdr = Include;
+  bool IsQuote = Hdr.consume_front("\"");
+  if (IsQuote ? Hdr.consume_back("\"")
+              : (Hdr.consume_front("<") && Hdr.consume_back(">"))) {
+    for (auto &Rule : Rules) {
+      if (Rule.Match->match(Hdr)) {
+        if (Rule.IncludeType == IncludeRule::Type::Disabled)
+          return llvm::None;
+        bool NewQuotes = (Rule.IncludeType)
+                             ? (*Rule.IncludeType == IncludeRule::Type::Quoted)
+                             : IsQuote;
+        std::string NewHdr = NewQuotes ? "\"" : "<";
+        std::string Err;
+        if (Rule.Replace) {
+          NewHdr += Rule.Match->sub(*Rule.Replace, Hdr, &Err);
+          if (!Err.empty()) {
+            log("Failed to regex replace include '{0}' with error: "
+                "'{1}')",
+                Hdr, Err);
+            break;
+          }
+        } else {
+          NewHdr += Hdr;
+        }
+        NewHdr += NewQuotes ? '"' : '>';
+        return std::move(NewHdr);
+      }
+    }
+  }
+  return Include.str();
+}
+
+void IncludeRenamer::addRule(IncludeRule &&Rule) {
+  assert(Rule.Match && Rule.Match->isValid());
+  std::lock_guard<std::mutex> Lock(Guard);
+  Rules.push_back(std::move(Rule));
+}
+
+void IncludeRenamer::addRules(ArrayRef<IncludeRule> Rules) {
+  assert(llvm::all_of(Rules, [](const IncludeRule &R) {
+    return R.Match && R.Match->isValid();
+  }));
+  std::lock_guard<std::mutex> Lock(Guard);
+  // Insert from the beginning as higher priority configs are loaded later.
+  this->Rules.insert(this->Rules.begin(), Rules.begin(), Rules.end());
+}
+
+bool IncludeRenamer::empty() const {
+  std::lock_guard<std::mutex> Lock(Guard);
+  return Rules.empty();
+}
+
+size_t IncludeRenamer::size() const {
+  std::lock_guard<std::mutex> Lock(Guard);
+  return Rules.size();
+}
+
+} // namespace clang::clangd

clang-tools-extra/clangd/ParsedAST.cpp

if (Inputs.Index && !BuildDir.getError()) {
       auto Inserter = std::make_shared<IncludeInserter>(
           Filename, Inputs.Contents, Style, BuildDir.get(),
           &Clang->getPreprocessor().getHeaderSearchInfo());
       if (Preamble) {
         for (const auto &Inc : Preamble->Includes.MainFileIncludes)
           Inserter->addExisting(Inc);
       }
       FixIncludes.emplace(Filename, Inserter, *Inputs.Index,
-                          /*IndexRequestLimit=*/5);
+                          /*IndexRequestLimit=*/5, Cfg.IncludeRules);
       ASTDiags.contributeFixes([&FixIncludes](DiagnosticsEngine::Level DiagLevl,
                                               const clang::Diagnostic &Info) {
         return FixIncludes->fix(DiagLevl, Info);
       });
       Clang->setExternalSemaSource(FixIncludes->unresolvedNameRecorder());
     }
   }
 

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

 //===-- CodeCompleteTests.cpp -----------------------------------*- C++ -*-===//
 //
 // 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 "ASTSignals.h"
 #include "Annotations.h"
 #include "ClangdServer.h"
 #include "CodeComplete.h"
 #include "Compiler.h"
+#include "IncludeRenamer.h"
 #include "Matchers.h"
 #include "Protocol.h"
 #include "Quality.h"
 #include "SourceCode.h"
 #include "SyncAPI.h"
 #include "TestFS.h"
 #include "TestIndex.h"
 #include "TestTU.h"
TEST(CompletionTest, InsertTheMostPopularHeader) {
   Sym.IncludeHeaders.emplace_back("\"bar.h\"", 1000);
 
   auto Results = completions("Fun^", {Sym}).Completions;
   assert(!Results.empty());
   EXPECT_THAT(Results[0], AllOf(named("Func"), insertInclude("\"bar.h\"")));
   EXPECT_EQ(Results[0].Includes.size(), 2u);
 }
 
+TEST(CompletionTest, InsertIncludeRules) {
+  std::string DeclFile = URI::create(testPath("foo")).toString();
+  Symbol Sym = func("Func");
+  Sym.CanonicalDeclaration.FileURI = DeclFile.c_str();
+  Sym.IncludeHeaders.emplace_back("\"foo.h\"", 2);
+
+  CodeCompleteOptions Opts;
+  auto Renamer = std::make_shared<IncludeRenamer>();
+  Renamer->addRule({std::make_shared<llvm::Regex>("foo"),
+                    IncludeRule::Type::Angled, std::string("my_foo")});
+  Opts.IncludeRenamer = Renamer;
+  auto Results = completions("Fun^", {Sym}, Opts).Completions;
+  assert(!Results.empty());
+  EXPECT_THAT(Results[0], AllOf(insertInclude("<my_foo.h>")));
+}
+
 TEST(CompletionTest, NoInsertIncludeIfOnePresent) {
   Annotations Test(R"cpp(
     #include "foo.h"
     Fun^
   )cpp");
   auto TU = TestTU::withCode(Test.code());
   TU.AdditionalFiles["foo.h"] = "";
 

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

 
 TEST_F(ConfigCompileTests, Style) {
   Frag = {};
   Frag.Style.FullyQualifiedNamespaces.push_back(std::string("foo"));
   Frag.Style.FullyQualifiedNamespaces.push_back(std::string("bar"));
   EXPECT_TRUE(compileAndApply());
   EXPECT_THAT(Conf.Style.FullyQualifiedNamespaces, ElementsAre("foo", "bar"));
 }
+
+TEST_F(ConfigCompileTests, IncludeRules) {
+
+  auto Add = [&](llvm::StringRef PathMatch = "", llvm::StringRef Type = "",
+                 llvm::StringRef Replace = "") {
+    Fragment::IncludeRuleBlock IRB;
+    if (!PathMatch.empty())
+      IRB.PathMatch.emplace(PathMatch.str());
+    if (!Type.empty())
+      IRB.Type.emplace(Type.str());
+    if (!Replace.empty())
+      IRB.Replace.emplace(Replace.str());
+    Frag.IncludeRules.push_back(std::move(IRB));
+  };
+
+  {
+    Frag = {};
+    Add();
+    EXPECT_TRUE(compileAndApply());
+    EXPECT_THAT(
+        Diags.Diagnostics,
+        Contains(AllOf(diagMessage("Include block must contain 'PathMatch'"),
+                       diagKind(llvm::SourceMgr::DK_Error))));
+    EXPECT_TRUE(Conf.IncludeRules->empty());
+  }
+  {
+    Frag = {};
+    Add("InvalidRegex(");
+    EXPECT_TRUE(compileAndApply());
+    EXPECT_THAT(
+        Diags.Diagnostics,
+        Contains(AllOf(diagMessage("Invalid regular expression "
+                                   "'InvalidRegex(': parentheses not balanced"),
+                       diagKind(llvm::SourceMgr::DK_Error))));
+    EXPECT_TRUE(Conf.IncludeRules->empty());
+  }
+  {
+    Frag = {};
+    Add("^library-10/");
+    EXPECT_TRUE(compileAndApply());
+    EXPECT_THAT(Diags.Diagnostics, IsEmpty());
+    EXPECT_EQ(Conf.IncludeRules->size(), 1U);
+  }
+  {
+    Frag = {};
+    Add("^library-10/", "Invalid");
+    EXPECT_TRUE(compileAndApply());
+    EXPECT_THAT(Diags.Diagnostics,
+                Contains(AllOf(
+                    diagMessage("Invalid Type value 'Invalid'. "
+                                "Valid values are Quoted, Angled, Disabled."),
+                    diagKind(llvm::SourceMgr::DK_Warning))));
+    EXPECT_EQ(Conf.IncludeRules->size(), 1U);
+  }
+
+  {
+    Frag = {};
+    Add("^library-10/", "Quoted");
+    Add("^library-12/", "Angled");
+    Add("^library-13/", "", "library/");
+    EXPECT_TRUE(compileAndApply());
+    EXPECT_THAT(Diags.Diagnostics, IsEmpty());
+    EXPECT_EQ(Conf.IncludeRules->size(), 3U);
+  }
+}
 } // namespace
 } // namespace config
 } // namespace clangd
 } // namespace clang

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

Style:
   FullyQualifiedNamespaces: [foo, bar])yaml");
   auto Results =
       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")));
 }
+
+TEST(ParseYAML, IncludeRules) {
+  CapturedDiags Diags;
+  Annotations YAML(R"yaml(
+IncludeRules:
+  - PathMatch: 'Library/'
+    Type:       Angled
+  - PathMatch: 'Library2/'
+    Type:       Quoted
+    Replace:    'Libary/'
+---
+IncludeRules:
+  $listinput^PathMatch:  'Library/'
+  Type:       Angled
+  Replace:    'Library2/'
+)yaml");
+  auto Results =
+      Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback());
+  ASSERT_EQ(Results.size(), 1u);
+  EXPECT_EQ(Results[0].IncludeRules.size(), 2U);
+  EXPECT_THAT(Diags.Diagnostics,
+              ElementsAre(AllOf(diagMessage("Expected list of Input Rules"),
+                                diagKind(llvm::SourceMgr::DK_Error),
+                                diagPos(YAML.point("listinput")))));
+}
 } // namespace
 } // namespace config
 } // namespace clangd
 } // namespace clang

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

 //===--- DiagnosticsTests.cpp ------------------------------------*- C++-*-===//
 //
 // 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 "Config.h"
 #include "Diagnostics.h"
 #include "Feature.h"
 #include "FeatureModule.h"
+#include "IncludeRenamer.h"
 #include "ParsedAST.h"
 #include "Protocol.h"
 #include "TestFS.h"
 #include "TestIndex.h"
 #include "TestTU.h"
 #include "TidyProvider.h"
 #include "index/MemIndex.h"
 #include "support/Context.h"
EXPECT_THAT(*TU.build().getDiagnostics(),
                   Diag(Test.range("unqualified"), "unknown type name 'X'"),
                   diagName("unknown_typename"),
                   withFix(Fix(Test.range("insert"), "#include \"a.h\"\n",
                               "Include \"a.h\" for symbol na::X"),
                           Fix(Test.range("insert"), "#include \"b.h\"\n",
                               "Include \"b.h\" for symbol na::nb::X")))));
 }
 
+TEST(IncludeFixerTest, InsertIncludeRules) {
+  Annotations Test(R"cpp(// error-ok
+$insert[[]]namespace na {
+namespace nb {
+void foo() {
+  $unqualified[[X]] x;
+}
+}
+}
+  )cpp");
+  auto TU = TestTU::withCode(Test.code());
+  auto Index = buildIndexWithSymbol(
+      {SymbolWithHeader{"na::X", "unittest:///foo.h", "\"foo.h\""},
+       SymbolWithHeader{"na::nb::X", "unittest:///bar.h", "\"bar.h\""}});
+  TU.ExternalIndex = Index.get();
+  Config Cfg;
+  Cfg.IncludeRules->addRule({std::make_shared<llvm::Regex>("^foo"),
+                             IncludeRule::Type::Angled, std::string("my_foo")});
+  Cfg.IncludeRules->addRule({std::make_shared<llvm::Regex>("^bar"),
+                             IncludeRule::Type::Disabled, None});
+  WithContextValue Ctx(Config::Key, std::move(Cfg));
+  EXPECT_THAT(*TU.build().getDiagnostics(),
+              UnorderedElementsAre(AllOf(
+                  Diag(Test.range("unqualified"), "unknown type name 'X'"),
+                  diagName("unknown_typename"),
+                  withFix(Fix(Test.range("insert"), "#include <my_foo.h>\n",
+                              "Include <my_foo.h> for symbol na::X")))));
+}
+
 TEST(IncludeFixerTest, NoCrashMemberAccess) {
   Annotations Test(R"cpp(// error-ok
     struct X { int  xyz; };
     void g() { X x; x.$[[xy]]; }
   )cpp");
   auto TU = TestTU::withCode(Test.code());
   auto Index = buildIndexWithSymbol(
       SymbolWithHeader{"na::X", "unittest:///a.h", "\"a.h\""});