[clangd] Disable printing of Value for tag-types on hover

[kadircet]

Summary

This is both confusing and crashy.

[sammccall]

clang-tools-extra/clangd/Hover.cpp

345

nit: tag -> record (not handling enums)

[kadircet]

• tag -> record in comments

clang-tools-extra/clangd/Hover.cpp

llvm::Optional<std::string> printExprValue(const Expr *E,
   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.isNull() || 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))
+  if (E->isValueDependent() || !E->EvaluateAsRValue(Constant, Ctx) ||
+      // Disable printing for tag-types, as they are usually confusing and might
+      // make clang crash while printing the expressions.
+      Constant.Val.isStruct() || Constant.Val.isUnion())
     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());
+  return Constant.Val.getAsString(Ctx, T);
 }
 
 llvm::Optional<std::string> printExprValue(const SelectionTree::Node *N,
                                            const ASTContext &Ctx) {
   for (; N; N = N->Parent) {
     // Try to evaluate the first evaluatable enclosing expression.
     if (const Expr *E = N->ASTNode.get<Expr>()) {
       if (auto Val = printExprValue(E, Ctx))

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

class Foo {})cpp";
          HI.Type = "struct X &(float)";
          HI.ReturnType = "struct X &";
          HI.Parameters.emplace();
          HI.Parameters->emplace_back();
          HI.Parameters->back().Type = "float";
          HI.Parameters->back().Name = "v";
          HI.AccessSpecifier = "public";
        }},
+      {// Field type initializer.
+       R"cpp(
+          struct X { int x = 2; };
+          X ^[[x]];
+          )cpp",
+       [](HoverInfo &HI) {
+         HI.Name = "x";
+         HI.Kind = index::SymbolKind::Variable;
+         HI.NamespaceScope = "";
+         HI.Definition = "X x";
+         HI.Type = "struct X";
+       }},
   };
   for (const auto &Case : Cases) {
     SCOPED_TRACE(Case.Code);
 
     Annotations T(Case.Code);
     TestTU TU = TestTU::withCode(T.code());
     TU.ExtraArgs.push_back("-std=c++17");
     // Types might be different depending on the target triplet, we chose a
const std::function<void(HoverInfo &)> ExpectedBuilder;
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "x";
             HI.Kind = index::SymbolKind::Field;
             HI.NamespaceScope = "";
             HI.LocalScope = "Foo::";
             HI.Type = "int";
             HI.Definition = "int x";
-            HI.Value = "{1}";
+            // FIXME: Initializer for x is a DesignatedInitListExpr, hence it is
+            // of struct type and omitted.
           }},
       {
           R"cpp(// Field, field designator
-            struct Foo { int x; };
+            struct Foo { int x; int y; };
             int main() {
-              Foo bar = { .^[[x]] = 2 };
+              Foo bar = { .^[[x]] = 2, .y = 2 };
             }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "x";
             HI.Kind = index::SymbolKind::Field;
             HI.NamespaceScope = "";
             HI.LocalScope = "Foo::";
             HI.Type = "int";
             HI.Definition = "int x";
-            HI.Value = "{2}";
           }},
       {
           R"cpp(// Method call
             struct Foo { int x(); };
             int main() {
               Foo bar;
               bar.^[[x]]();
             }
const std::function<void(HoverInfo &)> ExpectedBuilder;
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "test";
             HI.Kind = index::SymbolKind::Variable;
             HI.NamespaceScope = "";
             HI.LocalScope = "test::";
             HI.Type = "struct Test &&";
             HI.Definition = "Test &&test = {}";
-            HI.Value = "{}";
           }},
       {
           R"cpp(// auto on alias
           typedef int int_type;
           ^[[auto]] x = int_type();
           )cpp",
           [](HoverInfo &HI) { HI.Name = "int"; }},
       {
const std::function<void(HoverInfo &)> ExpectedBuilder;
           cls<cls<cls<int>>> [[fo^o]];
           )cpp",
           [](HoverInfo &HI) {
             HI.Definition = "cls<cls<cls<int>>> foo";
             HI.Kind = index::SymbolKind::Variable;
             HI.NamespaceScope = "";
             HI.Name = "foo";
             HI.Type = "cls<cls<cls<int>>>";
-            HI.Value = "{}";
           }},
       {
           R"cpp(// type of nested templates.
           template <class T> struct cls {};
           [[cl^s]]<cls<cls<int>>> foo;
           )cpp",
           [](HoverInfo &HI) {
             HI.Definition = "template <> struct cls<cls<cls<int>>> {}";