Lines Matching defs:Cand
1647 for (OverloadCandidateSet::iterator Cand = Conversions.begin();
1648 Cand != Conversions.end(); ++Cand)
1649 if (Cand->Best)
1650 ICS.Ambiguous.addConversion(Cand->FoundDecl, Cand->Function);
5010 for (OverloadCandidateSet::iterator Cand = CandidateSet.begin();
5011 Cand != CandidateSet.end(); ++Cand)
5012 if (Cand->Best)
5013 ICS.Ambiguous.addConversion(Cand->FoundDecl, Cand->Function);
9976 for (OverloadCandidateSet::iterator Cand = CandidateSet.begin(),
9978 Cand != CandEnd; ++Cand)
9979 if (Cand->Function) {
9980 Fns.erase(Cand->Function);
9981 if (FunctionTemplateDecl *FunTmpl = Cand->Function->getPrimaryTemplate())
10680 [](OverloadCandidate &Cand) { return &Cand; });
10696 llvm::any_of(Candidates, [&](OverloadCandidate *Cand) {
10698 return Cand->Viable && Cand->Function &&
10699 S.CUDA().IdentifyPreference(Caller, Cand->Function) ==
10703 auto IsWrongSideCandidate = [&](OverloadCandidate *Cand) {
10705 return Cand->Viable && Cand->Function &&
10706 S.CUDA().IdentifyPreference(Caller, Cand->Function) ==
10715 for (auto *Cand : Candidates) {
10716 Cand->Best = false;
10717 if (Cand->Viable) {
10719 isBetterOverloadCandidate(S, *Cand, *Best, Loc, Kind))
10720 Best = Cand;
10721 } else if (Cand->NotValidBecauseConstraintExprHasError()) {
10745 for (auto *Cand : Candidates) {
10746 if (Cand->Viable && !Cand->Best &&
10747 !isBetterOverloadCandidate(S, *Curr, *Cand, Loc, Kind)) {
10748 PendingBest.push_back(Cand);
10749 Cand->Best = true;
10751 if (S.isEquivalentInternalLinkageDeclaration(Cand->Function,
10753 EquivalentCands.push_back(Cand->Function);
11120 static void DiagnoseBadConversion(Sema &S, OverloadCandidate *Cand,
11122 const ImplicitConversionSequence &Conv = Cand->Conversions[I];
11124 assert(Cand->Function && "for now, candidate must be a function");
11125 FunctionDecl *Fn = Cand->Function;
11140 ClassifyOverloadCandidate(S, Cand->FoundDecl, Fn, Cand->getRewriteKind(),
11167 MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
11201 MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
11210 MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
11219 MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
11235 MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
11246 MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
11260 MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
11275 << (unsigned)(Cand->Fix.Kind);
11277 MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
11317 MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
11330 MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
11336 !checkAddressOfCandidateIsAvailable(S, Cand->Function))
11343 << (unsigned)(Cand->Fix.Kind);
11348 for (const FixItHint &HI : Cand->Fix.Hints)
11354 MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
11360 static bool CheckArityMismatch(Sema &S, OverloadCandidate *Cand,
11362 FunctionDecl *Fn = Cand->Function;
11376 assert((Cand->FailureKind == ovl_fail_too_few_arguments) ||
11377 (Cand->FailureKind == ovl_fail_bad_deduction &&
11378 Cand->DeductionFailure.getResult() ==
11381 assert((Cand->FailureKind == ovl_fail_too_many_arguments) ||
11382 (Cand->FailureKind == ovl_fail_bad_deduction &&
11383 Cand->DeductionFailure.getResult() ==
11450 static void DiagnoseArityMismatch(Sema &S, OverloadCandidate *Cand,
11452 if (!CheckArityMismatch(S, Cand, NumFormalArgs, Cand->TookAddressOfOverload))
11453 DiagnoseArityMismatch(S, Cand->FoundDecl, Cand->Function, NumFormalArgs,
11454 Cand->TookAddressOfOverload);
11750 static void DiagnoseBadDeduction(Sema &S, OverloadCandidate *Cand,
11753 TemplateDeductionResult TDK = Cand->DeductionFailure.getResult();
11756 if (CheckArityMismatch(S, Cand, NumArgs))
11759 DiagnoseBadDeduction(S, Cand->FoundDecl, Cand->Function, // pattern
11760 Cand->DeductionFailure, NumArgs, TakingCandidateAddress);
11764 static void DiagnoseBadTarget(Sema &S, OverloadCandidate *Cand) {
11766 FunctionDecl *Callee = Cand->Function;
11773 ClassifyOverloadCandidate(S, Cand->FoundDecl, Callee,
11774 Cand->getRewriteKind(), FnDesc);
11822 static void DiagnoseFailedEnableIfAttr(Sema &S, OverloadCandidate *Cand) {
11823 FunctionDecl *Callee = Cand->Function;
11824 EnableIfAttr *Attr = static_cast<EnableIfAttr*>(Cand->DeductionFailure.Data);
11831 static void DiagnoseFailedExplicitSpec(Sema &S, OverloadCandidate *Cand) {
11832 ExplicitSpecifier ES = ExplicitSpecifier::getFromDecl(Cand->Function);
11836 switch (Cand->Function->getDeclKind()) {
11844 Kind = Cand->Function->isImplicit() ? 0 : 2;
11854 FunctionDecl *First = Cand->Function->getFirstDecl();
11919 static void NoteFunctionCandidate(Sema &S, OverloadCandidate *Cand,
11923 FunctionDecl *Fn = Cand->Function;
11931 Cand->FailureKind != ovl_fail_bad_conversion)
11936 if (Cand->TookAddressOfOverload &&
11937 !Cand->Function->hasCXXExplicitFunctionObjectParameter() &&
11938 !Cand->Function->isStatic())
11942 if (Cand->Viable) {
11946 ClassifyOverloadCandidate(S, Cand->FoundDecl, Fn,
11947 Cand->getRewriteKind(), FnDesc);
11952 MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
11957 S.NoteOverloadCandidate(Cand->FoundDecl, Fn, Cand->getRewriteKind());
11972 switch (Cand->FailureKind) {
11975 return DiagnoseArityMismatch(S, Cand, NumArgs);
11978 return DiagnoseBadDeduction(S, Cand, NumArgs,
11984 MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
11994 MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
12001 return S.NoteOverloadCandidate(Cand->FoundDecl, Fn, Cand->getRewriteKind());
12004 unsigned I = (Cand->IgnoreObjectArgument ? 1 : 0);
12005 for (unsigned N = Cand->Conversions.size(); I != N; ++I)
12006 if (Cand->Conversions[I].isInitialized() && Cand->Conversions[I].isBad())
12007 return DiagnoseBadConversion(S, Cand, I, TakingCandidateAddress);
12012 return S.NoteOverloadCandidate(Cand->FoundDecl, Fn, Cand->getRewriteKind());
12016 return DiagnoseBadTarget(S, Cand);
12019 return DiagnoseFailedEnableIfAttr(S, Cand);
12022 return DiagnoseFailedExplicitSpec(S, Cand);
12032 MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
12036 bool Available = checkAddressOfCandidateIsAvailable(S, Cand->Function);
12048 ClassifyOverloadCandidate(S, Cand->FoundDecl, Fn,
12049 Cand->getRewriteKind(), FnDesc);
12063 static void NoteSurrogateCandidate(Sema &S, OverloadCandidate *Cand) {
12064 if (shouldSkipNotingLambdaConversionDecl(Cand->Surrogate))
12070 QualType FnType = Cand->Surrogate->getConversionType();
12094 if (!Cand->Viable &&
12095 Cand->FailureKind == ovl_fail_constraints_not_satisfied) {
12096 S.Diag(Cand->Surrogate->getLocation(),
12098 << Cand->Surrogate;
12100 if (S.CheckFunctionConstraints(Cand->Surrogate, Satisfaction))
12103 S.Diag(Cand->Surrogate->getLocation(), diag::note_ovl_surrogate_cand)
12110 OverloadCandidate *Cand) {
12111 assert(Cand->Conversions.size() <= 2 && "builtin operator is not binary");
12115 TypeStr += Cand->BuiltinParamTypes[0].getAsString();
12116 if (Cand->Conversions.size() == 1) {
12121 TypeStr += Cand->BuiltinParamTypes[1].getAsString();
12128 OverloadCandidate *Cand) {
12129 for (const ImplicitConversionSequence &ICS : Cand->Conversions) {
12138 static SourceLocation GetLocationForCandidate(const OverloadCandidate *Cand) {
12139 if (Cand->Function)
12140 return Cand->Function->getLocation();
12141 if (Cand->IsSurrogate)
12142 return Cand->Surrogate->getLocation();
12371 CompleteNonViableCandidate(Sema &S, OverloadCandidate *Cand,
12374 assert(!Cand->Viable);
12377 if (Cand->FailureKind != ovl_fail_bad_conversion)
12383 Cand->Fix.setConversionChecker(TryCopyInitialization);
12386 unsigned ConvCount = Cand->Conversions.size();
12387 for (unsigned ConvIdx = (Cand->IgnoreObjectArgument ? 1 : 0); /**/;
12390 if (Cand->Conversions[ConvIdx].isInitialized() &&
12391 Cand->Conversions[ConvIdx].isBad()) {
12392 Unfixable = !Cand->TryToFixBadConversion(ConvIdx, S);
12404 bool Reversed = Cand->isReversed();
12406 if (Cand->IsSurrogate) {
12408 = Cand->Surrogate->getConversionType().getNonReferenceType();
12414 } else if (Cand->Function) {
12416 Cand->Function->getType()->castAs<FunctionProtoType>()->getParamTypes();
12417 if (isa<CXXMethodDecl>(Cand->Function) &&
12418 !isa<CXXConstructorDecl>(Cand->Function) && !Reversed) {
12422 Cand->Function->getDeclName().getCXXOverloadedOperator() != OO_Call &&
12423 Cand->Function->getDeclName().getCXXOverloadedOperator() !=
12431 ParamTypes = Cand->BuiltinParamTypes;
12439 if (Cand->Conversions[ConvIdx].isInitialized()) {
12443 Cand->Conversions[ConvIdx].setAsIdentityConversion(
12446 Cand->Conversions[ConvIdx] =
12453 if (!Unfixable && Cand->Conversions[ConvIdx].isBad())
12454 Unfixable = !Cand->TryToFixBadConversion(ConvIdx, S);
12457 Cand->Conversions[ConvIdx].setEllipsis();
12469 for (iterator Cand = begin(), LastCand = end(); Cand != LastCand; ++Cand) {
12470 if (!Filter(*Cand))
12474 if (!Cand->Viable) {
12475 if (!Cand->Function && !Cand->IsSurrogate) {
12480 CompleteNonViableCandidate(S, Cand, Args, Kind);
12485 if (!Cand->Viable)
12490 if (!Cand->Best)
12495 Cands.push_back(Cand);
12511 CompleteCandidates(S, OCD_AllCandidates, Args, OpLoc, [](auto &Cand) {
12512 return (Cand.Viable == false &&
12513 Cand.FailureKind == ovl_fail_bad_target) ||
12514 (Cand.Function &&
12515 Cand.Function->template hasAttr<CUDAHostAttr>() &&
12516 Cand.Function->template hasAttr<CUDADeviceAttr>());
12558 OverloadCandidate *Cand = *I;
12566 if (Cand->Function)
12567 NoteFunctionCandidate(S, Cand, Args.size(),
12569 else if (Cand->IsSurrogate)
12570 NoteSurrogateCandidate(S, Cand);
12572 assert(Cand->Viable &&
12581 NoteAmbiguousUserConversions(S, OpLoc, Cand);
12586 NoteBuiltinOperatorCandidate(S, Opc, OpLoc, Cand);
12601 GetLocationForCandidate(const TemplateSpecCandidate *Cand) {
12602 return Cand->Specialization ? Cand->Specialization->getLocation()
12663 /// OCD == OCD_AllCandidates and Cand->Viable == false.
12670 for (iterator Cand = begin(), LastCand = end(); Cand != LastCand; ++Cand) {
12671 if (Cand->Specialization)
12672 Cands.push_back(Cand);
12686 TemplateSpecCandidate *Cand = *I;
12695 assert(Cand->Specialization &&
12697 Cand->NoteDeductionFailure(S, ForTakingAddress);
14562 for (OverloadCandidate &Cand : CandidateSet) {
14563 if (Cand.Viable && Cand.Function && Cand.isReversed() &&
14564 allowAmbiguity(Context, Cand.Function, FnDecl)) {
14567 *this, OpLoc, Cand.Conversions[ArgIdx],
14570 AmbiguousWith.push_back(Cand.Function);