Don't produce duplicate notes if we have deduction failure notes when resolving

the address of an overloaded function template.

llvm-svn: 188334

5 files changed, 22 insertions, 15 deletions

diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp
index c77abe8155b..06d1f0b0e2d 100644
--- a/clang/lib/Sema/SemaOverload.cpp
+++ b/clang/lib/Sema/SemaOverload.cpp
@@ -9390,7 +9390,6 @@ private:
       FailedCandidates.addCandidate()
           .set(FunctionTemplate->getTemplatedDecl(),
                MakeDeductionFailureInfo(Context, Result, Info));
-      (void)Result;
       return false;
     } 
     
@@ -9531,10 +9530,22 @@ public:
     S.Diag(OvlExpr->getLocStart(), diag::err_addr_ovl_no_viable)
         << OvlExpr->getName() << TargetFunctionType
         << OvlExpr->getSourceRange();
-    FailedCandidates.NoteCandidates(S, OvlExpr->getLocStart());
-    S.NoteAllOverloadCandidates(OvlExpr, TargetFunctionType);
-  } 
-  
+    if (FailedCandidates.empty())
+      S.NoteAllOverloadCandidates(OvlExpr, TargetFunctionType);
+    else {
+      // We have some deduction failure messages. Use them to diagnose
+      // the function templates, and diagnose the non-template candidates
+      // normally.
+      for (UnresolvedSetIterator I = OvlExpr->decls_begin(),
+                                 IEnd = OvlExpr->decls_end();
+           I != IEnd; ++I)
+        if (FunctionDecl *Fun =
+                dyn_cast<FunctionDecl>((*I)->getUnderlyingDecl()))
+          S.NoteOverloadCandidate(Fun, TargetFunctionType);
+      FailedCandidates.NoteCandidates(S, OvlExpr->getLocStart());
+    }
+  }
+
   bool IsInvalidFormOfPointerToMemberFunction() const {
     return TargetTypeIsNonStaticMemberFunction &&
       !OvlExprInfo.HasFormOfMemberPointer;
@@ -9695,7 +9706,6 @@ Sema::ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl,
       FailedCandidates.addCandidate()
           .set(FunctionTemplate->getTemplatedDecl(),
                MakeDeductionFailureInfo(Context, Result, Info));
-      (void)Result;
       continue;
     }
 
diff --git a/clang/test/CXX/over/over.over/p2.cpp b/clang/test/CXX/over/over.over/p2.cpp
index b6c1d6bfa25..d03b84a2d15 100644
--- a/clang/test/CXX/over/over.over/p2.cpp
+++ b/clang/test/CXX/over/over.over/p2.cpp
@@ -1,7 +1,7 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 template <typename T>
-T f0(T, T); // expected-note{{candidate}} expected-note{{candidate function}}
+T f0(T, T); // expected-note{{deduced conflicting types for parameter 'T' ('int' vs. 'float')}}
 
 void test_f0() {
   int (*f0a)(int, int) = f0;
diff --git a/clang/test/SemaCXX/addr-of-overloaded-function-casting.cpp b/clang/test/SemaCXX/addr-of-overloaded-function-casting.cpp
index 8698736b3ae..784c8a00074 100644
--- a/clang/test/SemaCXX/addr-of-overloaded-function-casting.cpp
+++ b/clang/test/SemaCXX/addr-of-overloaded-function-casting.cpp
@@ -5,10 +5,10 @@ void f(); // expected-note 9{{candidate function}}
 void f(int); // expected-note 9{{candidate function}}
 
 template <class T>
-void t(T); // expected-note 6{{candidate function}} \
+void t(T); // expected-note 3{{candidate function}} \
            // expected-note 3{{candidate template ignored: could not match 'void' against 'int'}}
 template <class T>
-void t(T *); // expected-note 6{{candidate function}} \
+void t(T *); // expected-note 3{{candidate function}} \
              // expected-note 3{{candidate template ignored: could not match 'void' against 'int'}}
 
 template<class T> void u(T);
diff --git a/clang/test/SemaCXX/cxx1y-deduced-return-type.cpp b/clang/test/SemaCXX/cxx1y-deduced-return-type.cpp
index 743ef4fbf2b..b8cb5f86320 100644
--- a/clang/test/SemaCXX/cxx1y-deduced-return-type.cpp
+++ b/clang/test/SemaCXX/cxx1y-deduced-return-type.cpp
@@ -159,8 +159,7 @@ namespace Templates {
   double &mem_check4 = take_fn<double>(Outer<double>::arg_multi);
 
   namespace Deduce1 {
-  template <typename T> auto f() { return 0; } // expected-note {{candidate}} \
-                                               // expected-note {{candidate function has different return type ('int' expected but has 'auto')}}
+  template <typename T> auto f() { return 0; } // expected-note {{couldn't infer template argument 'T'}}
     template<typename T> void g(T(*)()); // expected-note 2{{candidate}}
     void h() {
       auto p = f<int>;
@@ -173,8 +172,7 @@ namespace Templates {
   }
 
   namespace Deduce2 {
-  template <typename T> auto f(int) { return 0; } // expected-note {{candidate}} \
-    // expected-note {{candidate function has different return type ('int' expected but has 'auto')}}
+  template <typename T> auto f(int) { return 0; } // expected-note {{couldn't infer template argument 'T'}}
     template<typename T> void g(T(*)(int)); // expected-note 2{{candidate}}
     void h() {
       auto p = f<int>;
diff --git a/clang/test/SemaObjCXX/arc-nsconsumed-errors.mm b/clang/test/SemaObjCXX/arc-nsconsumed-errors.mm
index c1ce81b6693..c78d8a5f4ad 100644
--- a/clang/test/SemaObjCXX/arc-nsconsumed-errors.mm
+++ b/clang/test/SemaObjCXX/arc-nsconsumed-errors.mm
@@ -29,8 +29,7 @@ void releaser(__attribute__((ns_consumed)) id);
 releaser_t r2 = releaser; // no-warning
 
 template <typename T>
-void templateFunction(T) { } // expected-note {{candidate function}} \
-                             // expected-note {{candidate template ignored: could not match 'void (__strong id)' against 'void (id)'}} \
+void templateFunction(T) { } // expected-note {{candidate template ignored: could not match 'void (__strong id)' against 'void (id)'}} \
                              // expected-note {{candidate template ignored: failed template argument deduction}}
 releaser_t r3 = templateFunction<id>; // expected-error {{address of overloaded function 'templateFunction' does not match required type 'void (id)'}}