[Fix] Don't emit multiple diagnostics for the same error

[george.burgess.iv]

Summary

Given code like the following (stolen from tests):

template <typename T1, typename T2> int f(T1 *, const T2 *);
template <typename T1, typename T2> int f(const T1 *, T2 *);
int (*p)(const int *, const int *) = f;

Clang will currently emit two "address of overloaded function f is ambiguous" errors for the same assignment (on line 3).

This patch makes us only emit one.

[george.burgess.iv]

Un-nested an if statement.

[rsmith]

LGTM, thanks!

cfe/trunk/lib/Sema/SemaOverload.cpp

class AddressOfFunctionResolver {
    
   bool Complain;
   //DeclAccessPair& ResultFunctionAccessPair;
   ASTContext& Context;
 
   bool TargetTypeIsNonStaticMemberFunction;
   bool FoundNonTemplateFunction;
   bool StaticMemberFunctionFromBoundPointer;
+  bool HasComplained;
 
   OverloadExpr::FindResult OvlExprInfo; 
   OverloadExpr *OvlExpr;
   TemplateArgumentListInfo OvlExplicitTemplateArgs;
   SmallVector<std::pair<DeclAccessPair, FunctionDecl*>, 4> Matches;
   TemplateSpecCandidateSet FailedCandidates;
 
 public:
   AddressOfFunctionResolver(Sema &S, Expr *SourceExpr,
                             const QualType &TargetType, bool Complain)
       : S(S), SourceExpr(SourceExpr), TargetType(TargetType),
         Complain(Complain), Context(S.getASTContext()),
         TargetTypeIsNonStaticMemberFunction(
             !!TargetType->getAs<MemberPointerType>()),
         FoundNonTemplateFunction(false),
         StaticMemberFunctionFromBoundPointer(false),
+        HasComplained(false),
         OvlExprInfo(OverloadExpr::find(SourceExpr)),
         OvlExpr(OvlExprInfo.Expression),
         FailedCandidates(OvlExpr->getNameLoc()) {
     ExtractUnqualifiedFunctionTypeFromTargetType();
 
     if (TargetFunctionType->isFunctionType()) {
       if (UnresolvedMemberExpr *UME = dyn_cast<UnresolvedMemberExpr>(OvlExpr))
         if (!UME->isImplicitAccess() &&
if (FindAllFunctionsThatMatchTargetTypeExactly()) {
           EliminateAllExceptMostSpecializedTemplate();
       }
     }
 
     if (S.getLangOpts().CUDA && S.getLangOpts().CUDATargetOverloads &&
         Matches.size() > 1)
       EliminateSuboptimalCudaMatches();
   }
-  
+  bool hasComplained() const { return HasComplained; }
+
 private:
   bool isTargetTypeAFunction() const {
     return TargetFunctionType->isFunctionType();
   }
 
   // [ToType]     [Return]
 
   // R (*)(A) --> R (A), IsNonStaticMemberFunction = false
if (FunctionDecl *FunDecl = dyn_cast<FunctionDecl>(Fn)) {
         if (FunctionDecl *Caller = dyn_cast<FunctionDecl>(S.CurContext))
           if (!Caller->isImplicit() && S.CheckCUDATarget(Caller, FunDecl))
             return false;
 
       // If any candidate has a placeholder return type, trigger its deduction
       // now.
       if (S.getLangOpts().CPlusPlus14 &&
           FunDecl->getReturnType()->isUndeducedType() &&
-          S.DeduceReturnType(FunDecl, SourceExpr->getLocStart(), Complain))
+          S.DeduceReturnType(FunDecl, SourceExpr->getLocStart(), Complain)) {
+        HasComplained |= Complain;
         return false;
+      }
 
       QualType ResultTy;
       if (Context.hasSameUnqualifiedType(TargetFunctionType, 
                                          FunDecl->getType()) ||
           S.IsNoReturnConversion(FunDecl->getType(), TargetFunctionType,
                                  ResultTy)) {
         Matches.push_back(std::make_pair(CurAccessFunPair,
           cast<FunctionDecl>(FunDecl->getCanonicalDecl())));
UnresolvedSetIterator Result = S.getMostSpecialized(
         S.PDiag(diag::note_ovl_candidate) << (unsigned)oc_function_template,
         Complain, TargetFunctionType);
 
     if (Result != MatchesCopy.end()) {
       // Make it the first and only element
       Matches[0].first = Matches[Result - MatchesCopy.begin()].first;
       Matches[0].second = cast<FunctionDecl>(*Result);
       Matches.resize(1);
-    }
+    } else
+      HasComplained |= Complain;
   }
 
   void EliminateAllTemplateMatches() {
     //   [...] any function template specializations in the set are
     //   eliminated if the set also contains a non-template function, [...]
     for (unsigned I = 0, N = Matches.size(); I != N; ) {
       if (Matches[I].second->getPrimaryTemplate() == nullptr)
         ++I;
Sema::ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr,
                                          DeclAccessPair &FoundResult,
                                          bool *pHadMultipleCandidates) {
   assert(AddressOfExpr->getType() == Context.OverloadTy);
 
   AddressOfFunctionResolver Resolver(*this, AddressOfExpr, TargetType,
                                      Complain);
   int NumMatches = Resolver.getNumMatches();
   FunctionDecl *Fn = nullptr;
-  if (NumMatches == 0 && Complain) {
+  bool ShouldComplain = Complain && !Resolver.hasComplained();
+  if (NumMatches == 0 && ShouldComplain) {
     if (Resolver.IsInvalidFormOfPointerToMemberFunction())
       Resolver.ComplainIsInvalidFormOfPointerToMemberFunction();
     else
       Resolver.ComplainNoMatchesFound();
   }
-  else if (NumMatches > 1 && Complain)
+  else if (NumMatches > 1 && ShouldComplain)
     Resolver.ComplainMultipleMatchesFound();
   else if (NumMatches == 1) {
     Fn = Resolver.getMatchingFunctionDecl();
     assert(Fn);
     FoundResult = *Resolver.getMatchingFunctionAccessPair();
     if (Complain) {
       if (Resolver.IsStaticMemberFunctionFromBoundPointer())
         Resolver.ComplainIsStaticMemberFunctionFromBoundPointer();

cfe/trunk/test/SemaCXX/addr-of-overloaded-function.cpp

void g() {
       f(&g);
     }
     void f(bool (*)(int, char));
     static bool g(int, char);
   };
 }
 
 namespace PR8033 {
-  template <typename T1, typename T2> int f(T1 *, const T2 *); // expected-note {{candidate function [with T1 = const int, T2 = int]}} \
-  // expected-note{{candidate function}}
-  template <typename T1, typename T2> int f(const T1 *, T2 *); // expected-note {{candidate function [with T1 = int, T2 = const int]}} \
-  // expected-note{{candidate function}}
-  int (*p)(const int *, const int *) = f; // expected-error{{address of overloaded function 'f' is ambiguous}} \
-  // expected-error{{address of overloaded function 'f' is ambiguous}}
-
+  template <typename T1, typename T2> int f(T1 *, const T2 *); // expected-note {{candidate function [with T1 = const int, T2 = int]}}
+  template <typename T1, typename T2> int f(const T1 *, T2 *); // expected-note {{candidate function [with T1 = int, T2 = const int]}}
+  int (*p)(const int *, const int *) = f; // expected-error{{address of overloaded function 'f' is ambiguous}}
 }
 
 namespace PR8196 {
   template <typename T> struct mcdata {
     typedef int result_type;
   };
   template <class T> 
     typename mcdata<T>::result_type wrap_mean(mcdata<T> const&);