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

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

clang: lib/Sema/SemaExceptionSpec.cpp Source File

*RD = dyn_cast<CXXRecordDecl>(

);

(!RD || !RD->getIdentifier() || !RD->getDescribedClassTemplate() ||

!

.getIdentifier() || !

.getIdentifier()->isStr(

))

*ND = dyn_cast<NamespaceDecl>(RD->getDeclContext());

IsInStd = ND->isStdNamespace();

(!II || !(II->

(

) || II->

(

)) ||

!ND->isInStdNamespace())

llvm::StringSwitch<bool>(RD->getIdentifier()->getName())

.Case(

,

)

.Case(

, IsInStd)

.Case(

, IsInStd)

.Case(

, IsInStd)

.Case(

, IsInStd)

*BoolExpr =

(

)

llvm::APSInt

{1};

(RT->isRValueReferenceType()) {

(

.getBegin(), diag::err_rref_in_exception_spec)

DiagID = diag::err_incomplete_in_exception_spec;

ReturnValueOnError =

;

DiagID = diag::ext_incomplete_in_exception_spec;

ReturnValueOnError =

;

ReturnValueOnError;

(

.getBegin(), diag::err_wasm_reftype_exception_spec);

(

.getBegin(), diag::err_sizeless_in_exception_spec)

<< (

== 2 ? 1 : 0) << PointeeT <<

;

(

, diag::err_exception_spec_not_parsed);

(

, diag::err_exception_spec_not_parsed);

Listener->ResolvedExceptionSpec(FD);

DC->

() && cast<RecordDecl>(DC)->isBeingDefined();

Sema &S,

PartialDiagnostic &DiagID,

PartialDiagnostic &NoteID,

FunctionProtoType *Old, SourceLocation OldLoc,

FunctionProtoType *New, SourceLocation NewLoc,

*MissingExceptionSpecification =

,

*MissingEmptyExceptionSpecification =

,

AllowNoexceptAllMatchWithNoSpec =

,

IsOperatorNew =

);

(!isa<CXXDestructorDecl>(

) &&

->getDeclName().getCXXOverloadedOperator() != OO_Delete &&

->getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)

(!

->getTypeSourceInfo())

isa<CXXDestructorDecl>(

);

IsOperatorNew = OO == OO_New || OO == OO_Array_New;

MissingExceptionSpecification =

;

MissingEmptyExceptionSpecification =

;

DiagID = diag::err_mismatched_exception_spec;

ReturnValueOnError =

;

DiagID = diag::ext_mismatched_exception_spec;

ReturnValueOnError =

;

*

,

(DiagID),

(diag::note_previous_declaration),

&MissingExceptionSpecification, &MissingEmptyExceptionSpecification,

, IsOperatorNew)) {

(New->

(), diag::ext_implicit_exception_spec_mismatch)

(!MissingExceptionSpecification)

ReturnValueOnError;

(MissingEmptyExceptionSpecification &&

NewProto->getReturnType(), NewProto->getParamTypes(),

NewProto->getReturnType(), NewProto->getParamTypes(),

NewProto->getExtProtoInfo().withExceptionSpec(ESI)));

DiagID = diag::ext_missing_exception_specification;

ReturnValueOnError =

;

DiagID = diag::ext_missing_exception_specification;

ReturnValueOnError =

;

DiagID = diag::ext_missing_exception_specification;

ReturnValueOnError =

;

DiagID = diag::err_missing_exception_specification;

ReturnValueOnError =

;

llvm::raw_svector_ostream

(ExceptionSpecString);

(OldProto->getExceptionSpecType()) {

OnFirstException =

;

(

&

: OldProto->exceptions()) {

(OnFirstException)

OnFirstException =

;

assert(OldProto->getNoexceptExpr() !=

&&

);

<<

;

llvm_unreachable(

);

(!FTLoc.getTypePtr()->hasTrailingReturn())

ReturnValueOnError;

DiagID = diag::err_mismatched_exception_spec;

DiagID = diag::ext_mismatched_exception_spec;

*

,

(DiagID),

(diag::note_previous_declaration),

Old, OldLoc, New, NewLoc);

*MissingExceptionSpecification,

*MissingEmptyExceptionSpecification,

AllowNoexceptAllMatchWithNoSpec,

IsOperatorNew) {

(MissingExceptionSpecification)

*MissingExceptionSpecification =

;

(MissingEmptyExceptionSpecification)

*MissingEmptyExceptionSpecification =

;

);

(!AllowNoexceptAllMatchWithNoSpec &&

llvm::FoldingSetNodeID OldFSN, NewFSN;

(OldFSN == NewFSN)

(OldTypes.count(TypePtr))

NewTypes.insert(TypePtr);

(

&& OldTypes.size() == NewTypes.size())

(S.

().CPlusPlus11 && IsOperatorNew) {

WithExceptions = New;

WithExceptions = Old;

(Name && Name->getName() ==

) {

(ExRecord->isInStdNamespace()) {

(MissingExceptionSpecification && OldEST !=

&&

*MissingExceptionSpecification =

;

(MissingEmptyExceptionSpecification && OldCanThrow ==

) {

*MissingEmptyExceptionSpecification =

;

S.

(NewLoc, DiagID);

S.

(OldLoc, NoteID);

llvm_unreachable(

);

llvm_unreachable(

);

llvm_unreachable(

);

);

SkipSupersetFirstParameter, SuperLoc, Subset,

SkipSubsetFirstParameter, SubLoc);

(SubLoc, NoThrowDiagID);

(SuperLoc, NoteID);

(SubLoc, DiagID);

(SuperLoc, NoteID);

);

SubI = RefTy->getPointeeType();

Contained =

;

(SubLoc, DiagID);

(SuperLoc, NoteID);

SkipSupersetFirstParameter, SuperLoc, Subset,

SkipSupersetFirstParameter, SubLoc);

RetDiag = DiagID;

*

, RetDiag,

(),

assert((

->getNumParams() - (

)SkipTargetFirstParameter) ==

(Source->

() - (

)SkipSourceFirstParameter) &&

);

(

i = 0,

=

->getNumParams(); i !=

; ++i) {

ParamDiag = DiagID;

*

, ParamDiag,

(),

->getParamType(i + (SkipTargetFirstParameter ? 1 : 0)),

TargetLoc, Source->

(SkipSourceFirstParameter ? 1 : 0),

DiagID = diag::err_incompatible_exception_specs;

NestedDiagID = diag::err_deep_exception_specs_differ;

DiagID = diag::warn_incompatible_exception_specs;

NestedDiagID = diag::warn_deep_exception_specs_differ;

DiagID = diag::err_override_exception_spec;

DiagID = diag::ext_override_exception_spec;

(DiagID),

(diag::err_deep_exception_specs_differ),

(diag::note_overridden_virtual_function),

(diag::ext_override_exception_spec),

(

*SubStmt : S->children()) {

(isa_and_nonnull<FunctionDecl>(

) &&

->hasAttr<NoThrowAttr>())

(S.getLangOpts().CPlusPlus17 && isa_and_nonnull<CallExpr>(

)) {

= cast<CallExpr>(

)->getCallee();

=

->IgnoreParenImpCasts();

(

*Op = dyn_cast<BinaryOperator>(

)) {

assert(Op->getOpcode() == BO_PtrMemD || Op->getOpcode() == BO_PtrMemI);

= Op->getRHS()->getType()

= cast<MemberExpr>(

)->getMemberDecl()->getType();

}

(

*VD = dyn_cast_or_null<ValueDecl>(

))

(

.isValid() || (

.isInvalid() &&

))

FT = S.ResolveExceptionSpec(

.isInvalid() ?

->getBeginLoc() :

, FT);

(

*Dtor = RD->getDestructor()) {

(

*DD = dyn_cast<DecompositionDecl>(VD))

(

*B : DD->flat_bindings())

(

*HD = B->getHoldingVar())

(S->getStmtClass()) {

Expr::ConstantExprClass:

(cast<ConstantExpr>(S)->getSubExpr());

Expr::CXXThrowExprClass:

Expr::CXXDynamicCastExprClass: {

*CE = cast<CXXDynamicCastExpr>(S);

(CE->getType()->isVariablyModifiedType())

Expr::CXXTypeidExprClass:

Expr::CallExprClass:

Expr::CXXMemberCallExprClass:

Expr::CXXOperatorCallExprClass:

Expr::UserDefinedLiteralClass: {

*CE = cast<CallExpr>(S);

Expr::CXXConstructExprClass:

Expr::CXXTemporaryObjectExprClass: {

*CE = cast<CXXConstructExpr>(S);

(CE->getType()->isVariablyModifiedType())

Expr::CXXInheritedCtorInitExprClass: {

*ICIE = cast<CXXInheritedCtorInitExpr>(S);

Expr::LambdaExprClass: {

*Lambda = cast<LambdaExpr>(S);

Cap != CapEnd; ++Cap)

Expr::CXXNewExprClass: {

*NE = cast<CXXNewExpr>(S);

(NE->isTypeDependent())

Expr::CXXDeleteExprClass: {

*DE = cast<CXXDeleteExpr>(S);

DTy = DE->getDestroyedType();

*OperatorDelete = DE->getOperatorDelete();

Expr::CXXBindTemporaryExprClass: {

*BTE = cast<CXXBindTemporaryExpr>(S);

(*

, BTE, BTE->getTemporary()->getDestructor());

Expr::PseudoObjectExprClass: {

*POE = cast<PseudoObjectExpr>(S);

(

*

: POE->semantics()) {

Expr::ObjCMessageExprClass:

Expr::ObjCPropertyRefExprClass:

Expr::ObjCSubscriptRefExprClass:

Expr::ObjCArrayLiteralClass:

Expr::ObjCDictionaryLiteralClass:

Expr::ObjCBoxedExprClass:

Expr::CoawaitExprClass:

Expr::ConditionalOperatorClass:

Expr::CoyieldExprClass:

Expr::CXXRewrittenBinaryOperatorClass:

Expr::CXXStdInitializerListExprClass:

Expr::DesignatedInitExprClass:

Expr::DesignatedInitUpdateExprClass:

Expr::ExprWithCleanupsClass:

Expr::ExtVectorElementExprClass:

Expr::InitListExprClass:

Expr::ArrayInitLoopExprClass:

Expr::MemberExprClass:

Expr::ObjCIsaExprClass:

Expr::ObjCIvarRefExprClass:

Expr::ParenExprClass:

Expr::ParenListExprClass:

Expr::ShuffleVectorExprClass:

Expr::StmtExprClass:

Expr::ConvertVectorExprClass:

Expr::VAArgExprClass:

Expr::CXXParenListInitExprClass:

Expr::ResolvedUnexpandedPackExprClass:

Expr::CompoundLiteralExprClass:

Expr::CXXConstCastExprClass:

Expr::CXXAddrspaceCastExprClass:

Expr::CXXReinterpretCastExprClass:

Expr::BuiltinBitCastExprClass:

(cast<Expr>(S)->getType()->isVariablyModifiedType())

Expr::ArraySubscriptExprClass:

Expr::MatrixSubscriptExprClass:

Expr::ArraySectionExprClass:

Expr::OMPArrayShapingExprClass:

Expr::OMPIteratorExprClass:

Expr::BinaryOperatorClass:

Expr::DependentCoawaitExprClass:

Expr::CompoundAssignOperatorClass:

Expr::CStyleCastExprClass:

Expr::CXXStaticCastExprClass:

Expr::CXXFunctionalCastExprClass:

Expr::ImplicitCastExprClass:

Expr::MaterializeTemporaryExprClass:

Expr::UnaryOperatorClass: {

(

*CE = dyn_cast<CastExpr>(S))

(CE->getType()->isVariablyModifiedType())

Expr::CXXDefaultArgExprClass:

(cast<CXXDefaultArgExpr>(S)->getExpr());

Expr::CXXDefaultInitExprClass:

(cast<CXXDefaultInitExpr>(S)->getExpr());

Expr::ChooseExprClass: {

*CE = cast<ChooseExpr>(S);

(CE->isTypeDependent() || CE->isValueDependent())

(CE->getChosenSubExpr());

Expr::GenericSelectionExprClass:

(cast<GenericSelectionExpr>(S)->isResultDependent())

(cast<GenericSelectionExpr>(S)->getResultExpr());

Expr::CXXDependentScopeMemberExprClass:

Expr::CXXUnresolvedConstructExprClass:

Expr::DependentScopeDeclRefExprClass:

Expr::CXXFoldExprClass:

Expr::RecoveryExprClass:

Expr::AsTypeExprClass:

Expr::BinaryConditionalOperatorClass:

Expr::BlockExprClass:

Expr::CUDAKernelCallExprClass:

Expr::DeclRefExprClass:

Expr::ObjCBridgedCastExprClass:

Expr::ObjCIndirectCopyRestoreExprClass:

Expr::ObjCProtocolExprClass:

Expr::ObjCSelectorExprClass:

Expr::ObjCAvailabilityCheckExprClass:

Expr::OffsetOfExprClass:

Expr::PackExpansionExprClass:

Expr::SubstNonTypeTemplateParmExprClass:

Expr::SubstNonTypeTemplateParmPackExprClass:

Expr::FunctionParmPackExprClass:

Expr::UnaryExprOrTypeTraitExprClass:

Expr::UnresolvedLookupExprClass:

Expr::UnresolvedMemberExprClass:

Expr::TypoExprClass:

Expr::AddrLabelExprClass:

Expr::ArrayTypeTraitExprClass:

Expr::AtomicExprClass:

Expr::TypeTraitExprClass:

Expr::CXXBoolLiteralExprClass:

Expr::CXXNoexceptExprClass:

Expr::CXXNullPtrLiteralExprClass:

Expr::CXXPseudoDestructorExprClass:

Expr::CXXScalarValueInitExprClass:

Expr::CXXThisExprClass:

Expr::CXXUuidofExprClass:

Expr::CharacterLiteralClass:

Expr::ExpressionTraitExprClass:

Expr::FloatingLiteralClass:

Expr::GNUNullExprClass:

Expr::ImaginaryLiteralClass:

Expr::ImplicitValueInitExprClass:

Expr::IntegerLiteralClass:

Expr::FixedPointLiteralClass:

Expr::ArrayInitIndexExprClass:

Expr::NoInitExprClass:

Expr::ObjCEncodeExprClass:

Expr::ObjCStringLiteralClass:

Expr::ObjCBoolLiteralExprClass:

Expr::OpaqueValueExprClass:

Expr::PredefinedExprClass:

Expr::SizeOfPackExprClass:

Expr::PackIndexingExprClass:

Expr::StringLiteralClass:

Expr::SourceLocExprClass:

Expr::EmbedExprClass:

Expr::ConceptSpecializationExprClass:

Expr::RequiresExprClass:

Expr::HLSLOutArgExprClass:

Stmt::OpenACCEnterDataConstructClass:

Stmt::OpenACCExitDataConstructClass:

Stmt::OpenACCWaitConstructClass:

Stmt::OpenACCInitConstructClass:

Stmt::OpenACCShutdownConstructClass:

Stmt::OpenACCSetConstructClass:

Stmt::OpenACCUpdateConstructClass:

Expr::MSPropertyRefExprClass:

Expr::MSPropertySubscriptExprClass:

llvm_unreachable(

);

Stmt::OpenACCComputeConstructClass:

Stmt::OpenACCLoopConstructClass:

Stmt::OpenACCCombinedConstructClass:

Stmt::OpenACCDataConstructClass:

Stmt::OpenACCHostDataConstructClass:

Stmt::AttributedStmtClass:

Stmt::BreakStmtClass:

Stmt::CapturedStmtClass:

Stmt::SYCLKernelCallStmtClass:

Stmt::CaseStmtClass:

Stmt::CompoundStmtClass:

Stmt::ContinueStmtClass:

Stmt::CoreturnStmtClass:

Stmt::CoroutineBodyStmtClass:

Stmt::CXXCatchStmtClass:

Stmt::CXXForRangeStmtClass:

Stmt::DefaultStmtClass:

Stmt::DoStmtClass:

Stmt::ForStmtClass:

Stmt::GCCAsmStmtClass:

Stmt::GotoStmtClass:

Stmt::IndirectGotoStmtClass:

Stmt::LabelStmtClass:

Stmt::MSAsmStmtClass:

Stmt::MSDependentExistsStmtClass:

Stmt::NullStmtClass:

Stmt::ObjCAtCatchStmtClass:

Stmt::ObjCAtFinallyStmtClass:

Stmt::ObjCAtSynchronizedStmtClass:

Stmt::ObjCAutoreleasePoolStmtClass:

Stmt::ObjCForCollectionStmtClass:

Stmt::OMPAtomicDirectiveClass:

Stmt::OMPAssumeDirectiveClass:

Stmt::OMPBarrierDirectiveClass:

Stmt::OMPCancelDirectiveClass:

Stmt::OMPCancellationPointDirectiveClass:

Stmt::OMPCriticalDirectiveClass:

Stmt::OMPDistributeDirectiveClass:

Stmt::OMPDistributeParallelForDirectiveClass:

Stmt::OMPDistributeParallelForSimdDirectiveClass:

Stmt::OMPDistributeSimdDirectiveClass:

Stmt::OMPFlushDirectiveClass:

Stmt::OMPDepobjDirectiveClass:

Stmt::OMPScanDirectiveClass:

Stmt::OMPForDirectiveClass:

Stmt::OMPForSimdDirectiveClass:

Stmt::OMPMasterDirectiveClass:

Stmt::OMPMasterTaskLoopDirectiveClass:

Stmt::OMPMaskedTaskLoopDirectiveClass:

Stmt::OMPMasterTaskLoopSimdDirectiveClass:

Stmt::OMPMaskedTaskLoopSimdDirectiveClass:

Stmt::OMPOrderedDirectiveClass:

Stmt::OMPCanonicalLoopClass:

Stmt::OMPParallelDirectiveClass:

Stmt::OMPParallelForDirectiveClass:

Stmt::OMPParallelForSimdDirectiveClass:

Stmt::OMPParallelMasterDirectiveClass:

Stmt::OMPParallelMaskedDirectiveClass:

Stmt::OMPParallelMasterTaskLoopDirectiveClass:

Stmt::OMPParallelMaskedTaskLoopDirectiveClass:

Stmt::OMPParallelMasterTaskLoopSimdDirectiveClass:

Stmt::OMPParallelMaskedTaskLoopSimdDirectiveClass:

Stmt::OMPParallelSectionsDirectiveClass:

Stmt::OMPSectionDirectiveClass:

Stmt::OMPSectionsDirectiveClass:

Stmt::OMPSimdDirectiveClass:

Stmt::OMPTileDirectiveClass:

Stmt::OMPUnrollDirectiveClass:

Stmt::OMPReverseDirectiveClass:

Stmt::OMPInterchangeDirectiveClass:

Stmt::OMPSingleDirectiveClass:

Stmt::OMPTargetDataDirectiveClass:

Stmt::OMPTargetDirectiveClass:

Stmt::OMPTargetEnterDataDirectiveClass:

Stmt::OMPTargetExitDataDirectiveClass:

Stmt::OMPTargetParallelDirectiveClass:

Stmt::OMPTargetParallelForDirectiveClass:

Stmt::OMPTargetParallelForSimdDirectiveClass:

Stmt::OMPTargetSimdDirectiveClass:

Stmt::OMPTargetTeamsDirectiveClass:

Stmt::OMPTargetTeamsDistributeDirectiveClass:

Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass:

Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:

Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:

Stmt::OMPTargetUpdateDirectiveClass:

Stmt::OMPScopeDirectiveClass:

Stmt::OMPTaskDirectiveClass:

Stmt::OMPTaskgroupDirectiveClass:

Stmt::OMPTaskLoopDirectiveClass:

Stmt::OMPTaskLoopSimdDirectiveClass:

Stmt::OMPTaskwaitDirectiveClass:

Stmt::OMPTaskyieldDirectiveClass:

Stmt::OMPErrorDirectiveClass:

Stmt::OMPTeamsDirectiveClass:

Stmt::OMPTeamsDistributeDirectiveClass:

Stmt::OMPTeamsDistributeParallelForDirectiveClass:

Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass:

Stmt::OMPTeamsDistributeSimdDirectiveClass:

Stmt::OMPInteropDirectiveClass:

Stmt::OMPDispatchDirectiveClass:

Stmt::OMPMaskedDirectiveClass:

Stmt::OMPMetaDirectiveClass:

Stmt::OMPGenericLoopDirectiveClass:

Stmt::OMPTeamsGenericLoopDirectiveClass:

Stmt::OMPTargetTeamsGenericLoopDirectiveClass:

Stmt::OMPParallelGenericLoopDirectiveClass:

Stmt::OMPTargetParallelGenericLoopDirectiveClass:

Stmt::ReturnStmtClass:

Stmt::SEHExceptStmtClass:

Stmt::SEHFinallyStmtClass:

Stmt::SEHLeaveStmtClass:

Stmt::SEHTryStmtClass:

Stmt::SwitchStmtClass:

Stmt::WhileStmtClass:

Stmt::DeclStmtClass: {

(

*

: cast<DeclStmt>(S)->decls()) {

(

*VD = dyn_cast<VarDecl>(

))

(

*TND = dyn_cast<TypedefNameDecl>(

))

(TND->getUnderlyingType()->isVariablyModifiedType())

(

*VD = dyn_cast<ValueDecl>(

))

(VD->getType()->isVariablyModifiedType())

Stmt::IfStmtClass: {

*IS = cast<IfStmt>(S);

(

*

= IS->getInit())

(

*CondDS = IS->getConditionVariableDeclStmt())

(std::optional<const Stmt *> Case = IS->getNondiscardedCase(

))

Stmt::CXXTryStmtClass: {

*TS = cast<CXXTryStmt>(S);

*FinalHandler = TS->getHandler(TS->getNumHandlers() - 1);

Stmt::ObjCAtThrowStmtClass:

Stmt::ObjCAtTryStmtClass: {

*TS = cast<ObjCAtTryStmt>(S);

(

*Finally = TS->getFinallyStmt())

(

I = TS->getNumCatchStmts(); I != 0; --I) {

Stmt::SYCLUniqueStableNameExprClass:

Stmt::OpenACCAsteriskSizeExprClass:

llvm_unreachable(

);

llvm_unreachable(

);

Defines the Diagnostic-related interfaces.

enum clang::sema::@1704::IndirectLocalPathEntry::EntryKind Kind

Defines the clang::Expr interface and subclasses for C++ expressions.

llvm::MachO::Target Target

Defines the SourceManager interface.

Defines the Objective-C statement AST node classes.

static QualType getPointeeType(const MemRegion *R)

Defines the clang::TypeLoc interface and its subclasses.

APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...

SourceManager & getSourceManager()

CanQualType getCanonicalType(QualType T) const

Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...

QualType getPointerType(QualType T) const

Return the uniqued reference to the type for a pointer to the specified type.

void adjustExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI, bool AsWritten=false)

Change the exception specification on a function once it is delay-parsed, instantiated,...

bool hasSameUnqualifiedType(QualType T1, QualType T2) const

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

QualType getArrayDecayedType(QualType T) const

Return the properly qualified result of decaying the specified array type to a pointer.

QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const

Return a normal function type with a typed argument list.

QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals) const

Return this type as a completely-unqualified array type, capturing the qualifiers in Quals.

BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases...

A boolean literal, per ([C++ lex.bool] Boolean literals).

CXXCatchStmt - This represents a C++ catch block.

Stmt * getHandlerBlock() const

VarDecl * getExceptionDecl() const

Represents a C++ destructor within a class.

bool isCalledByDelete(const FunctionDecl *OpDel=nullptr) const

Will this destructor ever be called when considering which deallocation function is associated with t...

A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).

Represents a static or instance method of a struct/union/class.

const CXXRecordDecl * getParent() const

Return the parent of this method declaration, which is the class in which this method is defined.

Represents a C++ struct/union/class.

A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...

bool isTypeOperand() const

Expr * getExprOperand() const

bool isPotentiallyEvaluated() const

Determine whether this typeid has a type operand which is potentially evaluated, per C++11 [expr....

bool hasNullCheck() const

Whether this is of a form like "typeid(*ptr)" that can throw a std::bad_typeid if a pointer is a null...

CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).

CanQual< T > getUnqualifiedType() const

Retrieve the unqualified form of this type.

CastKind getCastKind() const

static ConstantExpr * Create(const ASTContext &Context, Expr *E, const APValue &Result)

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

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

void setInvalidDecl(bool Invalid=true)

setInvalidDecl - Indicates the Decl had a semantic error.

SourceLocation getLocation() const

DeclContext * getLexicalDeclContext()

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

OverloadedOperatorKind getCXXOverloadedOperator() const

If this name is the name of an overloadable operator in C++ (e.g., operator+), retrieve the kind of o...

TypeSourceInfo * getTypeSourceInfo() const

Information about one declarator, including the parsed type information and the identifier.

QualType getTypeAsWritten() const

getTypeAsWritten - Returns the type that this expression is casting to, as written in the source code...

This represents one expression.

bool isValueDependent() const

Determines whether the value of this expression depends on.

bool isTypeDependent() const

Determines whether the type of this expression depends on.

bool containsUnexpandedParameterPack() const

Whether this expression contains an unexpanded parameter pack (for C++11 variadic templates).

Expr * IgnoreParens() LLVM_READONLY

Skip past any parentheses which might surround this expression until reaching a fixed point.

static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)

Create a code modification hint that inserts the given code string at a specific location.

Represents a function declaration or definition.

unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const

Returns a value indicating whether this function corresponds to a builtin function.

bool hasCXXExplicitFunctionObjectParameter() const

bool isExternC() const

Determines whether this function is a function with external, C linkage.

bool isReplaceableGlobalAllocationFunction(std::optional< unsigned > *AlignmentParam=nullptr, bool *IsNothrow=nullptr) const

Determines whether this function is one of the replaceable global allocation functions: void *operato...

Represents a prototype with parameter type info, e.g.

bool hasDependentExceptionSpec() const

Return whether this function has a dependent exception spec.

ExceptionSpecificationType getExceptionSpecType() const

Get the kind of exception specification on this function.

unsigned getNumParams() const

QualType getParamType(unsigned i) const

unsigned getNumExceptions() const

Return the number of types in the exception specification.

bool hasExceptionSpec() const

Return whether this function has any kind of exception spec.

CanThrowResult canThrow() const

Determine whether this function type has a non-throwing exception specification.

Expr * getNoexceptExpr() const

Return the expression inside noexcept(expression), or a null pointer if there is none (because the ex...

ArrayRef< QualType > exceptions() const

exception_iterator exception_begin() const

FunctionDecl * getExceptionSpecDecl() const

If this function type has an exception specification which hasn't been determined yet (either because...

QualType getReturnType() const

One of these records is kept for each identifier that is lexed.

bool isStr(const char(&Str)[StrLen]) const

Return true if this is the identifier for the specified string.

A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...

capture_init_iterator capture_init_end()

Retrieve the iterator pointing one past the last initialization argument for this lambda expression.

Expr *const * const_capture_init_iterator

Const iterator that walks over the capture initialization arguments.

capture_init_iterator capture_init_begin()

Retrieve the first initialization argument for this lambda expression (which initializes the first ca...

A pointer to member type per C++ 8.3.3 - Pointers to members.

DeclarationName getDeclName() const

Get the actual, stored name of the declaration, which may be a special name.

Represents Objective-C's @catch statement.

unsigned getDiagID() const

PointerType - C99 6.7.5.1 - Pointer Declarators.

A (possibly-)qualified type.

bool isVolatileQualified() const

Determine whether this type is volatile-qualified.

bool isNull() const

Return true if this QualType doesn't point to a type yet.

bool isWebAssemblyReferenceType() const

Returns true if it is a WebAssembly Reference Type.

bool isConstQualified() const

Determine whether this type is const-qualified.

The collection of all-type qualifiers we support.

bool compatiblyIncludes(Qualifiers other, const ASTContext &Ctx) const

Determines if these qualifiers compatibly include another set.

A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...

redecl_range redecls() const

Returns an iterator range for all the redeclarations of the same decl.

Base for LValueReferenceType and RValueReferenceType.

QualType getPointeeType() const

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

Emit a diagnostic.

PartialDiagnostic PDiag(unsigned DiagID=0)

Build a partial diagnostic.

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

bool CheckSpecifiedExceptionType(QualType &T, SourceRange Range)

CheckSpecifiedExceptionType - Check if the given type is valid in an exception specification.

void EvaluateImplicitExceptionSpec(SourceLocation Loc, FunctionDecl *FD)

Evaluate the implicit exception specification for a defaulted special member function.

void InstantiateExceptionSpec(SourceLocation PointOfInstantiation, FunctionDecl *Function)

bool IsQualificationConversion(QualType FromType, QualType ToType, bool CStyle, bool &ObjCLifetimeConversion)

IsQualificationConversion - Determines whether the conversion from an rvalue of type FromType to ToTy...

ASTContext & getASTContext() const

SmallVector< std::pair< FunctionDecl *, FunctionDecl * >, 2 > DelayedEquivalentExceptionSpecChecks

All the function redeclarations seen during a class definition that had their exception spec checks d...

PrintingPolicy getPrintingPolicy() const

Retrieve a suitable printing policy for diagnostics.

ExprResult CheckConvertedConstantExpression(Expr *From, QualType T, llvm::APSInt &Value, CCEKind CCE)

bool CheckParamExceptionSpec(const PartialDiagnostic &NestedDiagID, const PartialDiagnostic &NoteID, const FunctionProtoType *Target, bool SkipTargetFirstParameter, SourceLocation TargetLoc, const FunctionProtoType *Source, bool SkipSourceFirstParameter, SourceLocation SourceLoc)

CheckParamExceptionSpec - Check if the parameter and return types of the two functions have equivalen...

SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)

Calls Lexer::getLocForEndOfToken()

const LangOptions & getLangOpts() const

const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)

ExprResult ActOnNoexceptSpec(Expr *NoexceptExpr, ExceptionSpecificationType &EST)

Check the given noexcept-specifier, convert its expression, and compute the appropriate ExceptionSpec...

AccessResult CheckBaseClassAccess(SourceLocation AccessLoc, QualType Base, QualType Derived, const CXXBasePath &Path, unsigned DiagID, bool ForceCheck=false, bool ForceUnprivileged=false)

Checks access for a hierarchy conversion.

SmallVector< std::pair< const CXXMethodDecl *, const CXXMethodDecl * >, 2 > DelayedOverridingExceptionSpecChecks

All the overriding functions seen during a class definition that had their exception spec checks dela...

bool isLibstdcxxEagerExceptionSpecHack(const Declarator &D)

Determine if we're in a case where we need to (incorrectly) eagerly parse an exception specification ...

bool CheckExceptionSpecSubset(const PartialDiagnostic &DiagID, const PartialDiagnostic &NestedDiagID, const PartialDiagnostic &NoteID, const PartialDiagnostic &NoThrowDiagID, const FunctionProtoType *Superset, bool SkipSupersetFirstParameter, SourceLocation SuperLoc, const FunctionProtoType *Subset, bool SkipSubsetFirstParameter, SourceLocation SubLoc)

CheckExceptionSpecSubset - Check whether the second function type's exception specification is a subs...

DeclContext * CurContext

CurContext - This is the current declaration context of parsing.

CanThrowResult canThrow(const Stmt *E)

@ CCEK_Noexcept

Condition in a noexcept(bool) specifier.

bool handlerCanCatch(QualType HandlerType, QualType ExceptionType)

bool CheckDistantExceptionSpec(QualType T)

CheckDistantExceptionSpec - Check if the given type is a pointer or pointer to member to a function w...

bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)

Ensure that the type T is a complete type.

bool CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New)

bool CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New, const CXXMethodDecl *Old)

CheckOverridingFunctionExceptionSpec - Checks whether the exception spec is a subset of base spec.

void UpdateExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI)

bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base)

Determine whether the type Derived is a C++ class that is derived from the type Base.

bool CheckExceptionSpecCompatibility(Expr *From, QualType ToType)

bool IsFunctionConversion(QualType FromType, QualType ToType, QualType &ResultTy)

Determine whether the conversion from FromType to ToType is a valid conversion that strips "noexcept"...

ASTMutationListener * getASTMutationListener() const

static CanThrowResult canCalleeThrow(Sema &S, const Expr *E, const Decl *D, SourceLocation Loc=SourceLocation())

Determine whether the callee of a particular function call can throw.

Encodes a location in the source.

bool isValid() const

Return true if this is a valid SourceLocation object.

bool isInSystemHeader(SourceLocation Loc) const

Returns if a SourceLocation is in a system header.

A trivial tuple used to represent a source range.

SourceLocation getBegin() const

Stmt - This represents one statement.

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

bool isDependentType() const

Whether this declaration declares a type that is dependent, i.e., a type that somehow depends on temp...

bool isBeingDefined() const

Determines whether this type is in the process of being defined.

Base wrapper for a particular "section" of type source info.

T getAs() const

Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...

TypeLoc IgnoreParens() const

A container of type source information.

bool isSizelessType() const

As an extension, we classify types as one of "sized" or "sizeless"; every type is one or the other.

CXXRecordDecl * getAsCXXRecordDecl() const

Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...

bool isPointerType() const

const T * castAs() const

Member-template castAs<specific type>.

bool isSpecificPlaceholderType(unsigned K) const

Test for a specific placeholder type.

bool isReferenceType() const

QualType getPointeeType() const

If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.

bool isDependentType() const

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

const Type * getBaseElementTypeUnsafe() const

Get the base element type of this type, potentially discarding type qualifiers.

bool isMemberPointerType() const

bool isObjectType() const

Determine whether this type is an object type.

bool isFunctionType() const

const T * getAs() const

Member-template getAs<specific type>'.

bool isNullPtrType() const

bool isRecordType() const

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

void setType(QualType newType)

Represents a variable declaration or definition.

QualType::DestructionKind needsDestruction(const ASTContext &Ctx) const

Would the destruction of this variable have any effect, and if so, what kind?

const Expr * getInit() const

bool isUsableInConstantExpressions(const ASTContext &C) const

Determine whether this variable's value can be used in a constant expression, according to the releva...

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

OverloadedOperatorKind

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

CanThrowResult

Possible results from evaluation of a noexcept expression.

static const FunctionProtoType * GetUnderlyingFunction(QualType T)

bool isDynamicExceptionSpec(ExceptionSpecificationType ESpecType)

static bool CheckEquivalentExceptionSpecImpl(Sema &S, const PartialDiagnostic &DiagID, const PartialDiagnostic &NoteID, const FunctionProtoType *Old, SourceLocation OldLoc, const FunctionProtoType *New, SourceLocation NewLoc, bool *MissingExceptionSpecification=nullptr, bool *MissingEmptyExceptionSpecification=nullptr, bool AllowNoexceptAllMatchWithNoSpec=false, bool IsOperatorNew=false)

CheckEquivalentExceptionSpec - Check if the two types have compatible exception specifications.

bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)

static bool hasImplicitExceptionSpec(FunctionDecl *Decl)

Determine whether a function has an implicitly-generated exception specification.

@ Self

'self' clause, allowed on Compute and Combined Constructs, plus 'update'.

CanThrowResult mergeCanThrow(CanThrowResult CT1, CanThrowResult CT2)

@ Result

The result type of a method or function.

static CanThrowResult canVarDeclThrow(Sema &Self, const VarDecl *VD)

static CanThrowResult canDynamicCastThrow(const CXXDynamicCastExpr *DC)

static CanThrowResult canSubStmtsThrow(Sema &Self, const Stmt *S)

const FunctionProtoType * T

static CanThrowResult canTypeidThrow(Sema &S, const CXXTypeidExpr *DC)

static bool CheckSpecForTypesEquivalent(Sema &S, const PartialDiagnostic &DiagID, const PartialDiagnostic &NoteID, QualType Target, SourceLocation TargetLoc, QualType Source, SourceLocation SourceLoc)

@ Success

Template argument deduction was successful.

ExceptionSpecificationType

The various types of exception specifications that exist in C++11.

@ EST_DependentNoexcept

noexcept(expression), value-dependent

@ EST_DynamicNone

throw()

@ EST_Uninstantiated

not instantiated yet

@ EST_Unparsed

not parsed yet

@ EST_NoThrow

Microsoft __declspec(nothrow) extension.

@ EST_None

no exception specification

@ EST_MSAny

Microsoft throw(...) extension.

@ EST_BasicNoexcept

noexcept

@ EST_NoexceptFalse

noexcept(expression), evals to 'false'

@ EST_Unevaluated

not evaluated yet, for special member function

@ EST_NoexceptTrue

noexcept(expression), evals to 'true'

@ EST_Dynamic

throw(T1, T2)

static bool exceptionSpecNotKnownYet(const FunctionDecl *FD)

Holds information about the various types of exception specification.

ExceptionSpecificationType Type

The kind of exception specification this is.

ArrayRef< QualType > Exceptions

Explicitly-specified list of exception types.

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