From: Abramo Bagnara Date: Sat, 19 Nov 2011 11:44:21 +0000 (+0000) Subject: Fixed HadMultipleCandidates loading. X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=22c107b2b99887b5aec6d1fd38210031e944e31f;p=clang Fixed HadMultipleCandidates loading. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@144995 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/clang/Sema/Initialization.h b/include/clang/Sema/Initialization.h index 13eae181e4..91d7677387 100644 --- a/include/clang/Sema/Initialization.h +++ b/include/clang/Sema/Initialization.h @@ -766,8 +766,9 @@ public: /// \param Function the function to which the overloaded function reference /// resolves. void AddAddressOverloadResolutionStep(FunctionDecl *Function, - DeclAccessPair Found); - + DeclAccessPair Found, + bool HadMultipleCandidates); + /// \brief Add a new step in the initialization that performs a derived-to- /// base cast. /// @@ -804,8 +805,9 @@ public: /// a constructor or a conversion function. void AddUserConversionStep(FunctionDecl *Function, DeclAccessPair FoundDecl, - QualType T); - + QualType T, + bool HadMultipleCandidates); + /// \brief Add a new step that performs a qualification conversion to the /// given type. void AddQualificationConversionStep(QualType Ty, @@ -821,7 +823,8 @@ public: /// \brief Add a constructor-initialization step. void AddConstructorInitializationStep(CXXConstructorDecl *Constructor, AccessSpecifier Access, - QualType T); + QualType T, + bool HadMultipleCandidates); /// \brief Add a zero-initialization step. void AddZeroInitializationStep(QualType T); diff --git a/include/clang/Sema/Sema.h b/include/clang/Sema/Sema.h index f1d5c2d239..d424ef49db 100644 --- a/include/clang/Sema/Sema.h +++ b/include/clang/Sema/Sema.h @@ -1556,10 +1556,12 @@ public: // R (S::*)(A) --> R (A) QualType ExtractUnqualifiedFunctionType(QualType PossiblyAFunctionType); - FunctionDecl *ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr, - QualType TargetType, - bool Complain, - DeclAccessPair &Found); + FunctionDecl * + ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr, + QualType TargetType, + bool Complain, + DeclAccessPair &Found, + bool *pHadMultipleCandidates = 0); FunctionDecl *ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl, bool Complain = false, diff --git a/lib/Sema/SemaInit.cpp b/lib/Sema/SemaInit.cpp index 1a8231876b..85cb76f8a0 100644 --- a/lib/Sema/SemaInit.cpp +++ b/lib/Sema/SemaInit.cpp @@ -2603,13 +2603,15 @@ bool InitializationSequence::endsWithNarrowing(ASTContext &Ctx, } } -void InitializationSequence::AddAddressOverloadResolutionStep( - FunctionDecl *Function, - DeclAccessPair Found) { +void +InitializationSequence +::AddAddressOverloadResolutionStep(FunctionDecl *Function, + DeclAccessPair Found, + bool HadMultipleCandidates) { Step S; S.Kind = SK_ResolveAddressOfOverloadedFunction; S.Type = Function->getType(); - S.Function.HadMultipleCandidates = false; + S.Function.HadMultipleCandidates = HadMultipleCandidates; S.Function.Function = Function; S.Function.FoundDecl = Found; Steps.push_back(S); @@ -2643,13 +2645,15 @@ void InitializationSequence::AddExtraneousCopyToTemporary(QualType T) { Steps.push_back(S); } -void InitializationSequence::AddUserConversionStep(FunctionDecl *Function, - DeclAccessPair FoundDecl, - QualType T) { +void +InitializationSequence::AddUserConversionStep(FunctionDecl *Function, + DeclAccessPair FoundDecl, + QualType T, + bool HadMultipleCandidates) { Step S; S.Kind = SK_UserConversion; S.Type = T; - S.Function.HadMultipleCandidates = false; + S.Function.HadMultipleCandidates = HadMultipleCandidates; S.Function.Function = Function; S.Function.FoundDecl = FoundDecl; Steps.push_back(S); @@ -2692,14 +2696,15 @@ void InitializationSequence::AddListInitializationStep(QualType T) { } void -InitializationSequence::AddConstructorInitializationStep( - CXXConstructorDecl *Constructor, - AccessSpecifier Access, - QualType T) { +InitializationSequence +::AddConstructorInitializationStep(CXXConstructorDecl *Constructor, + AccessSpecifier Access, + QualType T, + bool HadMultipleCandidates) { Step S; S.Kind = SK_ConstructorInitialization; S.Type = T; - S.Function.HadMultipleCandidates = false; + S.Function.HadMultipleCandidates = HadMultipleCandidates; S.Function.Function = Constructor; S.Function.FoundDecl = DeclAccessPair::make(Constructor, Access); Steps.push_back(S); @@ -2971,8 +2976,10 @@ static OverloadingResult TryRefInitWithConversionFunction(Sema &S, T2 = cv1T1; // Add the user-defined conversion step. + bool HadMultipleCandidates = (CandidateSet.size() > 1); Sequence.AddUserConversionStep(Function, Best->FoundDecl, - T2.getNonLValueExprType(S.Context)); + T2.getNonLValueExprType(S.Context), + HadMultipleCandidates); // Determine whether we need to perform derived-to-base or // cv-qualification adjustments. @@ -3041,11 +3048,12 @@ static void TryReferenceInitialization(Sema &S, // type of the resulting function. if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) { DeclAccessPair Found; - if (FunctionDecl *Fn = S.ResolveAddressOfOverloadedFunction(Initializer, - T1, - false, - Found)) { - Sequence.AddAddressOverloadResolutionStep(Fn, Found); + bool HadMultipleCandidates = false; + if (FunctionDecl *Fn + = S.ResolveAddressOfOverloadedFunction(Initializer, T1, false, Found, + &HadMultipleCandidates)) { + Sequence.AddAddressOverloadResolutionStep(Fn, Found, + HadMultipleCandidates); cv2T2 = Fn->getType(); T2 = cv2T2.getUnqualifiedType(); } else if (!T1->isRecordType()) { @@ -3388,10 +3396,11 @@ static void TryConstructorInitialization(Sema &S, // Add the constructor initialization step. Any cv-qualification conversion is // subsumed by the initialization. - Sequence.AddConstructorInitializationStep( - cast(Best->Function), - Best->FoundDecl.getAccess(), - DestType); + bool HadMultipleCandidates = (CandidateSet.size() > 1); + CXXConstructorDecl *CtorDecl = cast(Best->Function); + Sequence.AddConstructorInitializationStep(CtorDecl, + Best->FoundDecl.getAccess(), + DestType, HadMultipleCandidates); } /// \brief Attempt value initialization (C++ [dcl.init]p7). @@ -3589,11 +3598,13 @@ static void TryUserDefinedConversion(Sema &S, FunctionDecl *Function = Best->Function; S.MarkDeclarationReferenced(DeclLoc, Function); + bool HadMultipleCandidates = (CandidateSet.size() > 1); if (isa(Function)) { // Add the user-defined conversion step. Any cv-qualification conversion is // subsumed by the initialization. - Sequence.AddUserConversionStep(Function, Best->FoundDecl, DestType); + Sequence.AddUserConversionStep(Function, Best->FoundDecl, DestType, + HadMultipleCandidates); return; } @@ -3606,11 +3617,13 @@ static void TryUserDefinedConversion(Sema &S, // we just make a note of the actual destination type (possibly a // base class of the type returned by the conversion function) and // let the user-defined conversion step handle the conversion. - Sequence.AddUserConversionStep(Function, Best->FoundDecl, DestType); + Sequence.AddUserConversionStep(Function, Best->FoundDecl, DestType, + HadMultipleCandidates); return; } - Sequence.AddUserConversionStep(Function, Best->FoundDecl, ConvType); + Sequence.AddUserConversionStep(Function, Best->FoundDecl, ConvType, + HadMultipleCandidates); // If the conversion following the call to the conversion function // is interesting, add it as a separate step. diff --git a/lib/Sema/SemaOverload.cpp b/lib/Sema/SemaOverload.cpp index 24381a30d7..11b10a581a 100644 --- a/lib/Sema/SemaOverload.cpp +++ b/lib/Sema/SemaOverload.cpp @@ -8189,7 +8189,9 @@ public: << OvlExpr->getSourceRange(); S.NoteAllOverloadCandidates(OvlExpr); } - + + bool hadMultipleCandidates() const { return (OvlExpr->getNumDecls() > 1); } + int getNumMatches() const { return Matches.size(); } FunctionDecl* getMatchingFunctionDecl() const { @@ -8219,16 +8221,18 @@ public: /// resolved, and NULL otherwise. When @p Complain is true, this /// routine will emit diagnostics if there is an error. FunctionDecl * -Sema::ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr, QualType TargetType, - bool Complain, - DeclAccessPair &FoundResult) { - +Sema::ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr, + QualType TargetType, + bool Complain, + DeclAccessPair &FoundResult, + bool *pHadMultipleCandidates) { assert(AddressOfExpr->getType() == Context.OverloadTy); - - AddressOfFunctionResolver Resolver(*this, AddressOfExpr, TargetType, Complain); + + AddressOfFunctionResolver Resolver(*this, AddressOfExpr, TargetType, + Complain); int NumMatches = Resolver.getNumMatches(); FunctionDecl* Fn = 0; - if ( NumMatches == 0 && Complain) { + if (NumMatches == 0 && Complain) { if (Resolver.IsInvalidFormOfPointerToMemberFunction()) Resolver.ComplainIsInvalidFormOfPointerToMemberFunction(); else @@ -8244,7 +8248,9 @@ Sema::ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr, QualType TargetTyp if (Complain) CheckAddressOfMemberAccess(AddressOfExpr, FoundResult); } - + + if (pHadMultipleCandidates) + *pHadMultipleCandidates = Resolver.hadMultipleCandidates(); return Fn; }