[clang] Improve ctor initializer completions.

[kadircet]

Summary

Instead of providing generic "args" for member and base class
initializers, tries to fetch relevant constructors and show their signatures.

[ilya-biryukov]

Great idea, this will definitely improve the UX of completion!

NIT: a typo in the change description: 'bas' should be 'base'.
Pedantic NIT (sorry!): in the change description, we should probably use 'initializers' instead of 'initializations'

lib/Sema/SemaCodeComplete.cpp

812

Maybe add the ctor results directly to the result list without creating an intermediate vector?
See other comments about passing the field name to this function instead of replacing it in the resulting CCS afterwards.

5080

NIT: maybe pass the Builder explicitly? Even a local function that changes the state and without explicit data-flow (i.e. without accepting the thing it changes as a parameter) is a bit confusing?

5088

Why special-case the template specializations?
Are we trying to provide results for dependent types here?

5090

It seems this function is sometimes responsible for building the completion string and sometimes it's the responsibility of the calling function.
Could we move this responsibility to one of the places (probably the callers?)

5195

NIT: use early exits to simplify code.
I.e.

// NOTE: Moved from the end of the loop.
SawLastInitializer = false;

const CXXRecordDecl *RD = Field->getType()->getAsCXXRecordDecl();
if (!RD) {
  CreatePrimitiveConstructor(Builder.getAllocator().CopyString(FieldName));
  AddField(Field);
  continue;
}
...

5196

NIT: the ConstResults name is a bit confusing, because "const" has a another meaning in C++. Maybe rename to CtorResults and ConstructorResults?

5204

Could we pass the field name all the way down to the function that creates the original CodeCompletionString? (Instead of replacing the ctor name with a field name at the end)
This would mean less copies/allocations going around and would also be simpler to reason about (i.e. no "incomplete" code completion strings would be passed around).

5221

Maybe show a type of the field for non-class types? They can typically be initialized from a single value of that type (with some exceptions, but showing the type shouldn't be confusing).
E.g.

struct X {
  X() : ^ {} // could complete 'a({$1:int})`
  int a;
  int b;
};

[kadircet]

• Address comments.

lib/Sema/SemaCodeComplete.cpp

5088

Sorry, my bad forgot to add a comment. It is rather for backward compatibility. Since previous version was adding results directly without consulting results, it also added template specializations, whereas current version can't add them due to the filtering in resultbuilder(https://github.com/llvm-mirror/clang/blob/master/lib/Sema/SemaCodeComplete.cpp#L543). So, special casing in here to make sure we still provide those results, but can be deleted if seems unimportant.

Not adding a comment until we decide on keeping/deleting the special case.

[kadircet]

lib/Sema/SemaCodeComplete.cpp

5088

without consulting results -> without consulting "ResultBuilder"

[ilya-biryukov]

lib/Sema/SemaCodeComplete.cpp

5088

Maybe call AddResult instead of MaybeAddResult (it does not do the checking)?
I can hardly see why we might want to filter out any of the results.

Also, maybe pass a decl the particular constructor, rather than the CXXRecordDecl to the ResultBuilder?

[kadircet]

• Use addConstructorResult.

[kadircet]

• Add a generic constructor if found none.
• format && add comments.
• Add generic constructors to tests.

[ilya-biryukov]

include/clang/Sema/CodeCompleteConsumer.h

767 ↗

(On Diff #171259)

NIT: does "identifiers name" refer to a field name? Maybe use "field name" directly to avoid possibly confusion.

lib/Sema/SemaCodeComplete.cpp

2982

Maybe directly set the name here whenever PreferredTypedName is set and avoid changing the AddTypedNameChunk function?
This would keep the AddTypedNameChunk simpler and PreferredTypedName would simply become an overriden name that the code completion string should use instead of the declaration name.
I.e.

if (PreferredTypedName)
  Result.AddTypedTextChunk(Result.getAllocator().CopyString(PreferredTypedName));
else
  AddTypedNameChunk(Ctx, Policy, ...);

5198

Should we also have fallbacks for bases in addition to fields? They may also have non-class types.
Could we also add a test?
Should pop up in completions of dependent bases, e.g.

template <class T>
struct Y : T {};

template <class T>
struct X : std::vector<T> {}; // referring to an explicit template, however still dependent.

5199

Maybe add a comment that this is a fallback?

test/CodeCompletion/ordinary-name-cxx11.cpp

65 ↗

(On Diff #171259)

This completion is outside constructor initializers.
Why behavior change for these completions too?

[kadircet]

• Address comments & offline discussions.

[ZaMaZaN4iK]

lib/Sema/SemaCodeComplete.cpp

5092

Is it good idea to capture ALL by reference? Probably will be better to capture only required things by reference

[kadircet]

lib/Sema/SemaCodeComplete.cpp

5092

That's the case within the rest of the code, so I did that to be consistent, and apart from that I don't think this brings any disadvantages.

[ilya-biryukov]

lib/Sema/SemaCodeComplete.cpp

811

We don't seem to need this fwd-decl anymore. Remove it?

819

There's a function that does the same thing and also does some extra lifting to make sure implicit members are properly generated - Sema::LookupConstructors. Maybe use it instead?

829

Remove this code instead of commenting it out?

842

Maybe use range-baseed for loop?

5080

NIT: naming, use UpperCamelCase

5092

TypedName and TypeName are too similar. Maybe pick names that are easier to distinguish?
Name and Type seem to be a good fit

5093

Maybe use StringRef?

5108

CodeCompletionResult R looks redundant here? Do we really need it?

5123

The code past that point is the same between AddBase and AddField. Maybe move it into AddCtorsWithName?

[kadircet]

• Address comments.

lib/Sema/SemaCodeComplete.cpp

819

As talked offline we don't want this behavior.

829

Ah, sorry for the mess :(

5093

Don't think this looks any better, since we need to use .data() at chunk additions than.

Even if we try to push allocations all the way down until we add those chunks, we still get bad looking code since types are returned as std::string and we need to make a copy in the stack to be able to pass it as StringRef.

[ilya-biryukov]

Mostly NITs

lib/Sema/SemaCodeComplete.cpp

811

Maybe make the name shorter?
E.g. getConstructors or lookupConstructors?

843

Maybe inline Ctors?
I.e.

for (auto Ctor : getConstructorResults(SemaRef.Context, Record))

5081

Builder is not used outside GenerateCCS and AddDefaultCtorInit, maybe move its declaration into those lamdbas and remove from the enclosing function?
Would mean less mutable state to care about and the function seems big enough for that to matter.

5083

NIT: use auto

5085

NIT: use auto

5093

char* and StringRef have equivalent lifetime properties, so the set of cases you need to do extra copies is equivalent. Am I missing something?
But yeah, since AddChunk methods accept a char*, StringRef is not suitable because it's not guaranteed to be null-terminated. LG

test/CodeCompletion/ctor-initializer.cpp

44

Maybe use a single check CHECK-CC5-NOT: COMPLETION: Pattern : Base? (i.e. not mentioning the arguments)

68

Why do we want to change this test?

test/Index/complete-ctor-inits.cpp

33

Reading through the code, it seems MemberRef was the correct CursorKind here (the docs mention that MemberRef is a reference in non-expression context and ctor-initializer seems to be one of those).
Maybe keep it a MemberRef, since it looks simple enough.

Having CXXConstrutor instead of NotImpleneted is clearly a win, though :-)

[kadircet]

• Address comments.

[kadircet]

lib/Sema/SemaCodeComplete.cpp

5093

Yes, but I store those strings inside allocator and pass pointers of those stored ones. If I were to defer the allocation, I would need to keep copies of the strings myself until I call allocate on them.

test/CodeCompletion/ctor-initializer.cpp

68

This was for something else I've been testing, nvm.

The change below is however, to get rid of the compile error.

[ilya-biryukov]

lib/Sema/SemaCodeComplete.cpp

176

AddConstructorResults is not defined and not used. Remove it?

[kadircet]

• Revert back declaration.

[ilya-biryukov]

LGTM. Thanks for the change!

lib/Sema/SemaCodeComplete.cpp

private:
     /// object.
     ObjCImplementationDecl *ObjCImplementation;
 
     void AdjustResultPriorityForDecl(Result &R);
 
     void MaybeAddConstructorResults(Result R);
 
   public:
     explicit ResultBuilder(Sema &SemaRef, CodeCompletionAllocator &Allocator,
                            CodeCompletionTUInfo &CCTUInfo,
                            const CodeCompletionContext &CompletionContext,
                            LookupFilter Filter = nullptr)
       : SemaRef(SemaRef), Allocator(Allocator), CCTUInfo(CCTUInfo),
         Filter(Filter),
         AllowNestedNameSpecifiers(false), HasObjectTypeQualifiers(false),
         CompletionContext(CompletionContext),
         ObjCImplementation(nullptr)
if (!T.isNull()) {
       else if ((getSimplifiedTypeClass(PreferredType)
                                                == getSimplifiedTypeClass(TC)) &&
                !(PreferredType->isEnumeralType() && TC->isEnumeralType()))
         R.Priority /= CCF_SimilarTypeMatch;
     }
   }
 }
 
+DeclContext::lookup_result getConstructors(ASTContext &Context,
+                                           const CXXRecordDecl *Record) {
+  QualType RecordTy = Context.getTypeDeclType(Record);
+  DeclarationName ConstructorName =
+      Context.DeclarationNames.getCXXConstructorName(
+          Context.getCanonicalType(RecordTy));
+  return Record->lookup(ConstructorName);
+}
+
 void ResultBuilder::MaybeAddConstructorResults(Result R) {
   if (!SemaRef.getLangOpts().CPlusPlus || !R.Declaration ||
       !CompletionContext.wantConstructorResults())
     return;
 
-  ASTContext &Context = SemaRef.Context;
   const NamedDecl *D = R.Declaration;
   const CXXRecordDecl *Record = nullptr;
   if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(D))
     Record = ClassTemplate->getTemplatedDecl();
   else if ((Record = dyn_cast<CXXRecordDecl>(D))) {
     // Skip specializations and partial specializations.
     if (isa<ClassTemplateSpecializationDecl>(Record))
       return;
   } else {
     // There are no constructors here.
     return;
   }
 
   Record = Record->getDefinition();
   if (!Record)
     return;
 
-
-  QualType RecordTy = Context.getTypeDeclType(Record);
-  DeclarationName ConstructorName
-    = Context.DeclarationNames.getCXXConstructorName(
-                                           Context.getCanonicalType(RecordTy));
-  DeclContext::lookup_result Ctors = Record->lookup(ConstructorName);
-  for (DeclContext::lookup_iterator I = Ctors.begin(),
-                                          E = Ctors.end();
-       I != E; ++I) {
-    R.Declaration = *I;
+  for(auto Ctor : getConstructors(SemaRef.Context, Record)) {
+    R.Declaration = Ctor;
     R.CursorKind = getCursorKindForDecl(R.Declaration);
     Results.push_back(R);
   }
 }
 
 static bool isConstructor(const Decl *ND) {
   if (const auto *Tmpl = dyn_cast<FunctionTemplateDecl>(ND))
     ND = Tmpl->getTemplatedDecl();
CodeCompletionString *CodeCompletionResult::createCodeCompletionStringForDecl(
   for (const auto *I : ND->specific_attrs<AnnotateAttr>())
     Result.AddAnnotation(Result.getAllocator().CopyString(I->getAnnotation()));
 
   AddResultTypeChunk(Ctx, Policy, ND, CCContext.getBaseType(), Result);
 
   if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(ND)) {
     AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
                                    Ctx, Policy);
     AddTypedNameChunk(Ctx, Policy, ND, Result);
     Result.AddChunk(CodeCompletionString::CK_LeftParen);
     AddFunctionParameterChunks(PP, Policy, Function, Result);
     Result.AddChunk(CodeCompletionString::CK_RightParen);
     AddFunctionTypeQualsToCompletionString(Result, Function);
     return Result.TakeString();
   }
 
   if (const FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(ND)) {
if (Initializers[I]->isBaseInitializer())
       InitializedBases.insert(
         Context.getCanonicalType(QualType(Initializers[I]->getBaseClass(), 0)));
     else
       InitializedFields.insert(cast<FieldDecl>(
                                Initializers[I]->getAnyMember()));
   }
 
   // Add completions for base classes.
-  CodeCompletionBuilder Builder(Results.getAllocator(),
-                                Results.getCodeCompletionTUInfo());
   PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
   bool SawLastInitializer = Initializers.empty();
   CXXRecordDecl *ClassDecl = Constructor->getParent();
+
+  auto GenerateCCS = [&](const NamedDecl *ND, const char *Name) {
+    CodeCompletionBuilder Builder(Results.getAllocator(),
+                                  Results.getCodeCompletionTUInfo());
+    Builder.AddTypedTextChunk(Name);
+    Builder.AddChunk(CodeCompletionString::CK_LeftParen);
+    if (auto Function = dyn_cast<FunctionDecl>(ND))
+      AddFunctionParameterChunks(PP, Policy, Function, Builder);
+    else if (auto FunTemplDecl = dyn_cast<FunctionTemplateDecl>(ND))
+      AddFunctionParameterChunks(PP, Policy, FunTemplDecl->getTemplatedDecl(),
+                                 Builder);
+    Builder.AddChunk(CodeCompletionString::CK_RightParen);
+    return Builder.TakeString();
+  };
+  auto AddDefaultCtorInit = [&](const char *Name, const char *Type,
+                                const NamedDecl *ND) {
+    CodeCompletionBuilder Builder(Results.getAllocator(),
+                                  Results.getCodeCompletionTUInfo());
+    Builder.AddTypedTextChunk(Name);
+    Builder.AddChunk(CodeCompletionString::CK_LeftParen);
+    Builder.AddPlaceholderChunk(Type);
+    Builder.AddChunk(CodeCompletionString::CK_RightParen);
+    if (ND) {
+      auto CCR = CodeCompletionResult(
+          Builder.TakeString(), ND,
+          SawLastInitializer ? CCP_NextInitializer : CCP_MemberDeclaration);
+      if (isa<FieldDecl>(ND))
+        CCR.CursorKind = CXCursor_MemberRef;
+      return Results.AddResult(CCR);
+    }
+    return Results.AddResult(CodeCompletionResult(
+        Builder.TakeString(),
+        SawLastInitializer ? CCP_NextInitializer : CCP_MemberDeclaration));
+  };
+  auto AddCtorsWithName = [&](const CXXRecordDecl *RD, unsigned int Priority,
+                              const char *Name, const FieldDecl *FD) {
+    if (!RD)
+      return AddDefaultCtorInit(Name,
+                                FD ? Results.getAllocator().CopyString(
+                                         FD->getType().getAsString(Policy))
+                                   : Name,
+                                FD);
+    auto Ctors = getConstructors(Context, RD);
+    if (Ctors.begin() == Ctors.end())
+      return AddDefaultCtorInit(Name, Name, RD);
+    for (const auto Ctor : Ctors) {
+      auto CCR = CodeCompletionResult(GenerateCCS(Ctor, Name), RD, Priority);
+      CCR.CursorKind = getCursorKindForDecl(Ctor);
+      Results.AddResult(CCR);
+    }
+  };
+  auto AddBase = [&](const CXXBaseSpecifier &Base) {
+    const char *BaseName =
+        Results.getAllocator().CopyString(Base.getType().getAsString(Policy));
+    const auto *RD = Base.getType()->getAsCXXRecordDecl();
+    AddCtorsWithName(
+        RD, SawLastInitializer ? CCP_NextInitializer : CCP_MemberDeclaration,
+        BaseName, nullptr);
+  };
+  auto AddField = [&](const FieldDecl *FD) {
+    const char *FieldName =
+        Results.getAllocator().CopyString(FD->getIdentifier()->getName());
+    const CXXRecordDecl *RD = FD->getType()->getAsCXXRecordDecl();
+    AddCtorsWithName(
+        RD, SawLastInitializer ? CCP_NextInitializer : CCP_MemberDeclaration,
+        FieldName, FD);
+  };
+
   for (const auto &Base : ClassDecl->bases()) {
     if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))
              .second) {
       SawLastInitializer
         = !Initializers.empty() &&
           Initializers.back()->isBaseInitializer() &&
           Context.hasSameUnqualifiedType(Base.getType(),
                QualType(Initializers.back()->getBaseClass(), 0));
       continue;
     }
 
-    Builder.AddTypedTextChunk(
-               Results.getAllocator().CopyString(
-                          Base.getType().getAsString(Policy)));
-    Builder.AddChunk(CodeCompletionString::CK_LeftParen);
-    Builder.AddPlaceholderChunk("args");
-    Builder.AddChunk(CodeCompletionString::CK_RightParen);
-    Results.AddResult(CodeCompletionResult(Builder.TakeString(),
-                                   SawLastInitializer? CCP_NextInitializer
-                                                     : CCP_MemberDeclaration));
+    AddBase(Base);
     SawLastInitializer = false;
   }
 
   // Add completions for virtual base classes.
   for (const auto &Base : ClassDecl->vbases()) {
     if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))
              .second) {
       SawLastInitializer
         = !Initializers.empty() &&
           Initializers.back()->isBaseInitializer() &&
           Context.hasSameUnqualifiedType(Base.getType(),
                QualType(Initializers.back()->getBaseClass(), 0));
       continue;
     }
 
-    Builder.AddTypedTextChunk(
-               Builder.getAllocator().CopyString(
-                          Base.getType().getAsString(Policy)));
-    Builder.AddChunk(CodeCompletionString::CK_LeftParen);
-    Builder.AddPlaceholderChunk("args");
-    Builder.AddChunk(CodeCompletionString::CK_RightParen);
-    Results.AddResult(CodeCompletionResult(Builder.TakeString(),
-                                   SawLastInitializer? CCP_NextInitializer
-                                                     : CCP_MemberDeclaration));
+    AddBase(Base);
     SawLastInitializer = false;
   }
 
   // Add completions for members.
   for (auto *Field : ClassDecl->fields()) {
     if (!InitializedFields.insert(cast<FieldDecl>(Field->getCanonicalDecl()))
              .second) {
       SawLastInitializer
         = !Initializers.empty() &&
           Initializers.back()->isAnyMemberInitializer() &&
           Initializers.back()->getAnyMember() == Field;
       continue;
     }
 
     if (!Field->getDeclName())
       continue;
 
-    Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
-                                         Field->getIdentifier()->getName()));
-    Builder.AddChunk(CodeCompletionString::CK_LeftParen);
-    Builder.AddPlaceholderChunk("args");
-    Builder.AddChunk(CodeCompletionString::CK_RightParen);
-    Results.AddResult(CodeCompletionResult(Builder.TakeString(),
-                                   SawLastInitializer? CCP_NextInitializer
-                                                     : CCP_MemberDeclaration,
-                                           CXCursor_MemberRef,
-                                           CXAvailability_Available,
-                                           Field));
+    AddField(Field);
     SawLastInitializer = false;
   }
   Results.ExitScope();
 
   HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
                             Results.data(), Results.size());
 }
 
 /// Determine whether this scope denotes a namespace.
 static bool isNamespaceScope(Scope *S) {
   DeclContext *DC = S->getEntity();
   if (!DC)
     return false;
 
   return DC->isFileContext();
 }
 
 void Sema::CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro,
                                         bool AfterAmpersand) {
   ResultBuilder Results(*this, CodeCompleter->getAllocator(),
                         CodeCompleter->getCodeCompletionTUInfo(),
                         CodeCompletionContext::CCC_Other);
   Results.EnterNewScope();
 
   // Note what has already been captured.
   llvm::SmallPtrSet<IdentifierInfo *, 4> Known;
   bool IncludedThis = false;
   for (const auto &C : Intro.Captures) {
     if (C.Kind == LCK_This) {
       IncludedThis = true;
       continue;
     }
 
     Known.insert(C.Id);
   }
 
   // Look for other capturable variables.

test/CodeCompletion/ctor-initializer.cpp

 struct Base1 {
   Base1() : {}
   // RUN: %clang_cc1 -fsyntax-only -std=c++98 -code-completion-at=%s:2:12 %s -o - | FileCheck -check-prefix=CHECK-CC1 %s
   // RUN: %clang_cc1 -fsyntax-only -std=c++14 -code-completion-at=%s:2:12 %s -o - | FileCheck -check-prefix=CHECK-CC1 %s
-  // CHECK-CC1: COMPLETION: Pattern : member1(<#args#>)
-  // CHECK-CC1: COMPLETION: Pattern : member2(<#args#>
+  // CHECK-CC1: COMPLETION: Pattern : member1(<#int#>)
+  // CHECK-CC1: COMPLETION: Pattern : member2(<#float#>)
 
   Base1(int) : member1(123), {}
   // RUN: %clang_cc1 -fsyntax-only -std=c++98 -code-completion-at=%s:8:30 %s -o - | FileCheck -check-prefix=CHECK-CC2 %s
   // RUN: %clang_cc1 -fsyntax-only -std=c++14 -code-completion-at=%s:8:30 %s -o - | FileCheck -check-prefix=CHECK-CC2 %s
-  // CHECK-CC2-NOT: COMPLETION: Pattern : member1(<#args#>)
-  // CHECK-CC2: COMPLETION: Pattern : member2(<#args#>
+  // CHECK-CC2-NOT: COMPLETION: Pattern : member1(<#int#>)
+  // CHECK-CC2: COMPLETION: Pattern : member2(<#float#>)
 
   int member1;
   float member2;
 };
 
 struct Derived : public Base1 {
   Derived();
   Derived(int);
   Derived(float);
   int deriv1;
 };
 
 Derived::Derived() : {}
 // RUN: %clang_cc1 -fsyntax-only -std=c++98 -code-completion-at=%s:25:22 %s -o - | FileCheck -check-prefix=CHECK-CC3 %s
 // RUN: %clang_cc1 -fsyntax-only -std=c++14 -code-completion-at=%s:25:22 %s -o - | FileCheck -check-prefix=CHECK-CC3 %s
-// CHECK-CC3: COMPLETION: Pattern : Base1(<#args#>)
-// CHECK-CC3: COMPLETION: Pattern : deriv1(<#args#>)
+// CHECK-CC3: COMPLETION: Pattern : Base1()
+// CHECK-CC3: COMPLETION: Pattern : Base1(<#int#>)
+// CHECK-CC3: COMPLETION: Pattern : deriv1(<#int#>)
 
 Derived::Derived(int) try : {
 } catch (...) {
 }
-// RUN: %clang_cc1 -fsyntax-only -std=c++98 -code-completion-at=%s:31:29 %s -o - | FileCheck -check-prefix=CHECK-CC4 %s
-// RUN: %clang_cc1 -fsyntax-only -std=c++14 -code-completion-at=%s:31:29 %s -o - | FileCheck -check-prefix=CHECK-CC4 %s
-// CHECK-CC4: COMPLETION: Pattern : Base1(<#args#>)
-// CHECK-CC4: COMPLETION: Pattern : deriv1(<#args#>)
+// RUN: %clang_cc1 -fsyntax-only -std=c++98 -code-completion-at=%s:32:29 %s -o - | FileCheck -check-prefix=CHECK-CC3 %s
+// RUN: %clang_cc1 -fsyntax-only -std=c++14 -code-completion-at=%s:32:29 %s -o - | FileCheck -check-prefix=CHECK-CC3 %s
 
 Derived::Derived(float) try : Base1(),
 {
 } catch (...) {
 }
-// RUN: %clang_cc1 -fsyntax-only -std=c++98 -code-completion-at=%s:39:39 %s -o - | FileCheck -check-prefix=CHECK-CC5 %s
-// RUN: %clang_cc1 -fsyntax-only -std=c++14 -code-completion-at=%s:39:39 %s -o - | FileCheck -check-prefix=CHECK-CC5 %s
-// CHECK-CC5-NOT: COMPLETION: Pattern : Base1(<#args#>)
-// CHECK-CC5: COMPLETION: Pattern : deriv1(<#args#>)
+// RUN: %clang_cc1 -fsyntax-only -std=c++98 -code-completion-at=%s:38:39 %s -o - | FileCheck -check-prefix=CHECK-CC5 %s
+// RUN: %clang_cc1 -fsyntax-only -std=c++14 -code-completion-at=%s:38:39 %s -o - | FileCheck -check-prefix=CHECK-CC5 %s
+// CHECK-CC5-NOT: COMPLETION: Pattern : Base1
+// CHECK-CC5: COMPLETION: Pattern : deriv1(<#int#>)
 
 struct A {
   A() : , member2() {}
-  // RUN: %clang_cc1 -fsyntax-only -std=c++98 -code-completion-at=%s:49:9 %s -o - | FileCheck -check-prefix=CHECK-CC6 %s
-  // RUN: %clang_cc1 -fsyntax-only -std=c++14 -code-completion-at=%s:49:9 %s -o - | FileCheck -check-prefix=CHECK-CC6 %s
-  // CHECK-CC6: COMPLETION: Pattern : member1(<#args#>
+  // RUN: %clang_cc1 -fsyntax-only -std=c++98 -code-completion-at=%s:48:9 %s -o - | FileCheck -check-prefix=CHECK-CC6 %s
+  // RUN: %clang_cc1 -fsyntax-only -std=c++14 -code-completion-at=%s:48:9 %s -o - | FileCheck -check-prefix=CHECK-CC6 %s
+  // CHECK-CC6: COMPLETION: Pattern : member1(<#int#>)
   int member1, member2;
 };
 
 struct B {
   B() : member2() {}
-  // RUN: %clang_cc1 -fsyntax-only -std=c++98 -code-completion-at=%s:57:9 %s -o - | FileCheck -check-prefix=CHECK-CC7 %s
-  // RUN: %clang_cc1 -fsyntax-only -std=c++14 -code-completion-at=%s:57:9 %s -o - | FileCheck -check-prefix=CHECK-CC7 %s
-  // CHECK-CC7: COMPLETION: Pattern : member1(<#args#>
+  // RUN: %clang_cc1 -fsyntax-only -std=c++98 -code-completion-at=%s:56:9 %s -o - | FileCheck -check-prefix=CHECK-CC7 %s
+  // RUN: %clang_cc1 -fsyntax-only -std=c++14 -code-completion-at=%s:56:9 %s -o - | FileCheck -check-prefix=CHECK-CC7 %s
+  // CHECK-CC7: COMPLETION: Pattern : member1(<#int#>)
   // Check in the middle and at the end of identifier too.
-  // RUN: %clang_cc1 -fsyntax-only -std=c++98 -code-completion-at=%s:57:13 %s -o - | FileCheck -check-prefix=CHECK-CC8 %s
-  // RUN: %clang_cc1 -fsyntax-only -std=c++98 -code-completion-at=%s:57:16 %s -o - | FileCheck -check-prefix=CHECK-CC8 %s
-  // CHECK-CC8: COMPLETION: Pattern : member2(<#args#>
+  // RUN: %clang_cc1 -fsyntax-only -std=c++98 -code-completion-at=%s:56:13 %s -o - | FileCheck -check-prefix=CHECK-CC8 %s
+  // RUN: %clang_cc1 -fsyntax-only -std=c++98 -code-completion-at=%s:56:16 %s -o - | FileCheck -check-prefix=CHECK-CC8 %s
+  // CHECK-CC8: COMPLETION: Pattern : member2(<#int#>)
   int member1, member2;
 };
 
 struct Base2 {
   Base2(int);
 };
 
 struct Composition1 {
-  Composition1() : b2_elem() {}
-  // RUN: %clang_cc1 -fsyntax-only -std=c++98 -code-completion-at=%s:73:28 %s -o - | FileCheck -check-prefix=CHECK-CC9 %s
-  // RUN: %clang_cc1 -fsyntax-only -std=c++14 -code-completion-at=%s:73:28 %s -o - | FileCheck -check-prefix=CHECK-CC9 %s
+  Composition1() : b2_elem(2) {}
+  // RUN: %clang_cc1 -fsyntax-only -std=c++98 -code-completion-at=%s:72:28 %s -o - | FileCheck -check-prefix=CHECK-CC9 %s
+  // RUN: %clang_cc1 -fsyntax-only -std=c++14 -code-completion-at=%s:72:28 %s -o - | FileCheck -check-prefix=CHECK-CC9 %s
   // CHECK-CC9: OVERLOAD: Base2(<#int#>)
   // CHECK-CC9: OVERLOAD: Base2(<#const Base2 &#>)
   // CHECK-CC9-NOT: OVERLOAD: Composition1
   Composition1(Base2);
   Base2 b2_elem;
 };
 
 struct Composition2 {
   Composition2() : c1_elem(Base2(1)) {}
-  // RUN: %clang_cc1 -fsyntax-only -std=c++98 -code-completion-at=%s:84:34 %s -o - | FileCheck -check-prefix=CHECK-CC9 %s
-  // RUN: %clang_cc1 -fsyntax-only -std=c++14 -code-completion-at=%s:84:34 %s -o - | FileCheck -check-prefix=CHECK-CC9 %s
-  // RUN: %clang_cc1 -fsyntax-only -std=c++98 -code-completion-at=%s:84:35 %s -o - | FileCheck -check-prefix=CHECK-CC9 %s
-  // RUN: %clang_cc1 -fsyntax-only -std=c++14 -code-completion-at=%s:84:35 %s -o - | FileCheck -check-prefix=CHECK-CC9 %s
+  // RUN: %clang_cc1 -fsyntax-only -std=c++98 -code-completion-at=%s:83:34 %s -o - | FileCheck -check-prefix=CHECK-CC9 %s
+  // RUN: %clang_cc1 -fsyntax-only -std=c++14 -code-completion-at=%s:83:34 %s -o - | FileCheck -check-prefix=CHECK-CC9 %s
+  // RUN: %clang_cc1 -fsyntax-only -std=c++98 -code-completion-at=%s:83:35 %s -o - | FileCheck -check-prefix=CHECK-CC9 %s
+  // RUN: %clang_cc1 -fsyntax-only -std=c++14 -code-completion-at=%s:83:35 %s -o - | FileCheck -check-prefix=CHECK-CC9 %s
   Composition1 c1_elem;
 };
+// RUN: %clang_cc1 -fsyntax-only -std=c++98 -code-completion-at=%s:83:20 %s -o - | FileCheck -check-prefix=CHECK-CC10 %s
+// RUN: %clang_cc1 -fsyntax-only -std=c++14 -code-completion-at=%s:83:20 %s -o - | FileCheck -check-prefix=CHECK-CC10 %s
+// CHECK-CC10: Pattern : c1_elem()
+// CHECK-CC10: Pattern : c1_elem(<#Base2#>)
+
+template <class T>
+struct Y : T {};
+
+template <class T>
+struct X : Y<T> {
+  X() : Y<T>() {};
+};
+
+// RUN: %clang_cc1 -fsyntax-only -std=c++98 -code-completion-at=%s:100:9 %s -o - | FileCheck -check-prefix=CHECK-CC11 %s
+// RUN: %clang_cc1 -fsyntax-only -std=c++14 -code-completion-at=%s:100:9 %s -o - | FileCheck -check-prefix=CHECK-CC11 %s
+// CHECK-CC11: Pattern : Y<T>(<#Y<T>#>)

test/Index/complete-ctor-inits.cpp

struct PR23948 {
   template<class size> void invalid()
         :
   {}
 
   int a;
 };
 
 // RUN: c-index-test -code-completion-at=%s:18:10 %s | FileCheck -check-prefix=CHECK-CC1 %s
-// CHECK-CC1: MemberRef:{TypedText a}{LeftParen (}{Placeholder args}{RightParen )} (35)
-// CHECK-CC1: MemberRef:{TypedText b}{LeftParen (}{Placeholder args}{RightParen )} (35)
-// CHECK-CC1: MemberRef:{TypedText c}{LeftParen (}{Placeholder args}{RightParen )} (35)
-// CHECK-CC1: NotImplemented:{TypedText Virt}{LeftParen (}{Placeholder args}{RightParen )} (35)
-// CHECK-CC1: NotImplemented:{TypedText X<int>}{LeftParen (}{Placeholder args}{RightParen )} (7)
-// CHECK-CC1: NotImplemented:{TypedText Y}{LeftParen (}{Placeholder args}{RightParen )} (35)
+// CHECK-CC1: MemberRef:{TypedText a}{LeftParen (}{Placeholder int}{RightParen )} (35)
+// CHECK-CC1: MemberRef:{TypedText b}{LeftParen (}{Placeholder int}{RightParen )} (35)
+// CHECK-CC1: MemberRef:{TypedText c}{LeftParen (}{Placeholder int}{RightParen )} (35)
+// CHECK-CC1: CXXConstructor:{TypedText Virt}{LeftParen (}{Placeholder const Virt &}{RightParen )} (35)
+// CHECK-CC1: CXXConstructor:{TypedText Virt}{LeftParen (}{Placeholder Virt &&}{RightParen )} (35)
+// CHECK-CC1: CXXConstructor:{TypedText X<int>}{LeftParen (}{Placeholder int}{RightParen )} (7)
+// CHECK-CC1: CXXConstructor:{TypedText Y}{LeftParen (}{Placeholder const Y &}{RightParen )} (35)
+// CHECK-CC1: CXXConstructor:{TypedText Y}{LeftParen (}{Placeholder Y &&}{RightParen )} (35)
 
 // RUN: c-index-test -code-completion-at=%s:18:23 %s | FileCheck -check-prefix=CHECK-CC2 %s
-// CHECK-CC2: MemberRef:{TypedText a}{LeftParen (}{Placeholder args}{RightParen )} (35)
-// CHECK-CC2: MemberRef:{TypedText b}{LeftParen (}{Placeholder args}{RightParen )} (35)
-// CHECK-CC2: MemberRef:{TypedText c}{LeftParen (}{Placeholder args}{RightParen )} (35)
-// CHECK-CC2: NotImplemented:{TypedText Virt}{LeftParen (}{Placeholder args}{RightParen )} (35)
-// CHECK-CC2: NotImplemented:{TypedText Y}{LeftParen (}{Placeholder args}{RightParen )} (7)
+// CHECK-CC2: MemberRef:{TypedText a}{LeftParen (}{Placeholder int}{RightParen )} (35)
+// CHECK-CC2: MemberRef:{TypedText b}{LeftParen (}{Placeholder int}{RightParen )} (35)
+// CHECK-CC2: MemberRef:{TypedText c}{LeftParen (}{Placeholder int}{RightParen )} (35)
+// CHECK-CC2: CXXConstructor:{TypedText Virt}{LeftParen (}{Placeholder const Virt &}{RightParen )} (35)
+// CHECK-CC2: CXXConstructor:{TypedText Virt}{LeftParen (}{Placeholder Virt &&}{RightParen )} (35)
+// CHECK-CC2: CXXConstructor:{TypedText Y}{LeftParen (}{Placeholder const Y &}{RightParen )} (7)
+// CHECK-CC2: CXXConstructor:{TypedText Y}{LeftParen (}{Placeholder Y &&}{RightParen )} (7)
 
 // RUN: c-index-test -code-completion-at=%s:18:36 %s | FileCheck -check-prefix=CHECK-CC3 %s
-// CHECK-CC3: MemberRef:{TypedText a}{LeftParen (}{Placeholder args}{RightParen )} (35)
-// CHECK-CC3-NOT: MemberRef:{TypedText b}{LeftParen (}{Placeholder args}{RightParen )}
-// CHECK-CC3: MemberRef:{TypedText c}{LeftParen (}{Placeholder args}{RightParen )} (7)
-// CHECK-CC3-NOT: NotImplemented:{TypedText Virt}{LeftParen (}{Placeholder args}{RightParen )}
-// CHECK-CC3: NotImplemented:{TypedText Y}{LeftParen (}{Placeholder args}{RightParen )} (35)
+// CHECK-CC3: MemberRef:{TypedText a}{LeftParen (}{Placeholder int}{RightParen )} (35)
+// CHECK-CC3-NOT: MemberRef:{TypedText b}{LeftParen (}{Placeholder int}{RightParen )}
+// CHECK-CC3: MemberRef:{TypedText c}{LeftParen (}{Placeholder int}{RightParen )} (7)
+// CHECK-CC3-NOT: CXXConstructor:{TypedText Virt}{LeftParen (}{Placeholder const Virt &}{RightParen )} (35)
+// CHECK-CC3-NOT: CXXConstructor:{TypedText Virt}{LeftParen (}{Placeholder Virt &&}{RightParen )} (35)
+// CHECK-CC3: CXXConstructor:{TypedText Y}{LeftParen (}{Placeholder const Y &}{RightParen )} (35)
+// CHECK-CC3: CXXConstructor:{TypedText Y}{LeftParen (}{Placeholder Y &&}{RightParen )} (35)
 
 // RUN: c-index-test -code-completion-at=%s:22:10 -target i386-apple-darwin %s | FileCheck -check-prefix=CHECK-CC4 %s
-// CHECK-CC4: MemberRef:{TypedText a}{LeftParen (}{Placeholder args}{RightParen )} (7)
+// CHECK-CC4: MemberRef:{TypedText a}{LeftParen (}{Placeholder int}{RightParen )} (7)
 // RUN: c-index-test -code-completion-at=%s:26:10 %s

test/Index/complete-cxx-inline-methods.cpp

 class OtherClass : public MyCls {
 public:
   OtherClass(const OtherClass &other) : MyCls(other), value(value) { }
 
 private:
   int value;
   MyCls *object;
 };
+
+template <typename T>
+class X {};
+
+class Y : public X<int> {
+  Y() : X<int>() {}
+};
 }
 
 // RUN: c-index-test -code-completion-at=%s:4:9 -std=c++98 %s | FileCheck %s
 // RUN: c-index-test -code-completion-at=%s:13:7 -std=c++98 %s | FileCheck %s
 // CHECK:      CXXMethod:{ResultType Vec &}{TypedText operator=}{LeftParen (}{Placeholder const Vec &}{RightParen )} (79)
 // CHECK-NEXT: StructDecl:{TypedText Vec}{Text ::} (75)
 // CHECK-NEXT: FieldDecl:{ResultType int}{TypedText x} (35)
 // CHECK-NEXT: FieldDecl:{ResultType int}{TypedText y} (35)
 // CHECK-NEXT: CXXDestructor:{ResultType void}{TypedText ~Vec}{LeftParen (}{RightParen )} (79)
 // CHECK-NEXT: Completion contexts:
 // CHECK-NEXT: Dot member access
 // CHECK-NEXT: Container Kind: StructDecl
 
 // RUN: c-index-test -code-completion-at=%s:18:41 %s | FileCheck -check-prefix=CHECK-CTOR-INIT %s
-// CHECK-CTOR-INIT: NotImplemented:{TypedText MyCls}{LeftParen (}{Placeholder args}{RightParen )} (7)
-// CHECK-CTOR-INIT: MemberRef:{TypedText object}{LeftParen (}{Placeholder args}{RightParen )} (35)
-// CHECK-CTOR-INIT: MemberRef:{TypedText value}{LeftParen (}{Placeholder args}{RightParen )} (35)
+// CHECK-CTOR-INIT: ClassDecl:{TypedText MyCls}{LeftParen (}{Placeholder MyCls}{RightParen )} (7)
+// CHECK-CTOR-INIT: MemberRef:{TypedText object}{LeftParen (}{Placeholder MyCls *}{RightParen )} (35)
+// CHECK-CTOR-INIT: MemberRef:{TypedText value}{LeftParen (}{Placeholder int}{RightParen )} (35)
 // RUN: c-index-test -code-completion-at=%s:18:55 %s | FileCheck -check-prefix=CHECK-CTOR-INIT-2 %s
-// CHECK-CTOR-INIT-2-NOT: NotImplemented:{TypedText MyCls}{LeftParen (}{Placeholder args}{RightParen )}
-// CHECK-CTOR-INIT-2: MemberRef:{TypedText object}{LeftParen (}{Placeholder args}{RightParen )} (35)
-// CHECK-CTOR-INIT-2: MemberRef:{TypedText value}{LeftParen (}{Placeholder args}{RightParen )} (7)
+// CHECK-CTOR-INIT-2-NOT: ClassDecl:{TypedText MyCls}{LeftParen (}{Placeholder MyCls}{RightParen )} (7)
+// CHECK-CTOR-INIT-2: MemberRef:{TypedText object}{LeftParen (}{Placeholder MyCls *}{RightParen )} (35)
+// CHECK-CTOR-INIT-2: MemberRef:{TypedText value}{LeftParen (}{Placeholder int}{RightParen )} (7)
+// RUN: c-index-test -code-completion-at=%s:29:9 %s | FileCheck -check-prefix=CHECK-CTOR-INIT-3 %s
+// CHECK-CTOR-INIT-3: ClassDecl:{TypedText X<int>}{LeftParen (}{Placeholder X<int>}{RightParen )} (7)