[clangd][Hover] Dont crash on null types

[hokein]

Thanks, I was going to prepare a patch this morning, then realized this one.

clang-tools-extra/clangd/Hover.cpp

302

nit: now we can remove this if-else branch.

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

716

I think auto [x, y] = 1 should be enough to reproduce the crash.

[kadircet]

clang-tools-extra/clangd/Hover.cpp

302

well, I wasn't sure what we were logging for :/

but I think you are right, it seems hard to find in the best case.

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

716

i could swear this was not crashing the first time i checked :P

[kadircet]

address comments

clang-tools-extra/clangd/Hover.cpp

std::string printDefinition(const Decl *D) {
   OS.flush();
   return Definition;
 }
 
 std::string printType(QualType QT, const PrintingPolicy &Policy) {
   // TypePrinter doesn't resolve decltypes, so resolve them here.
   // FIXME: This doesn't handle composite types that contain a decltype in them.
   // We should rather have a printing policy for that.
-  while (const auto *DT = QT->getAs<DecltypeType>())
-    QT = DT->getUnderlyingType();
+  while (!QT.isNull() && QT->isDecltypeType())
+    QT = QT->getAs<DecltypeType>()->getUnderlyingType();
   return QT.getAsString(Policy);
 }
 
 std::string printType(const TemplateTypeParmDecl *TTP) {
   std::string Res = TTP->wasDeclaredWithTypename() ? "typename" : "class";
   if (TTP->isParameterPack())
     Res += "...";
   return Res;
void fillFunctionTypeAndParams(HoverInfo &HI, const Decl *D,
                                const FunctionDecl *FD,
                                const PrintingPolicy &Policy) {
   HI.Parameters.emplace();
   for (const ParmVarDecl *PVD : FD->parameters()) {
     HI.Parameters->emplace_back();
     auto &P = HI.Parameters->back();
     if (!PVD->getType().isNull()) {
       P.Type = printType(PVD->getType(), Policy);
     } else {
       std::string Param;
       llvm::raw_string_ostream OS(Param);
       PVD->dump(OS);
       OS.flush();
       elog("Got param with null type: {0}", Param);
     }
     if (!PVD->getName().empty())
       P.Name = PVD->getNameAsString();

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

class Foo {})cpp";
           )cpp",
        [](HoverInfo &HI) {
          HI.Name = "x";
          HI.Kind = index::SymbolKind::Variable;
          HI.NamespaceScope = "";
          HI.Definition = "X x";
          HI.Type = "struct X";
        }},
+      {// Don't crash on null types.
+       R"cpp(
+          #define M(l, r) l = r
+          int bar();
+          void foo() {
+            M(auto [^[[x]]], bar()); /*error-ok*/
+          }
+          )cpp",
+       [](HoverInfo &HI) {
+         HI.Name = "x";
+         HI.Kind = index::SymbolKind::Variable;
+         HI.NamespaceScope = "";
+         HI.LocalScope = "foo::";
+         HI.Definition = "";
+         HI.Type = "NULL TYPE";
+         // Bindings are in theory public members of an anonymous struct.
+         HI.AccessSpecifier = "public";
+       }},
   };
   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