Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/SemaConcept_8cpp_source.html below:

clang: lib/Sema/SemaConcept.cpp Source File

;

*LHS =

;

*RHS =

;

LogicalBinOp(

*

) {

(

*BO = dyn_cast<BinaryOperator>(

)) {

= BO->getExprLoc();

}

(

*OO = dyn_cast<CXXOperatorCallExpr>(

)) {

(OO->getNumArgs() == 2) {

Op = OO->getOperator();

= OO->getOperatorLoc();

isAnd()

{

Op == OO_AmpAmp; }

isOr()

{

Op == OO_PipePipe; }

()

{

isAnd() || isOr(); }

*getLHS()

{

LHS; }

*getRHS()

{

RHS; }

recreateBinOp(SemaRef, LHS,

*

(getRHS()));

assert((isAnd() || isOr()) &&

);

NextToken,

*PossibleNonPrimary,

IsTrailingRequiresClause) {

(LogicalBinOp BO = ConstraintExpression) {

PossibleNonPrimary) &&

}

(

*

= dyn_cast<ExprWithCleanups>(ConstraintExpression))

CheckForNonPrimary = [&] {

(!PossibleNonPrimary)

*PossibleNonPrimary =

(NextToken.

(tok::l_paren) &&

(IsTrailingRequiresClause ||

isa<UnresolvedLookupExpr>(ConstraintExpression) &&

CheckForNonPrimary();

diag::err_non_bool_atomic_constraint) <<

CheckForNonPrimary();

(PossibleNonPrimary)

*PossibleNonPrimary =

;

SatisfactionStackRAII {

Inserted =

;

llvm::FoldingSetNodeID &FSNID)

~SatisfactionStackRAII() {

<

Constra

Evaluator>

ConstraintEvaluator &Evaluator);

<

Constra

Evaluator>

ConstraintEvaluator &Evaluator) {

EffectiveDetailEndIndex = Satisfaction.

.size();

(Op == clang::OO_PipePipe && IsLHSSatisfied)

(Op == clang::OO_AmpAmp && !IsLHSSatisfied)

(Op == clang::OO_PipePipe && IsRHSSatisfied) {

EffectiveDetailEnd = Satisfaction.

.begin();

std::advance(EffectiveDetailEnd, EffectiveDetailEndIndex);

Satisfaction.

.erase(EffectiveDetailEnd, Satisfaction.

.end());

<

Constra

Evaluator>

ConstraintEvaluator &Evaluator) {

Conjunction = FE->

() == BinaryOperatorKind::BO_LAnd;

EffectiveDetailEndIndex = Satisfaction.

.size();

std::optional<unsigned> NumExpansions =

Evaluator.EvaluateFoldExpandedConstraintSize(FE);

(

I = 0; I < *NumExpansions; I++) {

Satisfaction, Evaluator);

(!Conjunction && IsRHSSatisfied) {

EffectiveDetailEnd = Satisfaction.

.begin();

std::advance(EffectiveDetailEnd, EffectiveDetailEndIndex);

Satisfaction.

.erase(EffectiveDetailEnd,

(Conjunction != IsRHSSatisfied)

Satisfaction, Evaluator);

<

Constra

Evaluator>

ConstraintEvaluator &Evaluator) {

(LogicalBinOp BO = ConstraintExpr)

S, BO.getLHS(), BO.getOp(), BO.getRHS(), Satisfaction, Evaluator);

(

*

= dyn_cast<ExprWithCleanups>(ConstraintExpr)) {

(

*FE = dyn_cast<CXXFoldExpr>(ConstraintExpr);

(FE->getOperator() == BinaryOperatorKind::BO_LAnd ||

FE->getOperator() == BinaryOperatorKind::BO_LOr)) {

Evaluator.EvaluateAtomicConstraint(ConstraintExpr);

(!SubstitutedAtomicExpr.

())

MessageSize = DiagString.size();

*Mem =

(S.

)

[MessageSize];

(Mem, DiagString.c_str(), MessageSize);

Satisfaction.

.emplace_back(

SubstitutedAtomicExpr.get()->getBeginLoc(),

StringRef(Mem, MessageSize)});

SubstitutedAtomicExpr;

EvalResult.

= &EvaluationDiags;

!EvaluationDiags.empty()) {

diag::err_non_constant_constraint_expression)

S.

(PDiag.first, PDiag.second);

assert(EvalResult.

.

() &&

);

Satisfaction.

.emplace_back(SubstitutedAtomicExpr.

());

SubstitutedAtomicExpr;

(

&List : MLTAL)

ConstraintEvaluator {

S, Sema::ExpressionEvaluationContext::ConstantEvaluated,

*

(Template), Info,

llvm::FoldingSetNodeID

;

SatisfactionStackRAII StackRAII(S, Template,

);

SubstitutedExpression =

MessageSize = DiagString.size();

*Mem =

(S.

)

[MessageSize];

(Mem, DiagString.c_str(), MessageSize);

Satisfaction.

.emplace_back(

SubstDiag.first, StringRef(Mem, MessageSize)});

CK_LValueToRValue, SubstitutedExpression.

(),

SubstitutedExpression;

std::optional<unsigned>

EvaluateFoldExpandedConstraintSize(

*FE)

{

assert(!Unexpanded.empty() &&

);

RetainExpansion =

;

NumExpansions = OrigNumExpansions;

MLTAL, Expand, RetainExpansion, NumExpansions) ||

!Expand || RetainExpansion)

(NumExpansions && S.

().BracketDepth < NumExpansions) {

clang::diag::err_fold_expression_limit_exceeded)

<< *NumExpansions << S.

().BracketDepth

NumExpansions;

S, ConstraintExpr, Satisfaction,

ConstraintEvaluator{S, Template, TemplateNameLoc, MLTAL, Satisfaction});

(ConstraintExprs.empty()) {

*

(Template), TemplateArgs, TemplateIDRange);

(

*ConstraintExpr : ConstraintExprs) {

S, Template, TemplateIDRange.

(), TemplateArgsLists,

ConstraintExpr, Satisfaction);

Converted.push_back(Res.

());

Converted.append(ConstraintExprs.size() - Converted.size(),

);

(ConstraintExprs.empty()) {

return ::CheckConstraintSatisfaction(

*

,

, ConstraintExprs, ConvertedConstraints,

TemplateArgsLists, TemplateIDRange, OutSatisfaction);

(

List : TemplateArgsLists)

FlattenedArgs.insert(FlattenedArgs.end(), List.Args.begin(),

llvm::FoldingSetNodeID ID;

(

*Cached = SatisfactionCache.FindNodeOrInsertPos(ID, InsertPos)) {

OutSatisfaction = *Cached;

std::make_unique<ConstraintSatisfaction>(Template, FlattenedArgs);

ConvertedConstraints, TemplateArgsLists,

TemplateIDRange, *Satisfaction)) {

OutSatisfaction = *Satisfaction;

(

*Cached = SatisfactionCache.FindNodeOrInsertPos(ID, InsertPos)) {

OutSatisfaction = *Cached;

OutSatisfaction = *Satisfaction;

SatisfactionCache.InsertNode(Satisfaction.release());

ConstraintEvaluator {

std::optional<unsigned>

EvaluateFoldExpandedConstraintSize(

*FE)

{

ConstraintEvaluator{*

})

Sema::addInstantiatedCapturesToScope(

*LambdaClass = cast<CXXMethodDecl>(

)->getParent();

*LambdaPattern = cast<CXXMethodDecl>(PatternDecl)->getParent();

Instantiated = 0;

AddSingleCapture = [&](

*CapturedPattern,

*CapturedVar = LambdaClass->getCapture(Index)->getCapturedVar();

.InstantiatedLocal(CapturedPattern, CapturedVar);

(

&CapturePattern : LambdaPattern->captures()) {

(!CapturePattern.capturesVariable()) {

*CapturedPattern = CapturePattern.getCapturedVar();

AddSingleCapture(CapturedPattern, Instantiated++);

.MakeInstantiatedLocalArgPack(CapturedPattern);

dyn_cast<VarDecl>(CapturedPattern)->getInit(), Unexpanded);

NumArgumentsInExpansion =

(!NumArgumentsInExpansion)

(

Arg = 0; Arg < *NumArgumentsInExpansion; ++Arg)

AddSingleCapture(CapturedPattern, Instantiated++);

Sema::SetupConstraintScope(

InstantiatingTemplate Inst(

(Inst.isInvalid())

(addInstantiatedParametersToScope(

(addInstantiatedParametersToScope(FD, FromMemTempl->getTemplatedDecl(),

InstantiatingTemplate Inst(

(Inst.isInvalid())

(addInstantiatedParametersToScope(FD, InstantiatedFrom,

, MLTAL))

std::optional<MultiLevelTemplateArgumentList>

Sema::SetupConstraintCheckingTemplateArgumentsAndScope(

,

std::nullopt,

(SetupConstraintScope(FD, TemplateArgs, MLTAL,

))

ForOverloadResolution) {

(

*MD = dyn_cast<CXXConversionDecl>(FD);

Satisfaction, UsageLoc,

std::optional<MultiLevelTemplateArgumentList> MLTAL =

SetupConstraintCheckingTemplateArgumentsAndScope(

(

*Method = dyn_cast<CXXMethodDecl>(FD)) {

ThisQuals = Method->getMethodQualifiers();

ForOverloadResolution);

SkipForSpecialization =

) {

, SkipForSpecialization);

AdjustConstraintDepth :

<AdjustConstraintDepth> {

TemplateDepth = 0;

AdjustConstraintDepth(

&SemaRef,

TemplateDepth)

: inherited(SemaRef), TemplateDepth(TemplateDepth) {}

inherited::TransformTemplateTypeParmType;

NewTTPDecl = cast_or_null<TemplateTypeParmDecl>(

TransformDecl(TL.

(), OldTTPDecl));

Result = getSema().Context.getTemplateTypeParmType(

->getDepth() + TemplateDepth,

->getIndex(),

->isParameterPack(),

*ConstrExpr) {

std::optional<LocalInstantiationScope> ScopeForParameters;

ScopeForParameters.emplace(S,

);

(!PVD->isParameterPack()) {

ScopeForParameters->InstantiatedLocal(PVD, PVD);

ScopeForParameters->MakeInstantiatedLocalArgPack(PVD);

ScopeForParameters->InstantiatedLocalPackArg(PVD, PVD);

std::optional<Sema::CXXThisScopeRAII> ThisScope;

std::optional<Sema::ContextRAII> ContextScope;

(

*RD = dyn_cast<CXXRecordDecl>(DC)) {

ContextScope.emplace(S,

*

(cast<DeclContext>(RD)),

SubstConstr.

();

*OldConstr,

*NewConstr) {

(OldConstr == NewConstr)

(

*SubstConstr =

OldConstr = SubstConstr;

(

*SubstConstr =

NewConstr = SubstConstr;

llvm::FoldingSetNodeID ID1, ID2;

);

(

*Constraint : ACs)

TemplateIDRange, Satisfaction))

TemplateArgString =

;

diag::err_template_arg_list_constraints_not_satisfied)

<< TemplateArgString << TemplateIDRange;

(TemplateAC.empty()) {

std::optional<MultiLevelTemplateArgumentList> MLTAL =

SetupConstraintCheckingTemplateArgumentsAndScope(

, TemplateArgs,

(

*Method = dyn_cast<CXXMethodDecl>(

)) {

ThisQuals = Method->getMethodQualifiers();

= Method->getParent();

PointOfInstantiation, Satisfaction);

&&

);

llvm_unreachable(

);

(!SubstDiag->DiagMessage.empty())

S.

(SubstDiag->DiagLoc,

diag::note_expr_requirement_expr_substitution_error)

<< (

)

<< SubstDiag->SubstitutedEntity

<< SubstDiag->DiagMessage;

S.

(SubstDiag->DiagLoc,

diag::note_expr_requirement_expr_unknown_substitution_error)

<< (

)

<< SubstDiag->SubstitutedEntity;

diag::note_expr_requirement_noexcept_not_met)

(!SubstDiag->DiagMessage.empty())

S.

(SubstDiag->DiagLoc,

diag::note_expr_requirement_type_requirement_substitution_error)

<< (

)

<< SubstDiag->SubstitutedEntity

<< SubstDiag->DiagMessage;

S.

(SubstDiag->DiagLoc,

diag::note_expr_requirement_type_requirement_unknown_substitution_error)

<< (

)

<< SubstDiag->SubstitutedEntity;

diag::note_expr_requirement_constraints_not_satisfied_simple)

diag::note_expr_requirement_constraints_not_satisfied)

<< (

)

<< ConstraintExpr;

llvm_unreachable(

);

&&

);

llvm_unreachable(

);

(!SubstDiag->DiagMessage.empty())

S.

(SubstDiag->DiagLoc,

diag::note_type_requirement_substitution_error) << (

)

<< SubstDiag->SubstitutedEntity << SubstDiag->DiagMessage;

S.

(SubstDiag->DiagLoc,

diag::note_type_requirement_unknown_substitution_error)

<< (

)

<< SubstDiag->SubstitutedEntity;

llvm_unreachable(

);

=

);

SubstitutionDiagnostic = std::pair<SourceLocation, StringRef>;

(

*SubstDiag =

.dyn_cast<SubstitutionDiagnostic *>())

S.

(SubstDiag->first, diag::note_nested_requirement_substitution_error)

<< SubstDiag->second;

(BO->getOpcode()) {

BO->getLHS()->EvaluateKnownConstInt(S.

).getBoolValue();

BO->getRHS()->EvaluateKnownConstInt(S.

).getBoolValue();

(BO->getLHS()->getType()->isIntegerType() &&

BO->getRHS()->getType()->isIntegerType()) {

BO->getLHS()->EvaluateAsInt(SimplifiedLHS, S.

,

BO->getRHS()->EvaluateAsInt(SimplifiedRHS, S.

,

(!SimplifiedLHS.

&& ! SimplifiedRHS.

) {

diag::note_atomic_constraint_evaluated_to_false_elaborated)

}

(

*CSE = dyn_cast<ConceptSpecializationExpr>(SubstExpr)) {

(CSE->getTemplateArgsAsWritten()->NumTemplateArgs == 1) {

CSE->getSourceRange().getBegin(),

note_single_arg_concept_specialization_constraint_evaluated_to_false)

<< CSE->getTemplateArgsAsWritten()->arguments()[0].getArgument()

<< CSE->getNamedConcept();

diag::note_concept_specialization_constraint_evaluated_to_false)

<< (

)

<< CSE;

}

(

*RE = dyn_cast<RequiresExpr>(SubstExpr)) {

(!Req->isDependent() && !Req->isSatisfied()) {

(

*

= dyn_cast<concepts::ExprRequirement>(Req))

(

*

= dyn_cast<concepts::TypeRequirement>(Req))

S, cast<concepts::NestedRequirement>(Req),

);

}

(

*TTE = dyn_cast<TypeTraitExpr>(SubstExpr);

TTE && TTE->getTrait() == clang::TypeTrait::BTT_IsDeducible) {

assert(TTE->getNumArgs() == 2);

diag::note_is_deducible_constraint_evaluated_to_false)

<< TTE->getArg(0)->getType() << TTE->getArg(1)->getType();

diag::note_atomic_constraint_evaluated_to_false)

<

SubstitutionDiagnostic>

&S,

llvm::PointerUnion<Expr *, SubstitutionDiagnostic *> &

,

=

) {

(

*

=

.template dyn_cast<SubstitutionDiagnostic *>()) {

S.

(

->first, diag::note_substituted_constraint_expr_is_ill_formed)

);

);

(

&

: Satisfaction) {

CacheEntry = NormalizationCache.find(ConstrainedDecl);

(CacheEntry == NormalizationCache.end()) {

NormalizedConstraint::fromConstraintExprs(*

, ConstrainedDecl,

AssociatedConstraints);

.try_emplace(ConstrainedDecl,

std::move(*Normalized))

CacheEntry->second;

AssociatedConstraints);

(!

.ParameterMapping) {

llvm::SmallBitVector OccurringIndices(TemplateParams->

());

0, OccurringIndices);

(

I = 0, J = 0,

= TemplateParams->

(); I !=

; ++I)

(OccurringIndices[I])

(&(TempArgs)[J++])

TemplateParams->

()[I],

? ArgsAsWritten->

()[I].getLocation()

.ParameterMapping.emplace(TempArgs, OccurringIndices.count());

: ArgsAsWritten->

().front().getSourceRange().getBegin();

: ArgsAsWritten->

().front().getSourceRange().getEnd();

.ConstraintDecl, {InstLocBegin, InstLocEnd});

(Inst.isInvalid())

.ParameterMapping.emplace(TempArgs, SubstArgs.

());

(

.isAtomic()) {

}

(

.isFoldExpanded()) {

.getFoldExpandedConstraint()->Kind,

.getFoldExpandedConstraint()->Pattern);

.getCompoundKind());

assert(

() &&

);

cast<CompoundConstraint>(

).getPointer()->LHS;

assert(

() &&

);

cast<CompoundConstraint>(

).getPointer()->RHS;

std::optional<NormalizedConstraint>

NormalizedConstraint::fromConstraintExprs(

&S,

*

,

assert(

.size() != 0);

Conjunction = fromConstraintExpr(S,

,

[0]);

std::nullopt;

(

I = 1; I <

.size(); ++I) {

Next = fromConstraintExpr(S,

,

[I]);

std::nullopt;

std::optional<NormalizedConstraint>

assert(

!=

);

(LogicalBinOp BO =

) {

LHS = fromConstraintExpr(S,

, BO.getLHS());

std::nullopt;

RHS = fromConstraintExpr(S,

, BO.getRHS());

std::nullopt;

}

(

*CSE = dyn_cast<const ConceptSpecializationExpr>(

)) {

S, CSE->getExprLoc(),

(Inst.isInvalid())

std::nullopt;

std::nullopt;

std::optional<NormalizedConstraint> New;

New.emplace(S.

, *SubNF);

std::nullopt;

}

(

*FE = dyn_cast<const CXXFoldExpr>(

);

(FE->getOperator() == BinaryOperatorKind::BO_LAnd ||

FE->getOperator() == BinaryOperatorKind::BO_LOr)) {

FE->getOperator() == BinaryOperatorKind::BO_LAnd

(FE->getInit()) {

LHS = fromConstraintExpr(S,

, FE->getLHS());

RHS = fromConstraintExpr(S,

, FE->getRHS());

std::nullopt;

(FE->isRightFold())

, std::move(*RHS), FE->getPattern()}};

, std::move(*LHS), FE->getPattern()}};

S.

, std::move(*LHS), std::move(*RHS),

= fromConstraintExpr(S,

, FE->getPattern());

std::nullopt;

, std::move(*Sub), FE->getPattern()}};

(it != BPacks.end())

LCNF.reserve(LCNF.size() + RCNF.size());

(!RCNF.empty())

LCNF.push_back(RCNF.pop_back_val());

Res.reserve(LCNF.size() * RCNF.size());

(

&LDisjunction : LCNF)

(

&RDisjunction : RCNF) {

NormalForm::value_type Combined;

Combined.reserve(LDisjunction.size() + RDisjunction.size());

std::copy(LDisjunction.begin(), LDisjunction.end(),

std::back_inserter(Combined));

std::copy(RDisjunction.begin(), RDisjunction.end(),

std::back_inserter(Combined));

Res.emplace_back(Combined);

LDNF.reserve(LDNF.size() + RDNF.size());

(!RDNF.empty())

LDNF.push_back(RDNF.pop_back_val());

Res.reserve(LDNF.size() * RDNF.size());

(

&LConjunction : LDNF) {

(

&RConjunction : RDNF) {

NormalForm::value_type Combined;

Combined.reserve(LConjunction.size() + RConjunction.size());

std::copy(LConjunction.begin(), LConjunction.end(),

std::back_inserter(Combined));

std::copy(RConjunction.begin(), RConjunction.end(),

std::back_inserter(Combined));

Res.emplace_back(Combined);

(

*FD1 = dyn_cast<FunctionDecl>(D1)) {

*FD2 = dyn_cast<FunctionDecl>(D2);

(void)IsExpectedEntity;

assert(IsExpectedEntity(FD1) && FD2 && IsExpectedEntity(FD2) &&

std::pair<NamedDecl *, NamedDecl *> Key{D1, D2};

CacheEntry = SubsumptionCache.find(Key);

(CacheEntry != SubsumptionCache.end()) {

= CacheEntry->second;

(

I = 0; I != AC1.size() && I != AC2.size(); ++I) {

(Depth2 > Depth1) {

AC1[I] = AdjustConstraintDepth(*

, Depth2 - Depth1)

.TransformExpr(

*

(AC1[I]))

}

(Depth1 > Depth2) {

AC2[I] = AdjustConstraintDepth(*

, Depth1 - Depth2)

.TransformExpr(

*

(AC2[I]))

*

, D1, AC1, D2, AC2,

,

SubsumptionCache.try_emplace(Key,

);

(AC1.empty() || AC2.empty())

NormalExprEvaluator =

*AmbiguousAtomic1 =

, *AmbiguousAtomic2 =

;

IdenticalExprEvaluator =

llvm::FoldingSetNodeID IDA, IDB;

EB->Profile(IDB,

,

);

AmbiguousAtomic1 = EA;

AmbiguousAtomic2 = EB;

Is1AtLeastAs2Normally =

Is2AtLeastAs1Normally =

Is1AtLeastAs2 =

(DNF1, CNF2, IdenticalExprEvaluator);

Is2AtLeastAs1 =

(DNF2, CNF1, IdenticalExprEvaluator);

(Is1AtLeastAs2 == Is1AtLeastAs2Normally &&

Is2AtLeastAs1 == Is2AtLeastAs1Normally)

assert(AmbiguousAtomic1 && AmbiguousAtomic2);

(AmbiguousAtomic1->

(), diag::note_ambiguous_atomic_constraints)

(AmbiguousAtomic2->getBeginLoc(),

diag::note_ambiguous_atomic_constraints_similar_expression)

<< AmbiguousAtomic2->getSourceRange();

(IsSimple ? RK_Simple : RK_Compound, Status == SS_Dependent,

Status == SS_Dependent &&

(

->containsUnexpandedParameterPack() ||

Req.containsUnexpandedParameterPack()),

Status == SS_Satisfied),

(

), NoexceptLoc(NoexceptLoc),

TypeReq(Req), SubstitutedConstraintExpr(SubstitutedConstraintExpr),

);

(SubstitutedConstraintExpr !=

));

(IsSimple ? RK_Simple : RK_Compound, Req.isDependent(),

Req.containsUnexpandedParameterPack(),

),

(ExprSubstDiag), NoexceptLoc(NoexceptLoc), TypeReq(Req),

Status(SS_ExprSubstitutionFailure) {

);

TypeConstraintInfo(TPL,

) {

assert(TPL->

() == 1);

cast<TemplateTypeParmDecl>(TPL->

(0))->getTypeConstraint();

);

Constraint->getTemplateArgsAsWritten() &&

Constraint->getTemplateArgsAsWritten()->arguments().drop_front(1));

TypeConstraintInfo.setInt(

?

:

);

Status(

->getType()->isInstantiationDependentType() ?

assert(isCompound() &&

);

cast<CompoundConstraint>(Constraint).getInt();

assert(isAtomic() &&

);

cast<AtomicConstraint *>(Constraint);

assert(isFoldExpanded() &&

);

cast<FoldExpandedConstraint *>(Constraint);

This file provides some common utility functions for processing Lambda related AST Constructs.

Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....

Defines Expressions and AST nodes for C++2a concepts.

static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)

Produce a diagnostic highlighting some portion of a literal.

llvm::MachO::Record Record

Defines and computes precedence levels for binary/ternary operators.

static std::string toString(const clang::SanitizerSet &Sanitizers)

Produce a string containing comma-separated names of sanitizers in Sanitizers set.

static bool CheckConstraintSatisfaction(Sema &S, const NamedDecl *Template, ArrayRef< const Expr * > ConstraintExprs, llvm::SmallVectorImpl< Expr * > &Converted, const MultiLevelTemplateArgumentList &TemplateArgsLists, SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction)

static const Expr * SubstituteConstraintExpressionWithoutSatisfaction(Sema &S, const Sema::TemplateCompareNewDeclInfo &DeclInfo, const Expr *ConstrExpr)

static ExprResult calculateConstraintSatisfaction(Sema &S, const Expr *ConstraintExpr, ConstraintSatisfaction &Satisfaction, const ConstraintEvaluator &Evaluator)

static bool DiagRecursiveConstraintEval(Sema &S, llvm::FoldingSetNodeID &ID, const NamedDecl *Templ, const Expr *E, const MultiLevelTemplateArgumentList &MLTAL)

static void diagnoseWellFormedUnsatisfiedConstraintExpr(Sema &S, Expr *SubstExpr, bool First=true)

static void diagnoseUnsatisfiedRequirement(Sema &S, concepts::ExprRequirement *Req, bool First)

static bool substituteParameterMappings(Sema &S, NormalizedConstraint &N, ConceptDecl *Concept, const MultiLevelTemplateArgumentList &MLTAL, const ASTTemplateArgumentListInfo *ArgsAsWritten)

static void diagnoseUnsatisfiedConstraintExpr(Sema &S, const llvm::PointerUnion< Expr *, SubstitutionDiagnostic * > &Record, bool First=true)

static unsigned CalculateTemplateDepthForConstraints(Sema &S, const NamedDecl *ND, bool SkipForSpecialization=false)

static bool isInvalid(LocType Loc, bool *Invalid)

__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

QualType getReferenceQualifiedType(const Expr *e) const

getReferenceQualifiedType - Given an expr, will return the type for that expression,...

bool hasSameUnqualifiedType(QualType T1, QualType T2) const

Determine whether the given types are equivalent after cvr-qualifiers have been removed.

AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load,...

SourceLocation getBeginLoc() const LLVM_READONLY

A builtin binary operation expression such as "x + y" or "x <= y".

static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)

Retrieve the overloaded operator kind that corresponds to the given binary opcode.

StringRef getOpcodeStr() const

static BinaryOperator * Create(const ASTContext &C, Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy, ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc, FPOptionsOverride FPFeatures)

static Opcode getOverloadedOpcode(OverloadedOperatorKind OO)

Retrieve the binary opcode that corresponds to the given overloaded operator.

Represents a C++ conversion function within a class.

Represents a folding of a pack over an operator.

SourceLocation getBeginLoc() const LLVM_READONLY

Expr * getInit() const

Get the operand that doesn't contain a pack, for a binary fold.

std::optional< unsigned > getNumExpansions() const

SourceLocation getEllipsisLoc() const

bool isLeftFold() const

Does this produce a left-associated sequence of operators?

bool isRightFold() const

Does this produce a right-associated sequence of operators?

Expr * getPattern() const

Get the pattern, that is, the operand that contains an unexpanded pack.

BinaryOperatorKind getOperator() const

Represents a C++ struct/union/class.

Declaration of a C++20 concept.

Expr * getConstraintExpr() const

Represents the specialization of a concept - evaluates to a prvalue of type bool.

SourceLocation getBeginLoc() const LLVM_READONLY

ArrayRef< TemplateArgument > getTemplateArguments() const

const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const

const ASTConstraintSatisfaction & getSatisfaction() const

Get elaborated satisfaction info about the template arguments' satisfaction of the named concept.

ConceptDecl * getNamedConcept() const

The result of a constraint satisfaction check, containing the necessary information to diagnose an un...

std::pair< SourceLocation, StringRef > SubstitutionDiagnostic

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &C)

llvm::SmallVector< Detail, 4 > Details

The substituted constraint expr, if the template arguments could be substituted into them,...

DeclContext - This is used only as base class of specific decl types that can act as declaration cont...

DeclContext * getParent()

getParent - Returns the containing DeclContext.

bool isTransparentContext() const

isTransparentContext - Determines whether this context is a "transparent" context,...

bool isDependentContext() const

Determines whether this context is dependent on a template parameter.

DeclContext * getNonTransparentContext()

Decl - This represents one declaration (or definition), e.g.

FriendObjectKind getFriendObjectKind() const

Determines whether this declaration is the object of a friend declaration and, if so,...

bool isFunctionOrFunctionTemplate() const

Whether this declaration is a function or function template.

FunctionDecl * getAsFunction() LLVM_READONLY

Returns the function itself, or the templated function if this is a function template.

bool isInvalidDecl() const

SourceLocation getLocation() const

DeclContext * getLexicalDeclContext()

getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).

virtual Decl * getCanonicalDecl()

Retrieves the "canonical" declaration of the given declaration.

virtual SourceRange getSourceRange() const LLVM_READONLY

Source range that this declaration covers.

Expr * getTrailingRequiresClause()

Get the constraint-expression introduced by the trailing requires-clause in the function/member decla...

RAII object that enters a new expression evaluation context.

This represents one expression.

@ SE_NoSideEffects

Strictly evaluate the expression.

bool isTypeDependent() const

Determines whether the type of this expression depends on.

Expr * IgnoreParenImpCasts() LLVM_READONLY

Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...

bool containsErrors() const

Whether this expression contains subexpressions which had errors, e.g.

bool EvaluateAsConstantExpr(EvalResult &Result, const ASTContext &Ctx, ConstantExprKind Kind=ConstantExprKind::Normal) const

Evaluate an expression that is required to be a constant expression.

SourceLocation getExprLoc() const LLVM_READONLY

getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...

Represents difference between two FPOptions values.

Represents a function declaration or definition.

FunctionTemplateDecl * getDescribedFunctionTemplate() const

Retrieves the function template that is described by this function declaration.

SourceLocation getPointOfInstantiation() const

Retrieve the (first) point of instantiation of a function template specialization or a member of a cl...

ArrayRef< ParmVarDecl * > parameters() const

FunctionTemplateDecl * getPrimaryTemplate() const

Retrieve the primary template that this function template specialization either specializes or was in...

const TemplateArgumentList * getTemplateSpecializationArgs() const

Retrieve the template arguments used to produce this function template specialization from the primar...

bool isTemplateInstantiation() const

Determines if the given function was instantiated from a function template.

TemplatedKind

The kind of templated function a FunctionDecl can be.

@ TK_MemberSpecialization

@ TK_DependentNonTemplate

@ TK_FunctionTemplateSpecialization

TemplatedKind getTemplatedKind() const

What kind of templated function this is.

FunctionDecl * getInstantiatedFromDecl() const

FunctionDecl * getInstantiatedFromMemberFunction() const

If this function is an instantiation of a member function of a class template specialization,...

Declaration of a template function.

FunctionDecl * getTemplatedDecl() const

Get the underlying function declaration of the template.

FunctionTemplateDecl * getInstantiatedFromMemberTemplate() const

static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat, FPOptionsOverride FPO)

const TypeClass * getTypePtr() const

Describes the capture of a variable or of this, or of a C++1y init-capture.

A stack-allocated class that identifies which local variable declaration instantiations are present i...

Data structure that captures multiple levels of template argument lists for use in template instantia...

const ArgList & getInnermost() const

Retrieve the innermost template argument list.

unsigned getNumLevels() const

Determine the number of levels in this template argument list.

unsigned getNumSubstitutedLevels() const

Determine the number of substituted levels in this template argument list.

const ArgList & getOutermost() const

Retrieve the outermost template argument list.

bool isAnyArgInstantiationDependent() const

This represents a decl that may have a name.

void EmitToString(DiagnosticsEngine &Diags, SmallVectorImpl< char > &Buf) const

A (possibly-)qualified type.

The collection of all-type qualifiers we support.

Scope - A scope is a transient data structure that is used while parsing the program.

SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)

Emit a diagnostic.

PartialDiagnostic PDiag(unsigned DiagID=0)

Build a partial diagnostic.

RAII object used to change the argument pack substitution index within a Sema object.

RAII object used to temporarily allow the C++ 'this' expression to be used, with the given qualifiers...

RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...

bool hasErrorOccurred() const

Determine whether any SFINAE errors have been trapped.

SourceLocation getLocation() const

bool ContainsDecl(const NamedDecl *ND) const

const DeclContext * getDeclContext() const

const NamedDecl * getDecl() const

const DeclContext * getLexicalDeclContext() const

Sema - This implements semantic analysis and AST building for C.

bool CheckInstantiatedFunctionTemplateConstraints(SourceLocation PointOfInstantiation, FunctionDecl *Decl, ArrayRef< TemplateArgument > TemplateArgs, ConstraintSatisfaction &Satisfaction)

bool CheckParameterPacksForExpansion(SourceLocation EllipsisLoc, SourceRange PatternRange, ArrayRef< UnexpandedParameterPack > Unexpanded, const MultiLevelTemplateArgumentList &TemplateArgs, bool &ShouldExpand, bool &RetainExpansion, std::optional< unsigned > &NumExpansions)

Determine whether we could expand a pack expansion with the given set of parameter packs into separat...

bool ConstraintExpressionDependsOnEnclosingTemplate(const FunctionDecl *Friend, unsigned TemplateDepth, const Expr *Constraint)

DiagnosticsEngine & getDiagnostics() const

ExprResult SubstConstraintExprWithoutSatisfaction(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs)

bool CheckConstraintExpression(const Expr *CE, Token NextToken=Token(), bool *PossibleNonPrimary=nullptr, bool IsTrailingRequiresClause=false)

Check whether the given expression is a valid constraint expression.

bool SubstTemplateArguments(ArrayRef< TemplateArgumentLoc > Args, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateArgumentListInfo &Outputs)

std::optional< unsigned > getNumArgumentsInExpansionFromUnexpanded(llvm::ArrayRef< UnexpandedParameterPack > Unexpanded, const MultiLevelTemplateArgumentList &TemplateArgs)

bool FriendConstraintsDependOnEnclosingTemplate(const FunctionDecl *FD)

bool EnsureTemplateArgumentListConstraints(TemplateDecl *Template, const MultiLevelTemplateArgumentList &TemplateArgs, SourceRange TemplateIDRange)

Ensure that the given template arguments satisfy the constraints associated with the given template,...

const LangOptions & getLangOpts() const

void collectUnexpandedParameterPacks(TemplateArgument Arg, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)

Collect the set of unexpanded parameter packs within the given template argument.

bool CheckConstraintSatisfaction(const NamedDecl *Template, ArrayRef< const Expr * > ConstraintExprs, const MultiLevelTemplateArgumentList &TemplateArgLists, SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction)

Check whether the given list of constraint expressions are satisfied (as if in a 'conjunction') given...

bool AreConstraintExpressionsEqual(const NamedDecl *Old, const Expr *OldConstr, const TemplateCompareNewDeclInfo &New, const Expr *NewConstr)

sema::FunctionScopeInfo * getCurFunction() const

std::optional< sema::TemplateDeductionInfo * > isSFINAEContext() const

Determines whether we are currently in a context where template argument substitution failures are no...

bool MaybeEmitAmbiguousAtomicConstraintsDiagnostic(NamedDecl *D1, ArrayRef< const Expr * > AC1, NamedDecl *D2, ArrayRef< const Expr * > AC2)

If D1 was not at least as constrained as D2, but would've been if a pair of atomic constraints involv...

MultiLevelTemplateArgumentList getTemplateInstantiationArgs(const NamedDecl *D, const DeclContext *DC=nullptr, bool Final=false, std::optional< ArrayRef< TemplateArgument > > Innermost=std::nullopt, bool RelativeToPrimary=false, const FunctionDecl *Pattern=nullptr, bool ForConstraintInstantiation=false, bool SkipForSpecialization=false, bool ForDefaultArgumentSubstitution=false)

Retrieve the template argument list(s) that should be used to instantiate the definition of the given...

ExprResult PerformContextuallyConvertToBool(Expr *From)

PerformContextuallyConvertToBool - Perform a contextual conversion of the expression From to bool (C+...

bool CheckFunctionConstraints(const FunctionDecl *FD, ConstraintSatisfaction &Satisfaction, SourceLocation UsageLoc=SourceLocation(), bool ForOverloadResolution=false)

Check whether the given function decl's trailing requires clause is satisfied, if any.

TemplateNameKindForDiagnostics getTemplateNameKindForDiagnostics(TemplateName Name)

bool IsAtLeastAsConstrained(NamedDecl *D1, MutableArrayRef< const Expr * > AC1, NamedDecl *D2, MutableArrayRef< const Expr * > AC2, bool &Result)

Check whether the given declaration's associated constraints are at least as constrained than another...

void PushSatisfactionStackEntry(const NamedDecl *D, const llvm::FoldingSetNodeID &ID)

void PopSatisfactionStackEntry()

ExprResult SubstConstraintExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs)

void MarkUsedTemplateParameters(const Expr *E, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used)

Mark which template parameters are used in a given expression.

@ ConstantEvaluated

The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...

@ Unevaluated

The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7),...

bool SatisfactionStackContains(const NamedDecl *D, const llvm::FoldingSetNodeID &ID) const

ExprResult BuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc, BinaryOperatorKind Operator)

TemplateArgumentLoc getIdentityTemplateArgumentLoc(NamedDecl *Param, SourceLocation Location)

Get a template argument mapping the given template parameter to itself, e.g.

std::string getTemplateArgumentBindingsText(const TemplateParameterList *Params, const TemplateArgumentList &Args)

Produces a formatted string that describes the binding of template parameters to template arguments.

void DiagnoseUnsatisfiedConstraint(const ConstraintSatisfaction &Satisfaction, bool First=true)

Emit diagnostics explaining why a constraint expression was deemed unsatisfied.

const NormalizedConstraint * getNormalizedAssociatedConstraints(NamedDecl *ConstrainedDecl, ArrayRef< const Expr * > AssociatedConstraints)

Encodes a location in the source.

bool isValid() const

Return true if this is a valid SourceLocation object.

A trivial tuple used to represent a source range.

SourceLocation getBegin() const

SourceRange getSourceRange() const LLVM_READONLY

SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, bool Canonical, bool ProfileLambdaExpr=false) const

Produce a unique representation of the given statement.

SourceLocation getBeginLoc() const LLVM_READONLY

A convenient class for passing around template argument information.

llvm::ArrayRef< TemplateArgumentLoc > arguments() const

Location wrapper for a TemplateArgument.

The base class of all kinds of template declarations (e.g., class, function, etc.).

void getAssociatedConstraints(llvm::SmallVectorImpl< const Expr * > &AC) const

Get the total constraint-expression associated with this template, including constraint-expressions d...

TemplateParameterList * getTemplateParameters() const

Get the list of template parameters.

Represents a C++ template name within the type system.

Stores a list of template parameters for a TemplateDecl and its derived classes.

NamedDecl * getParam(unsigned Idx)

static bool anyInstantiationDependentTemplateArguments(ArrayRef< TemplateArgumentLoc > Args)

Declaration of a template type parameter.

Wrapper for template type parameters.

Token - This structure provides full information about a lexed token.

bool is(tok::TokenKind K) const

is/isNot - Predicates to check if this token is a specific kind, as in "if (Tok.is(tok::l_brace)) {....

tok::TokenKind getKind() const

A semantic tree transformation that allows one to transform one abstract syntax tree into another.

Models the abbreviated syntax to constrain a template type parameter: template <convertible_to<string...

Expr * getImmediatelyDeclaredConstraint() const

Get the immediately-declared constraint expression introduced by this type-constraint,...

TyLocType push(QualType T)

Pushes space for a new TypeLoc of the given type.

A container of type source information.

SourceLocation getNameLoc() const

void setNameLoc(SourceLocation Loc)

The base class of the type hierarchy.

bool isSpecificBuiltinType(unsigned K) const

Test for a particular builtin type.

bool isDependentType() const

Whether this type is a dependent type, meaning that its definition somehow depends on a template para...

bool isFunctionType() const

Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...

bool isParameterPack() const

Determine whether this value is actually a function parameter pack, init-capture pack,...

bool isInitCapture() const

Whether this variable is the implicit variable for a lambda init-capture.

ReturnTypeRequirement()

No return type requirement was specified.

bool isTypeConstraint() const

SubstitutionDiagnostic * getSubstitutionDiagnostic() const

A requires-expression requirement which queries the validity and properties of an expression ('simple...

SubstitutionDiagnostic * getExprSubstitutionDiagnostic() const

ConceptSpecializationExpr * getReturnTypeRequirementSubstitutedConstraintExpr() const

@ SS_ConstraintsNotSatisfied

@ SS_TypeRequirementSubstitutionFailure

@ SS_ExprSubstitutionFailure

const ReturnTypeRequirement & getReturnTypeRequirement() const

SatisfactionStatus getSatisfactionStatus() const

SourceLocation getNoexceptLoc() const

ExprRequirement(Expr *E, bool IsSimple, SourceLocation NoexceptLoc, ReturnTypeRequirement Req, SatisfactionStatus Status, ConceptSpecializationExpr *SubstitutedConstraintExpr=nullptr)

Construct a compound requirement.

A requires-expression requirement which is satisfied when a general constraint expression is satisfie...

const ASTConstraintSatisfaction & getConstraintSatisfaction() const

StringRef getInvalidConstraintEntity()

A static requirement that can be used in a requires-expression to check properties of types and expre...

bool containsUnexpandedParameterPack() const

A requires-expression requirement which queries the existence of a type name or type template special...

SubstitutionDiagnostic * getSubstitutionDiagnostic() const

SatisfactionStatus getSatisfactionStatus() const

TypeRequirement(TypeSourceInfo *T)

Construct a type requirement from a type.

Provides information about an attempted template argument deduction, whose success or failure was des...

void takeSFINAEDiagnostic(PartialDiagnosticAt &PD)

Take ownership of the SFINAE diagnostic.

bool Sub(InterpState &S, CodePtr OpPC)

The JSON file list parser is used to communicate input to InstallAPI.

OverloadedOperatorKind

Enumeration specifying the different kinds of C++ overloaded operators.

@ OO_None

Not an overloaded operator.

NormalForm makeCNF(const NormalizedConstraint &Normalized)

NormalForm makeDNF(const NormalizedConstraint &Normalized)

@ OK_Ordinary

An ordinary object is located at an address in memory.

bool subsumes(const NormalForm &PDNF, const NormalForm &QCNF, const AtomicSubsumptionEvaluator &E)

std::pair< llvm::PointerUnion< const TemplateTypeParmType *, NamedDecl *, ResolvedUnexpandedPackExpr * >, SourceLocation > UnexpandedParameterPack

bool isLambdaCallOperator(const CXXMethodDecl *MD)

@ Result

The result type of a method or function.

std::pair< unsigned, unsigned > getDepthAndIndex(const NamedDecl *ND)

Retrieve the depth and index of a template parameter.

const NormalizedConstraint * getNormalizedAssociatedConstraints(Sema &S, NamedDecl *ConstrainedDecl, ArrayRef< const Expr * > AssociatedConstraints)

prec::Level getBinOpPrecedence(tok::TokenKind Kind, bool GreaterThanIsOperator, bool CPlusPlus11)

Return the precedence of the specified binary operator token.

bool isLambdaConversionOperator(CXXConversionDecl *C)

@ VK_PRValue

A pr-value expression (in the C++11 taxonomy) produces a temporary value.

const FunctionProtoType * T

std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt

A partial diagnostic along with the source location where this diagnostic occurs.

@ Other

Other implicit parameter.

The result of a constraint satisfaction check, containing the necessary information to diagnose an un...

Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".

SourceLocation getLAngleLoc() const

llvm::ArrayRef< TemplateArgumentLoc > arguments() const

unsigned NumTemplateArgs

The number of template arguments in TemplateArgs.

SourceLocation getRAngleLoc() const

bool subsumes(ASTContext &C, const AtomicConstraint &Other) const

bool hasMatchingParameterMapping(ASTContext &C, const AtomicConstraint &Other) const

const Expr * ConstraintExpr

EvalResult is a struct with detailed info about an evaluated expression.

APValue Val

Val - This is the value the expression can be folded to.

SmallVectorImpl< PartialDiagnosticAt > * Diag

Diag - If this is non-null, it will be filled in with a stack of notes indicating why evaluation fail...

NormalizedConstraint Constraint

static bool AreCompatibleForSubsumption(const FoldExpandedConstraint &A, const FoldExpandedConstraint &B)

A normalized constraint, as defined in C++ [temp.constr.normal], is either an atomic constraint,...

llvm::PointerUnion< AtomicConstraint *, FoldExpandedConstraint *, CompoundConstraint > Constraint

bool isFoldExpanded() const

NormalizedConstraint & getRHS() const

llvm::PointerIntPair< NormalizedConstraintPair *, 1, CompoundConstraintKind > CompoundConstraint

CompoundConstraintKind getCompoundKind() const

NormalizedConstraint(AtomicConstraint *C)

AtomicConstraint * getAtomicConstraint() const

FoldExpandedConstraint * getFoldExpandedConstraint() const

NormalizedConstraint & getLHS() const

A stack object to be created when performing template instantiation.

bool isInvalid() const

Determines whether we have exceeded the maximum recursive template instantiations.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4