reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

tools/clang/include/clang/Sema/Overload.h
  874       if (Function)
  875         return Function->getNumParams();
tools/clang/lib/Sema/SemaCodeComplete.cpp
 5060     if (Candidate.Function && Candidate.Function->isDeleted())
 5060     if (Candidate.Function && Candidate.Function->isDeleted())
 5063       Results.push_back(ResultCandidate(Candidate.Function));
tools/clang/lib/Sema/SemaExprCXX.cpp
 2252     FunctionDecl *FnDecl = Best->Function;
 2301           return C.Function->getNumParams() > 1 &&
 2302                  C.Function->getParamDecl(1)->getType()->isAlignValT();
 3487     FunctionDecl *FnDecl = Best->Function;
 5685       if (Best->Function)
 5686         Self.MarkFunctionReferenced(QuestionLoc, Best->Function);
tools/clang/lib/Sema/SemaInit.cpp
  532     CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
 4100   if (auto *CD = dyn_cast<CXXConversionDecl>(Best->Function)) {
 4122   CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
 4581   FunctionDecl *Function = Best->Function;
 5228   FunctionDecl *Function = Best->Function;
 6164     S.NoteDeletedFunction(Best->Function);
 6170   CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function);
 6231           Best->Function->getParamDecl(0)->getType().getNonReferenceType(),
 6286     S.CheckConstructorAccess(Loc, cast<CXXConstructorDecl>(Best->Function),
 6303     S.NoteDeletedFunction(Best->Function);
 8834         S.NoteDeletedFunction(Best->Function);
 9074         if (S.isImplicitlyDeleted(Best->Function))
 9076             << S.getSpecialMember(cast<CXXMethodDecl>(Best->Function))
 9082         S.NoteDeletedFunction(Best->Function);
 9138     CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
 9635                                  Candidate.Function == Function &&
 9887     NoteDeletedFunction(Best->Function);
 9896         cast<CXXDeductionGuideDecl>(Best->Function)->isExplicit()) {
 9897       bool IsDeductionGuide = !Best->Function->isImplicit();
 9900       Diag(Best->Function->getLocation(),
 9908     DiagnoseUseOfDecl(Best->Function, Kind.getLocation());
 9909     MarkFunctionReferenced(Kind.getLocation(), Best->Function);
 9917       SubstAutoType(TSInfo->getType(), Best->Function->getReturnType());
tools/clang/lib/Sema/SemaLookup.cpp
 3253       Result->setMethod(cast<CXXMethodDecl>(Best->Function));
 3258       Result->setMethod(cast<CXXMethodDecl>(Best->Function));
tools/clang/lib/Sema/SemaOverload.cpp
 1330         ICS.Ambiguous.addConversion(Cand->FoundDecl, Cand->Function);
 3296     CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function);
 3472           = dyn_cast<CXXConstructorDecl>(Best->Function)) {
 3500                  = dyn_cast<CXXConversionDecl>(Best->Function)) {
 4565     ICS.UserDefined.ConversionFunction = Best->Function;
 4578         ICS.Ambiguous.addConversion(Cand->FoundDecl, Cand->Function);
 5988           DeclAccessPair::make(Best->Function, Best->FoundDecl.getAccess());
 6143   Candidate.Function = Function;
 6699   Candidate.Function = Method;
 6842     Candidate.Function = MethodTmpl->getTemplatedDecl();
 6845       CandidateSet.getRewriteInfo().getRewriteKind(Candidate.Function, PO);
 6848         cast<CXXMethodDecl>(Candidate.Function)->isStatic() ||
 6906     Candidate.Function = FunctionTemplate->getTemplatedDecl();
 6909       CandidateSet.getRewriteInfo().getRewriteKind(Candidate.Function, PO);
 6915         isa<CXXMethodDecl>(Candidate.Function) &&
 6916         !isa<CXXConstructorDecl>(Candidate.Function);
 7083   Candidate.Function = Conversion;
 7249     Candidate.Function = FunctionTemplate->getTemplatedDecl();
 7289   Candidate.Function = nullptr;
 7490   Candidate.Function = nullptr;
 8266           if (!C->Viable || !C->Function || C->Function->getNumParams() != 2)
 8266           if (!C->Viable || !C->Function || C->Function->getNumParams() != 2)
 8269           if (C->Function->isFunctionTemplateSpecialization())
 8276           QualType FirstParamType = C->Function->getParamDecl(Reversed ? 1 : 0)
 8279           QualType SecondParamType = C->Function->getParamDecl(Reversed ? 0 : 1)
 9150     if (Cand->Function) {
 9151       Fns.erase(Cand->Function);
 9152       if (FunctionTemplateDecl *FunTmpl = Cand->Function->getPrimaryTemplate())
 9235   if (!Cand1.Function || !Cand1.Function->isMultiVersion() || !Cand2.Function ||
 9235   if (!Cand1.Function || !Cand1.Function->isMultiVersion() || !Cand2.Function ||
 9235   if (!Cand1.Function || !Cand1.Function->isMultiVersion() || !Cand2.Function ||
 9236       !Cand2.Function->isMultiVersion())
 9241   if (Cand1.Function->isInvalidDecl()) return false;
 9242   if (Cand2.Function->isInvalidDecl()) return true;
 9246   bool Cand1CPUDisp = Cand1.Function->hasAttr<CPUDispatchAttr>();
 9247   bool Cand2CPUDisp = Cand2.Function->hasAttr<CPUDispatchAttr>();
 9248   const auto *Cand1CPUSpec = Cand1.Function->getAttr<CPUSpecificAttr>();
 9249   const auto *Cand2CPUSpec = Cand2.Function->getAttr<CPUSpecificAttr>();
 9346       if (Cand1.Function && Cand1.Function == Cand2.Function &&
 9346       if (Cand1.Function && Cand1.Function == Cand2.Function &&
 9346       if (Cand1.Function && Cand1.Function == Cand2.Function &&
 9387       Cand1.Function && Cand2.Function &&
 9387       Cand1.Function && Cand2.Function &&
 9388       isa<CXXConversionDecl>(Cand1.Function) &&
 9389       isa<CXXConversionDecl>(Cand2.Function)) {
 9395         compareConversionFunctions(S, Cand1.Function, Cand2.Function);
 9395         compareConversionFunctions(S, Cand1.Function, Cand2.Function);
 9416       Cand1.Function && Cand2.Function &&
 9416       Cand1.Function && Cand2.Function &&
 9417       isa<CXXConstructorDecl>(Cand1.Function) !=
 9418           isa<CXXConstructorDecl>(Cand2.Function))
 9419     return isa<CXXConstructorDecl>(Cand1.Function);
 9423   bool Cand1IsSpecialization = Cand1.Function &&
 9424                                Cand1.Function->getPrimaryTemplate();
 9425   bool Cand2IsSpecialization = Cand2.Function &&
 9426                                Cand2.Function->getPrimaryTemplate();
 9436           = S.getMoreSpecializedTemplate(Cand1.Function->getPrimaryTemplate(),
 9437                                          Cand2.Function->getPrimaryTemplate(),
 9439                        isa<CXXConversionDecl>(Cand1.Function)? TPOC_Conversion
 9443       return BetterTemplate == Cand1.Function->getPrimaryTemplate();
 9458     auto *Cand1Class = cast<CXXRecordDecl>(Cand1.Function->getDeclContext());
 9459     auto *Cand2Class = cast<CXXRecordDecl>(Cand2.Function->getDeclContext());
 9479     auto *Guide1 = dyn_cast_or_null<CXXDeductionGuideDecl>(Cand1.Function);
 9480     auto *Guide2 = dyn_cast_or_null<CXXDeductionGuideDecl>(Cand2.Function);
 9493   if (Cand1.Function && Cand2.Function) {
 9493   if (Cand1.Function && Cand2.Function) {
 9494     Comparison Cmp = compareEnableIfAttrs(S, Cand1.Function, Cand2.Function);
 9494     Comparison Cmp = compareEnableIfAttrs(S, Cand1.Function, Cand2.Function);
 9499   if (S.getLangOpts().CUDA && Cand1.Function && Cand2.Function) {
 9499   if (S.getLangOpts().CUDA && Cand1.Function && Cand2.Function) {
 9501     return S.IdentifyCUDAPreference(Caller, Cand1.Function) >
 9502            S.IdentifyCUDAPreference(Caller, Cand2.Function);
 9505   bool HasPS1 = Cand1.Function != nullptr &&
 9506                 functionHasPassObjectSizeParams(Cand1.Function);
 9507   bool HasPS2 = Cand2.Function != nullptr &&
 9508                 functionHasPassObjectSizeParams(Cand2.Function);
 9611           return Cand->Viable && Cand->Function &&
 9612                  S.IdentifyCUDAPreference(Caller, Cand->Function) ==
 9618         return Cand->Viable && Cand->Function &&
 9619                S.IdentifyCUDAPreference(Caller, Cand->Function) ==
 9656         if (S.isEquivalentInternalLinkageDeclaration(Cand->Function,
 9657                                                      Curr->Function))
 9658           EquivalentCands.push_back(Cand->Function);
 9670   if (Best->Function && Best->Function->isDeleted())
 9670   if (Best->Function && Best->Function->isDeleted())
 9674     S.diagnoseEquivalentInternalLinkageDeclarations(Loc, Best->Function,
 9919   assert(Cand->Function && "for now, candidate must be a function");
 9920   FunctionDecl *Fn = Cand->Function;
10126       !checkAddressOfCandidateIsAvailable(S, Cand->Function))
10150   FunctionDecl *Fn = Cand->Function;
10226     DiagnoseArityMismatch(S, Cand->FoundDecl, Cand->Function, NumFormalArgs);
10491   DiagnoseBadDeduction(S, Cand->FoundDecl, Cand->Function, // pattern
10498   FunctionDecl *Callee = Cand->Function;
10555   FunctionDecl *Callee = Cand->Function;
10566   switch (Cand->Function->getDeclKind()) {
10568     ES = cast<CXXConstructorDecl>(Cand->Function)->getExplicitSpecifier();
10572     ES = cast<CXXConversionDecl>(Cand->Function)->getExplicitSpecifier();
10576     ES = cast<CXXDeductionGuideDecl>(Cand->Function)->getExplicitSpecifier();
10583   S.Diag(Cand->Function->getLocation(),
10591   FunctionDecl *Callee = Cand->Function;
10617   FunctionDecl *Fn = Cand->Function;
10706     bool Available = checkAddressOfCandidateIsAvailable(S, Cand->Function);
10780   if (Cand->Function)
10781     return Cand->Function->getLocation();
10997   } else if (Cand->Function) {
10999         Cand->Function->getType()->castAs<FunctionProtoType>()->getParamTypes();
11000     if (isa<CXXMethodDecl>(Cand->Function) &&
11001         !isa<CXXConstructorDecl>(Cand->Function)) {
11055         if (!Cand->Function && !Cand->IsSurrogate) {
11117     if (Cand->Function)
12163         SemaRef.Diag(Best->Function->getLocation(),
12167         SemaRef.Diag(Best->Function->getLocation(),
12174         SemaRef.Diag(Best->Function->getLocation(),
12391     FunctionDecl *FDecl = (*Best)->Function;
12452     FunctionDecl *FDecl = (*Best)->Function;
12468         !S.checkAddressOfFunctionIsAvailable(I->Function, /*Complain=*/false)) {
12599     FunctionDecl *FnDecl = Best->Function;
12854       FunctionDecl *FnDecl = Best->Function;
12887             if (Cand.Viable && Cand.Function == FnDecl &&
13100       if (isImplicitlyDeleted(Best->Function)) {
13101         CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
13114                          << getOperatorSpelling(Best->Function->getDeclName()
13180       FunctionDecl *FnDecl = Best->Function;
13441       Method = cast<CXXMethodDecl>(Best->Function);
13722   if (Best->Function == nullptr) {
13758   CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
13953   CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
14023   FunctionDecl *FD = Best->Function;