clangd: Provide hover info for include directives

[ckandeler]

Summary

It's quite useful to be able to hover over an #include and see the full
path to the header file.

[sammccall]

Thanks, this is great! I think we need to hold the line a bit on keeping different hovers uniform though.

clang-tools-extra/clangd/Hover.cpp

928

A HoverInfo with no name and no kind is a bit of a problem.

For the markdown rendering you're bailing out with a special case, which works but makes the layout inconsistent with other hovers. It's also harder to reason about the code when many kinds of symbols take different codepaths, which is one of the reasons we'd unified it.
We also have other clients of the C++ API that rely on name and preferably kind being present.

What about making Name the basename e.g. foo.h for #include "project/foo.h"

For Kind, there's no perfect Kind (using Module seems too confusing) and we can't easily extend the enum since we don't own it (we should fix this sometime...). Maybe just a FIXME there.

For the full path, it would be more consistent to store this in Definition if we can.
Only problem is Definition is a code block syntax-highlighted as C++. Quoting it will cause problems on windows (ugly escaped backslashes).
So I'd suggest adding const char* DefinitionLanguage = "cpp" to HoverInfo, and overriding it here. (And passing it through to codeBlock in present()).

clang-tools-extra/clangd/XRefs.cpp

537 ↗

(On Diff #362987)

This function is pretty simple and we don't use most of the result for hover.
Rather than making it public (and testing it!) and depending from hover->xrefs, can we just copy the needed bits into hover.cpp?

[ckandeler]

Addressed comments.

[ckandeler]

Addressed lint comments

[ckandeler]

Thanks for the review. Can you please merge it? I don't have the permissions.

[sammccall]

All done! Sorry for the delay.

clang-tools-extra/clangd/Hover.h

struct HoverInfo {
   std::string LocalScope;
   /// Name of the symbol, does not contain any "::".
   std::string Name;
   llvm::Optional<Range> SymRange;
   index::SymbolKind Kind = index::SymbolKind::Unknown;
   std::string Documentation;
   /// Source code containing the definition of the symbol.
   std::string Definition;
-
+  const char *DefinitionLanguage = "cpp";
   /// Access specifier for declarations inside class/struct/unions, empty for
   /// others.
   std::string AccessSpecifier;
   /// Pretty-printed variable type.
   /// Set only for variables.
   llvm::Optional<std::string> Type;
   /// Set for functions and lambdas.
   llvm::Optional<std::string> ReturnType;

clang-tools-extra/clangd/Hover.cpp

if (!CurLoc) {
     return llvm::None;
   }
   const auto &TB = AST.getTokens();
   auto TokensTouchingCursor = syntax::spelledTokensTouching(*CurLoc, TB);
   // Early exit if there were no tokens around the cursor.
   if (TokensTouchingCursor.empty())
     return llvm::None;
 
+  // Show full header file path if cursor is on include directive.
+  if (const auto MainFilePath =
+          getCanonicalPath(SM.getFileEntryForID(SM.getMainFileID()), SM)) {
+    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, *MainFilePath).file().str();
+      HI.DefinitionLanguage = "";
+      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);
   llvm::Optional<HoverInfo> HI;
   // Macros and deducedtype only works on identifiers and auto/decltype keywords
   // respectively. Therefore they are only trggered on whichever works for them,
if (auto Formatted =
     HI->Definition = *Formatted;
   HI->SymRange = halfOpenToRange(SM, HighlightRange);
 
   return HI;
 }
 
 markup::Document HoverInfo::present() const {
   markup::Document Output;
+
   // Header contains a text of the form:
   // variable `var`
   //
   // class `X`
   //
   // function `foo`
   //
   // expression
if (!LocalScope.empty()) {
       ScopeComment = "// In namespace " +
                      llvm::StringRef(*NamespaceScope).rtrim(':').str() + '\n';
     }
     std::string DefinitionWithAccess = !AccessSpecifier.empty()
                                            ? AccessSpecifier + ": " + Definition
                                            : Definition;
     // Note that we don't print anything for global namespace, to not annoy
     // non-c++ projects or projects that are not making use of namespaces.
-    Output.addCodeBlock(ScopeComment + DefinitionWithAccess);
+    Output.addCodeBlock(ScopeComment + DefinitionWithAccess,
+                        DefinitionLanguage);
   }
 
   return Output;
 }
 
 // If the backtick at `Offset` starts a probable quoted range, return the range
 // (including the quotes).
 llvm::Optional<llvm::StringRef> getBacktickQuoteRange(llvm::StringRef Line,

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

int foo = 3)",
           R"(variable foo
 
 Type: int
 Value = 3
 Passed by const reference as arg_a (converted to int)
 
 // In test::Bar
 int foo = 3)",
+      },
+      {
+          [](HoverInfo &HI) {
+            HI.Name = "stdio.h";
+            HI.Definition = "/usr/include/stdio.h";
+          },
+          R"(stdio.h
+
+/usr/include/stdio.h)",
       }};
 
   for (const auto &C : Cases) {
     HoverInfo HI;
     C.Builder(HI);
     EXPECT_EQ(HI.present().asPlainText(), C.ExpectedRender);
   }
 }