Improve the diagnostics used to report implicitly-generated class members

as parts of overload sets.  Also, refer to constructors as 'constructors'
rather than functions.

Adjust a lot of tests.



git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@92832 91177308-0d34-0410-b5e6-96231b3b80d8

include/clang/Basic/DiagnosticSemaKinds.td

@@ -895,18 +895,26 @@ def err_ovl_ambiguous_member_call : Error<
   "call to member function %0 is ambiguous">;
 def err_ovl_deleted_member_call : Error<
   "call to %select{unavailable|deleted}0 member function %1">;
-def err_ovl_candidate : Note<"candidate function">;
-def err_ovl_candidate_not_viable : Note<"function not viable because"
-                                        " of ambiguity in conversion of argument %0">;
+def note_ovl_candidate : Note<"candidate function">;
+def note_ovl_candidate_not_viable : Note<"function not viable because"
+                          " of ambiguity in conversion of argument %0">;
+def note_ovl_candidate_ctor : Note<"candidate constructor">;
+def note_ovl_candidate_implicit_copy_ctor : Note<
+    "candidate is the implicit copy constructor">;
+def note_ovl_candidate_implicit_default_ctor : Note<
+    "candidate is the implicit default constructor">;
+def note_ovl_candidate_meth : Note<"candidate function">;
+def note_ovl_candidate_implicit_copy_assign : Note<
+    "candidate is the implicit copy assignment operator">;
 def note_ambiguous_type_conversion: Note<
     "because of ambiguity in conversion of %0 to %1">;
-def err_ovl_template_candidate : Note<
+def note_ovl_template_candidate : Note<
   "candidate function template specialization %0">;
-def err_ovl_candidate_deleted : Note<
+def note_ovl_candidate_deleted : Note<
   "candidate function has been explicitly %select{made unavailable|deleted}0">;
-def err_ovl_builtin_binary_candidate : Note<
+def note_ovl_builtin_binary_candidate : Note<
     "built-in candidate %0">;
-def err_ovl_builtin_unary_candidate : Note<
+def note_ovl_builtin_unary_candidate : Note<
     "built-in candidate %0">;
 def err_ovl_no_viable_function_in_init : Error<
   "no matching constructor for initialization of %0">;
@@ -927,7 +935,7 @@ def err_ovl_ambiguous_object_call : Error<
   "call to object of type %0 is ambiguous">;
 def err_ovl_deleted_object_call : Error<
   "call to %select{unavailable|deleted}0 function call operator in type %1">;
-def err_ovl_surrogate_cand : Note<"conversion candidate of type %0">;
+def note_ovl_surrogate_cand : Note<"conversion candidate of type %0">;
 def err_member_call_without_object : Error<
   "call to non-static member function without an object argument">;
 

lib/Sema/Sema.h

@@ -1032,6 +1032,7 @@ public:
                          bool OnlyViable,
                          const char *Opc=0,
                          SourceLocation Loc=SourceLocation());
+  void NoteOverloadCandidate(FunctionDecl *Fn);
 
   FunctionDecl *ResolveAddressOfOverloadedFunction(Expr *From, QualType ToType,
                                                    bool Complain);

lib/Sema/SemaDeclCXX.cpp

@@ -4695,7 +4695,7 @@ Sema::CheckReferenceInit(Expr *&Init, QualType DeclType,
         for (int j = Conversions.ConversionFunctionSet.size()-1; 
              j >= 0; j--) {
           FunctionDecl *Func = Conversions.ConversionFunctionSet[j];
-          Diag(Func->getLocation(), diag::err_ovl_candidate);
+          NoteOverloadCandidate(Func);
         }
       }
       else {

lib/Sema/SemaExprCXX.cpp

@@ -921,7 +921,7 @@ Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal,
               << Type << Ex->getSourceRange();
         for (unsigned i= 0; i < ObjectPtrConversions.size(); i++) {
           CXXConversionDecl *Conv = ObjectPtrConversions[i];
-          Diag(Conv->getLocation(), diag::err_ovl_candidate);
+          NoteOverloadCandidate(Conv);
         }
         return ExprError();
       }

lib/Sema/SemaOverload.cpp

@@ -4274,6 +4274,44 @@ OverloadingResult Sema::BestViableFunction(OverloadCandidateSet& CandidateSet,
   return OR_Success;
 }
 
+/// Notes the location of an overload candidate.
+void Sema::NoteOverloadCandidate(FunctionDecl *Fn) {
+
+  if (CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(Fn)) {
+    // At least call it a 'constructor'.
+    if (!Ctor->isImplicit()) {
+      Diag(Ctor->getLocation(), diag::note_ovl_candidate_ctor);
+      return;
+    }
+
+    CXXRecordDecl *Record = Ctor->getParent();
+    if (Ctor->isCopyConstructor()) {
+      Diag(Record->getLocation(), diag::note_ovl_candidate_implicit_copy_ctor);
+      return;
+    }
+
+    Diag(Record->getLocation(), diag::note_ovl_candidate_implicit_default_ctor);
+    return;
+  }
+
+  if (CXXMethodDecl *Meth = dyn_cast<CXXMethodDecl>(Fn)) {
+    // This actually gets spelled 'candidate function' for now, but
+    // it doesn't hurt to split it out.
+    if (!Meth->isImplicit()) {
+      Diag(Meth->getLocation(), diag::note_ovl_candidate_meth);
+      return;
+    }
+
+    assert(Meth->isCopyAssignment()
+           && "implicit method is not copy assignment operator?");
+    Diag(Meth->getParent()->getLocation(),
+         diag::note_ovl_candidate_implicit_copy_assign);
+    return;
+  }
+
+  Diag(Fn->getLocation(), diag::note_ovl_candidate);
+}
+
 /// PrintOverloadCandidates - When overload resolution fails, prints
 /// diagnostic messages containing the candidates in the candidate
 /// set. If OnlyViable is true, only viable candidates will be printed.
@@ -4291,13 +4329,13 @@ Sema::PrintOverloadCandidates(OverloadCandidateSet& CandidateSet,
         if (Cand->Function->isDeleted() ||
             Cand->Function->getAttr<UnavailableAttr>()) {
           // Deleted or "unavailable" function.
-          Diag(Cand->Function->getLocation(), diag::err_ovl_candidate_deleted)
+          Diag(Cand->Function->getLocation(), diag::note_ovl_candidate_deleted)
             << Cand->Function->isDeleted();
         } else if (FunctionTemplateDecl *FunTmpl 
                      = Cand->Function->getPrimaryTemplate()) {
           // Function template specialization
           // FIXME: Give a better reason!
-          Diag(Cand->Function->getLocation(), diag::err_ovl_template_candidate)
+          Diag(Cand->Function->getLocation(), diag::note_ovl_template_candidate)
             << getTemplateArgumentBindingsText(FunTmpl->getTemplateParameters(),
                               *Cand->Function->getTemplateSpecializationArgs());
         } else {
@@ -4312,17 +4350,17 @@ Sema::PrintOverloadCandidates(OverloadCandidateSet& CandidateSet,
                   Conversion.ConversionFunctionSet.size() == 0)
                 continue;
               Diag(Cand->Function->getLocation(), 
-                   diag::err_ovl_candidate_not_viable) << (i+1);
+                   diag::note_ovl_candidate_not_viable) << (i+1);
               errReported = true;
               for (int j = Conversion.ConversionFunctionSet.size()-1; 
                    j >= 0; j--) {
                 FunctionDecl *Func = Conversion.ConversionFunctionSet[j];
-                Diag(Func->getLocation(), diag::err_ovl_candidate);
+                NoteOverloadCandidate(Func);
               }
             }
           }
           if (!errReported)
-            Diag(Cand->Function->getLocation(), diag::err_ovl_candidate);
+            NoteOverloadCandidate(Cand->Function);
         }
       } else if (Cand->IsSurrogate) {
         // Desugar the type of the surrogate down to a function type,
@@ -4352,7 +4390,7 @@ Sema::PrintOverloadCandidates(OverloadCandidateSet& CandidateSet,
         if (isRValueReference) FnType = Context.getRValueReferenceType(FnType);
         if (isLValueReference) FnType = Context.getLValueReferenceType(FnType);
 
-        Diag(Cand->Surrogate->getLocation(), diag::err_ovl_surrogate_cand)
+        Diag(Cand->Surrogate->getLocation(), diag::note_ovl_surrogate_cand)
           << FnType;
       } else if (OnlyViable) {
         assert(Cand->Conversions.size() <= 2 && 
@@ -4363,13 +4401,13 @@ Sema::PrintOverloadCandidates(OverloadCandidateSet& CandidateSet,
         TypeStr += Cand->BuiltinTypes.ParamTypes[0].getAsString();
         if (Cand->Conversions.size() == 1) {
           TypeStr += ")";
-          Diag(OpLoc, diag::err_ovl_builtin_unary_candidate) << TypeStr;
+          Diag(OpLoc, diag::note_ovl_builtin_unary_candidate) << TypeStr;
         }
         else {
           TypeStr += ", ";
           TypeStr += Cand->BuiltinTypes.ParamTypes[1].getAsString();
           TypeStr += ")";
-          Diag(OpLoc, diag::err_ovl_builtin_binary_candidate) << TypeStr;
+          Diag(OpLoc, diag::note_ovl_builtin_binary_candidate) << TypeStr;
         }
       }
       else if (!Cand->Viable && !Reported) {
@@ -4393,7 +4431,7 @@ Sema::PrintOverloadCandidates(OverloadCandidateSet& CandidateSet,
           for (unsigned j = 0; j < ICS.ConversionFunctionSet.size(); j++) {
             FunctionDecl *Func = 
               Cand->Conversions[ArgIdx].ConversionFunctionSet[j];
-            Diag(Func->getLocation(),diag::err_ovl_candidate);
+            NoteOverloadCandidate(Func);
           }
         }
         Reported = true;
@@ -4586,7 +4624,7 @@ Sema::ResolveAddressOfOverloadedFunction(Expr *From, QualType ToType,
                            PDiag(),
                            PDiag(diag::err_addr_ovl_ambiguous)
                                << TemplateMatches[0]->getDeclName(),
-                           PDiag(diag::err_ovl_template_candidate));
+                           PDiag(diag::note_ovl_template_candidate));
     MarkDeclarationReferenced(From->getLocStart(), Result);
     return Result;
   }
@@ -4611,7 +4649,7 @@ Sema::ResolveAddressOfOverloadedFunction(Expr *From, QualType ToType,
   Diag(From->getLocStart(), diag::err_addr_ovl_ambiguous)
     << RemainingMatches[0]->getDeclName();
   for (unsigned I = 0, N = RemainingMatches.size(); I != N; ++I)
-    Diag(RemainingMatches[I]->getLocation(), diag::err_ovl_candidate);
+    NoteOverloadCandidate(RemainingMatches[I]);
   return 0;
 }
 

test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-var.cpp

@@ -1,7 +1,7 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
-struct Base { }; // expected-note{{candidate function}}
-struct Derived : Base { }; // expected-note{{candidate function}}
+struct Base { }; // expected-note{{candidate is the implicit copy constructor}}
+struct Derived : Base { }; // expected-note{{candidate is the implicit copy constructor}}
 struct Unrelated { };
 struct Derived2 : Base { };
 struct Diamond : Derived, Derived2 { };

test/CXX/temp/temp.decls/temp.class/temp.static/p1-inst.cpp

@@ -14,7 +14,7 @@ struct InitOkay {
   InitOkay(int) { }
 };
 
-struct CannotInit { }; // expected-note{{candidate function}}
+struct CannotInit { }; // expected-note{{candidate is the implicit copy constructor}}
 
 int &returnInt() { return X<int>::value; }
 float &returnFloat() { return X<float>::value; }

test/CXX/temp/temp.decls/temp.class/temp.static/p1.cpp

@@ -12,7 +12,7 @@ struct X1 {
   X1(int);
 };
 
-struct X2 { }; // expected-note{{candidate function}}
+struct X2 { }; // expected-note{{candidate is the implicit copy constructor}}
 
 int& get_int() { return X0<int>::value; }
 X1& get_X1() { return X0<X1>::value; }

test/CXX/temp/temp.param/p3.cpp

@@ -15,7 +15,7 @@ template<template<class T> class Y> struct X1 {
 // could be interpreted as either a non-type template-parameter or a
 // type-parameter (because its identifier is the name of an already
 // existing class) is taken as a type-parameter. For example, 
-class T { /* ... */ };  // expected-note{{candidate function}}
+class T { /* ... */ };  // expected-note{{candidate is the implicit copy constructor}}
 int i; 
 
 template<class T, T i> struct X2 {

test/CXX/temp/temp.spec/temp.expl.spec/p15.cpp

@@ -1,7 +1,7 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 struct NonDefaultConstructible {
-  NonDefaultConstructible(const NonDefaultConstructible&); // expected-note{{candidate function}}
+  NonDefaultConstructible(const NonDefaultConstructible&); // expected-note{{candidate constructor}}
 };
 
 template<typename T, typename U>

test/CXX/temp/temp.spec/temp.expl.spec/p4.cpp

@@ -1,7 +1,7 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
-struct IntHolder { // expected-note{{here}} // expected-note 2{{candidate function}}
-  IntHolder(int); // expected-note 2{{candidate function}}
+struct IntHolder { // expected-note{{here}} // expected-note 2{{candidate is the implicit copy constructor}}
+  IntHolder(int); // expected-note 2{{candidate constructor}}
 };
 
 template<typename T, typename U>

test/CXX/temp/temp.spec/temp.explicit/p1.cpp

@@ -48,8 +48,8 @@ template void X1<int>::f<>(int&, int*); // expected-note{{instantiation}}
 
 // Explicitly instantiate members of a class template
 struct Incomplete; // expected-note{{forward declaration}}
-struct NonDefaultConstructible { // expected-note{{candidate function}}
-  NonDefaultConstructible(int); // expected-note{{candidate function}}
+struct NonDefaultConstructible { // expected-note{{candidate is the implicit copy constructor}}
+  NonDefaultConstructible(int); // expected-note{{candidate constructor}}
 };
 
 template<typename T, typename U>

test/SemaCXX/condition.cpp

@@ -16,8 +16,8 @@ void test() {
   for (;s;) ; // expected-error {{value of type 'struct S' is not contextually convertible to 'bool'}}
   switch (s) {} // expected-error {{statement requires expression of integer type ('struct S' invalid)}}
 
-  while (struct S {} x=0) ; // expected-error {{types may not be defined in conditions}} expected-error {{no viable conversion}} expected-error {{value of type 'struct S' is not contextually convertible to 'bool'}} expected-note{{candidate function}}
-  while (struct {} x=0) ; // expected-error {{types may not be defined in conditions}} expected-error {{no viable conversion}} expected-error {{value of type 'struct <anonymous>' is not contextually convertible to 'bool'}} expected-note{{candidate function}}
+  while (struct S {} x=0) ; // expected-error {{types may not be defined in conditions}} expected-error {{no viable conversion}} expected-error {{value of type 'struct S' is not contextually convertible to 'bool'}} expected-note{{candidate is the implicit copy constructor}}
+  while (struct {} x=0) ; // expected-error {{types may not be defined in conditions}} expected-error {{no viable conversion}} expected-error {{value of type 'struct <anonymous>' is not contextually convertible to 'bool'}} expected-note{{candidate is the implicit copy constructor}}
   switch (enum {E} x=0) ; // expected-error {{types may not be defined in conditions}} expected-error {{cannot initialize}}
 
   if (int x=0) { // expected-note 2 {{previous definition is here}}

test/SemaCXX/constructor-initializer.cpp

@@ -97,13 +97,10 @@ struct Current : Derived {
                                                   // expected-error {{member initializer 'NonExisting' does not name a non-static data member or}}
 };
 
-                        // FIXME. This is bad message!
-struct M {              // expected-note {{candidate function}} \
-                        // expected-note {{candidate function}} \
+struct M {              // expected-note 2 {{candidate is the implicit copy constructor}} \
                         // expected-note {{declared here}} \
                         // expected-note {{declared here}}
-  M(int i, int j);      // expected-note {{candidate function}} \
-                        // // expected-note {{candidate function}}
+  M(int i, int j);      // expected-note 2 {{candidate constructor}}
 };
 
 struct N : M  {

test/SemaCXX/conversion-function.cpp

@@ -56,9 +56,9 @@ public:
 
 // This used to crash Clang.
 struct Flip;
-struct Flop { // expected-note{{candidate function}}
+struct Flop { // expected-note{{candidate is the implicit copy constructor}}
   Flop();
-  Flop(const Flip&); // expected-note{{candidate function}}
+  Flop(const Flip&); // expected-note{{candidate constructor}}
 };
 struct Flip {
   operator Flop() const; // expected-note{{candidate function}}

test/SemaCXX/converting-constructor.cpp

@@ -27,7 +27,7 @@ public:
   FromShort(short s);
 };
 
-class FromShortExplicitly { // expected-note{{candidate function}}
+class FromShortExplicitly { // expected-note{{candidate is the implicit copy constructor}}
 public:
   explicit FromShortExplicitly(short s);
 };

test/SemaCXX/copy-initialization.cpp

@@ -2,7 +2,7 @@
 class X {
 public:
   explicit X(const X&);
-  X(int*); // expected-note 2{{candidate function}}
+  X(int*); // expected-note 2{{candidate constructor}}
   explicit X(float*);
 };
 

test/SemaCXX/dcl_init_aggr.cpp

@@ -40,9 +40,9 @@ char cv[4] = { 'a', 's', 'd', 'f', 0 }; // expected-error{{excess elements in ar
 struct TooFew { int a; char* b; int c; }; 
 TooFew too_few = { 1, "asdf" }; // okay
 
-struct NoDefaultConstructor { // expected-note 3 {{candidate function}} \
+struct NoDefaultConstructor { // expected-note 3 {{candidate is the implicit copy constructor}} \
                               // expected-note{{declared here}}
-  NoDefaultConstructor(int); // expected-note 3 {{candidate function}}
+  NoDefaultConstructor(int); // expected-note 3 {{candidate constructor}}
 };
 struct TooFewError { // expected-error{{implicit default constructor for}}
   int a;
@@ -115,7 +115,7 @@ B2 b2_2 = { 4, d2, 0 };
 B2 b2_3 = { c2, a2, a2 };
 
 // C++ [dcl.init.aggr]p15:
-union u { int a; char* b; }; // expected-note{{candidate function}}
+union u { int a; char* b; }; // expected-note{{candidate is the implicit copy constructor}}
 u u1 = { 1 }; 
 u u2 = u1; 
 u u3 = 1; // expected-error{{no viable conversion}}

test/SemaCXX/decl-init-ref.cpp

@@ -1,6 +1,6 @@
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++0x %s
 
-struct A {}; // expected-note {{candidate function}}
+struct A {}; // expected-note {{candidate is the implicit copy constructor}}
 
 struct BASE {
   operator A(); // expected-note {{candidate function}}

test/SemaCXX/default2.cpp

@@ -82,7 +82,7 @@ int Y::mem4(int i = a) // expected-error{{invalid use of nonstatic data member '
 // constructors.
 class Z {
 public:
-  Z(Z&, int i = 17); // expected-note 3 {{candidate function}}
+  Z(Z&, int i = 17); // expected-note 3 {{candidate constructor}}
 
   void f(Z& z) { 
     Z z2;    // expected-error{{no matching constructor for initialization}}
@@ -103,7 +103,7 @@ struct ZZ {
 
   void f(ZZ z = g()); // expected-error{{no matching constructor for initialization}}
 
-  ZZ(ZZ&, int = 17); // expected-note{{candidate function}}
+  ZZ(ZZ&, int = 17); // expected-note{{candidate constructor}}
 };
 
 // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#325

test/SemaCXX/direct-initializer.cpp

@@ -13,16 +13,16 @@ class Y {
   explicit Y(float);
 };
 
-class X { // expected-note{{candidate function}}
+class X { // expected-note{{candidate is the implicit copy constructor}}
 public:
-  explicit X(int); // expected-note{{candidate function}}
-  X(float, float, float); // expected-note{{candidate function}}
-  X(float, Y); // expected-note{{candidate function}}
+  explicit X(int); // expected-note{{candidate constructor}}
+  X(float, float, float); // expected-note{{candidate constructor}}
+  X(float, Y); // expected-note{{candidate constructor}}
 };
 
-class Z { // expected-note{{candidate function}}
+class Z { // expected-note{{candidate is the implicit copy constructor}}
 public:
-  Z(int); // expected-note{{candidate function}}
+  Z(int); // expected-note{{candidate constructor}}
 };
 
 void g() {

test/SemaCXX/functional-cast.cpp

@@ -10,10 +10,8 @@ struct InitViaConstructor {
   InitViaConstructor(int i = 7);
 };
 
-// FIXME: error messages for implicitly-declared special member
-// function candidates are very poor
-struct NoValueInit { // expected-note 2 {{candidate function}} 
-  NoValueInit(int i, int j); // expected-note 2 {{candidate function}}
+struct NoValueInit { // expected-note 2 {{candidate is the implicit copy constructor}} 
+  NoValueInit(int i, int j); // expected-note 2 {{candidate constructor}}
 };
 
 void test_cxx_functional_value_init() {

test/SemaCXX/namespace.cpp

@@ -9,7 +9,7 @@ int A; // expected-error {{redefinition of 'A' as different kind of symbol}}
 class A; // expected-error {{redefinition of 'A' as different kind of symbol}}
 
 class B {}; // expected-note {{previous definition is here}} \
-            // FIXME: ugly expected-note{{candidate function}}
+            // expected-note{{candidate is the implicit copy assignment operator}}
 
 void C(); // expected-note {{previous definition is here}}
 namespace C {} // expected-error {{redefinition of 'C' as different kind of symbol}}

test/SemaCXX/nested-name-spec.cpp

@@ -178,7 +178,7 @@ bool (foo_S::value);
 
 
 namespace somens {
-  struct a { }; // expected-note{{candidate function}}
+  struct a { }; // expected-note{{candidate is the implicit copy constructor}}
 }
 
 template <typename T>

test/SemaCXX/overloaded-builtin-operators.cpp

@@ -59,7 +59,7 @@ void f(Short s, Long l, Enum1 e1, Enum2 e2, Xpmf pmf) {
   // FIXME: should pass (void)static_cast<no&>(islong(e1 % e2));
 }
 
-struct ShortRef { // expected-note{{candidate function}}
+struct ShortRef { // expected-note{{candidate is the implicit copy assignment operator}}
   operator short&();
 };
 
@@ -67,7 +67,7 @@ struct LongRef {
   operator volatile long&();
 };
 
-struct XpmfRef { // expected-note{{candidate function}}
+struct XpmfRef { // expected-note{{candidate is the implicit copy assignment operator}}
   operator pmf&();
 };
 

test/SemaCXX/rval-references.cpp

@@ -67,8 +67,8 @@ struct MoveOnly {
   MoveOnly();
   MoveOnly(const MoveOnly&) = delete;	// expected-note {{candidate function}} \
   // expected-note 3{{explicitly marked deleted here}}
-  MoveOnly(MoveOnly&&);	// expected-note {{candidate function}}
-  MoveOnly(int&&);	// expected-note {{candidate function}}
+  MoveOnly(MoveOnly&&);	// expected-note {{candidate constructor}}
+  MoveOnly(int&&);	// expected-note {{candidate constructor}}
 };
 
 MoveOnly gmo;

test/SemaTemplate/constructor-template.cpp

@@ -52,8 +52,8 @@ template <> struct A<int>{A(const A<int>&);};
 struct B { A<int> x; B(B& a) : x(a.x) {} };
 
 struct X2 {
-  X2(); // expected-note{{candidate function}}
-  X2(X2&);	// expected-note {{candidate function}}
+  X2(); // expected-note{{candidate constructor}}
+  X2(X2&);	// expected-note {{candidate constructor}}
   template<typename T> X2(T);
 };
 
@@ -71,9 +71,9 @@ struct X3 {
 template<> X3::X3(X3); // expected-error{{must pass its first argument by reference}}
 
 struct X4 {
-  X4(); // expected-note{{candidate function}}
+  X4(); // expected-note{{candidate constructor}}
   ~X4();
-  X4(X4&);	// expected-note {{candidate function}}
+  X4(X4&);	// expected-note {{candidate constructor}}
   template<typename T> X4(const T&, int = 17);
 };
 

test/SemaTemplate/default-expr-arguments.cpp

@@ -5,7 +5,7 @@ class C { C(int a0 = 0); };
 template<>
 C<char>::C(int a0);
 
-struct S { }; // expected-note 3 {{candidate function}}
+struct S { }; // expected-note 3 {{candidate is the implicit copy constructor}}
 
 template<typename T> void f1(T a, T b = 10) { } // expected-error{{no viable conversion}}
 

test/SemaTemplate/explicit-instantiation.cpp

@@ -25,8 +25,8 @@ T X0<T>::value; // expected-error{{no matching constructor}}
 
 template int X0<int>::value;
 
-struct NotDefaultConstructible { // expected-note{{candidate function}}
-  NotDefaultConstructible(int); // expected-note{{candidate function}}
+struct NotDefaultConstructible { // expected-note{{candidate is the implicit copy constructor}}
+  NotDefaultConstructible(int); // expected-note{{candidate constructor}}
 };
 
 template NotDefaultConstructible X0<NotDefaultConstructible>::value; // expected-note{{instantiation}}

test/SemaTemplate/fun-template-def.cpp

@@ -8,7 +8,7 @@
 // Fake typeid, lacking a typeinfo header.
 namespace std { class type_info {}; }
 
-struct dummy {}; // expected-note 3 {{candidate function}}
+struct dummy {}; // expected-note 3 {{candidate is the implicit copy constructor}}
 
 template<typename T>
 int f0(T x) {

test/SemaTemplate/instantiate-expr-4.cpp

@@ -21,8 +21,8 @@ struct FunctionalCast0 {
 
 template struct FunctionalCast0<5>;
 
-struct X { // expected-note 3 {{candidate function}}
-  X(int, int); // expected-note 3 {{candidate function}}
+struct X { // expected-note 3 {{candidate is the implicit copy constructor}}
+  X(int, int); // expected-note 3 {{candidate constructor}}
 };
 
 template<int N, int M>

test/SemaTemplate/instantiate-static-var.cpp

@@ -30,7 +30,7 @@ T Z<T>::value; // expected-error{{no matching constructor}}
 struct DefCon {};
 
 struct NoDefCon { 
-  NoDefCon(const NoDefCon&); // expected-note{{candidate function}}
+  NoDefCon(const NoDefCon&); // expected-note{{candidate constructor}}
 };
 
 void test() {