[clangd] resolve forwarded parameters in Hover

[upsj]

Summary

This uses resolveForwardedParameters to get parameter names in Hover. The patch currently produces a slight inconsistency, since the definition uses the original function decl, while the parameters are resolved correctly.
I could use some feedback on how this should be handled - maybe add a comment in the style of "This function involves forwarding" that explains why the parameter names don't match?

[kadircet]

This looks like a nice idea, but i think we definitely need annotations to prevent confusion. I'd prefer something like:
assume foo(int x, Args... args);

function foo
-> void
Parameters:
- int x
- int a : forwarded to [bar:a](it'd be great if we could have location links here)
- int b : forwarded to [bar:b](again location links)

There's https://github.com/microsoft/language-server-protocol/issues/379 for asking to support links in hover, maybe we just need a way to point at a range inside a file

clang-tools-extra/clangd/Hover.cpp

HoverInfo::Param toHoverInfoParam(const ParmVarDecl *PVD,
   return Out;
 }
 
 // Populates Type, ReturnType, and Parameters for function-like decls.
 void fillFunctionTypeAndParams(HoverInfo &HI, const Decl *D,
                                const FunctionDecl *FD,
                                const PrintingPolicy &PP) {
   HI.Parameters.emplace();
-  for (const ParmVarDecl *PVD : FD->parameters())
+  for (const ParmVarDecl *PVD : resolveForwardingParameters(FD))
     HI.Parameters->emplace_back(toHoverInfoParam(PVD, PP));
 
   // We don't want any type info, if name already contains it. This is true for
   // constructors/destructors and conversion operators.
   const auto NK = FD->getDeclName().getNameKind();
   if (NK == DeclarationName::CXXConstructorName ||
       NK == DeclarationName::CXXDestructorName ||
       NK == DeclarationName::CXXConversionFunctionName)
     return;
 
   HI.ReturnType = printType(FD->getReturnType(), FD->getASTContext(), PP);
   QualType QT = FD->getType();
   if (const VarDecl *VD = llvm::dyn_cast<VarDecl>(D)) // Lambdas
     QT = VD->getType().getDesugaredType(D->getASTContext());
   HI.Type = printType(QT, D->getASTContext(), PP);
-  // FIXME: handle variadics.
 }
 
 // Non-negative numbers are printed using min digits
 // 0     => 0x0
 // 100   => 0x64
 // Negative numbers are sign-extended to 32/64 bits
 // -2    => 0xfffffffe
 // -2^32 => 0xfffffffeffffffff

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

class Foo final {})cpp";
          HI.Definition = "Foo<bool, true, false> foo(int, bool T = false)";
          HI.ReturnType = "Foo<bool, true, false>";
          HI.Type = "Foo<bool, true, false> (int, bool)";
          HI.Parameters = {
              {{"int"}, llvm::None, llvm::None},
              {{"bool"}, std::string("T"), std::string("false")},
          };
        }},
+      // Forwarding function decl
+      {R"cpp(
+          void baz(int a);
+          template <typename... Args>
+          void foo(Args... args) {
+            baz(args...);
+          }
+
+          void bar() {
+            [[fo^o]](3);
+          }
+          )cpp",
+       [](HoverInfo &HI) {
+         HI.NamespaceScope = "";
+         HI.Name = "foo";
+         HI.Kind = index::SymbolKind::Function;
+         HI.Definition = "template <> void foo << int >> (int args)";
+         HI.ReturnType = "void";
+         HI.Type = "void (int)";
+         HI.Parameters = {
+             {{"int"}, std::string("a"), llvm::None},
+         };
+       }},
       // Pointers to lambdas
       {R"cpp(
         void foo() {
           auto lamb = [](int T, bool B) -> bool { return T && B; };
           auto *b = &lamb;
           auto *[[^c]] = &b;
         }
         )cpp",