22#include "llvm/ADT/SmallPtrSet.h"
23#include "llvm/ADT/SmallString.h"
46 auto *RD = dyn_cast<CXXRecordDecl>(
CurContext);
51 if (!RD || !RD->getIdentifier() || !RD->getDescribedClassTemplate() ||
55 auto *ND = dyn_cast<NamespaceDecl>(RD->getDeclContext());
59 bool IsInStd = ND->isStdNamespace();
64 if (!II || !(II->
isStr(
"__debug") || II->
isStr(
"__profile")) ||
65 !ND->isInStdNamespace())
73 return llvm::StringSwitch<bool>(RD->getIdentifier()->getName())
75 .Case(
"pair", IsInStd)
76 .Case(
"priority_queue", IsInStd)
77 .Case(
"stack", IsInStd)
78 .Case(
"queue", IsInStd)
100 llvm::APSInt
Value{1};
147 if (RT->isRValueReferenceType()) {
151 Diag(Range.getBegin(), diag::err_rref_in_exception_spec)
164 unsigned DiagID = diag::err_incomplete_in_exception_spec;
165 bool ReturnValueOnError =
true;
167 DiagID = diag::ext_incomplete_in_exception_spec;
168 ReturnValueOnError =
false;
173 return ReturnValueOnError;
178 Diag(Range.getBegin(), diag::err_sizeless_in_exception_spec)
179 << (Kind == 2 ? 1 : 0) << PointeeT << Range;
212 Diag(Loc, diag::err_exception_spec_not_parsed);
236 Diag(Loc, diag::err_exception_spec_not_parsed);
248 Listener->ResolvedExceptionSpec(FD);
255 auto *MD = dyn_cast<CXXMethodDecl>(FD);
265 Sema &S,
const PartialDiagnostic &DiagID,
const PartialDiagnostic &NoteID,
266 const FunctionProtoType *Old, SourceLocation OldLoc,
267 const FunctionProtoType *New, SourceLocation NewLoc,
268 bool *MissingExceptionSpecification =
nullptr,
269 bool *MissingEmptyExceptionSpecification =
nullptr,
270 bool AllowNoexceptAllMatchWithNoSpec =
false,
bool IsOperatorNew =
false);
275 if (!isa<CXXDestructorDecl>(
Decl) &&
276 Decl->getDeclName().getCXXOverloadedOperator() != OO_Delete &&
277 Decl->getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
285 if (!
Decl->getTypeSourceInfo())
286 return isa<CXXDestructorDecl>(
Decl);
300 bool IsOperatorNew = OO == OO_New || OO == OO_Array_New;
301 bool MissingExceptionSpecification =
false;
302 bool MissingEmptyExceptionSpecification =
false;
304 unsigned DiagID = diag::err_mismatched_exception_spec;
305 bool ReturnValueOnError =
true;
307 DiagID = diag::ext_mismatched_exception_spec;
308 ReturnValueOnError =
false;
322 *
this,
PDiag(DiagID),
PDiag(diag::note_previous_declaration),
325 &MissingExceptionSpecification, &MissingEmptyExceptionSpecification,
326 true, IsOperatorNew)) {
343 if (!MissingExceptionSpecification)
344 return ReturnValueOnError;
356 if (MissingEmptyExceptionSpecification &&
362 NewProto->getReturnType(), NewProto->getParamTypes(),
389 NewProto->getReturnType(), NewProto->getParamTypes(),
390 NewProto->getExtProtoInfo().withExceptionSpec(ESI)));
394 DiagID = diag::ext_missing_exception_specification;
395 ReturnValueOnError =
false;
400 DiagID = diag::ext_missing_exception_specification;
401 ReturnValueOnError =
false;
409 DiagID = diag::ext_missing_exception_specification;
410 ReturnValueOnError =
false;
412 DiagID = diag::err_missing_exception_specification;
413 ReturnValueOnError =
true;
418 llvm::raw_svector_ostream
OS(ExceptionSpecString);
419 switch (OldProto->getExceptionSpecType()) {
426 bool OnFirstException =
true;
427 for (
const auto &E : OldProto->exceptions()) {
428 if (OnFirstException)
429 OnFirstException =
false;
447 assert(OldProto->getNoexceptExpr() !=
nullptr &&
"Expected non-null Expr");
452 OS <<
"__attribute__((nothrow))";
459 llvm_unreachable(
"This spec type is compatible with none.");
468 if (!FTLoc.getTypePtr()->hasTrailingReturn())
484 return ReturnValueOnError;
497 unsigned DiagID = diag::err_mismatched_exception_spec;
499 DiagID = diag::ext_mismatched_exception_spec;
501 *
this,
PDiag(DiagID),
PDiag(diag::note_previous_declaration),
502 Old, OldLoc, New, NewLoc);
520 bool *MissingExceptionSpecification,
521 bool *MissingEmptyExceptionSpecification,
522 bool AllowNoexceptAllMatchWithNoSpec,
bool IsOperatorNew) {
523 if (MissingExceptionSpecification)
524 *MissingExceptionSpecification =
false;
526 if (MissingEmptyExceptionSpecification)
527 *MissingEmptyExceptionSpecification =
false;
560 "Shouldn't see unknown exception specifications here");
574 if (!AllowNoexceptAllMatchWithNoSpec &&
587 llvm::FoldingSetNodeID OldFSN, NewFSN;
590 if (OldFSN == NewFSN)
606 if (OldTypes.count(TypePtr))
607 NewTypes.insert(TypePtr);
614 if (Success && OldTypes.size() == NewTypes.size())
621 if (S.
getLangOpts().CPlusPlus11 && IsOperatorNew) {
624 WithExceptions = New;
626 WithExceptions = Old;
633 if (Name && Name->getName() ==
"bad_alloc") {
635 if (ExRecord->isInStdNamespace()) {
645 if (MissingExceptionSpecification && OldEST !=
EST_None &&
649 *MissingExceptionSpecification =
true;
651 if (MissingEmptyExceptionSpecification && OldCanThrow ==
CT_Cannot) {
655 *MissingEmptyExceptionSpecification =
true;
661 S.
Diag(NewLoc, DiagID);
663 S.
Diag(OldLoc, NoteID);
756 llvm_unreachable(
"access check dependent for unprivileged context");
758 llvm_unreachable(
"access check delayed in non-declaration");
760 llvm_unreachable(
"unexpected access check result");
797 "Shouldn't see unknown exception specifications here");
820 Diag(SubLoc, NoThrowDiagID);
822 Diag(SuperLoc, NoteID);
830 Diag(SubLoc, DiagID);
832 Diag(SuperLoc, NoteID);
837 "Exception spec subset: non-dynamic case slipped through.");
842 SubI = RefTy->getPointeeType();
845 bool Contained =
false;
859 Diag(SubLoc, DiagID);
861 Diag(SuperLoc, NoteID);
897 auto RetDiag = DiagID;
900 *
this, RetDiag,
PDiag(),
908 "Functions have different argument counts.");
909 for (
unsigned i = 0, E =
Target->getNumParams(); i != E; ++i) {
910 auto ParamDiag = DiagID;
913 *
this, ParamDiag,
PDiag(),
933 unsigned DiagID = diag::err_incompatible_exception_specs;
934 unsigned NestedDiagID = diag::err_deep_exception_specs_differ;
939 DiagID = diag::warn_incompatible_exception_specs;
940 NestedDiagID = diag::warn_deep_exception_specs_differ;
983 unsigned DiagID = diag::err_override_exception_spec;
985 DiagID = diag::ext_override_exception_spec;
987 PDiag(diag::err_deep_exception_specs_differ),
988 PDiag(diag::note_overridden_virtual_function),
989 PDiag(diag::ext_override_exception_spec),
998 for (
const Stmt *SubStmt : S->children()) {
1012 if (D && isa<FunctionDecl>(D) && D->
hasAttr<NoThrowAttr>())
1018 if (S.getLangOpts().CPlusPlus17 && E && isa<CallExpr>(E)) {
1019 E = cast<CallExpr>(E)->getCallee();
1027 if (
auto *Op = dyn_cast<BinaryOperator>(E)) {
1028 assert(Op->getOpcode() == BO_PtrMemD || Op->getOpcode() == BO_PtrMemI);
1029 T = Op->getRHS()->getType()
1032 T = cast<MemberExpr>(E)->getMemberDecl()->getType();
1035 }
else if (
const ValueDecl *VD = dyn_cast_or_null<ValueDecl>(D))
1075 if (
auto *Dtor = RD->getDestructor()) {
1083 if (
auto *DD = dyn_cast<DecompositionDecl>(VD))
1084 for (
auto *B : DD->bindings())
1085 if (
auto *HD = B->getHoldingVar())
1116 if (!cast<CXXRecordDecl>(RT->
getDecl())->isPolymorphic())
1129 switch (S->getStmtClass()) {
1130 case Expr::ConstantExprClass:
1131 return canThrow(cast<ConstantExpr>(S)->getSubExpr());
1133 case Expr::CXXThrowExprClass:
1137 case Expr::CXXDynamicCastExprClass: {
1140 auto *CE = cast<CXXDynamicCastExpr>(S);
1142 if (CE->getType()->isVariablyModifiedType())
1150 case Expr::CXXTypeidExprClass:
1158 case Expr::CallExprClass:
1159 case Expr::CXXMemberCallExprClass:
1160 case Expr::CXXOperatorCallExprClass:
1161 case Expr::UserDefinedLiteralClass: {
1162 const CallExpr *CE = cast<CallExpr>(S);
1175 case Expr::CXXConstructExprClass:
1176 case Expr::CXXTemporaryObjectExprClass: {
1177 auto *CE = cast<CXXConstructExpr>(S);
1179 if (CE->getType()->isVariablyModifiedType())
1187 case Expr::CXXInheritedCtorInitExprClass: {
1188 auto *ICIE = cast<CXXInheritedCtorInitExpr>(S);
1192 case Expr::LambdaExprClass: {
1193 const LambdaExpr *Lambda = cast<LambdaExpr>(S);
1198 Cap != CapEnd; ++Cap)
1203 case Expr::CXXNewExprClass: {
1204 auto *NE = cast<CXXNewExpr>(S);
1206 if (NE->isTypeDependent())
1215 case Expr::CXXDeleteExprClass: {
1216 auto *DE = cast<CXXDeleteExpr>(S);
1218 QualType DTy = DE->getDestroyedType();
1224 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1235 case Expr::CXXBindTemporaryExprClass: {
1236 auto *BTE = cast<CXXBindTemporaryExpr>(S);
1239 canCalleeThrow(*
this, BTE, BTE->getTemporary()->getDestructor());
1245 case Expr::PseudoObjectExprClass: {
1246 auto *POE = cast<PseudoObjectExpr>(S);
1248 for (
const Expr *E : POE->semantics()) {
1258 case Expr::ObjCMessageExprClass:
1259 case Expr::ObjCPropertyRefExprClass:
1260 case Expr::ObjCSubscriptRefExprClass:
1266 case Expr::ObjCArrayLiteralClass:
1267 case Expr::ObjCDictionaryLiteralClass:
1268 case Expr::ObjCBoxedExprClass:
1273 case Expr::CoawaitExprClass:
1274 case Expr::ConditionalOperatorClass:
1275 case Expr::CoyieldExprClass:
1276 case Expr::CXXRewrittenBinaryOperatorClass:
1277 case Expr::CXXStdInitializerListExprClass:
1278 case Expr::DesignatedInitExprClass:
1279 case Expr::DesignatedInitUpdateExprClass:
1280 case Expr::ExprWithCleanupsClass:
1281 case Expr::ExtVectorElementExprClass:
1282 case Expr::InitListExprClass:
1283 case Expr::ArrayInitLoopExprClass:
1284 case Expr::MemberExprClass:
1285 case Expr::ObjCIsaExprClass:
1286 case Expr::ObjCIvarRefExprClass:
1287 case Expr::ParenExprClass:
1288 case Expr::ParenListExprClass:
1289 case Expr::ShuffleVectorExprClass:
1290 case Expr::StmtExprClass:
1291 case Expr::ConvertVectorExprClass:
1292 case Expr::VAArgExprClass:
1293 case Expr::CXXParenListInitExprClass:
1296 case Expr::CompoundLiteralExprClass:
1297 case Expr::CXXConstCastExprClass:
1298 case Expr::CXXAddrspaceCastExprClass:
1299 case Expr::CXXReinterpretCastExprClass:
1300 case Expr::BuiltinBitCastExprClass:
1302 if (cast<Expr>(S)->getType()->isVariablyModifiedType())
1307 case Expr::ArraySubscriptExprClass:
1308 case Expr::MatrixSubscriptExprClass:
1309 case Expr::OMPArraySectionExprClass:
1310 case Expr::OMPArrayShapingExprClass:
1311 case Expr::OMPIteratorExprClass:
1312 case Expr::BinaryOperatorClass:
1313 case Expr::DependentCoawaitExprClass:
1314 case Expr::CompoundAssignOperatorClass:
1315 case Expr::CStyleCastExprClass:
1316 case Expr::CXXStaticCastExprClass:
1317 case Expr::CXXFunctionalCastExprClass:
1318 case Expr::ImplicitCastExprClass:
1319 case Expr::MaterializeTemporaryExprClass:
1320 case Expr::UnaryOperatorClass: {
1322 if (
auto *CE = dyn_cast<CastExpr>(S))
1323 if (CE->getType()->isVariablyModifiedType())
1330 case Expr::CXXDefaultArgExprClass:
1331 return canThrow(cast<CXXDefaultArgExpr>(S)->getExpr());
1333 case Expr::CXXDefaultInitExprClass:
1334 return canThrow(cast<CXXDefaultInitExpr>(S)->getExpr());
1336 case Expr::ChooseExprClass: {
1337 auto *CE = cast<ChooseExpr>(S);
1338 if (CE->isTypeDependent() || CE->isValueDependent())
1340 return canThrow(CE->getChosenSubExpr());
1343 case Expr::GenericSelectionExprClass:
1344 if (cast<GenericSelectionExpr>(S)->isResultDependent())
1346 return canThrow(cast<GenericSelectionExpr>(S)->getResultExpr());
1349 case Expr::CXXDependentScopeMemberExprClass:
1350 case Expr::CXXUnresolvedConstructExprClass:
1351 case Expr::DependentScopeDeclRefExprClass:
1352 case Expr::CXXFoldExprClass:
1353 case Expr::RecoveryExprClass:
1356 case Expr::AsTypeExprClass:
1357 case Expr::BinaryConditionalOperatorClass:
1358 case Expr::BlockExprClass:
1359 case Expr::CUDAKernelCallExprClass:
1360 case Expr::DeclRefExprClass:
1361 case Expr::ObjCBridgedCastExprClass:
1362 case Expr::ObjCIndirectCopyRestoreExprClass:
1363 case Expr::ObjCProtocolExprClass:
1364 case Expr::ObjCSelectorExprClass:
1365 case Expr::ObjCAvailabilityCheckExprClass:
1366 case Expr::OffsetOfExprClass:
1367 case Expr::PackExpansionExprClass:
1368 case Expr::SubstNonTypeTemplateParmExprClass:
1369 case Expr::SubstNonTypeTemplateParmPackExprClass:
1370 case Expr::FunctionParmPackExprClass:
1371 case Expr::UnaryExprOrTypeTraitExprClass:
1372 case Expr::UnresolvedLookupExprClass:
1373 case Expr::UnresolvedMemberExprClass:
1374 case Expr::TypoExprClass:
1378 case Expr::AddrLabelExprClass:
1379 case Expr::ArrayTypeTraitExprClass:
1380 case Expr::AtomicExprClass:
1381 case Expr::TypeTraitExprClass:
1382 case Expr::CXXBoolLiteralExprClass:
1383 case Expr::CXXNoexceptExprClass:
1384 case Expr::CXXNullPtrLiteralExprClass:
1385 case Expr::CXXPseudoDestructorExprClass:
1386 case Expr::CXXScalarValueInitExprClass:
1387 case Expr::CXXThisExprClass:
1388 case Expr::CXXUuidofExprClass:
1389 case Expr::CharacterLiteralClass:
1390 case Expr::ExpressionTraitExprClass:
1391 case Expr::FloatingLiteralClass:
1392 case Expr::GNUNullExprClass:
1393 case Expr::ImaginaryLiteralClass:
1394 case Expr::ImplicitValueInitExprClass:
1395 case Expr::IntegerLiteralClass:
1396 case Expr::FixedPointLiteralClass:
1397 case Expr::ArrayInitIndexExprClass:
1398 case Expr::NoInitExprClass:
1399 case Expr::ObjCEncodeExprClass:
1400 case Expr::ObjCStringLiteralClass:
1401 case Expr::ObjCBoolLiteralExprClass:
1402 case Expr::OpaqueValueExprClass:
1403 case Expr::PredefinedExprClass:
1404 case Expr::SizeOfPackExprClass:
1405 case Expr::StringLiteralClass:
1406 case Expr::SourceLocExprClass:
1407 case Expr::ConceptSpecializationExprClass:
1408 case Expr::RequiresExprClass:
1412 case Expr::MSPropertyRefExprClass:
1413 case Expr::MSPropertySubscriptExprClass:
1414 llvm_unreachable(
"Invalid class for expression");
1417 case Stmt::AttributedStmtClass:
1418 case Stmt::BreakStmtClass:
1419 case Stmt::CapturedStmtClass:
1420 case Stmt::CaseStmtClass:
1421 case Stmt::CompoundStmtClass:
1422 case Stmt::ContinueStmtClass:
1423 case Stmt::CoreturnStmtClass:
1424 case Stmt::CoroutineBodyStmtClass:
1425 case Stmt::CXXCatchStmtClass:
1426 case Stmt::CXXForRangeStmtClass:
1427 case Stmt::DefaultStmtClass:
1428 case Stmt::DoStmtClass:
1429 case Stmt::ForStmtClass:
1430 case Stmt::GCCAsmStmtClass:
1431 case Stmt::GotoStmtClass:
1432 case Stmt::IndirectGotoStmtClass:
1433 case Stmt::LabelStmtClass:
1434 case Stmt::MSAsmStmtClass:
1435 case Stmt::MSDependentExistsStmtClass:
1436 case Stmt::NullStmtClass:
1437 case Stmt::ObjCAtCatchStmtClass:
1438 case Stmt::ObjCAtFinallyStmtClass:
1439 case Stmt::ObjCAtSynchronizedStmtClass:
1440 case Stmt::ObjCAutoreleasePoolStmtClass:
1441 case Stmt::ObjCForCollectionStmtClass:
1442 case Stmt::OMPAtomicDirectiveClass:
1443 case Stmt::OMPBarrierDirectiveClass:
1444 case Stmt::OMPCancelDirectiveClass:
1445 case Stmt::OMPCancellationPointDirectiveClass:
1446 case Stmt::OMPCriticalDirectiveClass:
1447 case Stmt::OMPDistributeDirectiveClass:
1448 case Stmt::OMPDistributeParallelForDirectiveClass:
1449 case Stmt::OMPDistributeParallelForSimdDirectiveClass:
1450 case Stmt::OMPDistributeSimdDirectiveClass:
1451 case Stmt::OMPFlushDirectiveClass:
1452 case Stmt::OMPDepobjDirectiveClass:
1453 case Stmt::OMPScanDirectiveClass:
1454 case Stmt::OMPForDirectiveClass:
1455 case Stmt::OMPForSimdDirectiveClass:
1456 case Stmt::OMPMasterDirectiveClass:
1457 case Stmt::OMPMasterTaskLoopDirectiveClass:
1458 case Stmt::OMPMaskedTaskLoopDirectiveClass:
1459 case Stmt::OMPMasterTaskLoopSimdDirectiveClass:
1460 case Stmt::OMPMaskedTaskLoopSimdDirectiveClass:
1461 case Stmt::OMPOrderedDirectiveClass:
1462 case Stmt::OMPCanonicalLoopClass:
1463 case Stmt::OMPParallelDirectiveClass:
1464 case Stmt::OMPParallelForDirectiveClass:
1465 case Stmt::OMPParallelForSimdDirectiveClass:
1466 case Stmt::OMPParallelMasterDirectiveClass:
1467 case Stmt::OMPParallelMaskedDirectiveClass:
1468 case Stmt::OMPParallelMasterTaskLoopDirectiveClass:
1469 case Stmt::OMPParallelMaskedTaskLoopDirectiveClass:
1470 case Stmt::OMPParallelMasterTaskLoopSimdDirectiveClass:
1471 case Stmt::OMPParallelMaskedTaskLoopSimdDirectiveClass:
1472 case Stmt::OMPParallelSectionsDirectiveClass:
1473 case Stmt::OMPSectionDirectiveClass:
1474 case Stmt::OMPSectionsDirectiveClass:
1475 case Stmt::OMPSimdDirectiveClass:
1476 case Stmt::OMPTileDirectiveClass:
1477 case Stmt::OMPUnrollDirectiveClass:
1478 case Stmt::OMPSingleDirectiveClass:
1479 case Stmt::OMPTargetDataDirectiveClass:
1480 case Stmt::OMPTargetDirectiveClass:
1481 case Stmt::OMPTargetEnterDataDirectiveClass:
1482 case Stmt::OMPTargetExitDataDirectiveClass:
1483 case Stmt::OMPTargetParallelDirectiveClass:
1484 case Stmt::OMPTargetParallelForDirectiveClass:
1485 case Stmt::OMPTargetParallelForSimdDirectiveClass:
1486 case Stmt::OMPTargetSimdDirectiveClass:
1487 case Stmt::OMPTargetTeamsDirectiveClass:
1488 case Stmt::OMPTargetTeamsDistributeDirectiveClass:
1489 case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass:
1490 case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
1491 case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
1492 case Stmt::OMPTargetUpdateDirectiveClass:
1493 case Stmt::OMPTaskDirectiveClass:
1494 case Stmt::OMPTaskgroupDirectiveClass:
1495 case Stmt::OMPTaskLoopDirectiveClass:
1496 case Stmt::OMPTaskLoopSimdDirectiveClass:
1497 case Stmt::OMPTaskwaitDirectiveClass:
1498 case Stmt::OMPTaskyieldDirectiveClass:
1499 case Stmt::OMPErrorDirectiveClass:
1500 case Stmt::OMPTeamsDirectiveClass:
1501 case Stmt::OMPTeamsDistributeDirectiveClass:
1502 case Stmt::OMPTeamsDistributeParallelForDirectiveClass:
1503 case Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass:
1504 case Stmt::OMPTeamsDistributeSimdDirectiveClass:
1505 case Stmt::OMPInteropDirectiveClass:
1506 case Stmt::OMPDispatchDirectiveClass:
1507 case Stmt::OMPMaskedDirectiveClass:
1508 case Stmt::OMPMetaDirectiveClass:
1509 case Stmt::OMPGenericLoopDirectiveClass:
1510 case Stmt::OMPTeamsGenericLoopDirectiveClass:
1511 case Stmt::OMPTargetTeamsGenericLoopDirectiveClass:
1512 case Stmt::OMPParallelGenericLoopDirectiveClass:
1513 case Stmt::OMPTargetParallelGenericLoopDirectiveClass:
1514 case Stmt::ReturnStmtClass:
1515 case Stmt::SEHExceptStmtClass:
1516 case Stmt::SEHFinallyStmtClass:
1517 case Stmt::SEHLeaveStmtClass:
1518 case Stmt::SEHTryStmtClass:
1519 case Stmt::SwitchStmtClass:
1520 case Stmt::WhileStmtClass:
1523 case Stmt::DeclStmtClass: {
1525 for (
const Decl *D : cast<DeclStmt>(S)->decls()) {
1526 if (
auto *VD = dyn_cast<VarDecl>(D))
1530 if (
auto *TND = dyn_cast<TypedefNameDecl>(D))
1531 if (TND->getUnderlyingType()->isVariablyModifiedType())
1533 if (
auto *VD = dyn_cast<ValueDecl>(D))
1534 if (VD->getType()->isVariablyModifiedType())
1540 case Stmt::IfStmtClass: {
1541 auto *IS = cast<IfStmt>(S);
1543 if (
const Stmt *Init = IS->getInit())
1545 if (
const Stmt *CondDS = IS->getConditionVariableDeclStmt())
1551 if (std::optional<const Stmt *> Case = IS->getNondiscardedCase(
Context))
1565 case Stmt::CXXTryStmtClass: {
1566 auto *TS = cast<CXXTryStmt>(S);
1569 const CXXCatchStmt *FinalHandler = TS->getHandler(TS->getNumHandlers() - 1);
1575 case Stmt::ObjCAtThrowStmtClass:
1578 case Stmt::ObjCAtTryStmtClass: {
1579 auto *TS = cast<ObjCAtTryStmt>(S);
1584 if (
const Stmt *Finally = TS->getFinallyStmt())
1586 for (
unsigned I = TS->getNumCatchStmts(); I != 0; --I) {
1598 case Stmt::SYCLUniqueStableNameExprClass:
1601 llvm_unreachable(
"Invalid class for statement");
1603 llvm_unreachable(
"Bogus StmtClass");
Defines the Diagnostic-related interfaces.
Defines the clang::Expr interface and subclasses for C++ expressions.
Defines the SourceManager interface.
Defines the Objective-C statement AST node classes.
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.
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals)
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals.
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.
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.
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.
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
bool isTypeOperand() const
Expr * getExprOperand() const
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)
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
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.
SourceLocation getBeginLoc() const LLVM_READONLY
IdentifierInfo * getIdentifier() const
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 * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
Classification Classify(ASTContext &Ctx) const
Classify - Classify this expression according to the C++11 expression taxonomy.
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 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 isConstQualified() const
Determine whether this type is const-qualified.
The collection of all-type qualifiers we support.
bool compatiblyIncludes(Qualifiers other) 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...
RecordDecl * getDecl() const
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Base for LValueReferenceType and RValueReferenceType.
QualType getPointeeType() const
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.
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...
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
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...
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
ExprResult CheckConvertedConstantExpression(Expr *From, QualType T, llvm::APSInt &Value, CCEKind CCE)
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< FunctionDecl *, FunctionDecl * >, 2 > DelayedEquivalentExceptionSpecChecks
All the function redeclarations seen during a class definition that had their exception spec checks d...
bool CheckParamExceptionSpec(const PartialDiagnostic &NestedDiagID, const PartialDiagnostic &NoteID, const FunctionProtoType *Target, SourceLocation TargetLoc, const FunctionProtoType *Source, SourceLocation SourceLoc)
CheckParamExceptionSpec - Check if the parameter and return types of the two functions have equivalen...
bool isLibstdcxxEagerExceptionSpecHack(const Declarator &D)
Determine if we're in a case where we need to (incorrectly) eagerly parse an exception specification ...
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 CheckExceptionSpecSubset(const PartialDiagnostic &DiagID, const PartialDiagnostic &NestedDiagID, const PartialDiagnostic &NoteID, const PartialDiagnostic &NoThrowDiagID, const FunctionProtoType *Superset, SourceLocation SuperLoc, const FunctionProtoType *Subset, SourceLocation SubLoc)
CheckExceptionSpecSubset - Check whether the second function type's exception specification is a subs...
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
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) 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...
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.
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)
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)
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
@ EST_DependentNoexcept
noexcept(expression), value-dependent
@ 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.