Index: include/clang/AST/ExprCXX.h =================================================================== --- include/clang/AST/ExprCXX.h (revision 119773) +++ include/clang/AST/ExprCXX.h (working copy) @@ -1489,28 +1489,28 @@ static bool ComputeDependence(UnresolvedSetIterator Begin, UnresolvedSetIterator End, const TemplateArgumentListInfo *Args); - + struct FindResult { - OverloadExpr *Expression; + const OverloadExpr *Expression; bool IsAddressOfOperand; bool HasFormOfMemberPointer; }; - + /// Finds the overloaded expression in the given expression of /// OverloadTy. /// /// \return the expression (which must be there) and true if it has /// the particular form of a member pointer expression - static FindResult find(Expr *E) { + static FindResult find(const Expr *E) { assert(E->getType()->isSpecificBuiltinType(BuiltinType::Overload)); FindResult Result; E = E->IgnoreParens(); if (isa(E)) { - assert(cast(E)->getOpcode() == UO_AddrOf); - E = cast(E)->getSubExpr(); - OverloadExpr *Ovl = cast(E->IgnoreParens()); + assert(cast(E)->getOpcode() == UO_AddrOf); + E = cast(E)->getSubExpr(); + const OverloadExpr *Ovl = cast(E->IgnoreParens()); Result.HasFormOfMemberPointer = (E == Ovl && Ovl->getQualifier()); Result.IsAddressOfOperand = true; @@ -1518,9 +1518,8 @@ } else { Result.HasFormOfMemberPointer = false; Result.IsAddressOfOperand = false; - Result.Expression = cast(E); + Result.Expression = cast(E); } - return Result; } Index: include/clang/Sema/Sema.h =================================================================== --- include/clang/Sema/Sema.h (revision 119773) +++ include/clang/Sema/Sema.h (working copy) @@ -1119,12 +1119,18 @@ OverloadCandidateSet& CandidateSet, bool PartialOverloading = false); - void NoteOverloadCandidate(FunctionDecl *Fn); + // Emit as a 'note' the specific overload candidate + void NoteOverloadCandidate(const FunctionDecl *Fn); + + // Emit as a series of 'note's all template and non-templates + // identified by the expression Expr + void NoteAllOverloadCandidates(const Expr* E); + FunctionDecl *ResolveAddressOfOverloadedFunction(Expr *From, QualType ToType, bool Complain, DeclAccessPair &Found); - FunctionDecl *ResolveSingleFunctionTemplateSpecialization(Expr *From); + FunctionDecl *ResolveSingleFunctionTemplateSpecialization(const Expr *From); Expr *FixOverloadedFunctionReference(Expr *E, DeclAccessPair FoundDecl, @@ -2699,9 +2705,9 @@ NamedDecl *PrevMemberDecl, AccessSpecifier LexicalAS); - AccessResult CheckUnresolvedMemberAccess(UnresolvedMemberExpr *E, + AccessResult CheckUnresolvedMemberAccess(const UnresolvedMemberExpr *E, DeclAccessPair FoundDecl); - AccessResult CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E, + AccessResult CheckUnresolvedLookupAccess(const UnresolvedLookupExpr *E, DeclAccessPair FoundDecl); AccessResult CheckAllocationAccess(SourceLocation OperatorLoc, SourceRange PlacementRange, @@ -2722,7 +2728,7 @@ Expr *ObjectExpr, Expr *ArgExpr, DeclAccessPair FoundDecl); - AccessResult CheckAddressOfMemberAccess(Expr *OvlExpr, + AccessResult CheckAddressOfMemberAccess(const Expr *OvlExpr, DeclAccessPair FoundDecl); AccessResult CheckBaseClassAccess(SourceLocation AccessLoc, QualType Base, QualType Derived, Index: lib/Sema/SemaAccess.cpp =================================================================== --- lib/Sema/SemaAccess.cpp (revision 119773) +++ lib/Sema/SemaAccess.cpp (working copy) @@ -1338,7 +1338,7 @@ } } -Sema::AccessResult Sema::CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E, +Sema::AccessResult Sema::CheckUnresolvedLookupAccess(const UnresolvedLookupExpr *E, DeclAccessPair Found) { if (!getLangOptions().AccessControl || !E->getNamingClass() || @@ -1354,7 +1354,7 @@ /// Perform access-control checking on a previously-unresolved member /// access which has now been resolved to a member. -Sema::AccessResult Sema::CheckUnresolvedMemberAccess(UnresolvedMemberExpr *E, +Sema::AccessResult Sema::CheckUnresolvedMemberAccess(const UnresolvedMemberExpr *E, DeclAccessPair Found) { if (!getLangOptions().AccessControl || Found.getAccess() == AS_public) @@ -1492,14 +1492,14 @@ return CheckAccess(*this, OpLoc, Entity); } -Sema::AccessResult Sema::CheckAddressOfMemberAccess(Expr *OvlExpr, +Sema::AccessResult Sema::CheckAddressOfMemberAccess(const Expr *OvlExpr, DeclAccessPair Found) { if (!getLangOptions().AccessControl || Found.getAccess() == AS_none || Found.getAccess() == AS_public) return AR_accessible; - OverloadExpr *Ovl = OverloadExpr::find(OvlExpr).Expression; + const OverloadExpr *Ovl = OverloadExpr::find(OvlExpr).Expression; CXXRecordDecl *NamingClass = Ovl->getNamingClass(); AccessTarget Entity(Context, AccessTarget::Member, NamingClass, Found, Index: lib/Sema/SemaCXXCast.cpp =================================================================== --- lib/Sema/SemaCXXCast.cpp (revision 119773) +++ lib/Sema/SemaCXXCast.cpp (working copy) @@ -22,7 +22,6 @@ using namespace clang; -static void NoteAllOverloadCandidates(Expr* const Expr, Sema& sema); enum TryCastResult { TC_NotApplicable, ///< The cast method is not applicable. @@ -491,7 +490,7 @@ Self.Diag(OpRange.getBegin(), diag::err_bad_reinterpret_cast_overload) << OverloadExpr::find(SrcExpr).Expression->getName() << DestType << OpRange; - NoteAllOverloadCandidates(SrcExpr, Self); + Self.NoteAllOverloadCandidates(SrcExpr); } else @@ -527,10 +526,10 @@ { if (SrcExpr->getType() == Self.Context.OverloadTy) { - OverloadExpr* oe = OverloadExpr::find(SrcExpr).Expression; + const OverloadExpr* oe = OverloadExpr::find(SrcExpr).Expression; Self.Diag(OpRange.getBegin(), diag::err_bad_static_cast_overload) << oe->getName() << DestType << OpRange << oe->getQualifierRange(); - NoteAllOverloadCandidates(SrcExpr, Self); + Self.NoteAllOverloadCandidates(SrcExpr); } else Self.Diag(OpRange.getBegin(), msg) << CT_Static @@ -1111,30 +1110,6 @@ } -static void NoteAllOverloadCandidates(Expr* const Expr, Sema& sema) -{ - - assert(Expr->getType() == sema.Context.OverloadTy); - - OverloadExpr::FindResult Ovl = OverloadExpr::find(Expr); - OverloadExpr *const OvlExpr = Ovl.Expression; - - for (UnresolvedSetIterator it = OvlExpr->decls_begin(), - end = OvlExpr->decls_end(); it != end; ++it) { - if ( FunctionTemplateDecl *ftd = - dyn_cast((*it)->getUnderlyingDecl()) ) - { - sema.NoteOverloadCandidate(ftd->getTemplatedDecl()); - } - else if ( FunctionDecl *f = - dyn_cast((*it)->getUnderlyingDecl()) ) - { - sema.NoteOverloadCandidate(f); - } - } -} - - static TryCastResult TryReinterpretCast(Sema &Self, Expr *SrcExpr, QualType DestType, bool CStyle, const SourceRange &OpRange, Index: lib/Sema/SemaOverload.cpp =================================================================== --- lib/Sema/SemaOverload.cpp (revision 119773) +++ lib/Sema/SemaOverload.cpp (working copy) @@ -5790,17 +5790,17 @@ }; OverloadCandidateKind ClassifyOverloadCandidate(Sema &S, - FunctionDecl *Fn, + const FunctionDecl *Fn, std::string &Description) { bool isTemplate = false; - if (FunctionTemplateDecl *FunTmpl = Fn->getPrimaryTemplate()) { + if (const FunctionTemplateDecl *FunTmpl = Fn->getPrimaryTemplate()) { isTemplate = true; Description = S.getTemplateArgumentBindingsText( FunTmpl->getTemplateParameters(), *Fn->getTemplateSpecializationArgs()); } - if (CXXConstructorDecl *Ctor = dyn_cast(Fn)) { + if (const CXXConstructorDecl *Ctor = dyn_cast(Fn)) { if (!Ctor->isImplicit()) return isTemplate ? oc_constructor_template : oc_constructor; @@ -5808,7 +5808,7 @@ : oc_implicit_default_constructor; } - if (CXXMethodDecl *Meth = dyn_cast(Fn)) { + if (const CXXMethodDecl *Meth = dyn_cast(Fn)) { // This actually gets spelled 'candidate function' for now, but // it doesn't hurt to split it out. if (!Meth->isImplicit()) @@ -5825,13 +5825,38 @@ } // end anonymous namespace // Notes the location of an overload candidate. -void Sema::NoteOverloadCandidate(FunctionDecl *Fn) { +void Sema::NoteOverloadCandidate(const FunctionDecl *Fn) { std::string FnDesc; OverloadCandidateKind K = ClassifyOverloadCandidate(*this, Fn, FnDesc); Diag(Fn->getLocation(), diag::note_ovl_candidate) << (unsigned) K << FnDesc; } + +//Notes the location of all overload candidates designated through +// OverloadedExpr +void Sema::NoteAllOverloadCandidates(const Expr* const OverloadedExpr) +{ + + assert(OverloadedExpr->getType() == Context.OverloadTy); + + OverloadExpr::FindResult Ovl = OverloadExpr::find(OverloadedExpr); + const OverloadExpr *const OvlExpr = Ovl.Expression; + + for (UnresolvedSetIterator it = OvlExpr->decls_begin(), + end = OvlExpr->decls_end(); it != end; ++it) { + if ( FunctionTemplateDecl *ftd = + dyn_cast((*it)->getUnderlyingDecl()) ) + { + NoteOverloadCandidate(ftd->getTemplatedDecl()); + } + else if ( FunctionDecl *f = + dyn_cast((*it)->getUnderlyingDecl()) ) + { + NoteOverloadCandidate(f); + } + } +} /// Diagnoses an ambiguous conversion. The partial diagnostic is the /// "lead" diagnostic; it will be given two arguments, the source and /// target types of the conversion. @@ -6509,13 +6534,36 @@ S.Diag(OpLoc, diag::note_ovl_too_many_candidates) << int(E - I); } -static bool CheckUnresolvedAccess(Sema &S, OverloadExpr *E, DeclAccessPair D) { - if (isa(E)) - return S.CheckUnresolvedLookupAccess(cast(E), D); +static bool CheckUnresolvedAccess(Sema &S, const OverloadExpr *E, DeclAccessPair D) { + if (isa(E)) + return S.CheckUnresolvedLookupAccess(cast(E), D); - return S.CheckUnresolvedMemberAccess(cast(E), D); + return S.CheckUnresolvedMemberAccess(cast(E), D); } + + +// [ToType] [Return] +// R (*)(A) --> R (A), IsNonStaticMemberFunction = false +// R (&)(A) --> R (A), IsNonStaticMemberFunction = false +// R (S::*)(A) --> R (A), IsNonStaticMemberFunction = true +static QualType inline GetFunctionTypeSansPtrOrRef( + const QualType& ToType + , bool *IsNonStaticMemberFunction ) +{ + QualType FunctionType = ToType; + if (const PointerType *ToTypePtr = ToType->getAs()) + FunctionType = ToTypePtr->getPointeeType(); + else if (const ReferenceType *ToTypeRef = ToType->getAs()) + FunctionType = ToTypeRef->getPointeeType(); + else if (const MemberPointerType *MemTypePtr = + ToType->getAs()) { + FunctionType = MemTypePtr->getPointeeType(); + *IsNonStaticMemberFunction = true; + } + return FunctionType; +} + /// ResolveAddressOfOverloadedFunction - Try to resolve the address of /// an overloaded function (C++ [over.over]), where @p From is an /// expression with overloaded function type and @p ToType is the type @@ -6535,18 +6583,16 @@ Sema::ResolveAddressOfOverloadedFunction(Expr *From, QualType ToType, bool Complain, DeclAccessPair &FoundResult) { - QualType FunctionType = ToType; - bool IsMember = false; - if (const PointerType *ToTypePtr = ToType->getAs()) - FunctionType = ToTypePtr->getPointeeType(); - else if (const ReferenceType *ToTypeRef = ToType->getAs()) - FunctionType = ToTypeRef->getPointeeType(); - else if (const MemberPointerType *MemTypePtr = - ToType->getAs()) { - FunctionType = MemTypePtr->getPointeeType(); - IsMember = true; - } + + bool IsNonStaticMember = false; + + QualType FunctionType = GetFunctionTypeSansPtrOrRef(ToType, + &IsNonStaticMember); + FunctionType = Context.getCanonicalType(FunctionType).getUnqualifiedType(); + + + // C++ [over.over]p1: // [...] [Note: any redundant set of parentheses surrounding the // overloaded function name is ignored (5.1). ] @@ -6559,21 +6605,19 @@ // and its operand is a qualified-id not enclosed in // parentheses. OverloadExpr::FindResult Ovl = OverloadExpr::find(From); - OverloadExpr *OvlExpr = Ovl.Expression; + const OverloadExpr *OvlExpr = Ovl.Expression; - // We expect a pointer or reference to function, or a function pointer. - FunctionType = Context.getCanonicalType(FunctionType).getUnqualifiedType(); if (!FunctionType->isFunctionType()) { - if (Complain) - Diag(From->getLocStart(), diag::err_addr_ovl_not_func_ptrref) - << OvlExpr->getName() << ToType; - - return 0; + if (Complain) + Diag(From->getLocStart(), diag::err_addr_ovl_not_func_ptrref) + << OvlExpr->getName() << ToType; + + return 0; } // If the overload expression doesn't have the form of a pointer to // member, don't try to convert it to a pointer-to-member type. - if (IsMember && !Ovl.HasFormOfMemberPointer) { + if (IsNonStaticMember && !Ovl.HasFormOfMemberPointer) { if (!Complain) return 0; // TODO: Should we condition this on whether any functions might @@ -6616,9 +6660,9 @@ = dyn_cast(FunctionTemplate->getTemplatedDecl())) { // Skip non-static function templates when converting to pointer, and // static when converting to member pointer. - if (Method->isStatic() == IsMember) + if (Method->isStatic() == IsNonStaticMember) continue; - } else if (IsMember) + } else if (IsNonStaticMember) continue; // C++ [over.over]p2: @@ -6649,13 +6693,13 @@ if (CXXMethodDecl *Method = dyn_cast(Fn)) { // Skip non-static functions when converting to pointer, and static // when converting to member pointer. - if (Method->isStatic() == IsMember) + if (Method->isStatic() == IsNonStaticMember) continue; // If we have explicit template arguments, skip non-templates. if (OvlExpr->hasExplicitTemplateArgs()) continue; - } else if (IsMember) + } else if (IsNonStaticMember) continue; if (FunctionDecl *FunDecl = dyn_cast(Fn)) { @@ -6769,7 +6813,8 @@ /// template, where that template-id refers to a single template whose template /// arguments are either provided by the template-id or have defaults, /// as described in C++0x [temp.arg.explicit]p3. -FunctionDecl *Sema::ResolveSingleFunctionTemplateSpecialization(Expr *From) { +FunctionDecl *Sema::ResolveSingleFunctionTemplateSpecialization(const + Expr *From) { // C++ [over.over]p1: // [...] [Note: any redundant set of parentheses surrounding the // overloaded function name is ignored (5.1). ] @@ -6780,7 +6825,7 @@ if (From->getType() != Context.OverloadTy) return 0; - OverloadExpr *OvlExpr = OverloadExpr::find(From).Expression; + const OverloadExpr *OvlExpr = OverloadExpr::find(From).Expression; // If we didn't actually find any template-ids, we're done. if (!OvlExpr->hasExplicitTemplateArgs()) Index: lib/Sema/SemaTemplateDeduction.cpp =================================================================== --- lib/Sema/SemaTemplateDeduction.cpp (revision 119773) +++ lib/Sema/SemaTemplateDeduction.cpp (working copy) @@ -1570,7 +1570,7 @@ OverloadExpr::FindResult R = OverloadExpr::find(Arg); - OverloadExpr *Ovl = R.Expression; + const OverloadExpr *Ovl = R.Expression; // C++0x [temp.deduct.call]p4 unsigned TDF = 0;