Added parameter names to signature help.

clang-tools-extra/clangd/CodeComplete.cpp

void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg,
     SigHelp.activeSignature = 0;
     assert(CurrentArg <= (unsigned)std::numeric_limits<int>::max() &&
            "too many arguments");
 
     SigHelp.activeParameter = static_cast<int>(CurrentArg);
 
     for (unsigned I = 0; I < NumCandidates; ++I) {
       OverloadCandidate Candidate = Candidates[I];
+
       // We want to avoid showing instantiated signatures, because they may be
       // long in some cases (e.g. when 'T' is substituted with 'std::string', we
       // would get 'std::basic_string<char>').
       if (auto *Func = Candidate.getFunction()) {
         if (auto *Pattern = Func->getTemplateInstantiationPattern())
           Candidate = OverloadCandidate(Pattern);
       }
       if (static_cast<int>(I) == SigHelp.activeSignature) {
llvm::sort(ScoredSignatures, [](const ScoredSignature &L,
           R.Quality.NumberOfOptionalParameters)
         return L.Quality.NumberOfOptionalParameters <
                R.Quality.NumberOfOptionalParameters;
       if (L.Quality.Kind != R.Quality.Kind) {
         using OC = CodeCompleteConsumer::OverloadCandidate;
         auto KindPriority = [&](OC::CandidateKind K) {
           switch (K) {
           case OC::CK_Aggregate:
-            return 1;
+            return 0;
           case OC::CK_Function:
-            return 2;
+            return 1;
           case OC::CK_FunctionType:
+            return 2;
+          case OC::CK_FunctionProtoTypeLoc:
             return 3;
           case OC::CK_FunctionTemplate:
             return 4;
           case OC::CK_Template:
             return 5;
           }
           llvm_unreachable("Unknown overload candidate type.");
         };

clang/include/clang/Sema/CodeCompleteConsumer.h

enum CandidateKind {
 
       /// The candidate is a function template, arguments are being completed.
       CK_FunctionTemplate,
 
       /// The "candidate" is actually a variable, expression, or block
       /// for which we only have a function prototype.
       CK_FunctionType,
 
+      CK_FunctionProtoTypeLoc,
+
       /// The candidate is a template, template arguments are being completed.
       CK_Template,
 
       /// The candidate is aggregate initialization of a record type.
       CK_Aggregate,
     };
 
   private:
     /// The kind of overload candidate.
     CandidateKind Kind;
 
     union {
       /// The function overload candidate, available when
       /// Kind == CK_Function.
       FunctionDecl *Function;
 
       /// The function template overload candidate, available when
       /// Kind == CK_FunctionTemplate.
       FunctionTemplateDecl *FunctionTemplate;
 
       /// The function type that describes the entity being called,
       /// when Kind == CK_FunctionType.
       const FunctionType *Type;
 
+      FunctionProtoTypeLoc ProtoTypeLoc;
+
       /// The template overload candidate, available when
       /// Kind == CK_Template.
       const TemplateDecl *Template;
 
       /// The class being aggregate-initialized,
       /// when Kind == CK_Aggregate
       const RecordDecl *AggregateType;
     };
OverloadCandidate(FunctionTemplateDecl *FunctionTemplateDecl)
       assert(FunctionTemplateDecl != nullptr);
     }
 
     OverloadCandidate(const FunctionType *Type)
         : Kind(CK_FunctionType), Type(Type) {
       assert(Type != nullptr);
     }
 
+    OverloadCandidate(FunctionProtoTypeLoc Prototype)
+        : Kind(CK_FunctionProtoTypeLoc), ProtoTypeLoc(Prototype) {
+      assert(!Prototype.isNull());
+    }
+
     OverloadCandidate(const RecordDecl *Aggregate)
         : Kind(CK_Aggregate), AggregateType(Aggregate) {
       assert(Aggregate != nullptr);
     }
 
     OverloadCandidate(const TemplateDecl *Template)
         : Kind(CK_Template), Template(Template) {}
 
FunctionTemplateDecl *getFunctionTemplate() const {
       assert(getKind() == CK_FunctionTemplate && "Not a function template");
       return FunctionTemplate;
     }
 
     /// Retrieve the function type of the entity, regardless of how the
     /// function is stored.
     const FunctionType *getFunctionType() const;
 
+    /// Retrieve the function ProtoTypeLoc candidate.
+    const FunctionProtoTypeLoc getFunctionProtoTypeLoc() const;
+
     const TemplateDecl *getTemplate() const {
       assert(getKind() == CK_Template && "Not a template");
       return Template;
     }
 
     /// Retrieve the aggregate type being initialized.
     const RecordDecl *getAggregate() const {
       assert(getKind() == CK_Aggregate);

clang/lib/Sema/CodeCompleteConsumer.cpp

CodeCompleteConsumer::OverloadCandidate::getFunctionType() const {
 
   case CK_FunctionTemplate:
     return FunctionTemplate->getTemplatedDecl()
         ->getType()
         ->getAs<FunctionType>();
 
   case CK_FunctionType:
     return Type;
-
+  case CK_FunctionProtoTypeLoc:
+    return ProtoTypeLoc.getTypePtr();
   case CK_Template:
   case CK_Aggregate:
     return nullptr;
   }
 
   llvm_unreachable("Invalid CandidateKind!");
 }
 
+ const FunctionProtoTypeLoc CodeCompleteConsumer::OverloadCandidate::getFunctionProtoTypeLoc() const {
+   if (Kind == CK_FunctionProtoTypeLoc)
+     return ProtoTypeLoc;
+   return FunctionProtoTypeLoc();
+ }
+
 unsigned CodeCompleteConsumer::OverloadCandidate::getNumParams() const {
   if (Kind == CK_Template)
     return Template->getTemplateParameters()->size();
 
   if (Kind == CK_Aggregate) {
     unsigned Count =
         std::distance(AggregateType->field_begin(), AggregateType->field_end());
     if (const auto *CRD = dyn_cast<CXXRecordDecl>(AggregateType))
       Count += CRD->getNumBases();
     return Count;
   }
 
   if (const auto *FT = getFunctionType())
     if (const auto *FPT = dyn_cast<FunctionProtoType>(FT))
       return FPT->getNumParams();
+  if (!getFunctionProtoTypeLoc().isNull()) {
+    return ProtoTypeLoc.getNumParams();
+  }
 
   return 0;
 }
 
 QualType
 CodeCompleteConsumer::OverloadCandidate::getParamType(unsigned N) const {
   if (Kind == CK_Aggregate) {
     if (const auto *CRD = dyn_cast<CXXRecordDecl>(AggregateType)) {
if (Kind == CK_Template) {
     return nullptr;
   }
 
   // Note that if we only have a FunctionProtoType, we don't have param decls.
   if (const auto *FD = getFunction()) {
     if (N < FD->param_size())
       return FD->getParamDecl(N);
   }
+  else if (!getFunctionProtoTypeLoc().isNull()) {
+    if (N < ProtoTypeLoc.getNumParams()) {
+      return ProtoTypeLoc.getParam(N);
+    }
+  }
+
   return nullptr;
 }
 
 //===----------------------------------------------------------------------===//
 // Code completion consumer implementation
 //===----------------------------------------------------------------------===//
 
 CodeCompleteConsumer::~CodeCompleteConsumer() = default;

clang/lib/Sema/SemaCodeComplete.cpp

 }
 
 /// Add function overload parameter chunks to the given code completion
 /// string.
 static void AddOverloadParameterChunks(ASTContext &Context,
                                        const PrintingPolicy &Policy,
                                        const FunctionDecl *Function,
                                        const FunctionProtoType *Prototype,
+                                       FunctionProtoTypeLoc PrototypeLoc,
                                        CodeCompletionBuilder &Result,
                                        unsigned CurrentArg, unsigned Start = 0,
                                        bool InOptional = false) {
   if (!Function && !Prototype) {
     Result.AddChunk(CodeCompletionString::CK_CurrentParameter, "...");
     return;
   }
 
   bool FirstParameter = true;
   unsigned NumParams =
       Function ? Function->getNumParams() : Prototype->getNumParams();
 
   for (unsigned P = Start; P != NumParams; ++P) {
     if (Function && Function->getParamDecl(P)->hasDefaultArg() && !InOptional) {
       // When we see an optional default argument, put that argument and
       // the remaining default arguments into a new, optional string.
       CodeCompletionBuilder Opt(Result.getAllocator(),
                                 Result.getCodeCompletionTUInfo());
       if (!FirstParameter)
         Opt.AddChunk(CodeCompletionString::CK_Comma);
       // Optional sections are nested.
-      AddOverloadParameterChunks(Context, Policy, Function, Prototype, Opt,
+      AddOverloadParameterChunks(Context, Policy, Function, Prototype, PrototypeLoc, Opt,
                                  CurrentArg, P, /*InOptional=*/true);
       Result.AddOptionalChunk(Opt.TakeString());
       return;
     }
 
     if (FirstParameter)
       FirstParameter = false;
     else
       Result.AddChunk(CodeCompletionString::CK_Comma);
 
     InOptional = false;
 
     // Format the placeholder string.
     std::string Placeholder;
     if (Function) {
       const ParmVarDecl *Param = Function->getParamDecl(P);
       Placeholder = FormatFunctionParameter(Policy, Param);
       if (Param->hasDefaultArg())
         Placeholder += GetDefaultValueString(Param, Context.getSourceManager(),
                                              Context.getLangOpts());
+    } else if (!PrototypeLoc.isNull()) {
+      if (P < PrototypeLoc.getNumParams()) {
+        const ParmVarDecl *Param = PrototypeLoc.getParam(P);
+        Placeholder = FormatFunctionParameter(Policy, Param);
+        if (Param->hasDefaultArg())
+          Placeholder += GetDefaultValueString(Param, Context.getSourceManager(),
+                                            Context.getLangOpts());
+      }
     } else {
       Placeholder = Prototype->getParamType(P).getAsString(Policy);
     }
 
     if (P == CurrentArg)
       Result.AddCurrentParameterChunk(
           Result.getAllocator().CopyString(Placeholder));
     else
CodeCompleteConsumer::OverloadCandidate::CreateSignatureString(
   }
 
   // Next, the brackets and parameters.
   Result.AddChunk(Braced ? CodeCompletionString::CK_LeftBrace
                          : CodeCompletionString::CK_LeftParen);
   if (getKind() == CK_Aggregate)
     AddOverloadAggregateChunks(getAggregate(), Policy, Result, CurrentArg);
   else
-    AddOverloadParameterChunks(S.getASTContext(), Policy, FDecl, Proto, Result,
+    AddOverloadParameterChunks(S.getASTContext(), Policy, FDecl, Proto, getFunctionProtoTypeLoc(), Result,
                                CurrentArg);
   Result.AddChunk(Braced ? CodeCompletionString::CK_RightBrace
                          : CodeCompletionString::CK_RightParen);
 
   return Result.TakeString();
 }
 
 unsigned clang::getMacroUsagePriority(StringRef MacroName,
if (Candidates.empty())
     return QualType();
   if (SemaRef.getPreprocessor().isCodeCompletionReached())
     SemaRef.CodeCompleter->ProcessOverloadCandidates(
         SemaRef, CurrentArg, Candidates.data(), Candidates.size(), OpenParLoc,
         Braced);
   return getParamType(SemaRef, Candidates, CurrentArg);
 }
 
+#include <iostream>
+static FunctionProtoTypeLoc GetPrototypeLoc(Expr *Fn) {
+  if (const auto *T = Fn->getType().getTypePtr()->getAs<TypedefType>()) {
+    const auto *D = T->getDecl();
+    
+    TypeLoc TypedefTarget = D->getTypeSourceInfo()->getTypeLoc();
+    if (auto P = TypedefTarget.getAs<PointerTypeLoc>()) {
+      TypedefTarget = P.getPointeeLoc();
+    }
+    if (auto P = TypedefTarget.getAs<ParenTypeLoc>()) {
+      TypedefTarget = P.getInnerLoc();
+    }
+    if (auto F = TypedefTarget.getAs<FunctionProtoTypeLoc>()) {
+      return F;
+    }
+  }
+  else if (const auto *DR = dyn_cast<DeclRefExpr>(Fn)) {
+    const auto *D = DR->getDecl();
+    if (const auto *const VD = dyn_cast<VarDecl>(D)) {
+        TypeLoc Target = VD->getTypeSourceInfo()->getTypeLoc();
+
+        if (auto P = Target.getAs<PointerTypeLoc>()) {
+          Target = P.getPointeeLoc();
+        }
+        if (auto P = Target.getAs<ParenTypeLoc>()) {
+          Target = P.getInnerLoc();
+        }
+        if (auto F = Target.getAs<FunctionProtoTypeLoc>()) {
+          return F;
+        }
+    }
+  }
+
+  return FunctionProtoTypeLoc();
+}
+
 QualType Sema::ProduceCallSignatureHelp(Expr *Fn, ArrayRef<Expr *> Args,
                                         SourceLocation OpenParLoc) {
   Fn = unwrapParenList(Fn);
   if (!CodeCompleter || !Fn)
     return QualType();
 
   // FIXME: Provide support for variadic template functions.
   // Ignore type-dependent call expressions entirely.
if (FD) { // We check whether it's a resolved function declaration.
         AddFunctionCandidates(R.asUnresolvedSet(), ArgExprs, CandidateSet,
                               /*ExplicitArgs=*/nullptr,
                               /*SuppressUserConversions=*/false,
                               /*PartialOverloading=*/true);
       }
     } else {
       // Lastly we check whether expression's type is function pointer or
       // function.
+
+      FunctionProtoTypeLoc P = GetPrototypeLoc(NakedFn);
       QualType T = NakedFn->getType();
       if (!T->getPointeeType().isNull())
         T = T->getPointeeType();
 
       if (auto FP = T->getAs<FunctionProtoType>()) {
         if (!TooManyArguments(FP->getNumParams(),
                               ArgsWithoutDependentTypes.size(),
                               /*PartialOverloading=*/true) ||
-            FP->isVariadic())
+            FP->isVariadic()) {
+              if (!P.isNull()) {
+                Results.push_back(ResultCandidate(P));
+              } else {
                 Results.push_back(ResultCandidate(FP));
+              }
+            }
       } else if (auto FT = T->getAs<FunctionType>())
         // No prototype and declaration, it may be a K & R style function.
         Results.push_back(ResultCandidate(FT));
     }
   }
   mergeCandidatesWithResults(*this, Results, CandidateSet, Loc, Args.size());
   QualType ParamType = ProduceSignatureHelp(*this, Results, Args.size(),
                                             OpenParLoc, /*Braced=*/false);