[clangd] Show values of more expressions on hover

[merge_guards_bot]

Build result: fail - 60143 tests passed, 2 failed and 729 were skipped.

failed: Clangd Unit Tests._/ClangdTests/FindExplicitReferencesTest.All
failed: LLVM.Bindings/Go/go.test

Log files: console-log.txt, CMakeCache.txt

[lh123]

clang-tools-extra/clangd/Hover.cpp

424

I think we should also support hover on literal.

[sammccall]

clang-tools-extra/clangd/Hover.cpp

424

sure - can you explain what you'd like to see/when you'd expect it to be useful?

[lh123]

clang-tools-extra/clangd/Hover.cpp

424

such as:

1. Hovering on "abc" shows char[4], we can get the length information of the string.
2. Get actual type for user-defined literal types.

c++
struct foo {};
struct foo {};

foo operator""_foo(unsigned long long v) { return {}; }

int main() {
    1_foo;
}

[lh123]

clang-tools-extra/clangd/Hover.cpp

424

struct foo {};

foo operator""_foo(unsigned long long v) { return {}; }

int main() {
    1_foo;
}

[kadircet]

clang-tools-extra/clangd/Hover.cpp

247

nit extract E->getType() into a variable

255

both Constant.Val.getInt and ECD->getInitVal are APSInt and it has an operator==, why cast to int64_t in between?

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

278

wow, that's hilarious.

460

what about GREEN (1) ?

[sammccall]

[sammccall]

GREEN -> GREEN (1)

[sammccall]

clang-tools-extra/clangd/Hover.cpp

255

operator== asserts(!) that the widths are equal. (And they're not always)
added a comment

424

Added a comment about literals.

[merge_guards_bot]

Build result: fail - 60136 tests passed, 2 failed and 729 were skipped.

failed: LLVM.CodeGen/NVPTX/vectorize-misaligned.ll
failed: LLVM.Transforms/LoadStoreVectorizer/AMDGPU/merge-stores.ll

Log files: console-log.txt, CMakeCache.txt

[kadircet]

it feels like rebasing went wrong :(

[sammccall]

Fix rebase

[kadircet]

LGTM, thanks!

[merge_guards_bot]

Build result: pass - 60178 tests passed, 0 failed and 732 were skipped.
Log files: console-log.txt, CMakeCache.txt

clang-tools-extra/clangd/Hover.cpp

 #include "AST.h"
 #include "CodeCompletionStrings.h"
 #include "FindTarget.h"
 #include "Logger.h"
 #include "Selection.h"
 #include "SourceCode.h"
 #include "index/SymbolCollector.h"
 
+#include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTTypeTraits.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/PrettyPrinter.h"
 
 namespace clang {
 namespace clangd {
 namespace {
 
if (const auto* CCD = llvm::dyn_cast<CXXConstructorDecl>(FD)) {
     QualType FunctionType = FD->getType();
     if (const VarDecl *VD = llvm::dyn_cast<VarDecl>(D)) // Lambdas
       FunctionType = VD->getType().getDesugaredType(D->getASTContext());
     HI.Type = FunctionType.getAsString(Policy);
   }
   // FIXME: handle variadics.
 }
 
+llvm::Optional<std::string> printExprValue(const Expr *E, const ASTContext &Ctx) {
+  Expr::EvalResult Constant;
+  // Evaluating [[foo]]() as "&foo" isn't useful, and prevents us walking up
+  // to the enclosing call.
+  QualType T = E->getType();
+  if (T->isFunctionType() || T->isFunctionPointerType() ||
+      T->isFunctionReferenceType())
+    return llvm::None;
+  // Attempt to evaluate. If expr is dependent, evaluation crashes!
+  if (E->isValueDependent() || !E->EvaluateAsRValue(Constant, Ctx))
+    return llvm::None;
+
+  // Show enums symbolically, not numerically like APValue::printPretty().
+  if (T->isEnumeralType() && Constant.Val.getInt().getMinSignedBits() <= 64) {
+    // Compare to int64_t to avoid bit-width match requirements.
+    int64_t Val = Constant.Val.getInt().getExtValue();
+    for (const EnumConstantDecl *ECD :
+         T->castAs<EnumType>()->getDecl()->enumerators())
+      if (ECD->getInitVal() == Val)
+        return llvm::formatv("{0} ({1})", ECD->getNameAsString(), Val).str();
+  }
+  return Constant.Val.getAsString(Ctx, E->getType());
+}
+
+llvm::Optional<std::string> printExprValue(const SelectionTree::Node *N,
+                                           const ASTContext &Ctx) {
+  for (; N; N = N->Parent) {
+    // Try to evaluate the first evaluable enclosing expression.
+    if (const Expr *E = N->ASTNode.get<Expr>()) {
+      if (auto Val = printExprValue(E, Ctx))
+        return Val;
+    } else if (N->ASTNode.get<Decl>() || N->ASTNode.get<Stmt>()) {
+      // Refuse to cross certain non-exprs. (TypeLoc are OK as part of Exprs).
+      // This tries to ensure we're showing a value related to the cursor.
+      break;
+    }
+  }
+  return llvm::None;
+}
+
 /// Generate a \p Hover object given the declaration \p D.
 HoverInfo getHoverContents(const Decl *D, const SymbolIndex *Index) {
   HoverInfo HI;
   const ASTContext &Ctx = D->getASTContext();
 
   HI.NamespaceScope = getNamespaceScope(D);
   if (!HI.NamespaceScope->empty())
     HI.NamespaceScope->append("::");
if (const FunctionDecl *FD = getUnderlyingFunction(D)) {
     fillFunctionTypeAndParams(HI, D, FD, Policy);
   } else if (const auto *VD = dyn_cast<ValueDecl>(D)) {
     HI.Type.emplace();
     llvm::raw_string_ostream OS(*HI.Type);
     VD->getType().print(OS, Policy);
   }
 
   // Fill in value with evaluated initializer if possible.
-  // FIXME(kadircet): Also set Value field for expressions like "sizeof" and
-  // function calls.
   if (const auto *Var = dyn_cast<VarDecl>(D)) {
-    if (const Expr *Init = Var->getInit()) {
-      Expr::EvalResult Result;
-      if (!Init->isValueDependent() && Init->EvaluateAsRValue(Result, Ctx)) {
-        HI.Value.emplace();
-        llvm::raw_string_ostream ValueOS(*HI.Value);
-        Result.Val.printPretty(ValueOS, const_cast<ASTContext &>(Ctx),
-                               Init->getType());
-      }
-    }
+    if (const Expr *Init = Var->getInit())
+      HI.Value = printExprValue(Init, Ctx);
   } else if (const auto *ECD = dyn_cast<EnumConstantDecl>(D)) {
     // Dependent enums (e.g. nested in template classes) don't have values yet.
     if (!ECD->getType()->isDependentType())
       HI.Value = ECD->getInitVal().toString(10);
   }
 
   HI.Definition = printDefinition(D);
   enhanceFromIndex(HI, D, Index);
if (!Offset) {
       llvm::consumeError(Offset.takeError());
       return llvm::None;
     }
     SelectionTree Selection(AST.getASTContext(), AST.getTokens(), *Offset);
     std::vector<const Decl *> Result;
     if (const SelectionTree::Node *N = Selection.commonAncestor()) {
       DeclRelationSet Rel = DeclRelation::TemplatePattern | DeclRelation::Alias;
       auto Decls = targetDecl(N->ASTNode, Rel);
-      if (!Decls.empty())
+      if (!Decls.empty()) {
         HI = getHoverContents(Decls.front(), Index);
+        // Look for a close enclosing expression to show the value of.
+        if (!HI->Value)
+          HI->Value = printExprValue(N, AST.getASTContext());
+      }
+      // FIXME: support hovers for other nodes?
+      //  - certain expressions (sizeof etc)
+      //  - built-in types
+      //  - literals (esp user-defined)
     }
   }
 
   if (!HI)
     return llvm::None;
 
   auto Replacements = format::reformat(
       Style, HI->Definition, tooling::Range(0, HI->Definition.size()));

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

void foo())cpp";
          HI.Kind = SymbolKind::Variable;
          HI.Definition = "decltype(lamb) bar";
          HI.Type = "class (lambda)";
          HI.ReturnType = "bool";
          HI.Parameters = {
              {std::string("int"), std::string("T"), llvm::None},
              {std::string("bool"), std::string("B"), llvm::None},
          };
+         HI.Value = "false";
          return HI;
        }},
       // Lambda variable
       {R"cpp(
         void foo() {
           int bar = 5;
           auto lamb = [&bar](int T, bool B) -> bool { return T && B && bar; };
           bool res = [[lam^b]](bar, false);
void foo())cpp";
        )cpp",
        [](HoverInfo &HI) {
          HI.Name = "GREEN";
          HI.NamespaceScope = "";
          HI.LocalScope = "Color::";
          HI.Definition = "GREEN";
          HI.Kind = SymbolKind::EnumMember;
          HI.Type = "enum Color";
-         HI.Value = "1";
+         HI.Value = "1"; // Numeric when hovering on the enumerator name.
+       }},
+      {R"cpp(
+        enum Color { RED, GREEN, };
+        Color x = GREEN;
+        Color y = [[^x]];
+       )cpp",
+       [](HoverInfo &HI) {
+         HI.Name = "x";
+         HI.NamespaceScope = "";
+         HI.Definition = "enum Color x = GREEN";
+         HI.Kind = SymbolKind::Variable;
+         HI.Type = "enum Color";
+         HI.Value = "GREEN (1)"; // Symbolic when hovering on an expression.
        }},
       // FIXME: We should use the Decl referenced, even if from an implicit
-      // instantiation. Then the scope would be Add<1, 2> and the value 3.
+      // instantiation. Then the scope would be Add<1, 2>.
       {R"cpp(
         template<int a, int b> struct Add {
           static constexpr int result = a + b;
         };
         int bar = Add<1, 2>::[[resu^lt]];
         )cpp",
        [](HoverInfo &HI) {
          HI.Name = "result";
          HI.Definition = "static constexpr int result = a + b";
          HI.Kind = SymbolKind::Property;
          HI.Type = "const int";
          HI.NamespaceScope = "";
          HI.LocalScope = "Add<a, b>::";
+         HI.Value = "3";
+       }},
+      {R"cpp(
+        constexpr int answer() { return 40 + 2; }
+        int x = [[ans^wer]]();
+        )cpp",
+       [](HoverInfo &HI) {
+         HI.Name = "answer";
+         HI.Definition = "constexpr int answer()";
+         HI.Kind = SymbolKind::Function;
+         HI.Type = "int ()";
+         HI.ReturnType = "int";
+         HI.Parameters.emplace();
+         HI.NamespaceScope = "";
+         HI.Value = "42";
        }},
       {R"cpp(
         const char *[[ba^r]] = "1234";
         )cpp",
        [](HoverInfo &HI) {
          HI.Name = "bar";
          HI.Definition = "const char *bar = \"1234\"";
          HI.Kind = SymbolKind::Variable;