When diagnosing an ambiguity, only note the candidates that contribute

to the ambiguity, rather than noting all viable candidates.

24 files changed, 140 insertions, 101 deletions

diff --git a/clang/include/clang/Sema/Overload.h b/clang/include/clang/Sema/Overload.h
index a97a7181f7d..728a596a92f 100644
--- a/clang/include/clang/Sema/Overload.h
+++ b/clang/include/clang/Sema/Overload.h
@@ -68,7 +68,10 @@ class Sema;
     OCD_AllCandidates,
 
     /// Requests that only viable candidates be shown.
-    OCD_ViableCandidates
+    OCD_ViableCandidates,
+
+    /// Requests that only tied-for-best candidates be shown.
+    OCD_AmbiguousCandidates
   };
 
   /// The parameter ordering that will be used for the candidate. This is
@@ -791,6 +794,15 @@ class Sema;
     /// Viable - True to indicate that this overload candidate is viable.
     bool Viable : 1;
 
+    /// Whether this candidate is the best viable function, or tied for being
+    /// the best viable function.
+    ///
+    /// For an ambiguous overload resolution, indicates whether this candidate
+    /// was part of the ambiguity kernel: the minimal non-empty set of viable
+    /// candidates such that all elements of the ambiguity kernel are better
+    /// than all viable candidates not in the ambiguity kernel.
+    bool Best : 1;
+
     /// IsSurrogate - True to indicate that this candidate is a
     /// surrogate for a conversion to a function pointer or reference
     /// (C++ [over.call.object]).
diff --git a/clang/lib/Sema/SemaCast.cpp b/clang/lib/Sema/SemaCast.cpp
index 0ebb5c68f7c..2ab0a11e532 100644
--- a/clang/lib/Sema/SemaCast.cpp
+++ b/clang/lib/Sema/SemaCast.cpp
@@ -423,7 +423,7 @@ static bool tryDiagnoseOverloadedCast(Sema &S, CastType CT,
 
   case OR_Ambiguous:
     msg = diag::err_ovl_ambiguous_conversion_in_cast;
-    howManyCandidates = OCD_ViableCandidates;
+    howManyCandidates = OCD_AmbiguousCandidates;
     break;
 
   case OR_Deleted:
diff --git a/clang/lib/Sema/SemaExprCXX.cpp b/clang/lib/Sema/SemaExprCXX.cpp
index 9aae9289b51..18efd8335d9 100644
--- a/clang/lib/Sema/SemaExprCXX.cpp
+++ b/clang/lib/Sema/SemaExprCXX.cpp
@@ -2323,7 +2323,7 @@ static bool resolveAllocationOverload(
           PartialDiagnosticAt(R.getNameLoc(),
                               S.PDiag(diag::err_ovl_ambiguous_call)
                                   << R.getLookupName() << Range),
-          S, OCD_ViableCandidates, Args);
+          S, OCD_AmbiguousCandidates, Args);
     }
     return true;
 
@@ -3513,7 +3513,7 @@ static bool resolveBuiltinNewDeleteOverload(Sema &S, CallExpr *TheCall,
         PartialDiagnosticAt(R.getNameLoc(),
                             S.PDiag(diag::err_ovl_ambiguous_call)
                                 << R.getLookupName() << Range),
-        S, OCD_ViableCandidates, Args);
+        S, OCD_AmbiguousCandidates, Args);
     return true;
 
   case OR_Deleted: {
diff --git a/clang/lib/Sema/SemaInit.cpp b/clang/lib/Sema/SemaInit.cpp
index 10cb7acad56..1296e767ff0 100644
--- a/clang/lib/Sema/SemaInit.cpp
+++ b/clang/lib/Sema/SemaInit.cpp
@@ -6154,7 +6154,7 @@ static ExprResult CopyObject(Sema &S,
                                      << (int)Entity.getKind()
                                      << CurInitExpr->getType()
                                      << CurInitExpr->getSourceRange()),
-        S, OCD_ViableCandidates, CurInitExpr);
+        S, OCD_AmbiguousCandidates, CurInitExpr);
     return ExprError();
 
   case OR_Deleted:
@@ -6295,7 +6295,7 @@ static void CheckCXX98CompatAccessibleCopy(Sema &S,
 
   case OR_Ambiguous:
     CandidateSet.NoteCandidates(PartialDiagnosticAt(Loc, Diag), S,
-                                OCD_ViableCandidates, CurInitExpr);
+                                OCD_AmbiguousCandidates, CurInitExpr);
     break;
 
   case OR_Deleted:
@@ -8806,7 +8806,7 @@ bool InitializationSequence::Diagnose(Sema &S,
                   : (S.PDiag(diag::err_ref_init_ambiguous)
                      << DestType << OnlyArg->getType()
                      << Args[0]->getSourceRange())),
-          S, OCD_ViableCandidates, Args);
+          S, OCD_AmbiguousCandidates, Args);
       break;
 
     case OR_No_Viable_Function: {
@@ -9000,7 +9000,7 @@ bool InitializationSequence::Diagnose(Sema &S,
             PartialDiagnosticAt(Kind.getLocation(),
                                 S.PDiag(diag::err_ovl_ambiguous_init)
                                     << DestType << ArgsRange),
-            S, OCD_ViableCandidates, Args);
+            S, OCD_AmbiguousCandidates, Args);
         break;
 
       case OR_No_Viable_Function:
@@ -9863,7 +9863,7 @@ QualType Sema::DeduceTemplateSpecializationFromInitializer(
             Kind.getLocation(),
             PDiag(diag::err_deduced_class_template_ctor_ambiguous)
                 << TemplateName),
-        *this, OCD_ViableCandidates, Inits);
+        *this, OCD_AmbiguousCandidates, Inits);
     return QualType();
 
   case OR_No_Viable_Function: {
diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp
index b79855a6afb..4417d22d133 100644
--- a/clang/lib/Sema/SemaOverload.cpp
+++ b/clang/lib/Sema/SemaOverload.cpp
@@ -1357,7 +1357,7 @@ TryUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
     ICS.Ambiguous.setToType(ToType);
     for (OverloadCandidateSet::iterator Cand = Conversions.begin();
          Cand != Conversions.end(); ++Cand)
-      if (Cand->Viable)
+      if (Cand->Best)
         ICS.Ambiguous.addConversion(Cand->FoundDecl, Cand->Function);
     break;
 
@@ -3578,7 +3578,10 @@ Sema::DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType) {
         (OvResult == OR_No_Viable_Function && !CandidateSet.empty())))
     return false;
 
-  auto Cands = CandidateSet.CompleteCandidates(*this, OCD_AllCandidates, From);
+  auto Cands = CandidateSet.CompleteCandidates(
+      *this,
+      OvResult == OR_Ambiguous ? OCD_AmbiguousCandidates : OCD_AllCandidates,
+      From);
   if (OvResult == OR_Ambiguous)
     Diag(From->getBeginLoc(), diag::err_typecheck_ambiguous_condition)
         << From->getType() << ToType << From->getSourceRange();
@@ -4602,7 +4605,7 @@ FindConversionForRefInit(Sema &S, ImplicitConversionSequence &ICS,
     ICS.setAmbiguous();
     for (OverloadCandidateSet::iterator Cand = CandidateSet.begin();
          Cand != CandidateSet.end(); ++Cand)
-      if (Cand->Viable)
+      if (Cand->Best)
         ICS.Ambiguous.addConversion(Cand->FoundDecl, Cand->Function);
     return true;
 
@@ -9653,11 +9656,13 @@ OverloadCandidateSet::BestViableFunction(Sema &S, SourceLocation Loc,
 
   // Find the best viable function.
   Best = end();
-  for (auto *Cand : Candidates)
+  for (auto *Cand : Candidates) {
+    Cand->Best = false;
     if (Cand->Viable)
       if (Best == end() ||
           isBetterOverloadCandidate(S, *Cand, *Best, Loc, Kind))
         Best = Cand;
+  }
 
   // If we didn't find any viable functions, abort.
   if (Best == end())
@@ -9665,22 +9670,33 @@ OverloadCandidateSet::BestViableFunction(Sema &S, SourceLocation Loc,
 
   llvm::SmallVector<const NamedDecl *, 4> EquivalentCands;
 
+  llvm::SmallVector<OverloadCandidate*, 4> PendingBest;
+  PendingBest.push_back(&*Best);
+  Best->Best = true;
+
   // Make sure that this function is better than every other viable
   // function. If not, we have an ambiguity.
-  for (auto *Cand : Candidates) {
-    if (Cand->Viable && Cand != Best &&
-        !isBetterOverloadCandidate(S, *Best, *Cand, Loc, Kind)) {
-      if (S.isEquivalentInternalLinkageDeclaration(Best->Function,
-                                                   Cand->Function)) {
-        EquivalentCands.push_back(Cand->Function);
-        continue;
+  while (!PendingBest.empty()) {
+    auto *Curr = PendingBest.pop_back_val();
+    for (auto *Cand : Candidates) {
+      if (Cand->Viable && !Cand->Best &&
+          !isBetterOverloadCandidate(S, *Curr, *Cand, Loc, Kind)) {
+        PendingBest.push_back(Cand);
+        Cand->Best = true;
+
+        if (S.isEquivalentInternalLinkageDeclaration(Cand->Function,
+                                                     Curr->Function))
+          EquivalentCands.push_back(Cand->Function);
+        else
+          Best = end();
       }
-
-      Best = end();
-      return OR_Ambiguous;
     }
   }
 
+  // If we found more than one best candidate, this is ambiguous.
+  if (Best == end())
+    return OR_Ambiguous;
+
   // Best is the best viable function.
   if (Best->Function && Best->Function->isDeleted())
     return OR_Deleted;
@@ -11080,15 +11096,30 @@ SmallVector<OverloadCandidate *, 32> OverloadCandidateSet::CompleteCandidates(
   for (iterator Cand = begin(), LastCand = end(); Cand != LastCand; ++Cand) {
     if (!Filter(*Cand))
       continue;
-    if (Cand->Viable)
-      Cands.push_back(Cand);
-    else if (OCD == OCD_AllCandidates) {
-      CompleteNonViableCandidate(S, Cand, Args, Kind);
-      if (Cand->Function || Cand->IsSurrogate)
-        Cands.push_back(Cand);
-      // Otherwise, this a non-viable builtin candidate.  We do not, in general,
-      // want to list every possible builtin candidate.
+    switch (OCD) {
+    case OCD_AllCandidates:
+      if (!Cand->Viable) {
+        if (!Cand->Function && !Cand->IsSurrogate) {
+          // This a non-viable builtin candidate.  We do not, in general,
+          // want to list every possible builtin candidate.
+          continue;
+        }
+        CompleteNonViableCandidate(S, Cand, Args, Kind);
+      }
+      break;
+
+    case OCD_ViableCandidates:
+      if (!Cand->Viable)
+        continue;
+      break;
+
+    case OCD_AmbiguousCandidates:
+      if (!Cand->Best)
+        continue;
+      break;
     }
+
+    Cands.push_back(Cand);
   }
 
   llvm::stable_sort(
@@ -12453,7 +12484,7 @@ static ExprResult FinishOverloadedCallExpr(Sema &SemaRef, Scope *S, Expr *Fn,
         PartialDiagnosticAt(Fn->getBeginLoc(),
                             SemaRef.PDiag(diag::err_ovl_ambiguous_call)
                                 << ULE->getName() << Fn->getSourceRange()),
-        SemaRef, OCD_ViableCandidates, Args);
+        SemaRef, OCD_AmbiguousCandidates, Args);
     break;
 
   case OR_Deleted: {
@@ -12699,7 +12730,7 @@ Sema::CreateOverloadedUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc,
                             PDiag(diag::err_ovl_ambiguous_oper_unary)
                                 << UnaryOperator::getOpcodeStr(Opc)
                                 << Input->getType() << Input->getSourceRange()),
-        *this, OCD_ViableCandidates, ArgsArray,
+        *this, OCD_AmbiguousCandidates, ArgsArray,
         UnaryOperator::getOpcodeStr(Opc), OpLoc);
     return ExprError();
 
@@ -13108,7 +13139,7 @@ ExprResult Sema::CreateOverloadedBinOp(SourceLocation OpLoc,
                                          << Args[1]->getType()
                                          << Args[0]->getSourceRange()
                                          << Args[1]->getSourceRange()),
-          *this, OCD_ViableCandidates, Args, BinaryOperator::getOpcodeStr(Opc),
+          *this, OCD_AmbiguousCandidates, Args, BinaryOperator::getOpcodeStr(Opc),
           OpLoc);
       return ExprError();
 
@@ -13293,7 +13324,7 @@ Sema::CreateOverloadedArraySubscriptExpr(SourceLocation LLoc,
                                         << Args[1]->getType()
                                         << Args[0]->getSourceRange()
                                         << Args[1]->getSourceRange()),
-          *this, OCD_ViableCandidates, Args, "[]", LLoc);
+          *this, OCD_AmbiguousCandidates, Args, "[]", LLoc);
       return ExprError();
 
     case OR_Deleted:
@@ -13485,7 +13516,7 @@ Sema::BuildCallToMemberFunction(Scope *S, Expr *MemExprE,
           PartialDiagnosticAt(UnresExpr->getMemberLoc(),
                               PDiag(diag::err_ovl_ambiguous_member_call)
                                   << DeclName << MemExprE->getSourceRange()),
-          *this, OCD_AllCandidates, Args);
+          *this, OCD_AmbiguousCandidates, Args);
       // FIXME: Leaking incoming expressions!
       return ExprError();
 
@@ -13717,7 +13748,7 @@ Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Obj,
                             PDiag(diag::err_ovl_ambiguous_object_call)
                                 << Object.get()->getType()
                                 << Object.get()->getSourceRange()),
-        *this, OCD_ViableCandidates, Args);
+        *this, OCD_AmbiguousCandidates, Args);
     break;
 
   case OR_Deleted:
@@ -13952,7 +13983,7 @@ Sema::BuildOverloadedArrowExpr(Scope *S, Expr *Base, SourceLocation OpLoc,
         PartialDiagnosticAt(OpLoc, PDiag(diag::err_ovl_ambiguous_oper_unary)
                                        << "->" << Base->getType()
                                        << Base->getSourceRange()),
-        *this, OCD_ViableCandidates, Base);
+        *this, OCD_AmbiguousCandidates, Base);
     return ExprError();
 
   case OR_Deleted:
@@ -14032,7 +14063,7 @@ ExprResult Sema::BuildLiteralOperatorCall(LookupResult &R,
     CandidateSet.NoteCandidates(
         PartialDiagnosticAt(R.getNameLoc(), PDiag(diag::err_ovl_ambiguous_call)
                                                 << R.getLookupName()),
-        *this, OCD_ViableCandidates, Args);
+        *this, OCD_AmbiguousCandidates, Args);
     return ExprError();
   }
 
diff --git a/clang/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p15.cpp b/clang/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p15.cpp
index 0c58da01be5..d64807ed5ab 100644
--- a/clang/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p15.cpp
+++ b/clang/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p15.cpp
@@ -8,7 +8,7 @@ struct B2 {
   B2(int); // expected-note {{candidate}}
 };
 
-struct D1 : B1, B2 { // expected-note 2{{candidate}}
+struct D1 : B1, B2 {
   using B1::B1; // expected-note {{inherited here}}
   using B2::B2; // expected-note {{inherited here}}
 };
@@ -35,11 +35,11 @@ namespace default_ctor {
     operator D&&();
   };
 
-  struct A { // expected-note 2{{candidate}}
+  struct A {
     A(); // expected-note {{candidate}}
 
-    A(C &&); // expected-note {{candidate}}
-    C &operator=(C&&); // expected-note {{candidate}}
+    A(C &&);
+    C &operator=(C&&);
 
     A(D &&);
     D &operator=(D&&); // expected-note {{candidate}}
@@ -47,11 +47,11 @@ namespace default_ctor {
     A(convert_to_D2); // expected-note {{candidate}}
   };
 
-  struct B { // expected-note 2{{candidate}}
+  struct B {
     B(); // expected-note {{candidate}}
 
-    B(C &&); // expected-note {{candidate}}
-    C &operator=(C&&); // expected-note {{candidate}}
+    B(C &&);
+    C &operator=(C&&);
 
     B(D &&);
     D &operator=(D&&); // expected-note {{candidate}}
@@ -66,14 +66,14 @@ namespace default_ctor {
     using B::operator=;
   };
   struct D : A, B {
-    using A::A; // expected-note 3{{inherited here}}
+    using A::A; // expected-note 2{{inherited here}}
     using A::operator=;
-    using B::B; // expected-note 3{{inherited here}}
+    using B::B; // expected-note 2{{inherited here}}
     using B::operator=;
 
     D(int);
-    D(const D&); // expected-note {{candidate}}
-    D &operator=(const D&); // expected-note {{candidate}}
+    D(const D&);
+    D &operator=(const D&);
   };
 
   C c;
diff --git a/clang/test/CXX/drs/dr15xx.cpp b/clang/test/CXX/drs/dr15xx.cpp
index bd714865eef..80a27e7863c 100644
--- a/clang/test/CXX/drs/dr15xx.cpp
+++ b/clang/test/CXX/drs/dr15xx.cpp
@@ -399,23 +399,20 @@ namespace dr1589 {   // dr1589: 3.7 c++11
   void g2() { f2({"foo","bar"}); }              // chooses #4
 
   namespace with_error {
-    void f0(long);                        // #0    expected-note {{candidate function}}
-    void f0(std::initializer_list<int>);  // #00   expected-note {{candidate function}}
-    void f0(std::initializer_list<int>, int = 0);  // Makes selection of #00 ambiguous \
-    // expected-note {{candidate function}}
-    void g0() { f0({1L}); }                 // chooses #00    expected-error{{call to 'f0' is ambiguous}}
-
-    void f1(int);                           // #1   expected-note {{candidate function}}
-    void f1(std::initializer_list<long>);   // #2   expected-note {{candidate function}}
-    void f1(std::initializer_list<long>, int = 0);   // Makes selection of #00 ambiguous \
-    // expected-note {{candidate function}}
-    void g1() { f1({42}); }                 // chooses #2   expected-error{{call to 'f1' is ambiguous}}
-
-    void f2(std::pair<const char*, const char*>); // #3   TODO: expected- note {{candidate function}}
-    void f2(std::initializer_list<std::string>);  // #4   expected-note {{candidate function}}
-    void f2(std::initializer_list<std::string>, int = 0);   // Makes selection of #00 ambiguous \
-    // expected-note {{candidate function}}
-    void g2() { f2({"foo","bar"}); }        // chooses #4   expected-error{{call to 'f2' is ambiguous}}
+    void f0(long);                        // #0
+    void f0(std::initializer_list<int>);  // #00     expected-note {{candidate function}}
+    void f0(std::initializer_list<int>, int = 0); // expected-note {{candidate function}}
+    void g0() { f0({1L}); }                 // expected-error{{call to 'f0' is ambiguous}}
+
+    void f1(int);                           // #1
+    void f1(std::initializer_list<long>);   // #2     expected-note {{candidate function}}
+    void f1(std::initializer_list<long>, int = 0); // expected-note {{candidate function}}
+    void g1() { f1({42}); }                 // expected-error{{call to 'f1' is ambiguous}}
+
+    void f2(std::pair<const char*, const char*>); // #3
+    void f2(std::initializer_list<std::string>);  // #4      expected-note {{candidate function}}
+    void f2(std::initializer_list<std::string>, int = 0); // expected-note {{candidate function}}
+    void g2() { f2({"foo","bar"}); }        // expected-error{{call to 'f2' is ambiguous}}
   }
 
 } // dr1589
diff --git a/clang/test/CXX/drs/dr16xx.cpp b/clang/test/CXX/drs/dr16xx.cpp
index 44d5b8f3f5b..3bbb1976364 100644
--- a/clang/test/CXX/drs/dr16xx.cpp
+++ b/clang/test/CXX/drs/dr16xx.cpp
@@ -111,13 +111,13 @@ namespace dr1638 { // dr1638: yes
 namespace dr1645 { // dr1645: 3.9
 #if __cplusplus >= 201103L
   struct A {
-    constexpr A(int, float = 0); // expected-note 2{{candidate}}
+    constexpr A(int, float = 0); // expected-note {{candidate}}
     explicit A(int, int = 0); // expected-note 2{{candidate}}
     A(int, int, int = 0) = delete; // expected-note {{candidate}}
   };
 
-  struct B : A { // expected-note 2{{candidate}}
-    using A::A; // expected-note 5{{inherited here}}
+  struct B : A {
+    using A::A; // expected-note 4{{inherited here}}
   };
 
   constexpr B a(0); // expected-error {{ambiguous}}
diff --git a/clang/test/CXX/over/over.match/over.match.funcs/over.match.class.deduct/p3.cpp b/clang/test/CXX/over/over.match/over.match.funcs/over.match.class.deduct/p3.cpp
index 4ed1d30b83d..2f895981b9b 100644
--- a/clang/test/CXX/over/over.match/over.match.funcs/over.match.class.deduct/p3.cpp
+++ b/clang/test/CXX/over/over.match/over.match.funcs/over.match.class.deduct/p3.cpp
@@ -2,7 +2,7 @@
 
 namespace std_example {
   template <class T> struct A {
-    explicit A(const T &, ...) noexcept; // expected-note {{explicit}} expected-note 2{{candidate}}
+    explicit A(const T &, ...) noexcept; // expected-note {{explicit}}
     A(T &&, ...); // expected-note 2{{candidate}}
   };
 
diff --git a/clang/test/CXX/special/class.inhctor/p1.cpp b/clang/test/CXX/special/class.inhctor/p1.cpp
index 842b725cb0b..389f365b742 100644
--- a/clang/test/CXX/special/class.inhctor/p1.cpp
+++ b/clang/test/CXX/special/class.inhctor/p1.cpp
@@ -3,19 +3,19 @@
 // Note: [class.inhctor] was removed by P0136R1. This tests the new behavior
 // for the wording that used to be there.
 
-struct A { // expected-note 4{{candidate constructor (the implicit}}
-  A(...); // expected-note 4{{candidate constructor}} expected-note 4{{candidate inherited constructor}}
+struct A {
+  A(...); // expected-note {{candidate constructor}} expected-note {{candidate inherited constructor}}
   A(int = 0, int = 0, int = 0, int = 0, ...); // expected-note 3{{candidate constructor}} expected-note 3{{candidate inherited constructor}}
   A(int = 0, int = 0, ...); // expected-note 3{{candidate constructor}} expected-note 3{{candidate inherited constructor}}
 
-  template<typename T> A(T, int = 0, ...); // expected-note 3{{candidate constructor}} expected-note 3{{candidate inherited constructor}}
+  template<typename T> A(T, int = 0, ...);
 
   template<typename T, int N> A(const T (&)[N]); // expected-note {{candidate constructor}} expected-note {{candidate inherited constructor}}
   template<typename T, int N> A(const T (&)[N], int = 0); // expected-note {{candidate constructor}} expected-note {{candidate inherited constructor}}
 };
 
-struct B : A { // expected-note 4{{candidate constructor (the implicit}}
-  using A::A; // expected-note 15{{inherited here}}
+struct B : A {
+  using A::A; // expected-note 9{{inherited here}}
   B(void*);
 };
 
diff --git a/clang/test/CXX/special/class.inhctor/p4.cpp b/clang/test/CXX/special/class.inhctor/p4.cpp
index 69fbea3e0eb..a5d2cd74b50 100644
--- a/clang/test/CXX/special/class.inhctor/p4.cpp
+++ b/clang/test/CXX/special/class.inhctor/p4.cpp
@@ -60,13 +60,13 @@ H h2("foo"); // expected-error {{call to deleted constructor of 'H'}}
 // same signature.
 namespace DRnnnn {
   struct A {
-    constexpr A(int, float = 0) {} // expected-note {{candidate}}
+    constexpr A(int, float = 0) {}
     explicit A(int, int = 0) {} // expected-note {{candidate}}
 
     A(int, int, int = 0) = delete; // expected-note {{deleted}}
   };
   struct B : A {
-    using A::A; // expected-note 3{{inherited here}}
+    using A::A; // expected-note 2{{inherited here}}
   };
 
   constexpr B b0(0, 0.0f); // ok, constexpr
diff --git a/clang/test/CXX/special/class.inhctor/p7.cpp b/clang/test/CXX/special/class.inhctor/p7.cpp
index 2d7acdcc2ce..4bbc2fc098a 100644
--- a/clang/test/CXX/special/class.inhctor/p7.cpp
+++ b/clang/test/CXX/special/class.inhctor/p7.cpp
@@ -9,7 +9,7 @@ struct B1 {
 struct B2 {
   B2(int); // expected-note {{candidate}}
 };
-struct D1 : B1, B2 { // expected-note 2{{candidate}}
+struct D1 : B1, B2 {
   using B1::B1; // expected-note {{inherited here}}
   using B2::B2; // expected-note {{inherited here}}
 };
diff --git a/clang/test/SemaCXX/ambig-user-defined-conversions.cpp b/clang/test/SemaCXX/ambig-user-defined-conversions.cpp
index 276c1b07b5d..8d8fa4fef6d 100644
--- a/clang/test/SemaCXX/ambig-user-defined-conversions.cpp
+++ b/clang/test/SemaCXX/ambig-user-defined-conversions.cpp
@@ -13,7 +13,7 @@ namespace test0 {
   extern B f(); 
   B b1;
 
-  void func(const int ci, const char cc); // expected-note {{candidate function}}
+  void func(const int ci, const char cc);
   void func(const char ci, const B b); // expected-note {{candidate function}}
   void func(const B b, const int ci); // expected-note {{candidate function}}
 
diff --git a/clang/test/SemaCXX/builtin-ptrtomember-ambig.cpp b/clang/test/SemaCXX/builtin-ptrtomember-ambig.cpp
index 61e347879a7..4330c0cc48a 100644
--- a/clang/test/SemaCXX/builtin-ptrtomember-ambig.cpp
+++ b/clang/test/SemaCXX/builtin-ptrtomember-ambig.cpp
@@ -17,11 +17,8 @@ struct C : B {
 
 
 void foo(C c, int A::* pmf) {
-       				// FIXME. Why so many built-in candidates?
 	int i = c->*pmf; 	// expected-error {{use of overloaded operator '->*' is ambiguous}} \
-				// expected-note {{built-in candidate operator->*(const struct A *, const int struct A::*)}} \
 				// expected-note {{built-in candidate operator->*(const struct A *, int struct A::*)}} \
-				// expected-note {{built-in candidate operator->*(struct A *, const int struct A::*)}} \
 				// expected-note {{built-in candidate operator->*(struct A *, int struct A::*)}}
 }
 
diff --git a/clang/test/SemaCXX/builtin-ptrtomember-overload-1.cpp b/clang/test/SemaCXX/builtin-ptrtomember-overload-1.cpp
index 2d93c6b2dff..a717c283ab7 100644
--- a/clang/test/SemaCXX/builtin-ptrtomember-overload-1.cpp
+++ b/clang/test/SemaCXX/builtin-ptrtomember-overload-1.cpp
@@ -42,5 +42,5 @@ void foo1(C1 c1, int A::* pmf) {
 void foo1(C1 c1, int E::* pmf) {
         int i = c1->*pmf;	// expected-error {{use of overloaded operator '->*' is ambiguous}} \
                                 // expected-note {{because of ambiguity in conversion of 'C1' to 'E *'}} \
-                                // expected-note 4 {{built-in candidate operator}}
+                                // expected-note 2 {{built-in candidate operator}}
 }
diff --git a/clang/test/SemaCXX/copy-initialization.cpp b/clang/test/SemaCXX/copy-initialization.cpp
index cd7e5f07e14..8866fe70db8 100644
--- a/clang/test/SemaCXX/copy-initialization.cpp
+++ b/clang/test/SemaCXX/copy-initialization.cpp
@@ -4,7 +4,7 @@
 
 class X {
 public:
-  explicit X(const X&); // expected-note {{candidate constructor}}
+  explicit X(const X&);
   X(int*); // expected-note 3{{candidate constructor}}
   explicit X(float*); // expected-note {{candidate constructor}}
 };
diff --git a/clang/test/SemaCXX/cxx0x-initializer-constructor.cpp b/clang/test/SemaCXX/cxx0x-initializer-constructor.cpp
index 870bbe5ce36..513c670d392 100644
--- a/clang/test/SemaCXX/cxx0x-initializer-constructor.cpp
+++ b/clang/test/SemaCXX/cxx0x-initializer-constructor.cpp
@@ -266,7 +266,7 @@ namespace PR12120 {
   struct A { explicit A(int); A(float); }; // expected-note {{declared here}}
   A a = { 0 }; // expected-error {{constructor is explicit}}
 
-  struct B { explicit B(short); B(long); }; // expected-note 4{{candidate}}
+  struct B { explicit B(short); B(long); }; // expected-note 2{{candidate}}
   B b = { 0 }; // expected-error {{ambiguous}}
 
   struct C { explicit C(short); C(long); }; // expected-note 2{{candidate}}
diff --git a/clang/test/SemaCXX/microsoft-vs-float128.cpp b/clang/test/SemaCXX/microsoft-vs-float128.cpp
index d271e470032..77d24988129 100644
--- a/clang/test/SemaCXX/microsoft-vs-float128.cpp
+++ b/clang/test/SemaCXX/microsoft-vs-float128.cpp
@@ -11,7 +11,7 @@ template <typename T> struct is_same<T, T> { static constexpr bool value = true;
 
 
 struct S {
-  // The only numeric types S can be converted to is __int128 and __float128.
+  // The only numeric types S can be converted to are [unsigned] __int128 and __float128.
   template <typename T, typename = typename enable_if<
                             !((__is_integral(T) && sizeof(T) != 16) ||
                               is_same<T, float>::value ||
@@ -29,6 +29,8 @@ void f() {
   double d = S() + 1.0;
 #ifndef MS
   // expected-error@-2{{use of overloaded operator '+' is ambiguous}}
-  // expected-note@-3 36{{built-in candidate operator+}}
+  // expected-note@-3 {{built-in candidate operator+(__float128, double)}}
+  // expected-note@-4 {{built-in candidate operator+(__int128, double)}}
+  // expected-note@-5 {{built-in candidate operator+(unsigned __int128, double)}}
 #endif
 }
diff --git a/clang/test/SemaCXX/overload-call.cpp b/clang/test/SemaCXX/overload-call.cpp
index befa927f067..a34bce5014a 100644
--- a/clang/test/SemaCXX/overload-call.cpp
+++ b/clang/test/SemaCXX/overload-call.cpp
@@ -12,9 +12,9 @@ void test_f(int iv, float fv) {
 }
 
 int* g(int, float, int); // expected-note {{candidate function}}
-float* g(int, int, int); // expected-note {{candidate function}}
+float* g(int, int, int);
 double* g(int, float, float); // expected-note {{candidate function}}
-char* g(int, float, ...); // expected-note {{candidate function}}
+char* g(int, float, ...);
 void g();
 
 void test_g(int iv, float fv) {
diff --git a/clang/test/SemaCXX/overload-member-call.cpp b/clang/test/SemaCXX/overload-member-call.cpp
index 2d017a499ad..41f3946de0b 100644
--- a/clang/test/SemaCXX/overload-member-call.cpp
+++ b/clang/test/SemaCXX/overload-member-call.cpp
@@ -14,7 +14,7 @@ struct X {
 
   int& g(int) const; // expected-note 2 {{candidate function}}
   float& g(int); // expected-note 2 {{candidate function}}
-  static double& g(double); // expected-note 2 {{candidate function}}
+  static double& g(double);
 
   void h(int);
 
diff --git a/clang/test/SemaCXX/overloaded-builtin-operators.cpp b/clang/test/SemaCXX/overloaded-builtin-operators.cpp
index 4fa376aed03..d237dfe6c09 100644
--- a/clang/test/SemaCXX/overloaded-builtin-operators.cpp
+++ b/clang/test/SemaCXX/overloaded-builtin-operators.cpp
@@ -194,10 +194,9 @@ struct A {
 };
 
 void test_dr425(A a) {
-  // FIXME: lots of candidates here!
   (void)(1.0f * a); // expected-error{{ambiguous}} \
                     // expected-note 4{{candidate}} \
-                    // expected-note {{remaining 140 candidates omitted; pass -fshow-overloads=all to show them}}
+                    // expected-note {{remaining 8 candidates omitted; pass -fshow-overloads=all to show them}}
 }
 
 // pr5432
@@ -237,9 +236,10 @@ namespace PR8477 {
     (void)(foo - zero);
     (void)(zero + foo);
     (void)(zero[foo]);
+    // FIXME: It would be nice to report fewer candidates here.
     (void)(foo - foo); // expected-error{{use of overloaded operator '-' is ambiguous}} \
     // expected-note 4{{built-in candidate operator-}} \
-    // expected-note{{candidates omitted}}
+    // expected-note{{142 candidates omitted}}
     return foo[zero] == zero;
   }
 }
diff --git a/clang/test/SemaTemplate/cxx1z-using-declaration.cpp b/clang/test/SemaTemplate/cxx1z-using-declaration.cpp
index 87ca748f8fd..ba5918ce098 100644
--- a/clang/test/SemaTemplate/cxx1z-using-declaration.cpp
+++ b/clang/test/SemaTemplate/cxx1z-using-declaration.cpp
@@ -16,7 +16,7 @@ void test_Unexpanded() {
 }
 
 // Test using non-type members from pack of base classes.
-template<typename ...T> struct A : T... { // expected-note 2{{candidate}}
+template<typename ...T> struct A : T... {
   using T::T ...; // expected-note 2{{inherited here}}
   using T::operator() ...;
   using T::operator T* ...;
@@ -41,7 +41,7 @@ namespace test_A {
     Y(int, int);
     void operator()(int, int);
     operator Y *();
-    void h(int, int); // expected-note {{not viable}}
+    void h(int, int);
   };
   struct Z {
     Z();
@@ -177,14 +177,14 @@ namespace test_lambda1 {
   };
   struct B {
     template<typename> struct X {
-      void f(int, int); // expected-note {{declared here}} expected-note {{not viable}}
+      void f(int, int); // expected-note {{declared here}}
       using type = int;
     };
   };
   struct C {
     template<typename> struct X {
       void f(int); // expected-note {{candidate}}
-      void f(int, int); // expected-note {{not viable}}
+      void f(int, int);
       using type = int;
     };
   };
diff --git a/clang/test/SemaTemplate/instantiate-expr-3.cpp b/clang/test/SemaTemplate/instantiate-expr-3.cpp
index 90c322cbf37..142e4ebcedc 100644
--- a/clang/test/SemaTemplate/instantiate-expr-3.cpp
+++ b/clang/test/SemaTemplate/instantiate-expr-3.cpp
@@ -23,7 +23,7 @@ namespace N1 {
 }
 
 namespace N2 {
-  long& operator+=(N1::X&, long); // expected-note{{candidate}}
+  long& operator+=(N1::X&, long);
 
   template<typename T, typename U, typename Result>
   struct PlusEquals0 {
diff --git a/clang/test/SemaTemplate/temp_arg_nontype.cpp b/clang/test/SemaTemplate/temp_arg_nontype.cpp
index 330a954e0dd..08ed7d5004a 100644
--- a/clang/test/SemaTemplate/temp_arg_nontype.cpp
+++ b/clang/test/SemaTemplate/temp_arg_nontype.cpp
@@ -445,10 +445,10 @@ namespace nondependent_default_arg_ordering {
   template<typename A> void f(X<A>); // expected-note {{candidate}}
   template<typename A> void f(X<A, &m>); // expected-note {{candidate}}
   template<typename A, A B> void f(X<A, B>); // expected-note 2{{candidate}}
-  template<template<typename U, U> class T, typename A, int *B> void f(T<A, B>); // expected-note 2{{candidate}}
+  template<template<typename U, U> class T, typename A, int *B> void f(T<A, B>);
   void g() {
     // FIXME: The first and second function templates above should be
-    // considered more specialized than the last two, but during partial
+    // considered more specialized than the third, but during partial
     // ordering we fail to check that we actually deduced template arguments
     // that make the deduced A identical to A.
     X<int *, &n> x; f(x); // expected-error {{ambiguous}}