[clangd] Use include_cleaner spelling strategies in clangd.

[VitaNuo]

Remove unrelated formatting.

[VitaNuo]

Duplicate of https://reviews.llvm.org/D152913. Landed the other one.

clang-tools-extra/clangd/Hover.cpp

 #include "Config.h"
 #include "FindTarget.h"
 #include "Headers.h"
 #include "IncludeCleaner.h"
 #include "ParsedAST.h"
 #include "Selection.h"
 #include "SourceCode.h"
 #include "clang-include-cleaner/Analysis.h"
+#include "clang-include-cleaner/IncludeSpeller.h"
 #include "clang-include-cleaner/Types.h"
 #include "index/SymbolCollector.h"
 #include "support/Logger.h"
 #include "support/Markup.h"
 #include "support/Trace.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/AST/ASTTypeTraits.h"
void maybeAddSymbolProviders(ParsedAST &AST, HoverInfo &HI,
   // Pick the best-ranked non-#include'd provider
   const auto &H = RankedProviders.front();
   if (H.kind() == include_cleaner::Header::Physical &&
       H.physical() == SM.getFileEntryForID(SM.getMainFileID()))
     // Do not show main file as provider, otherwise we'll show provider info
     // on local variables, etc.
     return;
 
-  HI.Provider = spellHeader(AST, SM.getFileEntryForID(SM.getMainFileID()), H);
+  HI.Provider = include_cleaner::spellHeader(
+      {H, AST.getPreprocessor().getHeaderSearchInfo(),
+       SM.getFileEntryForID(SM.getMainFileID())});
 }
 
 // FIXME: similar functions are present in FindHeaders.cpp (symbolName)
 // and IncludeCleaner.cpp (getSymbolName). Introduce a name() method into
 // include_cleaner::Symbol instead.
 std::string getSymbolName(include_cleaner::Symbol Sym) {
   std::string Name;
   switch (Sym.kind()) {

clang-tools-extra/clangd/IncludeCleaner.h

 void setIncludeCleanerAnalyzesStdlib(bool B);
 
 /// Converts the clangd include representation to include-cleaner
 /// include representation.
 include_cleaner::Includes
 convertIncludes(const SourceManager &SM,
                 const llvm::ArrayRef<Inclusion> Includes);
 
-/// Determines the header spelling of an include-cleaner header
-/// representation. The spelling contains the ""<> characters.
-std::string spellHeader(ParsedAST &AST, const FileEntry *MainFile,
-                        include_cleaner::Header Provider);
-
 std::vector<include_cleaner::SymbolReference>
 collectMacroReferences(ParsedAST &AST);
 
 /// Find the first provider in the list that is matched by the includes.
 std::optional<include_cleaner::Header>
 firstMatchedProvider(const include_cleaner::Includes &Includes,
                      llvm::ArrayRef<include_cleaner::Header> Providers);
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INCLUDECLEANER_H

clang-tools-extra/clangd/IncludeCleaner.cpp

llvm::StringRef ResolvedPath =
         getResolvedPath(SymbolWithMissingInclude.Providers.front());
     if (isFilteredByConfig(Cfg, ResolvedPath)) {
       dlog("IncludeCleaner: not diagnosing missing include {0}, filtered by "
            "config",
            ResolvedPath);
       continue;
     }
 
-    std::string Spelling =
-        spellHeader(AST, MainFile, SymbolWithMissingInclude.Providers.front());
+    std::string Spelling = include_cleaner::spellHeader(
+        {SymbolWithMissingInclude.Providers.front(),
+         AST.getPreprocessor().getHeaderSearchInfo(), MainFile});
 
     llvm::StringRef HeaderRef{Spelling};
     bool Angled = HeaderRef.starts_with("<");
     // We might suggest insertion of an existing include in edge cases, e.g.,
     // include is present in a PP-disabled region, or spelling of the header
     // turns out to be the same as one of the unresolved includes in the
     // main file.
     std::optional<tooling::Replacement> Replacement = HeaderIncludes.insert(
if (!FE) {
       continue;
     }
     TransformedInc.Resolved = *FE;
     ConvertedIncludes.add(std::move(TransformedInc));
   }
   return ConvertedIncludes;
 }
 
-std::string spellHeader(ParsedAST &AST, const FileEntry *MainFile,
-                        include_cleaner::Header Provider) {
-  if (Provider.kind() == include_cleaner::Header::Physical) {
-    if (auto CanonicalPath =
-            getCanonicalPath(Provider.physical()->getLastRef(),
-                             AST.getSourceManager().getFileManager())) {
-      std::string SpelledHeader =
-          llvm::cantFail(URI::includeSpelling(URI::create(*CanonicalPath)));
-      if (!SpelledHeader.empty())
-        return SpelledHeader;
-    }
-  }
-  return include_cleaner::spellHeader(
-      {Provider, AST.getPreprocessor().getHeaderSearchInfo(), MainFile});
-}
-
 std::vector<const Inclusion *>
 getUnused(ParsedAST &AST,
           const llvm::DenseSet<IncludeStructure::HeaderID> &ReferencedFiles,
           const llvm::StringSet<> &ReferencedPublicHeaders) {
   trace::Span Tracer("IncludeCleaner::getUnused");
   const Config &Cfg = Config::current();
   std::vector<const Inclusion *> Unused;
   for (const Inclusion &MFI : AST.getIncludeStructure().MainFileIncludes) {
return MapInfo::getHashValue(LHS.Symbol) <
            MapInfo::getHashValue(RHS.Symbol);
   });
   MissingIncludes.erase(llvm::unique(MissingIncludes), MissingIncludes.end());
   std::vector<const Inclusion *> UnusedIncludes =
       getUnused(AST, Used, /*ReferencedPublicHeaders*/ {});
   return {std::move(UnusedIncludes), std::move(MissingIncludes)};
 }
 
-std::optional<Fix> removeAllUnusedIncludes(llvm::ArrayRef<Diag> UnusedIncludes) {
+std::optional<Fix>
+removeAllUnusedIncludes(llvm::ArrayRef<Diag> UnusedIncludes) {
   if (UnusedIncludes.empty())
     return std::nullopt;
 
   Fix RemoveAll;
   RemoveAll.Message = "remove all unused includes";
   for (const auto &Diag : UnusedIncludes) {
     assert(Diag.Fixes.size() == 1 && "Expected exactly one fix.");
     RemoveAll.Edits.insert(RemoveAll.Edits.end(),
                            Diag.Fixes.front().Edits.begin(),
                            Diag.Fixes.front().Edits.end());
   }
 
   // TODO(hokein): emit a suitable text for the label.
   ChangeAnnotation Annotation = {/*label=*/"",
                                  /*needsConfirmation=*/true,
                                  /*description=*/""};
   static const ChangeAnnotationIdentifier RemoveAllUnusedID =
       "RemoveAllUnusedIncludes";
addAllMissingIncludes(llvm::ArrayRef<Diag> MissingIncludeDiags) {
 
   Fix AddAllMissing;
   AddAllMissing.Message = "add all missing includes";
   // A map to deduplicate the edits with the same new text.
   // newText (#include "my_missing_header.h") -> TextEdit.
   llvm::StringMap<TextEdit> Edits;
   for (const auto &Diag : MissingIncludeDiags) {
     assert(Diag.Fixes.size() == 1 && "Expected exactly one fix.");
-    for (const auto& Edit : Diag.Fixes.front().Edits) {
+    for (const auto &Edit : Diag.Fixes.front().Edits) {
       Edits.try_emplace(Edit.newText, Edit);
     }
   }
   // FIXME(hokein): emit used symbol reference in the annotation.
   ChangeAnnotation Annotation = {/*label=*/"",
                                  /*needsConfirmation=*/true,
                                  /*description=*/""};
   static const ChangeAnnotationIdentifier AddAllMissingID =
       "AddAllMissingIncludes";
   unsigned I = 0;
   for (auto &It : Edits) {
     ChangeAnnotationIdentifier ID = AddAllMissingID + std::to_string(I++);
     AddAllMissing.Edits.push_back(std::move(It.getValue()));
     AddAllMissing.Edits.back().annotationId = ID;
 
     AddAllMissing.Annotations.push_back({ID, Annotation});
   }
   return AddAllMissing;
 }
-Fix fixAll(const Fix& RemoveAllUnused, const Fix& AddAllMissing) {
+Fix fixAll(const Fix &RemoveAllUnused, const Fix &AddAllMissing) {
   Fix FixAll;
   FixAll.Message = "fix all includes";
 
   for (const auto &F : RemoveAllUnused.Edits)
     FixAll.Edits.push_back(F);
   for (const auto &F : AddAllMissing.Edits)
     FixAll.Edits.push_back(F);
 
-  for (const auto& A : RemoveAllUnused.Annotations)
+  for (const auto &A : RemoveAllUnused.Annotations)
     FixAll.Annotations.push_back(A);
-  for (const auto& A : AddAllMissing.Annotations)
+  for (const auto &A : AddAllMissing.Annotations)
     FixAll.Annotations.push_back(A);
   return FixAll;
 }
 
-std::vector<Diag> generateIncludeCleanerDiagnostic(
-    ParsedAST &AST, const IncludeCleanerFindings &Findings,
+std::vector<Diag>
+generateIncludeCleanerDiagnostic(ParsedAST &AST,
+                                 const IncludeCleanerFindings &Findings,
                                  llvm::StringRef Code) {
   std::vector<Diag> UnusedIncludes = generateUnusedIncludeDiagnostics(
       AST.tuPath(), Findings.UnusedIncludes, Code);
   std::optional<Fix> RemoveAllUnused = removeAllUnusedIncludes(UnusedIncludes);
 
-  std::vector<Diag> MissingIncludeDiags = generateMissingIncludeDiagnostics(
-      AST, Findings.MissingIncludes, Code);
+  std::vector<Diag> MissingIncludeDiags =
+      generateMissingIncludeDiagnostics(AST, Findings.MissingIncludes, Code);
   std::optional<Fix> AddAllMissing = addAllMissingIncludes(MissingIncludeDiags);
 
   std::optional<Fix> FixAll;
   if (RemoveAllUnused && AddAllMissing)
     FixAll = fixAll(*RemoveAllUnused, *AddAllMissing);
 
   auto AddBatchFix = [](const std::optional<Fix> &F, clang::clangd::Diag *Out) {
-    if (!F) return;
+    if (!F)
+      return;
     Out->Fixes.push_back(*F);
   };
   for (auto &Diag : MissingIncludeDiags) {
-    AddBatchFix(MissingIncludeDiags.size() > 1
-                    ? AddAllMissing
-                    : std::nullopt,
+    AddBatchFix(MissingIncludeDiags.size() > 1 ? AddAllMissing : std::nullopt,
                 &Diag);
     AddBatchFix(FixAll, &Diag);
   }
   for (auto &Diag : UnusedIncludes) {
-    AddBatchFix(UnusedIncludes.size() > 1 ? RemoveAllUnused
-                                          : std::nullopt,
+    AddBatchFix(UnusedIncludes.size() > 1 ? RemoveAllUnused : std::nullopt,
                 &Diag);
     AddBatchFix(FixAll, &Diag);
   }
 
   auto Result = std::move(MissingIncludeDiags);
-  llvm::move(UnusedIncludes,
-             std::back_inserter(Result));
+  llvm::move(UnusedIncludes, std::back_inserter(Result));
   return Result;
 }
 
 std::vector<Diag> issueIncludeCleanerDiagnostics(ParsedAST &AST,
                                                  llvm::StringRef Code) {
   // Interaction is only polished for C/CPP.
   if (AST.getLangOpts().ObjC)
     return {};