Basic reform of chunks for overload completion results.

[francisco.lopes]

Summary

The code building the code completion string for overloads was providing
less detail compared to the one building completion strings for function
declarations. There was no information about optionals and no information
about what's a parameter and what's a function identifier, everything
besides ResultType, CurrentParameter and special characters was classified
as Text.

This makes code completion strings for overload candidates to follow a
pattern very similar, but not identical, to the one in use for function
declarations:

• return type chunk: ResultType
• function identifier chunk: Text
• parameter chunks: Placeholder
• optional parameter chunks: Optional
• current parameter chunk: CurrentParameter

[francisco.lopes]

This rebases over master and squashes an irrelevant commit.

[klimek]

Generally makes sense to me - how does the experience change in the actual code completion of overloads in an editor using this?

lib/Sema/SemaCodeComplete.cpp

2840–2841

So we're both recursing and looping? This seems like a strange pattern to me, that at least needs a comment.

[francisco.lopes]

@klimek The client code has opportunity to better highlight individual tokens and warn the user what parameters are required and what aren't. Although the Russian nesting doll approach to optionals may turn the treatment slightly more complex, but it's the approach already employed elsewhere in the codebase as in AddFunctionParameterChunks.

lib/Sema/SemaCodeComplete.cpp

2840–2841

OK.

[francisco.lopes]

Add comment about recursive approach that's being employed.

[klimek]

lg

lib/Sema/SemaCodeComplete.cpp

2840

Perhaps simply "Optional section are nested." :)

[francisco.lopes]

lib/Sema/SemaCodeComplete.cpp

2840

Sad OK :(

[francisco.lopes]

Reword comment.

[francisco.lopes]

Landed in SVN revision 227309.

Thanks for the review Manuel.

include/clang/Sema/CodeCompleteConsumer.h

public:
     /// function is stored.
     const FunctionType *getFunctionType() const;
 
     /// \brief Create a new code-completion string that describes the function
     /// signature of this overload candidate.
     CodeCompletionString *CreateSignatureString(unsigned CurrentArg,
                                                 Sema &S,
                                       CodeCompletionAllocator &Allocator,
-                                      CodeCompletionTUInfo &CCTUInfo) const;
+                                      CodeCompletionTUInfo &CCTUInfo,
+                                      bool IncludeBriefComments) const;
   };
 
   CodeCompleteConsumer(const CodeCompleteOptions &CodeCompleteOpts,
                        bool OutputIsBinary)
     : CodeCompleteOpts(CodeCompleteOpts), OutputIsBinary(OutputIsBinary)
   { }
 
   /// \brief Whether the code-completion consumer wants to see macros.

lib/Sema/CodeCompleteConsumer.cpp

case CodeCompletionResult::RK_Pattern: {
       OS << "Pattern : " 
          << Results[I].Pattern->getAsString() << '\n';
       break;
     }
     }
   }
 }
 
+// This function is used solely to preserve the former presentation of overloads
+// by "clang -cc1 -code-completion-at", since CodeCompletionString::getAsString
+// needs to be improved for printing the newer and more detailed overload
+// chunks.
+static std::string getOverloadAsString(const CodeCompletionString &CCS) {
+  std::string Result;
+  llvm::raw_string_ostream OS(Result);
+
+  for (auto &C : CCS) {
+    switch (C.Kind) {
+    case CodeCompletionString::CK_Informative:
+    case CodeCompletionString::CK_ResultType:
+      OS << "[#" << C.Text << "#]";
+      break;
+
+    case CodeCompletionString::CK_CurrentParameter:
+      OS << "<#" << C.Text << "#>";
+      break;
+
+    default: OS << C.Text; break;
+    }
+  }
+  return OS.str();
+}
+
 void 
 PrintingCodeCompleteConsumer::ProcessOverloadCandidates(Sema &SemaRef,
                                                         unsigned CurrentArg,
                                               OverloadCandidate *Candidates,
                                                      unsigned NumCandidates) {
   for (unsigned I = 0; I != NumCandidates; ++I) {
     if (CodeCompletionString *CCS
           = Candidates[I].CreateSignatureString(CurrentArg, SemaRef,
-                                                getAllocator(), CCTUInfo)) {
-      OS << "OVERLOAD: " << CCS->getAsString() << "\n";
+                                                getAllocator(), CCTUInfo,
+                                                includeBriefComments())) {
+      OS << "OVERLOAD: " << getOverloadAsString(*CCS) << "\n";
     }
   }
 }
 
 /// \brief Retrieve the effective availability of the given declaration.
 static AvailabilityResult getDeclAvailability(const Decl *D) {
   AvailabilityResult AR = D->getAvailability();
   if (isa<EnumConstantDecl>(D))

lib/Sema/SemaCodeComplete.cpp

if (Qualifier)
     AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative, 
                                    Ctx, Policy);
 
   Result.AddTypedTextChunk(
                        Result.getAllocator().CopyString(ND->getNameAsString()));
   return Result.TakeString();
 }
 
+/// \brief 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,
+                                       CodeCompletionBuilder &Result,
+                                       unsigned CurrentArg,
+                                       unsigned Start = 0,
+                                       bool InOptional = false) {
+  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,
+                                 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)
+      Placeholder = FormatFunctionParameter(Context, Policy,
+                                            Function->getParamDecl(P));
+    else
+      Placeholder = Prototype->getParamType(P).getAsString(Policy);
+
+    if (P == CurrentArg)
+      Result.AddCurrentParameterChunk(
+        Result.getAllocator().CopyString(Placeholder));
+    else
+      Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Placeholder));
+  }
+
+  if (Prototype && Prototype->isVariadic()) {
+    CodeCompletionBuilder Opt(Result.getAllocator(),
+                              Result.getCodeCompletionTUInfo());
+    if (!FirstParameter)
+      Opt.AddChunk(CodeCompletionString::CK_Comma);
+
+    if (CurrentArg < NumParams)
+      Opt.AddPlaceholderChunk("...");
+    else
+      Opt.AddCurrentParameterChunk("...");
+
+    Result.AddOptionalChunk(Opt.TakeString());
+  }
+}
+
 CodeCompletionString *
 CodeCompleteConsumer::OverloadCandidate::CreateSignatureString(
-                                                          unsigned CurrentArg,
-                                                               Sema &S,
+                                             unsigned CurrentArg, Sema &S,
                                              CodeCompletionAllocator &Allocator,
-                                     CodeCompletionTUInfo &CCTUInfo) const {
+                                             CodeCompletionTUInfo &CCTUInfo,
+                                             bool IncludeBriefComments) const {
   PrintingPolicy Policy = getCompletionPrintingPolicy(S);
 
   // FIXME: Set priority, availability appropriately.
   CodeCompletionBuilder Result(Allocator,CCTUInfo, 1, CXAvailability_Available);
   FunctionDecl *FDecl = getFunction();
-  AddResultTypeChunk(S.Context, Policy, FDecl, Result);
-  const FunctionProtoType *Proto 
+  const FunctionProtoType *Proto
     = dyn_cast<FunctionProtoType>(getFunctionType());
   if (!FDecl && !Proto) {
     // Function without a prototype. Just give the return type and a 
     // highlighted ellipsis.
     const FunctionType *FT = getFunctionType();
-    Result.AddTextChunk(GetCompletionTypeString(FT->getReturnType(), S.Context,
-                                                Policy, Result.getAllocator()));
+    Result.AddResultTypeChunk(Result.getAllocator().CopyString(
+      FT->getReturnType().getAsString(Policy)));
     Result.AddChunk(CodeCompletionString::CK_LeftParen);
     Result.AddChunk(CodeCompletionString::CK_CurrentParameter, "...");
     Result.AddChunk(CodeCompletionString::CK_RightParen);
     return Result.TakeString();
   }
-  
-  if (FDecl)
+  if (FDecl) {
+    if (IncludeBriefComments && CurrentArg < FDecl->getNumParams())
+      if (auto RC = S.getASTContext().getRawCommentForAnyRedecl(
+          FDecl->getParamDecl(CurrentArg)))
+        Result.addBriefComment(RC->getBriefText(S.getASTContext()));
+    AddResultTypeChunk(S.Context, Policy, FDecl, Result);
     Result.AddTextChunk(
-                    Result.getAllocator().CopyString(FDecl->getNameAsString()));
-  else
-    Result.AddTextChunk(Result.getAllocator().CopyString(
-        Proto->getReturnType().getAsString(Policy)));
-
-  Result.AddChunk(CodeCompletionString::CK_LeftParen);
-  unsigned NumParams = FDecl ? FDecl->getNumParams() : Proto->getNumParams();
-  for (unsigned I = 0; I != NumParams; ++I) {
-    if (I)
-      Result.AddChunk(CodeCompletionString::CK_Comma);
-    
-    std::string ArgString;
-    QualType ArgType;
-    
-    if (FDecl) {
-      ArgString = FDecl->getParamDecl(I)->getNameAsString();
-      ArgType = FDecl->getParamDecl(I)->getOriginalType();
-    } else {
-      ArgType = Proto->getParamType(I);
-    }
-    
-    ArgType.getAsStringInternal(ArgString, Policy);
-    
-    if (I == CurrentArg)
-      Result.AddChunk(CodeCompletionString::CK_CurrentParameter,
-                      Result.getAllocator().CopyString(ArgString));
-    else
-      Result.AddTextChunk(Result.getAllocator().CopyString(ArgString));
+    Result.AddResultTypeChunk(
+      Result.getAllocator().CopyString(
+        Proto->getReturnType().getAsString(Policy)));
   }
-  
-  if (Proto && Proto->isVariadic()) {
-    Result.AddChunk(CodeCompletionString::CK_Comma);
-    if (CurrentArg < NumParams)
-      Result.AddTextChunk("...");
-    else
-      Result.AddChunk(CodeCompletionString::CK_CurrentParameter, "...");
-  }
+  Result.AddChunk(CodeCompletionString::CK_LeftParen);
+  AddOverloadParameterChunks(S.getASTContext(), Policy, FDecl, Proto, Result,
+                             CurrentArg);
   Result.AddChunk(CodeCompletionString::CK_RightParen);
-  
   return Result.TakeString();
 }
 
 unsigned clang::getMacroUsagePriority(StringRef MacroName, 
                                       const LangOptions &LangOpts,
                                       bool PreferredTypeIsPointer) {
   unsigned Priority = CCP_Macro;
   
void Sema::CodeCompleteCall(Scope *S, Expr *Fn, ArrayRef<Expr *> Args) {
   if (!CodeCompleter)
     return;
 
   // When we're code-completing for a call, we fall back to ordinary
   // name code-completion whenever we can't produce specific
   // results. We may want to revisit this strategy in the future,
   // e.g., by merging the two kinds of results.
 
-  // FIXME: Provide support for highlighting optional parameters.
   // FIXME: Provide support for variadic template functions.
 
   // Ignore type-dependent call expressions entirely.
   if (!Fn || Fn->isTypeDependent() || anyNullArguments(Args) ||
       Expr::hasAnyTypeDependentArguments(Args)) {
     CodeCompleteOrdinaryName(S, PCC_Expression);
     return;
   }
AddFunctionCandidates(Decls, ArgExprs, CandidateSet, TemplateArgs,
                           /*PartialOverloading=*/true);
   } else {
     FunctionDecl *FD = nullptr;
     if (auto MCE = dyn_cast<MemberExpr>(NakedFn))
       FD = dyn_cast<FunctionDecl>(MCE->getMemberDecl());
     else if (auto DRE = dyn_cast<DeclRefExpr>(NakedFn))
       FD = dyn_cast<FunctionDecl>(DRE->getDecl());
     if (FD) { // We check whether it's a resolved function declaration.
-      if (!getLangOpts().CPlusPlus || 
+      if (!getLangOpts().CPlusPlus ||
           !FD->getType()->getAs<FunctionProtoType>())
         Results.push_back(ResultCandidate(FD));
       else
         AddOverloadCandidate(FD, DeclAccessPair::make(FD, FD->getAccess()),
                              Args, CandidateSet,
                              /*SuppressUsedConversions=*/false,
                              /*PartialOverloading=*/true);
 
if (!CodeCompleter)
     return;
 
   // A complete type is needed to lookup for constructors.
   if (RequireCompleteType(Loc, Type, 0))
     return;
 
   // FIXME: Provide support for member initializers.
   // FIXME: Provide support for variadic template constructors.
-  // FIXME: Provide support for highlighting optional parameters.
 
   OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
 
   for (auto C : LookupConstructors(Type->getAsCXXRecordDecl())) {
     if (auto FD = dyn_cast<FunctionDecl>(C)) {
       AddOverloadCandidate(FD, DeclAccessPair::make(FD, C->getAccess()),
                            Args, CandidateSet,
                            /*SuppressUsedConversions=*/false,

test/Index/code-completion.cpp

 // CHECK-MEMBER: CXXDestructor:{ResultType void}{Informative Y::}{TypedText ~Y}{LeftParen (}{RightParen )}
 // CHECK-MEMBER: CXXDestructor:{ResultType void}{TypedText ~Z}{LeftParen (}{RightParen )}
 // CHECK-MEMBER: Completion contexts:
 // CHECK-MEMBER-NEXT: Dot member access
 // CHECK-MEMBER-NEXT: Container Kind: StructDecl
 // CHECK-MEMBER-NEXT: Container is complete
 // CHECK-MEMBER-NEXT: Container USR: c:@S@Z
 
-// CHECK-OVERLOAD: OverloadCandidate:{ResultType int &}{Text overloaded}{LeftParen (}{Text Z z}{Comma , }{CurrentParameter int second}{RightParen )}
-// CHECK-OVERLOAD: OverloadCandidate:{ResultType float &}{Text overloaded}{LeftParen (}{Text int i}{Comma , }{CurrentParameter long second}{RightParen )}
-// CHECK-OVERLOAD: OverloadCandidate:{ResultType double &}{Text overloaded}{LeftParen (}{Text float f}{Comma , }{CurrentParameter int second}{RightParen )}
+// CHECK-OVERLOAD: OverloadCandidate:{ResultType int &}{Text overloaded}{LeftParen (}{Placeholder Z z}{Comma , }{CurrentParameter int second}{RightParen )}
+// CHECK-OVERLOAD: OverloadCandidate:{ResultType float &}{Text overloaded}{LeftParen (}{Placeholder int i}{Comma , }{CurrentParameter long second}{RightParen )}
+// CHECK-OVERLOAD: OverloadCandidate:{ResultType double &}{Text overloaded}{LeftParen (}{Placeholder float f}{Comma , }{CurrentParameter int second}{RightParen )}
 // CHECK-OVERLOAD: Completion contexts:
 // CHECK-OVERLOAD-NEXT: Any type
 // CHECK-OVERLOAD-NEXT: Any value
 // CHECK-OVERLOAD-NEXT: Enum tag
 // CHECK-OVERLOAD-NEXT: Union tag
 // CHECK-OVERLOAD-NEXT: Struct tag
 // CHECK-OVERLOAD-NEXT: Class name
 // CHECK-OVERLOAD-NEXT: Nested name specifier

test/Index/complete-call.cpp

 // CHECK-CC2-NEXT: Enum tag
 // CHECK-CC2-NEXT: Union tag
 // CHECK-CC2-NEXT: Struct tag
 // CHECK-CC2-NEXT: Class name
 // CHECK-CC2-NEXT: Nested name specifier
 // CHECK-CC2-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:49:9 %s | FileCheck -check-prefix=CHECK-CC3 %s
-// CHECK-CC3: OverloadCandidate:{ResultType void}{Text foo_3}{LeftParen (}{CurrentParameter void *}{Comma , }{Text void *}{RightParen )} (1)
-// CHECK-CC3: OverloadCandidate:{ResultType void}{Text foo_3}{LeftParen (}{CurrentParameter int}{Comma , }{Text int}{RightParen )} (1)
+// CHECK-CC3: OverloadCandidate:{ResultType void}{Text foo_3}{LeftParen (}{CurrentParameter void *}{Comma , }{Placeholder void *}{RightParen )} (1)
+// CHECK-CC3: OverloadCandidate:{ResultType void}{Text foo_3}{LeftParen (}{CurrentParameter int}{Comma , }{Placeholder int}{RightParen )} (1)
 // CHECK-CC3: Completion contexts:
 // CHECK-CC3-NEXT: Any type
 // CHECK-CC3-NEXT: Any value
 // CHECK-CC3-NEXT: Enum tag
 // CHECK-CC3-NEXT: Union tag
 // CHECK-CC3-NEXT: Struct tag
 // CHECK-CC3-NEXT: Class name
 // CHECK-CC3-NEXT: Nested name specifier
 // CHECK-CC3-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:49:12 %s | FileCheck -check-prefix=CHECK-CC4 %s
-// CHECK-CC4: OverloadCandidate:{ResultType void}{Text foo_3}{LeftParen (}{Text int}{Comma , }{CurrentParameter int}{RightParen )} (1)
+// CHECK-CC4: OverloadCandidate:{ResultType void}{Text foo_3}{LeftParen (}{Placeholder int}{Comma , }{CurrentParameter int}{RightParen )} (1)
 // CHECK-CC4: Completion contexts:
 // CHECK-CC4-NEXT: Any type
 // CHECK-CC4-NEXT: Any value
 // CHECK-CC4-NEXT: Enum tag
 // CHECK-CC4-NEXT: Union tag
 // CHECK-CC4-NEXT: Struct tag
 // CHECK-CC4-NEXT: Class name
 // CHECK-CC4-NEXT: Nested name specifier
 // CHECK-CC4-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:50:11 %s | FileCheck -check-prefix=CHECK-CC5 %s
-// CHECK-CC5: OverloadCandidate:{ResultType void}{Text foo_3}{LeftParen (}{Text void *}{Comma , }{CurrentParameter void *}{RightParen )} (1)
+// CHECK-CC5: OverloadCandidate:{ResultType void}{Text foo_3}{LeftParen (}{Placeholder void *}{Comma , }{CurrentParameter void *}{RightParen )} (1)
 // CHECK-CC5: Completion contexts:
 // CHECK-CC5-NEXT: Any type
 // CHECK-CC5-NEXT: Any value
 // CHECK-CC5-NEXT: Enum tag
 // CHECK-CC5-NEXT: Union tag
 // CHECK-CC5-NEXT: Struct tag
 // CHECK-CC5-NEXT: Class name
 // CHECK-CC5-NEXT: Nested name specifier
 // CHECK-CC5-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:51:12 %s | FileCheck -check-prefix=CHECK-CC6 %s
-// CHECK-CC6: OverloadCandidate:{ResultType void}{Text foo_4}{LeftParen (}{Text int}{Comma , }{CurrentParameter int}{RightParen )} (1)
+// CHECK-CC6: OverloadCandidate:{ResultType void}{Text foo_4}{LeftParen (}{Placeholder int}{Comma , }{CurrentParameter int}{RightParen )} (1)
 // CHECK-CC6: Completion contexts:
 // CHECK-CC6-NEXT: Any type
 // CHECK-CC6-NEXT: Any value
 // CHECK-CC6-NEXT: Enum tag
 // CHECK-CC6-NEXT: Union tag
 // CHECK-CC6-NEXT: Struct tag
 // CHECK-CC6-NEXT: Class name
 // CHECK-CC6-NEXT: Nested name specifier
 // CHECK-CC6-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:52:11 %s | FileCheck -check-prefix=CHECK-CC7 %s
-// CHECK-CC7: OverloadCandidate:{ResultType void}{Text foo_4}{LeftParen (}{Text void *}{Comma , }{CurrentParameter int}{RightParen )} (1)
+// CHECK-CC7: OverloadCandidate:{ResultType void}{Text foo_4}{LeftParen (}{Placeholder void *}{Comma , }{CurrentParameter int}{RightParen )} (1)
 // CHECK-CC7: Completion contexts:
 // CHECK-CC7-NEXT: Any type
 // CHECK-CC7-NEXT: Any value
 // CHECK-CC7-NEXT: Enum tag
 // CHECK-CC7-NEXT: Union tag
 // CHECK-CC7-NEXT: Struct tag
 // CHECK-CC7-NEXT: Class name
 // CHECK-CC7-NEXT: Nested name specifier
 // CHECK-CC7-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:53:12 %s | FileCheck -check-prefix=CHECK-CC8 %s
-// CHECK-CC8: OverloadCandidate:{ResultType void}{Text foo_5}{LeftParen (}{Text int}{Comma , }{CurrentParameter void *}{RightParen )} (1)
-// CHECK-CC8: OverloadCandidate:{ResultType void}{Text foo_5}{LeftParen (}{Text int}{Comma , }{CurrentParameter int}{RightParen )} (1)
+// CHECK-CC8: OverloadCandidate:{ResultType void}{Text foo_5}{LeftParen (}{Placeholder int}{Comma , }{CurrentParameter void *}{RightParen )} (1)
+// CHECK-CC8: OverloadCandidate:{ResultType void}{Text foo_5}{LeftParen (}{Placeholder int}{Comma , }{CurrentParameter int}{RightParen )} (1)
 // CHECK-CC8: Completion contexts:
 // CHECK-CC8-NEXT: Any type
 // CHECK-CC8-NEXT: Any value
 // CHECK-CC8-NEXT: Enum tag
 // CHECK-CC8-NEXT: Union tag
 // CHECK-CC8-NEXT: Struct tag
 // CHECK-CC8-NEXT: Class name
 // CHECK-CC8-NEXT: Nested name specifier

 // CHECK-CC11-NEXT: Enum tag
 // CHECK-CC11-NEXT: Union tag
 // CHECK-CC11-NEXT: Struct tag
 // CHECK-CC11-NEXT: Class name
 // CHECK-CC11-NEXT: Nested name specifier
 // CHECK-CC11-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:57:12 %s | FileCheck -check-prefix=CHECK-CC12 %s
-// CHECK-CC12: OverloadCandidate:{ResultType void}{Text foo_8}{LeftParen (}{Text int}{Comma , }{CurrentParameter int}{RightParen )} (1)
+// CHECK-CC12: OverloadCandidate:{ResultType void}{Text foo_8}{LeftParen (}{Placeholder int}{Comma , }{CurrentParameter int}{RightParen )} (1)
 // CHECK-CC12: Completion contexts:
 // CHECK-CC12-NEXT: Any type
 // CHECK-CC12-NEXT: Any value
 // CHECK-CC12-NEXT: Enum tag
 // CHECK-CC12-NEXT: Union tag
 // CHECK-CC12-NEXT: Struct tag
 // CHECK-CC12-NEXT: Class name
 // CHECK-CC12-NEXT: Nested name specifier
 // CHECK-CC12-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:58:12 %s | FileCheck -check-prefix=CHECK-CC13 %s
-// CHECK-CC13: OverloadCandidate:{ResultType void}{Text foo_9}{LeftParen (}{Text int}{Comma , }{CurrentParameter T}{RightParen )} (1)
+// CHECK-CC13: OverloadCandidate:{ResultType void}{Text foo_9}{LeftParen (}{Placeholder int}{Comma , }{CurrentParameter T}{RightParen )} (1)
 // CHECK-CC13: Completion contexts:
 // CHECK-CC13-NEXT: Any type
 // CHECK-CC13-NEXT: Any value
 // CHECK-CC13-NEXT: Enum tag
 // CHECK-CC13-NEXT: Union tag
 // CHECK-CC13-NEXT: Struct tag
 // CHECK-CC13-NEXT: Class name
 // CHECK-CC13-NEXT: Nested name specifier
 // CHECK-CC13-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:59:11 %s | FileCheck -check-prefix=CHECK-CC14 %s
-// CHECK-CC14: OverloadCandidate:{ResultType void}{Text foo_9}{LeftParen (}{Text void *}{Comma , }{CurrentParameter T}{RightParen )} (1)
+// CHECK-CC14: OverloadCandidate:{ResultType void}{Text foo_9}{LeftParen (}{Placeholder void *}{Comma , }{CurrentParameter T}{RightParen )} (1)
 // CHECK-CC14: Completion contexts:
 // CHECK-CC14-NEXT: Any type
 // CHECK-CC14-NEXT: Any value
 // CHECK-CC14-NEXT: Enum tag
 // CHECK-CC14-NEXT: Union tag
 // CHECK-CC14-NEXT: Struct tag
 // CHECK-CC14-NEXT: Class name
 // CHECK-CC14-NEXT: Nested name specifier
 // CHECK-CC14-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:60:10 %s | FileCheck -check-prefix=CHECK-CC15 %s
-// CHECK-CC15: OverloadCandidate:{ResultType void}{Text foo_10}{LeftParen (}{CurrentParameter U}{Comma , }{Text void *}{Comma , }{Text void *}{RightParen )} (1)
-// CHECK-CC15: OverloadCandidate:{ResultType void}{Text foo_10}{LeftParen (}{CurrentParameter T}{Comma , }{Text int}{Comma , }{Text int}{RightParen )} (1)
+// CHECK-CC15: OverloadCandidate:{ResultType void}{Text foo_10}{LeftParen (}{CurrentParameter U}{Comma , }{Placeholder void *}{Comma , }{Placeholder void *}{RightParen )} (1)
+// CHECK-CC15: OverloadCandidate:{ResultType void}{Text foo_10}{LeftParen (}{CurrentParameter T}{Comma , }{Placeholder int}{Comma , }{Placeholder int}{RightParen )} (1)
 // CHECK-CC15: Completion contexts:
 // CHECK-CC15-NEXT: Any type
 // CHECK-CC15-NEXT: Any value
 // CHECK-CC15-NEXT: Enum tag
 // CHECK-CC15-NEXT: Union tag
 // CHECK-CC15-NEXT: Struct tag
 // CHECK-CC15-NEXT: Class name
 // CHECK-CC15-NEXT: Nested name specifier
 // CHECK-CC15-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:60:13 %s | FileCheck -check-prefix=CHECK-CC16 %s
-// CHECK-CC16: OverloadCandidate:{ResultType void}{Text foo_10}{LeftParen (}{Text int}{Comma , }{CurrentParameter void *}{Comma , }{Text void *}{RightParen )} (1)
-// CHECK-CC16: OverloadCandidate:{ResultType void}{Text foo_10}{LeftParen (}{Text int}{Comma , }{CurrentParameter int}{Comma , }{Text int}{RightParen )} (1)
+// CHECK-CC16: OverloadCandidate:{ResultType void}{Text foo_10}{LeftParen (}{Placeholder int}{Comma , }{CurrentParameter void *}{Comma , }{Placeholder void *}{RightParen )} (1)
+// CHECK-CC16: OverloadCandidate:{ResultType void}{Text foo_10}{LeftParen (}{Placeholder int}{Comma , }{CurrentParameter int}{Comma , }{Placeholder int}{RightParen )} (1)
 // CHECK-CC16: Completion contexts:
 // CHECK-CC16-NEXT: Any type
 // CHECK-CC16-NEXT: Any value
 // CHECK-CC16-NEXT: Enum tag
 // CHECK-CC16-NEXT: Union tag
 // CHECK-CC16-NEXT: Struct tag
 // CHECK-CC16-NEXT: Class name
 // CHECK-CC16-NEXT: Nested name specifier
 // CHECK-CC16-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:60:17 %s | FileCheck -check-prefix=CHECK-CC17 %s
-// CHECK-CC17: OverloadCandidate:{ResultType void}{Text foo_10}{LeftParen (}{Text int}{Comma , }{Text int}{Comma , }{CurrentParameter int}{RightParen )} (1)
+// CHECK-CC17: OverloadCandidate:{ResultType void}{Text foo_10}{LeftParen (}{Placeholder int}{Comma , }{Placeholder int}{Comma , }{CurrentParameter int}{RightParen )} (1)
 // CHECK-CC17: Completion contexts:
 // CHECK-CC17-NEXT: Any type
 // CHECK-CC17-NEXT: Any value
 // CHECK-CC17-NEXT: Enum tag
 // CHECK-CC17-NEXT: Union tag
 // CHECK-CC17-NEXT: Struct tag
 // CHECK-CC17-NEXT: Class name
 // CHECK-CC17-NEXT: Nested name specifier
 // CHECK-CC17-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:61:10 %s | FileCheck -check-prefix=CHECK-CC18 %s
-// CHECK-CC18: OverloadCandidate:{ResultType void}{Text foo_11}{LeftParen (}{CurrentParameter T}{Comma , }{Text U}{RightParen )} (1)
+// CHECK-CC18: OverloadCandidate:{ResultType void}{Text foo_11}{LeftParen (}{CurrentParameter T}{Comma , }{Placeholder U}{RightParen )} (1)
 // CHECK-CC18: Completion contexts:
 // CHECK-CC18-NEXT: Any type
 // CHECK-CC18-NEXT: Any value
 // CHECK-CC18-NEXT: Enum tag
 // CHECK-CC18-NEXT: Union tag
 // CHECK-CC18-NEXT: Struct tag
 // CHECK-CC18-NEXT: Class name
 // CHECK-CC18-NEXT: Nested name specifier
 // CHECK-CC18-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:61:13 %s | FileCheck -check-prefix=CHECK-CC19 %s
-// CHECK-CC19: OverloadCandidate:{ResultType void}{Text foo_11}{LeftParen (}{Text int}{Comma , }{CurrentParameter U}{RightParen )} (1)
+// CHECK-CC19: OverloadCandidate:{ResultType void}{Text foo_11}{LeftParen (}{Placeholder int}{Comma , }{CurrentParameter U}{RightParen )} (1)
 // CHECK-CC19: Completion contexts:
 // CHECK-CC19-NEXT: Any type
 // CHECK-CC19-NEXT: Any value
 // CHECK-CC19-NEXT: Enum tag
 // CHECK-CC19-NEXT: Union tag
 // CHECK-CC19-NEXT: Struct tag
 // CHECK-CC19-NEXT: Class name
 // CHECK-CC19-NEXT: Nested name specifier
 // CHECK-CC19-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:62:15 %s | FileCheck -check-prefix=CHECK-CC20 %s
-// CHECK-CC20: OverloadCandidate:{ResultType void}{Text foo_11}{LeftParen (}{CurrentParameter int}{Comma , }{Text U}{RightParen )} (1)
+// CHECK-CC20: OverloadCandidate:{ResultType void}{Text foo_11}{LeftParen (}{CurrentParameter int}{Comma , }{Placeholder U}{RightParen )} (1)
 // CHECK-CC20: Completion contexts:
 // CHECK-CC20-NEXT: Any type
 // CHECK-CC20-NEXT: Any value
 // CHECK-CC20-NEXT: Enum tag
 // CHECK-CC20-NEXT: Union tag
 // CHECK-CC20-NEXT: Struct tag
 // CHECK-CC20-NEXT: Class name
 // CHECK-CC20-NEXT: Nested name specifier
 // CHECK-CC20-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:62:18 %s | FileCheck -check-prefix=CHECK-CC21 %s
-// CHECK-CC21: OverloadCandidate:{ResultType void}{Text foo_11}{LeftParen (}{Text int}{Comma , }{CurrentParameter U}{RightParen )} (1)
+// CHECK-CC21: OverloadCandidate:{ResultType void}{Text foo_11}{LeftParen (}{Placeholder int}{Comma , }{CurrentParameter U}{RightParen )} (1)
 // CHECK-CC21: Completion contexts:
 // CHECK-CC21-NEXT: Any type
 // CHECK-CC21-NEXT: Any value
 // CHECK-CC21-NEXT: Enum tag
 // CHECK-CC21-NEXT: Union tag
 // CHECK-CC21-NEXT: Struct tag
 // CHECK-CC21-NEXT: Class name
 // CHECK-CC21-NEXT: Nested name specifier
 // CHECK-CC21-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:63:26 %s | FileCheck -check-prefix=CHECK-CC22 %s
-// CHECK-CC22: OverloadCandidate:{ResultType void}{Text foo_11}{LeftParen (}{Text int}{Comma , }{CurrentParameter void *}{RightParen )} (1)
+// CHECK-CC22: OverloadCandidate:{ResultType void}{Text foo_11}{LeftParen (}{Placeholder int}{Comma , }{CurrentParameter void *}{RightParen )} (1)
 // CHECK-CC22: Completion contexts:
 // CHECK-CC22-NEXT: Any type
 // CHECK-CC22-NEXT: Any value
 // CHECK-CC22-NEXT: Enum tag
 // CHECK-CC22-NEXT: Union tag
 // CHECK-CC22-NEXT: Struct tag
 // CHECK-CC22-NEXT: Class name
 // CHECK-CC22-NEXT: Nested name specifier
 // CHECK-CC22-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:64:10 %s | FileCheck -check-prefix=CHECK-CC23 %s
-// CHECK-CC23: OverloadCandidate:{ResultType void}{Text foo_12}{LeftParen (}{CurrentParameter int}{Comma , }{Text int}{RightParen )} (1)
+// CHECK-CC23: OverloadCandidate:{ResultType void}{Text foo_12}{LeftParen (}{CurrentParameter int}{Comma , }{Placeholder int}{RightParen )} (1)
 // CHECK-CC23: Completion contexts:
 // CHECK-CC23-NEXT: Any type
 // CHECK-CC23-NEXT: Any value
 // CHECK-CC23-NEXT: Enum tag
 // CHECK-CC23-NEXT: Union tag
 // CHECK-CC23-NEXT: Struct tag
 // CHECK-CC23-NEXT: Class name
 // CHECK-CC23-NEXT: Nested name specifier
 // CHECK-CC23-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:64:12 %s | FileCheck -check-prefix=CHECK-CC24 %s
-// CHECK-CC24: OverloadCandidate:{ResultType void}{Text foo_12}{LeftParen (}{Text void *}{Comma , }{CurrentParameter void *}{RightParen )} (1)
+// CHECK-CC24: OverloadCandidate:{ResultType void}{Text foo_12}{LeftParen (}{Placeholder void *}{Comma , }{CurrentParameter void *}{RightParen )} (1)
 // CHECK-CC24: Completion contexts:
 // CHECK-CC24-NEXT: Any type
 // CHECK-CC24-NEXT: Any value
 // CHECK-CC24-NEXT: Enum tag
 // CHECK-CC24-NEXT: Union tag
 // CHECK-CC24-NEXT: Struct tag
 // CHECK-CC24-NEXT: Class name
 // CHECK-CC24-NEXT: Nested name specifier

 // CHECK-CC26-NEXT: Enum tag
 // CHECK-CC26-NEXT: Union tag
 // CHECK-CC26-NEXT: Struct tag
 // CHECK-CC26-NEXT: Class name
 // CHECK-CC26-NEXT: Nested name specifier
 // CHECK-CC26-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:69:11 %s | FileCheck -check-prefix=CHECK-CC27 %s
-// CHECK-CC27: OverloadCandidate:{ResultType void}{Text foo_3}{LeftParen (}{CurrentParameter int}{Comma , }{Text int}{RightParen )} (1)
-// CHECK-CC27: OverloadCandidate:{ResultType void}{Text foo_3}{LeftParen (}{CurrentParameter void *}{Comma , }{Text void *}{RightParen )} (1)
+// CHECK-CC27: OverloadCandidate:{ResultType void}{Text foo_3}{LeftParen (}{CurrentParameter int}{Comma , }{Placeholder int}{RightParen )} (1)
+// CHECK-CC27: OverloadCandidate:{ResultType void}{Text foo_3}{LeftParen (}{CurrentParameter void *}{Comma , }{Placeholder void *}{RightParen )} (1)
 // CHECK-CC27: Completion contexts:
 // CHECK-CC27-NEXT: Any type
 // CHECK-CC27-NEXT: Any value
 // CHECK-CC27-NEXT: Enum tag
 // CHECK-CC27-NEXT: Union tag
 // CHECK-CC27-NEXT: Struct tag
 // CHECK-CC27-NEXT: Class name
 // CHECK-CC27-NEXT: Nested name specifier
 // CHECK-CC27-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:69:14 %s | FileCheck -check-prefix=CHECK-CC28 %s
-// CHECK-CC28: OverloadCandidate:{ResultType void}{Text foo_3}{LeftParen (}{Text int}{Comma , }{CurrentParameter int}{RightParen )} (1)
+// CHECK-CC28: OverloadCandidate:{ResultType void}{Text foo_3}{LeftParen (}{Placeholder int}{Comma , }{CurrentParameter int}{RightParen )} (1)
 // CHECK-CC28: Completion contexts:
 // CHECK-CC28-NEXT: Any type
 // CHECK-CC28-NEXT: Any value
 // CHECK-CC28-NEXT: Enum tag
 // CHECK-CC28-NEXT: Union tag
 // CHECK-CC28-NEXT: Struct tag
 // CHECK-CC28-NEXT: Class name
 // CHECK-CC28-NEXT: Nested name specifier
 // CHECK-CC28-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:70:13 %s | FileCheck -check-prefix=CHECK-CC29 %s
-// CHECK-CC29: OverloadCandidate:{ResultType void}{Text foo_3}{LeftParen (}{Text void *}{Comma , }{CurrentParameter void *}{RightParen )} (1)
+// CHECK-CC29: OverloadCandidate:{ResultType void}{Text foo_3}{LeftParen (}{Placeholder void *}{Comma , }{CurrentParameter void *}{RightParen )} (1)
 // CHECK-CC29: Completion contexts:
 // CHECK-CC29-NEXT: Any type
 // CHECK-CC29-NEXT: Any value
 // CHECK-CC29-NEXT: Enum tag
 // CHECK-CC29-NEXT: Union tag
 // CHECK-CC29-NEXT: Struct tag
 // CHECK-CC29-NEXT: Class name
 // CHECK-CC29-NEXT: Nested name specifier
 // CHECK-CC29-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:71:14 %s | FileCheck -check-prefix=CHECK-CC30 %s
-// CHECK-CC30: OverloadCandidate:{ResultType void}{Text foo_4}{LeftParen (}{Text int}{Comma , }{CurrentParameter int}{RightParen )} (1)
+// CHECK-CC30: OverloadCandidate:{ResultType void}{Text foo_4}{LeftParen (}{Placeholder int}{Comma , }{CurrentParameter int}{RightParen )} (1)
 // CHECK-CC30: Completion contexts:
 // CHECK-CC30-NEXT: Any type
 // CHECK-CC30-NEXT: Any value
 // CHECK-CC30-NEXT: Enum tag
 // CHECK-CC30-NEXT: Union tag
 // CHECK-CC30-NEXT: Struct tag
 // CHECK-CC30-NEXT: Class name
 // CHECK-CC30-NEXT: Nested name specifier
 // CHECK-CC30-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:72:13 %s | FileCheck -check-prefix=CHECK-CC31 %s
-// CHECK-CC31: OverloadCandidate:{ResultType void}{Text foo_4}{LeftParen (}{Text void *}{Comma , }{CurrentParameter int}{RightParen )} (1)
+// CHECK-CC31: OverloadCandidate:{ResultType void}{Text foo_4}{LeftParen (}{Placeholder void *}{Comma , }{CurrentParameter int}{RightParen )} (1)
 // CHECK-CC31: Completion contexts:
 // CHECK-CC31-NEXT: Any type
 // CHECK-CC31-NEXT: Any value
 // CHECK-CC31-NEXT: Enum tag
 // CHECK-CC31-NEXT: Union tag
 // CHECK-CC31-NEXT: Struct tag
 // CHECK-CC31-NEXT: Class name
 // CHECK-CC31-NEXT: Nested name specifier
 // CHECK-CC31-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:73:14 %s | FileCheck -check-prefix=CHECK-CC32 %s
-// CHECK-CC32: OverloadCandidate:{ResultType void}{Text foo_5}{LeftParen (}{Text int}{Comma , }{CurrentParameter int}{RightParen )} (1)
-// CHECK-CC32: OverloadCandidate:{ResultType void}{Text foo_5}{LeftParen (}{Text int}{Comma , }{CurrentParameter void *}{RightParen )} (1)
+// CHECK-CC32: OverloadCandidate:{ResultType void}{Text foo_5}{LeftParen (}{Placeholder int}{Comma , }{CurrentParameter int}{RightParen )} (1)
+// CHECK-CC32: OverloadCandidate:{ResultType void}{Text foo_5}{LeftParen (}{Placeholder int}{Comma , }{CurrentParameter void *}{RightParen )} (1)
 // CHECK-CC32: Completion contexts:
 // CHECK-CC32-NEXT: Any type
 // CHECK-CC32-NEXT: Any value
 // CHECK-CC32-NEXT: Enum tag
 // CHECK-CC32-NEXT: Union tag
 // CHECK-CC32-NEXT: Struct tag
 // CHECK-CC32-NEXT: Class name
 // CHECK-CC32-NEXT: Nested name specifier

 // CHECK-CC35-NEXT: Enum tag
 // CHECK-CC35-NEXT: Union tag
 // CHECK-CC35-NEXT: Struct tag
 // CHECK-CC35-NEXT: Class name
 // CHECK-CC35-NEXT: Nested name specifier
 // CHECK-CC35-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:77:14 %s | FileCheck -check-prefix=CHECK-CC36 %s
-// CHECK-CC36: OverloadCandidate:{ResultType void}{Text foo_8}{LeftParen (}{Text int}{Comma , }{CurrentParameter int}{RightParen )} (1)
+// CHECK-CC36: OverloadCandidate:{ResultType void}{Text foo_8}{LeftParen (}{Placeholder int}{Comma , }{CurrentParameter int}{RightParen )} (1)
 // CHECK-CC36: Completion contexts:
 // CHECK-CC36-NEXT: Any type
 // CHECK-CC36-NEXT: Any value
 // CHECK-CC36-NEXT: Enum tag
 // CHECK-CC36-NEXT: Union tag
 // CHECK-CC36-NEXT: Struct tag
 // CHECK-CC36-NEXT: Class name
 // CHECK-CC36-NEXT: Nested name specifier
 // CHECK-CC36-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:78:14 %s | FileCheck -check-prefix=CHECK-CC37 %s
-// CHECK-CC37: OverloadCandidate:{ResultType void}{Text foo_9}{LeftParen (}{Text int}{Comma , }{CurrentParameter T}{RightParen )} (1)
+// CHECK-CC37: OverloadCandidate:{ResultType void}{Text foo_9}{LeftParen (}{Placeholder int}{Comma , }{CurrentParameter T}{RightParen )} (1)
 // CHECK-CC37: Completion contexts:
 // CHECK-CC37-NEXT: Any type
 // CHECK-CC37-NEXT: Any value
 // CHECK-CC37-NEXT: Enum tag
 // CHECK-CC37-NEXT: Union tag
 // CHECK-CC37-NEXT: Struct tag
 // CHECK-CC37-NEXT: Class name
 // CHECK-CC37-NEXT: Nested name specifier
 // CHECK-CC37-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:79:13 %s | FileCheck -check-prefix=CHECK-CC38 %s
-// CHECK-CC38: OverloadCandidate:{ResultType void}{Text foo_9}{LeftParen (}{Text void *}{Comma , }{CurrentParameter T}{RightParen )} (1)
+// CHECK-CC38: OverloadCandidate:{ResultType void}{Text foo_9}{LeftParen (}{Placeholder void *}{Comma , }{CurrentParameter T}{RightParen )} (1)
 // CHECK-CC38: Completion contexts:
 // CHECK-CC38-NEXT: Any type
 // CHECK-CC38-NEXT: Any value
 // CHECK-CC38-NEXT: Enum tag
 // CHECK-CC38-NEXT: Union tag
 // CHECK-CC38-NEXT: Struct tag
 // CHECK-CC38-NEXT: Class name
 // CHECK-CC38-NEXT: Nested name specifier
 // CHECK-CC38-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:80:12 %s | FileCheck -check-prefix=CHECK-CC39 %s
-// CHECK-CC39: OverloadCandidate:{ResultType void}{Text foo_10}{LeftParen (}{CurrentParameter T}{Comma , }{Text int}{Comma , }{Text int}{RightParen )} (1)
-// CHECK-CC39: OverloadCandidate:{ResultType void}{Text foo_10}{LeftParen (}{CurrentParameter U}{Comma , }{Text void *}{Comma , }{Text void *}{RightParen )} (1)
+// CHECK-CC39: OverloadCandidate:{ResultType void}{Text foo_10}{LeftParen (}{CurrentParameter T}{Comma , }{Placeholder int}{Comma , }{Placeholder int}{RightParen )} (1)
+// CHECK-CC39: OverloadCandidate:{ResultType void}{Text foo_10}{LeftParen (}{CurrentParameter U}{Comma , }{Placeholder void *}{Comma , }{Placeholder void *}{RightParen )} (1)
 // CHECK-CC39: Completion contexts:
 // CHECK-CC39-NEXT: Any type
 // CHECK-CC39-NEXT: Any value
 // CHECK-CC39-NEXT: Enum tag
 // CHECK-CC39-NEXT: Union tag
 // CHECK-CC39-NEXT: Struct tag
 // CHECK-CC39-NEXT: Class name
 // CHECK-CC39-NEXT: Nested name specifier
 // CHECK-CC39-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:80:15 %s | FileCheck -check-prefix=CHECK-CC40 %s
-// CHECK-CC40: OverloadCandidate:{ResultType void}{Text foo_10}{LeftParen (}{Text int}{Comma , }{CurrentParameter int}{Comma , }{Text int}{RightParen )} (1)
-// CHECK-CC40: OverloadCandidate:{ResultType void}{Text foo_10}{LeftParen (}{Text int}{Comma , }{CurrentParameter void *}{Comma , }{Text void *}{RightParen )} (1)
+// CHECK-CC40: OverloadCandidate:{ResultType void}{Text foo_10}{LeftParen (}{Placeholder int}{Comma , }{CurrentParameter int}{Comma , }{Placeholder int}{RightParen )} (1)
+// CHECK-CC40: OverloadCandidate:{ResultType void}{Text foo_10}{LeftParen (}{Placeholder int}{Comma , }{CurrentParameter void *}{Comma , }{Placeholder void *}{RightParen )} (1)
 // CHECK-CC40: Completion contexts:
 // CHECK-CC40-NEXT: Any type
 // CHECK-CC40-NEXT: Any value
 // CHECK-CC40-NEXT: Enum tag
 // CHECK-CC40-NEXT: Union tag
 // CHECK-CC40-NEXT: Struct tag
 // CHECK-CC40-NEXT: Class name
 // CHECK-CC40-NEXT: Nested name specifier
 // CHECK-CC40-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:80:19 %s | FileCheck -check-prefix=CHECK-CC41 %s
-// CHECK-CC41: OverloadCandidate:{ResultType void}{Text foo_10}{LeftParen (}{Text int}{Comma , }{Text int}{Comma , }{CurrentParameter int}{RightParen )} (1)
+// CHECK-CC41: OverloadCandidate:{ResultType void}{Text foo_10}{LeftParen (}{Placeholder int}{Comma , }{Placeholder int}{Comma , }{CurrentParameter int}{RightParen )} (1)
 // CHECK-CC41: Completion contexts:
 // CHECK-CC41-NEXT: Any type
 // CHECK-CC41-NEXT: Any value
 // CHECK-CC41-NEXT: Enum tag
 // CHECK-CC41-NEXT: Union tag
 // CHECK-CC41-NEXT: Struct tag
 // CHECK-CC41-NEXT: Class name
 // CHECK-CC41-NEXT: Nested name specifier
 // CHECK-CC41-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:81:12 %s | FileCheck -check-prefix=CHECK-CC42 %s
-// CHECK-CC42: OverloadCandidate:{ResultType void}{Text foo_11}{LeftParen (}{CurrentParameter T}{Comma , }{Text U}{RightParen )} (1)
+// CHECK-CC42: OverloadCandidate:{ResultType void}{Text foo_11}{LeftParen (}{CurrentParameter T}{Comma , }{Placeholder U}{RightParen )} (1)
 // CHECK-CC42: Completion contexts:
 // CHECK-CC42-NEXT: Any type
 // CHECK-CC42-NEXT: Any value
 // CHECK-CC42-NEXT: Enum tag
 // CHECK-CC42-NEXT: Union tag
 // CHECK-CC42-NEXT: Struct tag
 // CHECK-CC42-NEXT: Class name
 // CHECK-CC42-NEXT: Nested name specifier
 // CHECK-CC42-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:81:15 %s | FileCheck -check-prefix=CHECK-CC43 %s
-// CHECK-CC43: OverloadCandidate:{ResultType void}{Text foo_11}{LeftParen (}{Text int}{Comma , }{CurrentParameter U}{RightParen )} (1)
+// CHECK-CC43: OverloadCandidate:{ResultType void}{Text foo_11}{LeftParen (}{Placeholder int}{Comma , }{CurrentParameter U}{RightParen )} (1)
 // CHECK-CC43: Completion contexts:
 // CHECK-CC43-NEXT: Any type
 // CHECK-CC43-NEXT: Any value
 // CHECK-CC43-NEXT: Enum tag
 // CHECK-CC43-NEXT: Union tag
 // CHECK-CC43-NEXT: Struct tag
 // CHECK-CC43-NEXT: Class name
 // CHECK-CC43-NEXT: Nested name specifier
 // CHECK-CC43-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:82:17 %s | FileCheck -check-prefix=CHECK-CC44 %s
-// CHECK-CC44: OverloadCandidate:{ResultType void}{Text foo_11}{LeftParen (}{CurrentParameter int}{Comma , }{Text U}{RightParen )} (1)
+// CHECK-CC44: OverloadCandidate:{ResultType void}{Text foo_11}{LeftParen (}{CurrentParameter int}{Comma , }{Placeholder U}{RightParen )} (1)
 // CHECK-CC44: Completion contexts:
 // CHECK-CC44-NEXT: Any type
 // CHECK-CC44-NEXT: Any value
 // CHECK-CC44-NEXT: Enum tag
 // CHECK-CC44-NEXT: Union tag
 // CHECK-CC44-NEXT: Struct tag
 // CHECK-CC44-NEXT: Class name
 // CHECK-CC44-NEXT: Nested name specifier
 // CHECK-CC44-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:82:20 %s | FileCheck -check-prefix=CHECK-CC45 %s
-// CHECK-CC45: OverloadCandidate:{ResultType void}{Text foo_11}{LeftParen (}{Text int}{Comma , }{CurrentParameter U}{RightParen )} (1)
+// CHECK-CC45: OverloadCandidate:{ResultType void}{Text foo_11}{LeftParen (}{Placeholder int}{Comma , }{CurrentParameter U}{RightParen )} (1)
 // CHECK-CC45: Completion contexts:
 // CHECK-CC45-NEXT: Any type
 // CHECK-CC45-NEXT: Any value
 // CHECK-CC45-NEXT: Enum tag
 // CHECK-CC45-NEXT: Union tag
 // CHECK-CC45-NEXT: Struct tag
 // CHECK-CC45-NEXT: Class name
 // CHECK-CC45-NEXT: Nested name specifier
 // CHECK-CC45-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:83:28 %s | FileCheck -check-prefix=CHECK-CC46 %s
-// CHECK-CC46: OverloadCandidate:{ResultType void}{Text foo_11}{LeftParen (}{Text int}{Comma , }{CurrentParameter void *}{RightParen )} (1)
+// CHECK-CC46: OverloadCandidate:{ResultType void}{Text foo_11}{LeftParen (}{Placeholder int}{Comma , }{CurrentParameter void *}{RightParen )} (1)
 // CHECK-CC46: Completion contexts:
 // CHECK-CC46-NEXT: Any type
 // CHECK-CC46-NEXT: Any value
 // CHECK-CC46-NEXT: Enum tag
 // CHECK-CC46-NEXT: Union tag
 // CHECK-CC46-NEXT: Struct tag
 // CHECK-CC46-NEXT: Class name
 // CHECK-CC46-NEXT: Nested name specifier
 // CHECK-CC46-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:84:12 %s | FileCheck -check-prefix=CHECK-CC47 %s
-// CHECK-CC47: OverloadCandidate:{ResultType void}{Text foo_12}{LeftParen (}{CurrentParameter int}{Comma , }{Text int}{RightParen )} (1)
+// CHECK-CC47: OverloadCandidate:{ResultType void}{Text foo_12}{LeftParen (}{CurrentParameter int}{Comma , }{Placeholder int}{RightParen )} (1)
 // CHECK-CC47: Completion contexts:
 // CHECK-CC47-NEXT: Any type
 // CHECK-CC47-NEXT: Any value
 // CHECK-CC47-NEXT: Enum tag
 // CHECK-CC47-NEXT: Union tag
 // CHECK-CC47-NEXT: Struct tag
 // CHECK-CC47-NEXT: Class name
 // CHECK-CC47-NEXT: Nested name specifier
 // CHECK-CC47-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:84:14 %s | FileCheck -check-prefix=CHECK-CC48 %s
-// CHECK-CC48: OverloadCandidate:{ResultType void}{Text foo_12}{LeftParen (}{Text void *}{Comma , }{CurrentParameter void *}{RightParen )} (1)
+// CHECK-CC48: OverloadCandidate:{ResultType void}{Text foo_12}{LeftParen (}{Placeholder void *}{Comma , }{CurrentParameter void *}{RightParen )} (1)
 // CHECK-CC48: Completion contexts:
 // CHECK-CC48-NEXT: Any type
 // CHECK-CC48-NEXT: Any value
 // CHECK-CC48-NEXT: Enum tag
 // CHECK-CC48-NEXT: Union tag
 // CHECK-CC48-NEXT: Struct tag
 // CHECK-CC48-NEXT: Class name
 // CHECK-CC48-NEXT: Nested name specifier
 // CHECK-CC48-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:85:12 %s | FileCheck -check-prefix=CHECK-CC49 %s
-// CHECK-CC49: OverloadCandidate:{ResultType void}{Text foo_13}{LeftParen (}{CurrentParameter int}{Comma , }{Text T}{Comma , }{Text T}{RightParen )} (1)
+// CHECK-CC49: OverloadCandidate:{ResultType void}{Text foo_13}{LeftParen (}{CurrentParameter int}{Comma , }{Placeholder T}{Comma , }{Placeholder T}{RightParen )} (1)
 // CHECK-CC49: Completion contexts:
 // CHECK-CC49-NEXT: Any type
 // CHECK-CC49-NEXT: Any value
 // CHECK-CC49-NEXT: Enum tag
 // CHECK-CC49-NEXT: Union tag
 // CHECK-CC49-NEXT: Struct tag
 // CHECK-CC49-NEXT: Class name
 // CHECK-CC49-NEXT: Nested name specifier
 // CHECK-CC49-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:85:15 %s | FileCheck -check-prefix=CHECK-CC50 %s
-// CHECK-CC50: OverloadCandidate:{ResultType void}{Text foo_13}{LeftParen (}{Text int}{Comma , }{CurrentParameter T}{Comma , }{Text T}{RightParen )} (1)
+// CHECK-CC50: OverloadCandidate:{ResultType void}{Text foo_13}{LeftParen (}{Placeholder int}{Comma , }{CurrentParameter T}{Comma , }{Placeholder T}{RightParen )} (1)
 // CHECK-CC50: Completion contexts:
 // CHECK-CC50-NEXT: Any type
 // CHECK-CC50-NEXT: Any value
 // CHECK-CC50-NEXT: Enum tag
 // CHECK-CC50-NEXT: Union tag
 // CHECK-CC50-NEXT: Struct tag
 // CHECK-CC50-NEXT: Class name
 // CHECK-CC50-NEXT: Nested name specifier
 // CHECK-CC50-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:85:19 %s | FileCheck -check-prefix=CHECK-CC51 %s
-// CHECK-CC51: OverloadCandidate:{ResultType void}{Text foo_13}{LeftParen (}{Text int}{Comma , }{Text int}{Comma , }{CurrentParameter int}{RightParen )} (1)
+// CHECK-CC51: OverloadCandidate:{ResultType void}{Text foo_13}{LeftParen (}{Placeholder int}{Comma , }{Placeholder int}{Comma , }{CurrentParameter int}{RightParen )} (1)
 // CHECK-CC51: Completion contexts:
 // CHECK-CC51-NEXT: Any type
 // CHECK-CC51-NEXT: Any value
 // CHECK-CC51-NEXT: Enum tag
 // CHECK-CC51-NEXT: Union tag
 // CHECK-CC51-NEXT: Struct tag
 // CHECK-CC51-NEXT: Class name
 // CHECK-CC51-NEXT: Nested name specifier

test/Index/complete-constructor-params.cpp

int main() {
   S<int> s(42, 42, 42);
 
   S<int>(42, 42, 42,);
   S<int> z(42, 42, 42,);
 }
 
 // RUN: c-index-test -code-completion-at=%s:11:10 %s | FileCheck -check-prefix=CHECK-CC1 %s
 // CHECK-CC1: OverloadCandidate:{Text S}{LeftParen (}{CurrentParameter const S<int> &}{RightParen )} (1)
-// CHECK-CC1: OverloadCandidate:{Text S}{LeftParen (}{CurrentParameter int}{Comma , }{Text U}{Comma , }{Text U}{RightParen )} (1)
+// CHECK-CC1: OverloadCandidate:{Text S}{LeftParen (}{CurrentParameter int}{Comma , }{Placeholder U}{Comma , }{Placeholder U}{RightParen )} (1)
 // CHECK-CC1: Completion contexts:
 // CHECK-CC1-NEXT: Any type
 // CHECK-CC1-NEXT: Any value
 // CHECK-CC1-NEXT: Enum tag
 // CHECK-CC1-NEXT: Union tag
 // CHECK-CC1-NEXT: Struct tag
 // CHECK-CC1-NEXT: Class name
 // CHECK-CC1-NEXT: Nested name specifier
 // CHECK-CC1-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:12:10 %s | FileCheck -check-prefix=CHECK-CC2 %s
 // CHECK-CC2: OverloadCandidate:{Text S}{LeftParen (}{CurrentParameter const S<int> &}{RightParen )} (1)
-// CHECK-CC2: OverloadCandidate:{Text S}{LeftParen (}{CurrentParameter int}{Comma , }{Text U}{Comma , }{Text U}{RightParen )} (1)
+// CHECK-CC2: OverloadCandidate:{Text S}{LeftParen (}{CurrentParameter int}{Comma , }{Placeholder U}{Comma , }{Placeholder U}{RightParen )} (1)
 // CHECK-CC2: Completion contexts:
 // CHECK-CC2-NEXT: Any type
 // CHECK-CC2-NEXT: Any value
 // CHECK-CC2-NEXT: Enum tag
 // CHECK-CC2-NEXT: Union tag
 // CHECK-CC2-NEXT: Struct tag
 // CHECK-CC2-NEXT: Class name
 // CHECK-CC2-NEXT: Nested name specifier
 // CHECK-CC2-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:12:13 %s | FileCheck -check-prefix=CHECK-CC3 %s
-// CHECK-CC3: OverloadCandidate:{Text S}{LeftParen (}{Text int}{Comma , }{CurrentParameter U}{Comma , }{Text U}{RightParen )} (1)
+// CHECK-CC3: OverloadCandidate:{Text S}{LeftParen (}{Placeholder int}{Comma , }{CurrentParameter U}{Comma , }{Placeholder U}{RightParen )} (1)
 // CHECK-CC3: Completion contexts:
 // CHECK-CC3-NEXT: Any type
 // CHECK-CC3-NEXT: Any value
 // CHECK-CC3-NEXT: Enum tag
 // CHECK-CC3-NEXT: Union tag
 // CHECK-CC3-NEXT: Struct tag
 // CHECK-CC3-NEXT: Class name
 // CHECK-CC3-NEXT: Nested name specifier
 // CHECK-CC3-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:12:17 %s | FileCheck -check-prefix=CHECK-CC4 %s
-// CHECK-CC4: OverloadCandidate:{Text S}{LeftParen (}{Text int}{Comma , }{Text int}{Comma , }{CurrentParameter int}{RightParen )} (1)
+// CHECK-CC4: OverloadCandidate:{Text S}{LeftParen (}{Placeholder int}{Comma , }{Placeholder int}{Comma , }{CurrentParameter int}{RightParen )} (1)
 // CHECK-CC4: Completion contexts:
 // CHECK-CC4-NEXT: Any type
 // CHECK-CC4-NEXT: Any value
 // CHECK-CC4-NEXT: Enum tag
 // CHECK-CC4-NEXT: Union tag
 // CHECK-CC4-NEXT: Struct tag
 // CHECK-CC4-NEXT: Class name
 // CHECK-CC4-NEXT: Nested name specifier
 // CHECK-CC4-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:13:12 %s | FileCheck -check-prefix=CHECK-CC5 %s
 // CHECK-CC5: OverloadCandidate:{Text S}{LeftParen (}{CurrentParameter const S<int> &}{RightParen )} (1)
-// CHECK-CC5: OverloadCandidate:{Text S}{LeftParen (}{CurrentParameter int}{Comma , }{Text U}{Comma , }{Text U}{RightParen )} (1)
+// CHECK-CC5: OverloadCandidate:{Text S}{LeftParen (}{CurrentParameter int}{Comma , }{Placeholder U}{Comma , }{Placeholder U}{RightParen )} (1)
 // CHECK-CC5: Completion contexts:
 // CHECK-CC5-NEXT: Any type
 // CHECK-CC5-NEXT: Any value
 // CHECK-CC5-NEXT: Enum tag
 // CHECK-CC5-NEXT: Union tag
 // CHECK-CC5-NEXT: Struct tag
 // CHECK-CC5-NEXT: Class name
 // CHECK-CC5-NEXT: Nested name specifier
 // CHECK-CC5-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:13:15 %s | FileCheck -check-prefix=CHECK-CC6 %s
-// CHECK-CC6: OverloadCandidate:{Text S}{LeftParen (}{Text int}{Comma , }{CurrentParameter U}{Comma , }{Text U}{RightParen )} (1)
+// CHECK-CC6: OverloadCandidate:{Text S}{LeftParen (}{Placeholder int}{Comma , }{CurrentParameter U}{Comma , }{Placeholder U}{RightParen )} (1)
 // CHECK-CC6: Completion contexts:
 // CHECK-CC6-NEXT: Any type
 // CHECK-CC6-NEXT: Any value
 // CHECK-CC6-NEXT: Enum tag
 // CHECK-CC6-NEXT: Union tag
 // CHECK-CC6-NEXT: Struct tag
 // CHECK-CC6-NEXT: Class name
 // CHECK-CC6-NEXT: Nested name specifier
 // CHECK-CC6-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:13:19 %s | FileCheck -check-prefix=CHECK-CC7 %s
-// CHECK-CC7: OverloadCandidate:{Text S}{LeftParen (}{Text int}{Comma , }{Text int}{Comma , }{CurrentParameter int}{RightParen )} (1)
+// CHECK-CC7: OverloadCandidate:{Text S}{LeftParen (}{Placeholder int}{Comma , }{Placeholder int}{Comma , }{CurrentParameter int}{RightParen )} (1)
 // CHECK-CC7: Completion contexts:
 // CHECK-CC7-NEXT: Any type
 // CHECK-CC7-NEXT: Any value
 // CHECK-CC7-NEXT: Enum tag
 // CHECK-CC7-NEXT: Union tag
 // CHECK-CC7-NEXT: Struct tag
 // CHECK-CC7-NEXT: Class name
 // CHECK-CC7-NEXT: Nested name specifier

test/Index/complete-functor-call.cpp

int main() {
   s(42,);
   s(s,);
   s(0, 42, 42,);
 }
 
 // RUN: c-index-test -code-completion-at=%s:16:5 %s | FileCheck -check-prefix=CHECK-CC1 %s
 // CHECK-CC1: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{CurrentParameter int}{RightParen )} (1)
 // CHECK-CC1: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{CurrentParameter T}{RightParen )} (1)
-// CHECK-CC1: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{CurrentParameter void *}{Comma , }{Text T}{Comma , }{Text T}{RightParen )} (1)
+// CHECK-CC1: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{CurrentParameter void *}{Comma , }{Placeholder T}{Comma , }{Placeholder T}{RightParen )} (1)
 // CHECK-CC1: Completion contexts:
 // CHECK-CC1-NEXT: Any type
 // CHECK-CC1-NEXT: Any value
 // CHECK-CC1-NEXT: Enum tag
 // CHECK-CC1-NEXT: Union tag
 // CHECK-CC1-NEXT: Struct tag
 // CHECK-CC1-NEXT: Class name
 // CHECK-CC1-NEXT: Nested name specifier
 // CHECK-CC1-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:17:5 %s | FileCheck -check-prefix=CHECK-CC2 %s
 // CHECK-CC2: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{CurrentParameter int}{RightParen )} (1)
 // CHECK-CC2: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{CurrentParameter T}{RightParen )} (1)
-// CHECK-CC2: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{CurrentParameter void *}{Comma , }{Text T}{Comma , }{Text T}{RightParen )} (1)
+// CHECK-CC2: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{CurrentParameter void *}{Comma , }{Placeholder T}{Comma , }{Placeholder T}{RightParen )} (1)
 // CHECK-CC2: Completion contexts:
 // CHECK-CC2-NEXT: Any type
 // CHECK-CC2-NEXT: Any value
 // CHECK-CC2-NEXT: Enum tag
 // CHECK-CC2-NEXT: Union tag
 // CHECK-CC2-NEXT: Struct tag
 // CHECK-CC2-NEXT: Class name
 // CHECK-CC2-NEXT: Nested name specifier
 // CHECK-CC2-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:18:5 %s | FileCheck -check-prefix=CHECK-CC3 %s
 // CHECK-CC3: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{CurrentParameter int}{RightParen )} (1)
 // CHECK-CC3: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{CurrentParameter T}{RightParen )} (1)
-// CHECK-CC3: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{CurrentParameter void *}{Comma , }{Text T}{Comma , }{Text T}{RightParen )} (1)
+// CHECK-CC3: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{CurrentParameter void *}{Comma , }{Placeholder T}{Comma , }{Placeholder T}{RightParen )} (1)
 // CHECK-CC3: Completion contexts:
 // CHECK-CC3-NEXT: Any type
 // CHECK-CC3-NEXT: Any value
 // CHECK-CC3-NEXT: Enum tag
 // CHECK-CC3-NEXT: Union tag
 // CHECK-CC3-NEXT: Struct tag
 // CHECK-CC3-NEXT: Class name
 // CHECK-CC3-NEXT: Nested name specifier
 // CHECK-CC3-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:18:7 %s | FileCheck -check-prefix=CHECK-CC4 %s
-// CHECK-CC4: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{Text void *}{Comma , }{CurrentParameter T}{Comma , }{Text T}{RightParen )} (1)
+// CHECK-CC4: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{Placeholder void *}{Comma , }{CurrentParameter T}{Comma , }{Placeholder T}{RightParen )} (1)
 // CHECK-CC4: Completion contexts:
 // CHECK-CC4-NEXT: Any type
 // CHECK-CC4-NEXT: Any value
 // CHECK-CC4-NEXT: Enum tag
 // CHECK-CC4-NEXT: Union tag
 // CHECK-CC4-NEXT: Struct tag
 // CHECK-CC4-NEXT: Class name
 // CHECK-CC4-NEXT: Nested name specifier
 // CHECK-CC4-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:18:10 %s | FileCheck -check-prefix=CHECK-CC5 %s
-// CHECK-CC5: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{Text void *}{Comma , }{Text S<void *>}{Comma , }{CurrentParameter S<void *>}{RightParen )} (1)
+// CHECK-CC5: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{Placeholder void *}{Comma , }{Placeholder S<void *>}{Comma , }{CurrentParameter S<void *>}{RightParen )} (1)
 // CHECK-CC5: Completion contexts:
 // CHECK-CC5-NEXT: Any type
 // CHECK-CC5-NEXT: Any value
 // CHECK-CC5-NEXT: Enum tag
 // CHECK-CC5-NEXT: Union tag
 // CHECK-CC5-NEXT: Struct tag
 // CHECK-CC5-NEXT: Class name
 // CHECK-CC5-NEXT: Nested name specifier
 // CHECK-CC5-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:19:17 %s | FileCheck -check-prefix=CHECK-CC6 %s
 // CHECK-CC6: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{CurrentParameter int}{RightParen )} (1)
 // CHECK-CC6: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{CurrentParameter T}{RightParen )} (1)
-// CHECK-CC6: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{CurrentParameter void *}{Comma , }{Text T}{Comma , }{Text T}{RightParen )} (1)
+// CHECK-CC6: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{CurrentParameter void *}{Comma , }{Placeholder T}{Comma , }{Placeholder T}{RightParen )} (1)
 // CHECK-CC6: OverloadCandidate:{ResultType const S<T> *}{Text operator()}{LeftParen (}{CurrentParameter const S<T> &s}{RightParen )} (1)
 // CHECK-CC6: Completion contexts:
 // CHECK-CC6-NEXT: Any type
 // CHECK-CC6-NEXT: Any value
 // CHECK-CC6-NEXT: Enum tag
 // CHECK-CC6-NEXT: Union tag
 // CHECK-CC6-NEXT: Struct tag
 // CHECK-CC6-NEXT: Class name
 // CHECK-CC6-NEXT: Nested name specifier
 // CHECK-CC6-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:19:28 %s | FileCheck -check-prefix=CHECK-CC7 %s
 // CHECK-CC7: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{CurrentParameter int}{RightParen )} (1)
 // CHECK-CC7: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{CurrentParameter T}{RightParen )} (1)
-// CHECK-CC7: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{CurrentParameter int}{Comma , }{Text T}{Comma , }{Text T}{RightParen )} (1)
+// CHECK-CC7: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{CurrentParameter int}{Comma , }{Placeholder T}{Comma , }{Placeholder T}{RightParen )} (1)
 // CHECK-CC7: OverloadCandidate:{ResultType const S<T> *}{Text operator()}{LeftParen (}{CurrentParameter const S<T> &s}{RightParen )} (1)
 // CHECK-CC7: Completion contexts:
 // CHECK-CC7-NEXT: Any type
 // CHECK-CC7-NEXT: Any value
 // CHECK-CC7-NEXT: Enum tag
 // CHECK-CC7-NEXT: Union tag
 // CHECK-CC7-NEXT: Struct tag
 // CHECK-CC7-NEXT: Class name
 // CHECK-CC7-NEXT: Nested name specifier
 // CHECK-CC7-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:19:31 %s | FileCheck -check-prefix=CHECK-CC8 %s
-// CHECK-CC8: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{Text int}{Comma , }{CurrentParameter T}{Comma , }{Text T}{RightParen )} (1)
+// CHECK-CC8: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{Placeholder int}{Comma , }{CurrentParameter T}{Comma , }{Placeholder T}{RightParen )} (1)
 // CHECK-CC8: Completion contexts:
 // CHECK-CC8-NEXT: Any type
 // CHECK-CC8-NEXT: Any value
 // CHECK-CC8-NEXT: Enum tag
 // CHECK-CC8-NEXT: Union tag
 // CHECK-CC8-NEXT: Struct tag
 // CHECK-CC8-NEXT: Class name
 // CHECK-CC8-NEXT: Nested name specifier
 // CHECK-CC8-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:19:35 %s | FileCheck -check-prefix=CHECK-CC9 %s
-// CHECK-CC9: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{Text int}{Comma , }{Text int}{Comma , }{CurrentParameter int}{RightParen )} (1)
+// CHECK-CC9: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{Placeholder int}{Comma , }{Placeholder int}{Comma , }{CurrentParameter int}{RightParen )} (1)
 // CHECK-CC9: Completion contexts:
 // CHECK-CC9-NEXT: Any type
 // CHECK-CC9-NEXT: Any value
 // CHECK-CC9-NEXT: Enum tag
 // CHECK-CC9-NEXT: Union tag
 // CHECK-CC9-NEXT: Struct tag
 // CHECK-CC9-NEXT: Class name
 // CHECK-CC9-NEXT: Nested name specifier

 // CHECK-CC12-NEXT: Struct tag
 // CHECK-CC12-NEXT: Class name
 // CHECK-CC12-NEXT: Nested name specifier
 // CHECK-CC12-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:12:28 %s | FileCheck -check-prefix=CHECK-CC13 %s
 // CHECK-CC13: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{CurrentParameter int}{RightParen )} (1)
 // CHECK-CC13: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{CurrentParameter T}{RightParen )} (1)
-// CHECK-CC13: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{CurrentParameter void *}{Comma , }{Text T}{Comma , }{Text T}{RightParen )} (1)
+// CHECK-CC13: OverloadCandidate:{ResultType void}{Text operator()}{LeftParen (}{CurrentParameter void *}{Comma , }{Placeholder T}{Comma , }{Placeholder T}{RightParen )} (1)
 // CHECK-CC13: Completion contexts:
 // CHECK-CC13-NEXT: Any type
 // CHECK-CC13-NEXT: Any value
 // CHECK-CC13-NEXT: Enum tag
 // CHECK-CC13-NEXT: Union tag
 // CHECK-CC13-NEXT: Struct tag
 // CHECK-CC13-NEXT: Class name
 // CHECK-CC13-NEXT: Nested name specifier
 // CHECK-CC13-NEXT: Objective-C interface

test/Index/complete-optional-params.cpp

+// Note: the run lines follow their respective tests, since line/column
+// matter in this test.
+
+void foo(int a = 42, int = 42);
+void bar(int a, int b = 42, int c = 42);
+void baz(int a = 42, ...);
+struct S{ S(int a = 42, int = 42) {} };
+
+int main() {
+    foo(42, 42);
+    bar(42, 42, 42);
+    baz(42, 42, 42);
+    S s(42, 42);
+}
+
+// RUN: c-index-test -code-completion-at=%s:10:9 %s | FileCheck -check-prefix=CHECK-CC1 %s
+// CHECK-CC1: OverloadCandidate:{ResultType void}{Text foo}{LeftParen (}{Optional {CurrentParameter int a}{Optional {Comma , }{Placeholder int}}}{RightParen )} (1)
+// CHECK-CC1: Completion contexts:
+// CHECK-CC1-NEXT: Any type
+// CHECK-CC1-NEXT: Any value
+// CHECK-CC1-NEXT: Enum tag
+// CHECK-CC1-NEXT: Union tag
+// CHECK-CC1-NEXT: Struct tag
+// CHECK-CC1-NEXT: Class name
+// CHECK-CC1-NEXT: Nested name specifier
+// CHECK-CC1-NEXT: Objective-C interface
+
+// RUN: c-index-test -code-completion-at=%s:11:9 %s | FileCheck -check-prefix=CHECK-CC2 %s
+// CHECK-CC2: OverloadCandidate:{ResultType void}{Text bar}{LeftParen (}{CurrentParameter int a}{Optional {Comma , }{Placeholder int b}{Optional {Comma , }{Placeholder int c}}}{RightParen )} (1)
+// CHECK-CC2: Completion contexts:
+// CHECK-CC2-NEXT: Any type
+// CHECK-CC2-NEXT: Any value
+// CHECK-CC2-NEXT: Enum tag
+// CHECK-CC2-NEXT: Union tag
+// CHECK-CC2-NEXT: Struct tag
+// CHECK-CC2-NEXT: Class name
+// CHECK-CC2-NEXT: Nested name specifier
+// CHECK-CC2-NEXT: Objective-C interface
+
+// RUN: c-index-test -code-completion-at=%s:11:16 %s | FileCheck -check-prefix=CHECK-CC3 %s
+// CHECK-CC3: OverloadCandidate:{ResultType void}{Text bar}{LeftParen (}{Placeholder int a}{Optional {Comma , }{Placeholder int b}{Optional {Comma , }{CurrentParameter int c}}}{RightParen )} (1)
+// CHECK-CC3: Completion contexts:
+// CHECK-CC3-NEXT: Any type
+// CHECK-CC3-NEXT: Any value
+// CHECK-CC3-NEXT: Enum tag
+// CHECK-CC3-NEXT: Union tag
+// CHECK-CC3-NEXT: Struct tag
+// CHECK-CC3-NEXT: Class name
+// CHECK-CC3-NEXT: Nested name specifier
+// CHECK-CC3-NEXT: Objective-C interface
+
+// RUN: c-index-test -code-completion-at=%s:12:16 %s | FileCheck -check-prefix=CHECK-CC4 %s
+// CHECK-CC4: OverloadCandidate:{ResultType void}{Text baz}{LeftParen (}{Optional {Placeholder int a}{Optional {Comma , }{CurrentParameter ...}}}{RightParen )} (1)
+// CHECK-CC4: Completion contexts:
+// CHECK-CC4-NEXT: Any type
+// CHECK-CC4-NEXT: Any value
+// CHECK-CC4-NEXT: Enum tag
+// CHECK-CC4-NEXT: Union tag
+// CHECK-CC4-NEXT: Struct tag
+// CHECK-CC4-NEXT: Class name
+// CHECK-CC4-NEXT: Nested name specifier
+// CHECK-CC4-NEXT: Objective-C interface
+
+// RUN: c-index-test -code-completion-at=%s:13:9 %s | FileCheck -check-prefix=CHECK-CC5 %s
+// CHECK-CC5: OverloadCandidate:{Text S}{LeftParen (}{Optional {CurrentParameter int a}{Optional {Comma , }{Placeholder int}}}{RightParen )} (1)
+// CHECK-CC5: OverloadCandidate:{Text S}{LeftParen (}{CurrentParameter const S &}{RightParen )} (1)
+// CHECK-CC5: Completion contexts:
+// CHECK-CC5-NEXT: Any type
+// CHECK-CC5-NEXT: Any value
+// CHECK-CC5-NEXT: Enum tag
+// CHECK-CC5-NEXT: Union tag
+// CHECK-CC5-NEXT: Struct tag
+// CHECK-CC5-NEXT: Class name
+// CHECK-CC5-NEXT: Nested name specifier
+// CHECK-CC5-NEXT: Objective-C interface

test/Index/complete-pointer-and-reference-to-functions.cpp

 // Note: the run lines follow their respective tests, since line/column
 // matter in this test.
 
 template<class T> void (&foo(T))(T);
 template<class T> void (*bar(T))(T);
 template<class T> void (&baz(T))(T, ...);
 template<class T> void (*fiz(T))(T, ...);
 
 int main() {
   foo(42)(42);
   bar(42)(42);
   baz(42)(42, 42, 42);
   fiz(42)(42, 42, 42);
 }
 
 // RUN: c-index-test -code-completion-at=%s:10:11 %s | FileCheck -check-prefix=CHECK-CC1 %s
-// CHECK-CC1: OverloadCandidate:{Text void}{LeftParen (}{CurrentParameter int}{RightParen )} (1)
+// CHECK-CC1: OverloadCandidate:{ResultType void}{LeftParen (}{CurrentParameter int}{RightParen )} (1)
 // CHECK-CC1: Completion contexts:
 // CHECK-CC1-NEXT: Any type
 // CHECK-CC1-NEXT: Any value
 // CHECK-CC1-NEXT: Enum tag
 // CHECK-CC1-NEXT: Union tag
 // CHECK-CC1-NEXT: Struct tag
 // CHECK-CC1-NEXT: Class name
 // CHECK-CC1-NEXT: Nested name specifier
 // CHECK-CC1-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:11:11 %s | FileCheck -check-prefix=CHECK-CC2 %s
-// CHECK-CC2: OverloadCandidate:{Text void}{LeftParen (}{CurrentParameter int}{RightParen )} (1)
+// CHECK-CC2: OverloadCandidate:{ResultType void}{LeftParen (}{CurrentParameter int}{RightParen )} (1)
 // CHECK-CC2: Completion contexts:
 // CHECK-CC2-NEXT: Any type
 // CHECK-CC2-NEXT: Any value
 // CHECK-CC2-NEXT: Enum tag
 // CHECK-CC2-NEXT: Union tag
 // CHECK-CC2-NEXT: Struct tag
 // CHECK-CC2-NEXT: Class name
 // CHECK-CC2-NEXT: Nested name specifier
 // CHECK-CC2-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:12:18 %s | FileCheck -check-prefix=CHECK-CC3 %s
-// CHECK-CC3: OverloadCandidate:{Text void}{LeftParen (}{Text int}{Comma , }{CurrentParameter ...}{RightParen )} (1)
+// CHECK-CC3: OverloadCandidate:{ResultType void}{LeftParen (}{Placeholder int}{Optional {Comma , }{CurrentParameter ...}}{RightParen )} (1)
 // CHECK-CC3: Completion contexts:
 // CHECK-CC3-NEXT: Any type
 // CHECK-CC3-NEXT: Any value
 // CHECK-CC3-NEXT: Enum tag
 // CHECK-CC3-NEXT: Union tag
 // CHECK-CC3-NEXT: Struct tag
 // CHECK-CC3-NEXT: Class name
 // CHECK-CC3-NEXT: Nested name specifier
 // CHECK-CC3-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:13:18 %s | FileCheck -check-prefix=CHECK-CC4 %s
-// CHECK-CC4: OverloadCandidate:{Text void}{LeftParen (}{Text int}{Comma , }{CurrentParameter ...}{RightParen )} (1)
+// CHECK-CC4: OverloadCandidate:{ResultType void}{LeftParen (}{Placeholder int}{Optional {Comma , }{CurrentParameter ...}}{RightParen )} (1)
 // CHECK-CC4: Completion contexts:
 // CHECK-CC4-NEXT: Any type
 // CHECK-CC4-NEXT: Any value
 // CHECK-CC4-NEXT: Enum tag
 // CHECK-CC4-NEXT: Union tag
 // CHECK-CC4-NEXT: Struct tag
 // CHECK-CC4-NEXT: Class name
 // CHECK-CC4-NEXT: Nested name specifier
 // CHECK-CC4-NEXT: Objective-C interface

tools/libclang/CIndexCodeCompletion.cpp

public:
 
     void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg,
                                    OverloadCandidate *Candidates,
                                    unsigned NumCandidates) override {
       StoredResults.reserve(StoredResults.size() + NumCandidates);
       for (unsigned I = 0; I != NumCandidates; ++I) {
         CodeCompletionString *StoredCompletion
           = Candidates[I].CreateSignatureString(CurrentArg, S, getAllocator(),
-                                                getCodeCompletionTUInfo());
+                                                getCodeCompletionTUInfo(),
+                                                includeBriefComments());
         
         CXCompletionResult R;
         R.CursorKind = CXCursor_OverloadCandidate;
         R.CompletionString = StoredCompletion;
         StoredResults.push_back(R);
       }
     }