22#include "llvm/ADT/SmallPtrSet.h"
45 auto *RD = dyn_cast<CXXRecordDecl>(
CurContext);
50 if (!RD || !RD->getIdentifier() || !RD->getDescribedClassTemplate() ||
51 !
D.getIdentifier() || !
D.getIdentifier()->isStr(
"swap"))
54 auto *ND = dyn_cast<NamespaceDecl>(RD->getDeclContext());
58 bool IsInStd = ND->isStdNamespace();
63 if (!II || !(II->
isStr(
"__debug") || II->
isStr(
"__profile")) ||
64 !ND->isInStdNamespace())
72 return llvm::StringSwitch<bool>(RD->getIdentifier()->getName())
74 .Case(
"pair", IsInStd)
75 .Case(
"priority_queue", IsInStd)
76 .Case(
"stack", IsInStd)
77 .Case(
"queue", IsInStd)
99 llvm::APSInt
Value{1};
140 if (RT->isRValueReferenceType()) {
144 Diag(
Range.getBegin(), diag::err_rref_in_exception_spec)
157 unsigned DiagID = diag::err_incomplete_in_exception_spec;
158 bool ReturnValueOnError =
true;
160 DiagID = diag::ext_incomplete_in_exception_spec;
161 ReturnValueOnError =
false;
166 return ReturnValueOnError;
170 Diag(
Range.getBegin(), diag::err_wasm_reftype_exception_spec);
177 Diag(
Range.getBegin(), diag::err_sizeless_in_exception_spec)
178 << (
Kind == 2 ? 1 : 0) << PointeeT <<
Range;
208 Diag(
Loc, diag::err_exception_spec_not_parsed);
232 Diag(
Loc, diag::err_exception_spec_not_parsed);
244 Listener->ResolvedExceptionSpec(FD);
258 return DC->
isRecord() && cast<RecordDecl>(DC)->isBeingDefined();
262 Sema &S,
const PartialDiagnostic &DiagID,
const PartialDiagnostic &NoteID,
263 const FunctionProtoType *Old, SourceLocation OldLoc,
264 const FunctionProtoType *New, SourceLocation NewLoc,
265 bool *MissingExceptionSpecification =
nullptr,
266 bool *MissingEmptyExceptionSpecification =
nullptr,
267 bool AllowNoexceptAllMatchWithNoSpec =
false,
bool IsOperatorNew =
false);
272 if (!isa<CXXDestructorDecl>(
Decl) &&
273 Decl->getDeclName().getCXXOverloadedOperator() != OO_Delete &&
274 Decl->getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
282 if (!
Decl->getTypeSourceInfo())
283 return isa<CXXDestructorDecl>(
Decl);
297 bool IsOperatorNew = OO == OO_New || OO == OO_Array_New;
298 bool MissingExceptionSpecification =
false;
299 bool MissingEmptyExceptionSpecification =
false;
301 unsigned DiagID = diag::err_mismatched_exception_spec;
302 bool ReturnValueOnError =
true;
304 DiagID = diag::ext_mismatched_exception_spec;
305 ReturnValueOnError =
false;
319 *
this,
PDiag(DiagID),
PDiag(diag::note_previous_declaration),
322 &MissingExceptionSpecification, &MissingEmptyExceptionSpecification,
323 true, IsOperatorNew)) {
340 if (!MissingExceptionSpecification)
341 return ReturnValueOnError;
353 if (MissingEmptyExceptionSpecification &&
359 NewProto->getReturnType(), NewProto->getParamTypes(),
386 NewProto->getReturnType(), NewProto->getParamTypes(),
387 NewProto->getExtProtoInfo().withExceptionSpec(ESI)));
391 DiagID = diag::ext_missing_exception_specification;
392 ReturnValueOnError =
false;
397 DiagID = diag::ext_missing_exception_specification;
398 ReturnValueOnError =
false;
406 DiagID = diag::ext_missing_exception_specification;
407 ReturnValueOnError =
false;
409 DiagID = diag::err_missing_exception_specification;
410 ReturnValueOnError =
true;
415 llvm::raw_svector_ostream
OS(ExceptionSpecString);
416 switch (OldProto->getExceptionSpecType()) {
423 bool OnFirstException =
true;
424 for (
const auto &
E : OldProto->exceptions()) {
425 if (OnFirstException)
426 OnFirstException =
false;
444 assert(OldProto->getNoexceptExpr() !=
nullptr &&
"Expected non-null Expr");
449 OS <<
"__attribute__((nothrow))";
456 llvm_unreachable(
"This spec type is compatible with none.");
465 if (!FTLoc.getTypePtr()->hasTrailingReturn())
481 return ReturnValueOnError;
490 unsigned DiagID = diag::err_mismatched_exception_spec;
492 DiagID = diag::ext_mismatched_exception_spec;
494 *
this,
PDiag(DiagID),
PDiag(diag::note_previous_declaration),
495 Old, OldLoc, New, NewLoc);
513 bool *MissingExceptionSpecification,
514 bool *MissingEmptyExceptionSpecification,
515 bool AllowNoexceptAllMatchWithNoSpec,
bool IsOperatorNew) {
516 if (MissingExceptionSpecification)
517 *MissingExceptionSpecification =
false;
519 if (MissingEmptyExceptionSpecification)
520 *MissingEmptyExceptionSpecification =
false;
553 "Shouldn't see unknown exception specifications here");
567 if (!AllowNoexceptAllMatchWithNoSpec &&
580 llvm::FoldingSetNodeID OldFSN, NewFSN;
583 if (OldFSN == NewFSN)
599 if (OldTypes.count(TypePtr))
600 NewTypes.insert(TypePtr);
607 if (
Success && OldTypes.size() == NewTypes.size())
614 if (S.
getLangOpts().CPlusPlus11 && IsOperatorNew) {
617 WithExceptions = New;
619 WithExceptions = Old;
626 if (Name && Name->getName() ==
"bad_alloc") {
628 if (ExRecord->isInStdNamespace()) {
638 if (MissingExceptionSpecification && OldEST !=
EST_None &&
642 *MissingExceptionSpecification =
true;
644 if (MissingEmptyExceptionSpecification && OldCanThrow ==
CT_Cannot) {
648 *MissingEmptyExceptionSpecification =
true;
654 S.
Diag(NewLoc, DiagID);
656 S.
Diag(OldLoc, NoteID);
749 llvm_unreachable(
"access check dependent for unprivileged context");
751 llvm_unreachable(
"access check delayed in non-declaration");
753 llvm_unreachable(
"unexpected access check result");
785 "Shouldn't see unknown exception specifications here");
802 SkipSupersetFirstParameter, SuperLoc, Subset,
803 SkipSubsetFirstParameter, SubLoc);
809 Diag(SubLoc, NoThrowDiagID);
811 Diag(SuperLoc, NoteID);
819 Diag(SubLoc, DiagID);
821 Diag(SuperLoc, NoteID);
826 "Exception spec subset: non-dynamic case slipped through.");
831 SubI = RefTy->getPointeeType();
834 bool Contained =
false;
848 Diag(SubLoc, DiagID);
850 Diag(SuperLoc, NoteID);
856 SkipSupersetFirstParameter, SuperLoc, Subset,
857 SkipSupersetFirstParameter, SubLoc);
881 auto RetDiag = DiagID;
884 *
this, RetDiag,
PDiag(),
891 assert((
Target->getNumParams() - (
unsigned)SkipTargetFirstParameter) ==
892 (Source->
getNumParams() - (
unsigned)SkipSourceFirstParameter) &&
893 "Functions have different argument counts.");
894 for (
unsigned i = 0,
E =
Target->getNumParams(); i !=
E; ++i) {
895 auto ParamDiag = DiagID;
898 *
this, ParamDiag,
PDiag(),
899 Target->getParamType(i + (SkipTargetFirstParameter ? 1 : 0)),
900 TargetLoc, Source->
getParamType(SkipSourceFirstParameter ? 1 : 0),
919 unsigned DiagID = diag::err_incompatible_exception_specs;
920 unsigned NestedDiagID = diag::err_deep_exception_specs_differ;
925 DiagID = diag::warn_incompatible_exception_specs;
926 NestedDiagID = diag::warn_deep_exception_specs_differ;
970 unsigned DiagID = diag::err_override_exception_spec;
972 DiagID = diag::ext_override_exception_spec;
974 PDiag(DiagID),
PDiag(diag::err_deep_exception_specs_differ),
975 PDiag(diag::note_overridden_virtual_function),
976 PDiag(diag::ext_override_exception_spec),
985 for (
const Stmt *SubStmt : S->children()) {
999 if (isa_and_nonnull<FunctionDecl>(
D) &&
D->hasAttr<NoThrowAttr>())
1005 if (S.getLangOpts().CPlusPlus17 && isa_and_nonnull<CallExpr>(
E)) {
1006 E = cast<CallExpr>(
E)->getCallee();
1011 E =
E->IgnoreParenImpCasts();
1014 if (
auto *Op = dyn_cast<BinaryOperator>(
E)) {
1015 assert(Op->getOpcode() == BO_PtrMemD || Op->getOpcode() == BO_PtrMemI);
1016 T = Op->getRHS()->getType()
1019 T = cast<MemberExpr>(
E)->getMemberDecl()->getType();
1022 }
else if (
const ValueDecl *VD = dyn_cast_or_null<ValueDecl>(
D))
1042 if (
Loc.isValid() || (
Loc.isInvalid() &&
E))
1043 FT = S.ResolveExceptionSpec(
Loc.isInvalid() ?
E->getBeginLoc() :
Loc, FT);
1062 if (
auto *Dtor = RD->getDestructor()) {
1070 if (
auto *DD = dyn_cast<DecompositionDecl>(VD))
1071 for (
auto *B : DD->bindings())
1072 if (
auto *HD = B->getHoldingVar())
1114 switch (S->getStmtClass()) {
1115 case Expr::ConstantExprClass:
1116 return canThrow(cast<ConstantExpr>(S)->getSubExpr());
1118 case Expr::CXXThrowExprClass:
1122 case Expr::CXXDynamicCastExprClass: {
1125 auto *CE = cast<CXXDynamicCastExpr>(S);
1127 if (CE->getType()->isVariablyModifiedType())
1135 case Expr::CXXTypeidExprClass:
1144 case Expr::CallExprClass:
1145 case Expr::CXXMemberCallExprClass:
1146 case Expr::CXXOperatorCallExprClass:
1147 case Expr::UserDefinedLiteralClass: {
1148 const CallExpr *CE = cast<CallExpr>(S);
1161 case Expr::CXXConstructExprClass:
1162 case Expr::CXXTemporaryObjectExprClass: {
1163 auto *CE = cast<CXXConstructExpr>(S);
1165 if (CE->getType()->isVariablyModifiedType())
1173 case Expr::CXXInheritedCtorInitExprClass: {
1174 auto *ICIE = cast<CXXInheritedCtorInitExpr>(S);
1178 case Expr::LambdaExprClass: {
1179 const LambdaExpr *Lambda = cast<LambdaExpr>(S);
1184 Cap != CapEnd; ++Cap)
1189 case Expr::CXXNewExprClass: {
1190 auto *NE = cast<CXXNewExpr>(S);
1192 if (NE->isTypeDependent())
1201 case Expr::CXXDeleteExprClass: {
1202 auto *DE = cast<CXXDeleteExpr>(S);
1204 QualType DTy = DE->getDestroyedType();
1208 const FunctionDecl *OperatorDelete = DE->getOperatorDelete();
1210 if (!OperatorDelete->isDestroyingOperatorDelete()) {
1222 case Expr::CXXBindTemporaryExprClass: {
1223 auto *BTE = cast<CXXBindTemporaryExpr>(S);
1226 canCalleeThrow(*
this, BTE, BTE->getTemporary()->getDestructor());
1232 case Expr::PseudoObjectExprClass: {
1233 auto *POE = cast<PseudoObjectExpr>(S);
1235 for (
const Expr *
E : POE->semantics()) {
1245 case Expr::ObjCMessageExprClass:
1246 case Expr::ObjCPropertyRefExprClass:
1247 case Expr::ObjCSubscriptRefExprClass:
1253 case Expr::ObjCArrayLiteralClass:
1254 case Expr::ObjCDictionaryLiteralClass:
1255 case Expr::ObjCBoxedExprClass:
1260 case Expr::CoawaitExprClass:
1261 case Expr::ConditionalOperatorClass:
1262 case Expr::CoyieldExprClass:
1263 case Expr::CXXRewrittenBinaryOperatorClass:
1264 case Expr::CXXStdInitializerListExprClass:
1265 case Expr::DesignatedInitExprClass:
1266 case Expr::DesignatedInitUpdateExprClass:
1267 case Expr::ExprWithCleanupsClass:
1268 case Expr::ExtVectorElementExprClass:
1269 case Expr::InitListExprClass:
1270 case Expr::ArrayInitLoopExprClass:
1271 case Expr::MemberExprClass:
1272 case Expr::ObjCIsaExprClass:
1273 case Expr::ObjCIvarRefExprClass:
1274 case Expr::ParenExprClass:
1275 case Expr::ParenListExprClass:
1276 case Expr::ShuffleVectorExprClass:
1277 case Expr::StmtExprClass:
1278 case Expr::ConvertVectorExprClass:
1279 case Expr::VAArgExprClass:
1280 case Expr::CXXParenListInitExprClass:
1283 case Expr::CompoundLiteralExprClass:
1284 case Expr::CXXConstCastExprClass:
1285 case Expr::CXXAddrspaceCastExprClass:
1286 case Expr::CXXReinterpretCastExprClass:
1287 case Expr::BuiltinBitCastExprClass:
1289 if (cast<Expr>(S)->getType()->isVariablyModifiedType())
1294 case Expr::ArraySubscriptExprClass:
1295 case Expr::MatrixSubscriptExprClass:
1296 case Expr::ArraySectionExprClass:
1297 case Expr::OMPArrayShapingExprClass:
1298 case Expr::OMPIteratorExprClass:
1299 case Expr::BinaryOperatorClass:
1300 case Expr::DependentCoawaitExprClass:
1301 case Expr::CompoundAssignOperatorClass:
1302 case Expr::CStyleCastExprClass:
1303 case Expr::CXXStaticCastExprClass:
1304 case Expr::CXXFunctionalCastExprClass:
1305 case Expr::ImplicitCastExprClass:
1306 case Expr::MaterializeTemporaryExprClass:
1307 case Expr::UnaryOperatorClass: {
1309 if (
auto *CE = dyn_cast<CastExpr>(S))
1310 if (CE->getType()->isVariablyModifiedType())
1317 case Expr::CXXDefaultArgExprClass:
1318 return canThrow(cast<CXXDefaultArgExpr>(S)->getExpr());
1320 case Expr::CXXDefaultInitExprClass:
1321 return canThrow(cast<CXXDefaultInitExpr>(S)->getExpr());
1323 case Expr::ChooseExprClass: {
1324 auto *CE = cast<ChooseExpr>(S);
1325 if (CE->isTypeDependent() || CE->isValueDependent())
1327 return canThrow(CE->getChosenSubExpr());
1330 case Expr::GenericSelectionExprClass:
1331 if (cast<GenericSelectionExpr>(S)->isResultDependent())
1333 return canThrow(cast<GenericSelectionExpr>(S)->getResultExpr());
1336 case Expr::CXXDependentScopeMemberExprClass:
1337 case Expr::CXXUnresolvedConstructExprClass:
1338 case Expr::DependentScopeDeclRefExprClass:
1339 case Expr::CXXFoldExprClass:
1340 case Expr::RecoveryExprClass:
1343 case Expr::AsTypeExprClass:
1344 case Expr::BinaryConditionalOperatorClass:
1345 case Expr::BlockExprClass:
1346 case Expr::CUDAKernelCallExprClass:
1347 case Expr::DeclRefExprClass:
1348 case Expr::ObjCBridgedCastExprClass:
1349 case Expr::ObjCIndirectCopyRestoreExprClass:
1350 case Expr::ObjCProtocolExprClass:
1351 case Expr::ObjCSelectorExprClass:
1352 case Expr::ObjCAvailabilityCheckExprClass:
1353 case Expr::OffsetOfExprClass:
1354 case Expr::PackExpansionExprClass:
1355 case Expr::SubstNonTypeTemplateParmExprClass:
1356 case Expr::SubstNonTypeTemplateParmPackExprClass:
1357 case Expr::FunctionParmPackExprClass:
1358 case Expr::UnaryExprOrTypeTraitExprClass:
1359 case Expr::UnresolvedLookupExprClass:
1360 case Expr::UnresolvedMemberExprClass:
1361 case Expr::TypoExprClass:
1365 case Expr::AddrLabelExprClass:
1366 case Expr::ArrayTypeTraitExprClass:
1367 case Expr::AtomicExprClass:
1368 case Expr::TypeTraitExprClass:
1369 case Expr::CXXBoolLiteralExprClass:
1370 case Expr::CXXNoexceptExprClass:
1371 case Expr::CXXNullPtrLiteralExprClass:
1372 case Expr::CXXPseudoDestructorExprClass:
1373 case Expr::CXXScalarValueInitExprClass:
1374 case Expr::CXXThisExprClass:
1375 case Expr::CXXUuidofExprClass:
1376 case Expr::CharacterLiteralClass:
1377 case Expr::ExpressionTraitExprClass:
1378 case Expr::FloatingLiteralClass:
1379 case Expr::GNUNullExprClass:
1380 case Expr::ImaginaryLiteralClass:
1381 case Expr::ImplicitValueInitExprClass:
1382 case Expr::IntegerLiteralClass:
1383 case Expr::FixedPointLiteralClass:
1384 case Expr::ArrayInitIndexExprClass:
1385 case Expr::NoInitExprClass:
1386 case Expr::ObjCEncodeExprClass:
1387 case Expr::ObjCStringLiteralClass:
1388 case Expr::ObjCBoolLiteralExprClass:
1389 case Expr::OpaqueValueExprClass:
1390 case Expr::PredefinedExprClass:
1391 case Expr::SizeOfPackExprClass:
1392 case Expr::PackIndexingExprClass:
1393 case Expr::StringLiteralClass:
1394 case Expr::SourceLocExprClass:
1395 case Expr::EmbedExprClass:
1396 case Expr::ConceptSpecializationExprClass:
1397 case Expr::RequiresExprClass:
1398 case Expr::HLSLOutArgExprClass:
1399 case Stmt::OpenACCEnterDataConstructClass:
1400 case Stmt::OpenACCExitDataConstructClass:
1401 case Stmt::OpenACCWaitConstructClass:
1402 case Stmt::OpenACCInitConstructClass:
1403 case Stmt::OpenACCShutdownConstructClass:
1407 case Expr::MSPropertyRefExprClass:
1408 case Expr::MSPropertySubscriptExprClass:
1409 llvm_unreachable(
"Invalid class for expression");
1412 case Stmt::OpenACCComputeConstructClass:
1413 case Stmt::OpenACCLoopConstructClass:
1414 case Stmt::OpenACCCombinedConstructClass:
1415 case Stmt::OpenACCDataConstructClass:
1416 case Stmt::OpenACCHostDataConstructClass:
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::OMPAssumeDirectiveClass:
1444 case Stmt::OMPBarrierDirectiveClass:
1445 case Stmt::OMPCancelDirectiveClass:
1446 case Stmt::OMPCancellationPointDirectiveClass:
1447 case Stmt::OMPCriticalDirectiveClass:
1448 case Stmt::OMPDistributeDirectiveClass:
1449 case Stmt::OMPDistributeParallelForDirectiveClass:
1450 case Stmt::OMPDistributeParallelForSimdDirectiveClass:
1451 case Stmt::OMPDistributeSimdDirectiveClass:
1452 case Stmt::OMPFlushDirectiveClass:
1453 case Stmt::OMPDepobjDirectiveClass:
1454 case Stmt::OMPScanDirectiveClass:
1455 case Stmt::OMPForDirectiveClass:
1456 case Stmt::OMPForSimdDirectiveClass:
1457 case Stmt::OMPMasterDirectiveClass:
1458 case Stmt::OMPMasterTaskLoopDirectiveClass:
1459 case Stmt::OMPMaskedTaskLoopDirectiveClass:
1460 case Stmt::OMPMasterTaskLoopSimdDirectiveClass:
1461 case Stmt::OMPMaskedTaskLoopSimdDirectiveClass:
1462 case Stmt::OMPOrderedDirectiveClass:
1463 case Stmt::OMPCanonicalLoopClass:
1464 case Stmt::OMPParallelDirectiveClass:
1465 case Stmt::OMPParallelForDirectiveClass:
1466 case Stmt::OMPParallelForSimdDirectiveClass:
1467 case Stmt::OMPParallelMasterDirectiveClass:
1468 case Stmt::OMPParallelMaskedDirectiveClass:
1469 case Stmt::OMPParallelMasterTaskLoopDirectiveClass:
1470 case Stmt::OMPParallelMaskedTaskLoopDirectiveClass:
1471 case Stmt::OMPParallelMasterTaskLoopSimdDirectiveClass:
1472 case Stmt::OMPParallelMaskedTaskLoopSimdDirectiveClass:
1473 case Stmt::OMPParallelSectionsDirectiveClass:
1474 case Stmt::OMPSectionDirectiveClass:
1475 case Stmt::OMPSectionsDirectiveClass:
1476 case Stmt::OMPSimdDirectiveClass:
1477 case Stmt::OMPTileDirectiveClass:
1478 case Stmt::OMPUnrollDirectiveClass:
1479 case Stmt::OMPReverseDirectiveClass:
1480 case Stmt::OMPInterchangeDirectiveClass:
1481 case Stmt::OMPSingleDirectiveClass:
1482 case Stmt::OMPTargetDataDirectiveClass:
1483 case Stmt::OMPTargetDirectiveClass:
1484 case Stmt::OMPTargetEnterDataDirectiveClass:
1485 case Stmt::OMPTargetExitDataDirectiveClass:
1486 case Stmt::OMPTargetParallelDirectiveClass:
1487 case Stmt::OMPTargetParallelForDirectiveClass:
1488 case Stmt::OMPTargetParallelForSimdDirectiveClass:
1489 case Stmt::OMPTargetSimdDirectiveClass:
1490 case Stmt::OMPTargetTeamsDirectiveClass:
1491 case Stmt::OMPTargetTeamsDistributeDirectiveClass:
1492 case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass:
1493 case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
1494 case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
1495 case Stmt::OMPTargetUpdateDirectiveClass:
1496 case Stmt::OMPScopeDirectiveClass:
1497 case Stmt::OMPTaskDirectiveClass:
1498 case Stmt::OMPTaskgroupDirectiveClass:
1499 case Stmt::OMPTaskLoopDirectiveClass:
1500 case Stmt::OMPTaskLoopSimdDirectiveClass:
1501 case Stmt::OMPTaskwaitDirectiveClass:
1502 case Stmt::OMPTaskyieldDirectiveClass:
1503 case Stmt::OMPErrorDirectiveClass:
1504 case Stmt::OMPTeamsDirectiveClass:
1505 case Stmt::OMPTeamsDistributeDirectiveClass:
1506 case Stmt::OMPTeamsDistributeParallelForDirectiveClass:
1507 case Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass:
1508 case Stmt::OMPTeamsDistributeSimdDirectiveClass:
1509 case Stmt::OMPInteropDirectiveClass:
1510 case Stmt::OMPDispatchDirectiveClass:
1511 case Stmt::OMPMaskedDirectiveClass:
1512 case Stmt::OMPMetaDirectiveClass:
1513 case Stmt::OMPGenericLoopDirectiveClass:
1514 case Stmt::OMPTeamsGenericLoopDirectiveClass:
1515 case Stmt::OMPTargetTeamsGenericLoopDirectiveClass:
1516 case Stmt::OMPParallelGenericLoopDirectiveClass:
1517 case Stmt::OMPTargetParallelGenericLoopDirectiveClass:
1518 case Stmt::ReturnStmtClass:
1519 case Stmt::SEHExceptStmtClass:
1520 case Stmt::SEHFinallyStmtClass:
1521 case Stmt::SEHLeaveStmtClass:
1522 case Stmt::SEHTryStmtClass:
1523 case Stmt::SwitchStmtClass:
1524 case Stmt::WhileStmtClass:
1527 case Stmt::DeclStmtClass: {
1529 for (
const Decl *
D : cast<DeclStmt>(S)->decls()) {
1530 if (
auto *VD = dyn_cast<VarDecl>(
D))
1534 if (
auto *TND = dyn_cast<TypedefNameDecl>(
D))
1535 if (TND->getUnderlyingType()->isVariablyModifiedType())
1537 if (
auto *VD = dyn_cast<ValueDecl>(
D))
1538 if (VD->getType()->isVariablyModifiedType())
1544 case Stmt::IfStmtClass: {
1545 auto *IS = cast<IfStmt>(S);
1547 if (
const Stmt *
Init = IS->getInit())
1549 if (
const Stmt *CondDS = IS->getConditionVariableDeclStmt())
1555 if (std::optional<const Stmt *> Case = IS->getNondiscardedCase(
Context))
1569 case Stmt::CXXTryStmtClass: {
1570 auto *TS = cast<CXXTryStmt>(S);
1573 const CXXCatchStmt *FinalHandler = TS->getHandler(TS->getNumHandlers() - 1);
1579 case Stmt::ObjCAtThrowStmtClass:
1582 case Stmt::ObjCAtTryStmtClass: {
1583 auto *TS = cast<ObjCAtTryStmt>(S);
1588 if (
const Stmt *Finally = TS->getFinallyStmt())
1590 for (
unsigned I = TS->getNumCatchStmts(); I != 0; --I) {
1602 case Stmt::SYCLUniqueStableNameExprClass:
1604 case Stmt::OpenACCAsteriskSizeExprClass:
1607 llvm_unreachable(
"Invalid class for statement");
1609 llvm_unreachable(
"Bogus StmtClass");
Defines the Diagnostic-related interfaces.
enum clang::sema::@1712::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.
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_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.