[clangd] Show used symbols on hover.

clang-tools-extra/clangd/Hover.cpp

 //===--- Hover.cpp - Information about code at the cursor location --------===//
 //
 // 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 "Hover.h"
 
 #include "AST.h"
 #include "CodeCompletionStrings.h"
 #include "Config.h"
 #include "FindTarget.h"
+#include "IncludeCleaner.h"
 #include "ParsedAST.h"
 #include "Selection.h"
 #include "SourceCode.h"
+#include "clang-include-cleaner/Types.h"
 #include "index/SymbolCollector.h"
 #include "support/Markup.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/AST/ASTTypeTraits.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclBase.h"
for (const auto &Inc : AST.getIncludeStructure().MainFileIncludes) {
     if (Inc.Resolved.empty() || Inc.HashLine != Pos.line)
       continue;
     HoverInfo HI;
     HI.Name = std::string(llvm::sys::path::filename(Inc.Resolved));
     // FIXME: We don't have a fitting value for Kind.
     HI.Definition =
         URIForFile::canonicalize(Inc.Resolved, AST.tuPath()).file().str();
     HI.DefinitionLanguage = "";
+
+    // TODO(bakalova) Continue here. Identify a good place to insert symbol refs.
+    // Definition is not a good place.
+    std::vector<include_cleaner::SymbolReference> MacroReferences =
+        collectMacroReferences(AST);
+    CachedIncludeCleaner IncludeCleaner(AST, MacroReferences);
+    llvm::DenseSet<UsedSymbol> SymbolRefs =
+        IncludeCleaner.computeUsedSymbols(Inc);
+    if (!SymbolRefs.empty()) {
+      HI.Definition.append("\nUsed symbols:\n");
+    }
+    for (UsedSymbol Ref : SymbolRefs) {
+        HI.Definition.append(Ref.Name);
+        HI.Definition.append("\n");
+    }
     return HI;
   }
 
   // To be used as a backup for highlighting the selected token, we use back as
   // it aligns better with biases elsewhere (editors tend to send the position
   // for the left of the hovered token).
   CharSourceRange HighlightRange =
       TokensTouchingCursor.back().range(SM).toCharRange(SM);

clang-tools-extra/clangd/IncludeCleaner.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_INCLUDECLEANER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INCLUDECLEANER_H
 
 #include "Config.h"
 #include "Headers.h"
 #include "ParsedAST.h"
+#include "clang-include-cleaner/Types.h"
 #include "index/CanonicalIncludes.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Tooling/Inclusions/StandardLibrary.h"
+#include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/STLFunctionalExtras.h"
 #include "llvm/ADT/StringSet.h"
 #include <optional>
 #include <vector>
 
 namespace clang {
 namespace clangd {
 
 struct ReferencedLocations {
   llvm::DenseSet<SourceLocation> User;
   llvm::DenseSet<tooling::stdlib::Symbol> Stdlib;
 };
 
+struct UsedSymbol {
+  std::string Name;
+  SourceLocation Location;
+};
+
 class CachedIncludeCleaner {
 
 public:
   CachedIncludeCleaner(
       ParsedAST &AST,
       const std::vector<include_cleaner::SymbolReference> &MacroReferences)
       : AST(AST), MacroReferences(MacroReferences), SM(AST.getSourceManager()) {
   }
 
   void run();
   std::vector<std::pair<std::string, unsigned>> computeMissingIncludes();
   std::vector<const Inclusion *> computeUnusedIncludesExperimental();
+  llvm::DenseSet<UsedSymbol> computeUsedSymbols(const Inclusion &Inclusion);
 
 private:
   ParsedAST &AST;
   const std::vector<include_cleaner::SymbolReference> &MacroReferences;
   llvm::SmallVector<include_cleaner::SymbolReference> Refs;
   llvm::SmallVector<llvm::SmallVector<include_cleaner::Header>> ProviderRefs;
   SourceManager &SM;
 

 /// - references to std-namespaced C types are not properly tracked:
 ///   instead of std::size_t -> <cstddef> we see ::size_t -> <stddef.h>
 /// FIXME: remove this hack once the implementation is good enough.
 void setIncludeCleanerAnalyzesStdlib(bool B);
 
 } // namespace clangd
 } // namespace clang
 
+namespace llvm {
+template <> struct llvm::DenseMapInfo<clang::clangd::UsedSymbol> {
+  static clang::clangd::UsedSymbol getEmptyKey() {
+    constexpr clang::SourceLocation::UIntTy Zero = 0;
+    return clang::clangd::UsedSymbol{
+        "", clang::SourceLocation::getFromRawEncoding(~Zero)};
+  }
+
+  static clang::clangd::UsedSymbol getTombstoneKey() {
+    constexpr clang::SourceLocation::UIntTy Zero = 0;
+    return clang::clangd::UsedSymbol{
+        "", clang::SourceLocation::getFromRawEncoding(~Zero - 1)};
+  }
+
+  static unsigned getHashValue(clang::clangd::UsedSymbol Sym) {
+    return std::hash<std::string>{}(Sym.Name);
+  }
+
+  static bool isEqual(clang::clangd::UsedSymbol LHS,
+                      clang::clangd::UsedSymbol RHS) {
+    return LHS.Name == RHS.Name;
+  }
+};
+} // namespace llvm
+
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INCLUDECLEANER_H

clang-tools-extra/clangd/IncludeCleaner.cpp

 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Basic/FileEntry.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Tooling/Syntax/Tokens.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/STLFunctionalExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Regex.h"
for (const include_cleaner::Header &H : Providers) {
           Used.insert(HeaderID);
         break;
       }
     }
   }
   return getUnused(AST, Used, /*ReferencedPublicHeaders*/ {});
 }
 
+// TODO(bakalova) Add unit test
+llvm::DenseSet<UsedSymbol>
+CachedIncludeCleaner::computeUsedSymbols(const Inclusion &Inclusion) {
+  if (Refs.empty()) {
+    run();
+  }
+  llvm::DenseSet<UsedSymbol> UsedSymbols;
+  // TODO(bakalova) Avoid double loop by adding a cache by header?
+  for (unsigned I = 0; I < Refs.size(); ++I) {
+    include_cleaner::SymbolReference Ref{Refs[I]};
+    std::string Name;
+    SourceLocation Location{Ref.RefLocation};
+    // TODO(bakalova) Name is not enough. Can I get more context? Check other hovers to see how
+    // they get more stuff (from a Decl?)
+    switch(Ref.Target.kind()) {
+       case include_cleaner::Symbol::Declaration:
+        Name = cast<NamedDecl>(Ref.Target.declaration())
+            .getDeclName()
+            .getAsString();   
+        break;
+      case include_cleaner::Symbol::Macro:
+        Name = Ref.Target.macro().Name->getName(); 
+        break;
+    }
+    llvm::SmallVector<include_cleaner::Header> Providers = ProviderRefs[I];
+    for (const include_cleaner::Header &H : Providers) {
+      switch (H.kind()) {
+      case include_cleaner::Header::Physical:
+        if (H.physical()->tryGetRealPathName().contains(
+                llvm::StringRef(Inclusion.Written).trim("\"<>"))) {
+          UsedSymbols.insert({Name, Location});
+        }
+        break;
+      case include_cleaner::Header::Standard:
+        if (Inclusion.Written == H.standard().name()) {
+          UsedSymbols.insert({Name, Location});
+        }
+        break;
+      // TODO(bakalova) does the verbatim thing include quotes or not?
+      case include_cleaner::Header::Verbatim:
+        if (Inclusion.Written == H.verbatim()) {
+          UsedSymbols.insert({Name, Location});
+        }
+        break;
+      }
+    }
+  }
+  return UsedSymbols;
+}
+
 include_cleaner::Includes
 CachedIncludeCleaner::convertIncludes(const SourceManager &SM,
                                       std::vector<Inclusion> MainFileIncludes) {
   include_cleaner::Includes Includes;
   for (const Inclusion &Inc : MainFileIncludes) {
     llvm::ErrorOr<const FileEntry *> ResolvedOrError =
         SM.getFileManager().getFile(Inc.Resolved);
     const FileEntry *Resolved = nullptr;