37#include "llvm/ADT/ArrayRef.h"
38#include "llvm/ADT/DenseMap.h"
39#include "llvm/ADT/STLExtras.h"
40#include "llvm/ADT/SmallPtrSet.h"
41#include "llvm/ADT/SmallString.h"
42#include "llvm/ADT/SmallVector.h"
43#include "llvm/ADT/StringExtras.h"
71 bool HasLeadingEmptyMacro) {
100 Diag(
decl->getLocation(), diag::err_non_variable_decl_in_for);
101 decl->setInvalidDecl();
134 enum { Equality, Inequality, Relational, ThreeWay } Kind;
137 if (!Op->isComparisonOp())
140 if (Op->getOpcode() == BO_EQ)
142 else if (Op->getOpcode() == BO_NE)
144 else if (Op->getOpcode() == BO_Cmp)
147 assert(Op->isRelationalOp());
150 Loc = Op->getOperatorLoc();
151 CanAssign = Op->getLHS()->IgnoreParenImpCasts()->isLValue();
153 switch (Op->getOperator()) {
157 case OO_ExclaimEqual:
162 case OO_GreaterEqual:
173 Loc = Op->getOperatorLoc();
174 CanAssign = Op->getArg(0)->IgnoreParenImpCasts()->isLValue();
185 S.
Diag(Loc, diag::warn_unused_comparison)
191 if (Kind == Inequality)
192 S.
Diag(Loc, diag::note_inequality_comparison_to_or_assign)
194 else if (Kind == Equality)
195 S.
Diag(Loc, diag::note_equality_comparison_to_assign)
207 StringRef Msg = A->getMessage();
211 return S.
Diag(Loc, diag::warn_unused_constructor) << A << R1 << R2;
212 return S.
Diag(Loc, diag::warn_unused_result) << A << R1 << R2;
216 return S.
Diag(Loc, diag::warn_unused_constructor_msg) << A << Msg << R1
218 return S.
Diag(Loc, diag::warn_unused_result_msg) << A << Msg << R1 << R2;
225 const Expr *E = dyn_cast_or_null<Expr>(S);
240 bool ShouldSuppress =
244 const Expr *WarnExpr;
269 if (
const FullExpr *Temps = dyn_cast<FullExpr>(E))
270 E = Temps->getSubExpr();
272 E = TempExpr->getSubExpr();
278 if (
const auto *Cast = dyn_cast<CastExpr>(E))
279 if (Cast->getCastKind() == CK_NoOp ||
280 Cast->getCastKind() == CK_ConstructorConversion)
281 E = Cast->getSubExpr()->IgnoreImpCasts();
283 if (
const CallExpr *CE = dyn_cast<CallExpr>(E)) {
288 CE->getUnusedResultAttr(
Context)),
296 if (
const Decl *FD = CE->getCalleeDecl()) {
299 if (FD->hasAttr<PureAttr>()) {
300 Diag(Loc, diag::warn_unused_call) << R1 << R2 <<
"pure";
303 if (FD->hasAttr<ConstAttr>()) {
304 Diag(Loc, diag::warn_unused_call) << R1 << R2 <<
"const";
308 }
else if (
const auto *CE = dyn_cast<CXXConstructExpr>(E)) {
310 const auto *A = Ctor->getAttr<WarnUnusedResultAttr>();
311 A = A ? A : Ctor->getParent()->getAttr<WarnUnusedResultAttr>();
315 }
else if (
const auto *ILE = dyn_cast<InitListExpr>(E)) {
316 if (
const TagDecl *TD = ILE->getType()->getAsTagDecl()) {
322 }
else if (ShouldSuppress)
327 if (
getLangOpts().ObjCAutoRefCount && ME->isDelegateInitCall()) {
328 Diag(Loc, diag::err_arc_unused_init_message) << R1;
338 const Expr *Source = POE->getSyntacticForm();
340 if (
LangOpts.OpenMP && isa<CallExpr>(Source) &&
341 POE->getNumSemanticExprs() == 1 &&
342 isa<CallExpr>(POE->getSemanticExpr(0)))
344 if (isa<ObjCSubscriptRefExpr>(Source))
345 DiagID = diag::warn_unused_container_subscript_expr;
346 else if (isa<ObjCPropertyRefExpr>(Source))
347 DiagID = diag::warn_unused_property_expr;
349 = dyn_cast<CXXFunctionalCastExpr>(E)) {
350 const Expr *E = FC->getSubExpr();
352 E = TE->getSubExpr();
353 if (isa<CXXTemporaryObjectExpr>(E))
356 if (
const CXXRecordDecl *RD = CE->getType()->getAsCXXRecordDecl())
357 if (!RD->getAttr<WarnUnusedAttr>())
361 else if (
const CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(E)) {
369 Diag(Loc, diag::warn_unused_voidptr)
379 Diag(Loc, diag::warn_unused_volatile) << R1 << R2;
386 if (DiagID != diag::warn_unused_comma_left_operand || !
isSFINAEContext())
388 PDiag(DiagID) << R1 << R2);
413 const unsigned NumElts = Elts.size();
418 const unsigned MixedDeclsCodeID =
getLangOpts().C99
419 ? diag::warn_mixed_decls_code
420 : diag::ext_mixed_decls_code;
425 for (; i != NumElts && isa<DeclStmt>(Elts[i]); ++i)
429 for (; i != NumElts && !isa<DeclStmt>(Elts[i]); ++i)
433 Decl *D = *cast<DeclStmt>(Elts[i])->decl_begin();
443 for (
unsigned i = 0; i != NumElts - 1; ++i)
479 auto CheckAndFinish = [&](
Expr *E) {
486 llvm::APSInt TempVal;
492 if (!E->isValueDependent())
506 if (Converted.
get() == Val.
get())
507 Converted = CheckAndFinish(Val.
get());
515 assert((LHSVal.
isInvalid() || LHSVal.
get()) &&
"missing LHS value");
518 "missing RHS value");
521 Diag(CaseLoc, diag::err_case_not_in_switch);
532 Diag(CaseLoc, diag::err_acc_branch_in_out_compute_construct)
538 CaseLoc, DotDotDotLoc, ColonLoc);
545 cast<CaseStmt>(S)->setSubStmt(SubStmt);
552 Diag(DefaultLoc, diag::err_default_not_in_switch);
558 Diag(DefaultLoc, diag::err_acc_branch_in_out_compute_construct)
573 Diag(IdentLoc, diag::err_redefinition_of_label) << TheDecl->
getDeclName();
581 Diag(IdentLoc, diag::warn_reserved_extern_symbol)
582 << TheDecl << static_cast<int>(Status);
586 if (
getCurScope()->isInOpenACCComputeConstructScope())
608 for (
const auto *A : Attrs) {
609 if (A->getKind() == attr::MustTail) {
624 if (!SemanticAttrs.empty())
640 if (!checkMustTailAttr(St, MTA))
646 auto IgnoreImplicitAsWritten = [](
Expr *E) ->
Expr * {
657bool Sema::checkMustTailAttr(
const Stmt *St,
const Attr &MTA) {
659 "musttail cannot be checked from a dependent context");
662 auto IgnoreParenImplicitAsWritten = [](
const Expr *E) ->
const Expr * {
668 const Expr *E = cast<ReturnStmt>(St)->getRetValue();
669 const auto *CE = dyn_cast_or_null<CallExpr>(IgnoreParenImplicitAsWritten(E));
676 if (
const auto *EWC = dyn_cast<ExprWithCleanups>(E)) {
677 if (EWC->cleanupsHaveSideEffects()) {
678 Diag(St->
getBeginLoc(), diag::err_musttail_needs_trivial_args) << &MTA;
689 ft_non_static_member,
690 ft_pointer_to_member,
691 } MemberType = ft_non_member;
696 } CallerType, CalleeType;
699 bool IsCallee) ->
bool {
700 if (isa<CXXConstructorDecl, CXXDestructorDecl>(CMD)) {
702 << IsCallee << isa<CXXDestructorDecl>(CMD);
704 Diag(CMD->getBeginLoc(), diag::note_musttail_structors_forbidden)
705 << isa<CXXDestructorDecl>(CMD);
710 Type.MemberType = FuncType::ft_static_member;
712 Type.This = CMD->getFunctionObjectParameterType();
713 Type.MemberType = FuncType::ft_non_static_member;
719 const auto *CallerDecl = dyn_cast<FunctionDecl>(
CurContext);
730 Diag(St->
getBeginLoc(), diag::err_musttail_forbidden_from_this_context)
733 }
else if (
const auto *CMD = dyn_cast<CXXMethodDecl>(
CurContext)) {
735 if (!GetMethodType(CMD, CallerType,
false))
743 const auto *CalleeBinOp = dyn_cast<BinaryOperator>(CalleeExpr);
745 ? CE->getCalleeDecl()->getBeginLoc()
750 dyn_cast_or_null<CXXMethodDecl>(CE->getCalleeDecl())) {
752 if (!GetMethodType(CMD, CalleeType,
true))
754 }
else if (CalleeBinOp && CalleeBinOp->isPtrMemOp()) {
758 CalleeType.This =
QualType(MPT->getClass(), 0);
760 CalleeType.MemberType = FuncType::ft_pointer_to_member;
761 }
else if (isa<CXXPseudoDestructorExpr>(CalleeExpr)) {
773 if (!CalleeType.Func || !CallerType.Func) {
775 if (!CalleeType.Func && CE->getDirectCallee()) {
776 Diag(CE->getDirectCallee()->getBeginLoc(),
777 diag::note_musttail_fix_non_prototype);
779 if (!CallerType.Func)
780 Diag(CallerDecl->getBeginLoc(), diag::note_musttail_fix_non_prototype);
791 if (CallerType.Func->getCallConv() != CalleeType.Func->getCallConv()) {
792 if (
const auto *ND = dyn_cast_or_null<NamedDecl>(CE->getCalleeDecl()))
794 <<
true << ND->getDeclName();
796 Diag(St->
getBeginLoc(), diag::err_musttail_callconv_mismatch) <<
false;
797 Diag(CalleeLoc, diag::note_musttail_callconv_mismatch)
804 if (CalleeType.Func->isVariadic() || CallerType.Func->isVariadic()) {
809 const auto *CalleeDecl = CE->getCalleeDecl();
810 if (CalleeDecl && CalleeDecl->hasAttr<CXX11NoReturnAttr>()) {
816 if (CallerType.This.isNull() != CalleeType.This.isNull()) {
817 if (
const auto *ND = dyn_cast_or_null<NamedDecl>(CE->getCalleeDecl())) {
819 << CallerType.MemberType << CalleeType.MemberType <<
true
820 << ND->getDeclName();
821 Diag(CalleeLoc, diag::note_musttail_callee_defined_here)
822 << ND->getDeclName();
825 << CallerType.MemberType << CalleeType.MemberType <<
false;
830 auto CheckTypesMatch = [
this](FuncType CallerType, FuncType CalleeType,
840 unsigned Select) ->
bool {
848 if (!CallerType.This.isNull() &&
852 if (!DoTypesMatch(CallerType.Func->getReturnType(),
856 if (CallerType.Func->getNumParams() != CalleeType.Func->getNumParams()) {
858 << CalleeType.Func->getNumParams();
864 size_t N = CallerType.Func->getNumParams();
865 for (
size_t I = 0; I < N; I++) {
866 if (!DoTypesMatch(CalleeParams[I], CallerParams[I],
868 PD << static_cast<int>(I) + 1;
877 if (!CheckTypesMatch(CallerType, CalleeType, PD)) {
878 if (
const auto *ND = dyn_cast_or_null<NamedDecl>(CE->getCalleeDecl()))
880 <<
true << ND->getDeclName();
896 CommaVisitor(
Sema &SemaRef) : Inherited(SemaRef.Context), SemaRef(SemaRef) {}
914 bool ConstevalOrNegatedConsteval =
918 Expr *CondExpr = Cond.
get().second;
919 assert((CondExpr || ConstevalOrNegatedConsteval) &&
920 "If statement: missing condition");
924 CommaVisitor(*this).Visit(CondExpr);
926 if (!ConstevalOrNegatedConsteval && !elseStmt)
929 if (ConstevalOrNegatedConsteval ||
931 auto DiagnoseLikelihood = [&](
const Stmt *S) {
934 diag::warn_attribute_has_no_effect_on_compile_time_if)
935 << A << ConstevalOrNegatedConsteval << A->getRange();
937 diag::note_attribute_has_no_effect_on_compile_time_if_here)
938 << ConstevalOrNegatedConsteval
945 DiagnoseLikelihood(thenStmt);
946 DiagnoseLikelihood(elseStmt);
948 std::tuple<bool, const Attr *, const Attr *> LHC =
950 if (std::get<0>(LHC)) {
951 const Attr *ThenAttr = std::get<1>(LHC);
952 const Attr *ElseAttr = std::get<2>(LHC);
954 diag::warn_attributes_likelihood_ifstmt_conflict)
955 << ThenAttr << ThenAttr->
getRange();
957 << ElseAttr << ElseAttr->
getRange();
961 if (ConstevalOrNegatedConsteval) {
967 if (FD && FD->isImmediateFunction())
971 Diags.
Report(IfLoc, diag::warn_consteval_if_always_true) << Immediate;
974 return BuildIfStmt(IfLoc, StatementKind, LParenLoc, InitStmt, Cond, RParenLoc,
975 thenStmt, ElseLoc, elseStmt);
988 isa<ObjCAvailabilityCheckExpr>(Cond.
get().second))
992 Cond.
get().first, Cond.
get().second, LParenLoc,
993 RParenLoc, thenStmt, ElseLoc, elseStmt);
997 struct CaseCompareFunctor {
998 bool operator()(
const std::pair<llvm::APSInt, CaseStmt*> &LHS,
999 const llvm::APSInt &RHS) {
1000 return LHS.first < RHS;
1002 bool operator()(
const std::pair<llvm::APSInt, CaseStmt*> &LHS,
1003 const std::pair<llvm::APSInt, CaseStmt*> &RHS) {
1004 return LHS.first < RHS.first;
1006 bool operator()(
const llvm::APSInt &LHS,
1007 const std::pair<llvm::APSInt, CaseStmt*> &RHS) {
1008 return LHS < RHS.first;
1016 const std::pair<llvm::APSInt, CaseStmt*>& rhs) {
1017 if (lhs.first < rhs.first)
1020 if (lhs.first == rhs.first &&
1021 lhs.second->getCaseLoc() < rhs.second->getCaseLoc())
1028static bool CmpEnumVals(
const std::pair<llvm::APSInt, EnumConstantDecl*>& lhs,
1029 const std::pair<llvm::APSInt, EnumConstantDecl*>& rhs)
1031 return lhs.first < rhs.first;
1036static bool EqEnumVals(
const std::pair<llvm::APSInt, EnumConstantDecl*>& lhs,
1037 const std::pair<llvm::APSInt, EnumConstantDecl*>& rhs)
1039 return lhs.first == rhs.first;
1045 if (
const auto *FE = dyn_cast<FullExpr>(E))
1046 E = FE->getSubExpr();
1047 while (
const auto *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
1048 if (ImpCast->getCastKind() != CK_IntegralCast)
break;
1049 E = ImpCast->getSubExpr();
1059 SwitchConvertDiagnoser(
Expr *Cond)
1065 return S.
Diag(Loc, diag::err_typecheck_statement_requires_integer) << T;
1070 return S.
Diag(Loc, diag::err_switch_incomplete_class_type)
1076 return S.
Diag(Loc, diag::err_switch_explicit_conversion) << T << ConvTy;
1087 return S.
Diag(Loc, diag::err_switch_multiple_conversions) << T;
1098 llvm_unreachable(
"conversion functions are permitted");
1100 } SwitchDiagnoser(Cond);
1109 Cond = CondResult.
get();
1122 Expr *CondExpr = Cond.
get().second;
1123 assert((Cond.
isInvalid() || CondExpr) &&
"switch with no condition");
1136 Diag(SwitchLoc, diag::warn_bool_switch_condition)
1144 LParenLoc, RParenLoc);
1150static void AdjustAPSInt(llvm::APSInt &Val,
unsigned BitWidth,
bool IsSigned) {
1151 Val = Val.extOrTrunc(BitWidth);
1152 Val.setIsSigned(IsSigned);
1158 unsigned UnpromotedWidth,
bool UnpromotedSign) {
1166 if (UnpromotedWidth < Val.getBitWidth()) {
1167 llvm::APSInt ConvVal(Val);
1168 AdjustAPSInt(ConvVal, UnpromotedWidth, UnpromotedSign);
1169 AdjustAPSInt(ConvVal, Val.getBitWidth(), Val.isSigned());
1174 S.
Diag(Loc, diag::warn_case_value_overflow) <<
toString(Val, 10)
1185 const Expr *CaseExpr,
1186 EnumValsTy::iterator &EI,
1187 EnumValsTy::iterator &EIEnd,
1188 const llvm::APSInt &Val) {
1194 if (
const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
1203 if (ED->
hasAttr<FlagEnumAttr>())
1206 while (EI != EIEnd && EI->first < Val)
1209 if (EI != EIEnd && EI->first == Val)
1222 if (!CondEnumType || !CaseEnumType)
1229 if (!CaseEnumType->getDecl()->getIdentifier() &&
1230 !CaseEnumType->getDecl()->getTypedefNameForAnonDecl())
1236 S.
Diag(Case->
getExprLoc(), diag::warn_comparison_of_mixed_enum_types_switch)
1246 assert(SS ==
getCurFunction()->SwitchStack.back().getPointer() &&
1247 "switch stack missing push/pop!");
1252 SS->
setBody(BodyStmt, SwitchLoc);
1266 const Expr *CondExprBeforePromotion = CondExpr;
1272 bool HasDependentValue
1281 unsigned CondWidthBeforePromotion
1283 bool CondIsSignedBeforePromotion
1290 CaseValsTy CaseVals;
1293 typedef std::vector<std::pair<llvm::APSInt, CaseStmt*> > CaseRangesTy;
1294 CaseRangesTy CaseRanges;
1298 bool CaseListIsErroneous =
false;
1306 if (
DefaultStmt *DS = dyn_cast<DefaultStmt>(SC)) {
1307 if (TheDefaultStmt) {
1308 Diag(DS->getDefaultLoc(), diag::err_multiple_default_labels_defined);
1315 CaseListIsErroneous =
true;
1317 TheDefaultStmt = DS;
1325 HasDependentValue =
true;
1331 const Expr *LoBeforePromotion = Lo;
1338 CondIsSignedBeforePromotion);
1350 HasDependentValue =
true;
1353 CaseRanges.push_back(std::make_pair(LoVal, CS));
1355 CaseVals.push_back(std::make_pair(LoVal, CS));
1359 if (!HasDependentValue) {
1362 llvm::APSInt ConstantCondValue;
1363 bool HasConstantCond =
false;
1364 if (!TheDefaultStmt) {
1369 ConstantCondValue =
Result.Val.getInt();
1370 assert(!HasConstantCond ||
1371 (ConstantCondValue.getBitWidth() == CondWidth &&
1372 ConstantCondValue.isSigned() == CondIsSigned));
1373 Diag(SwitchLoc, diag::warn_switch_default);
1375 bool ShouldCheckConstantCond = HasConstantCond;
1380 if (!CaseVals.empty()) {
1381 for (
unsigned i = 0, e = CaseVals.size(); i != e; ++i) {
1382 if (ShouldCheckConstantCond &&
1383 CaseVals[i].first == ConstantCondValue)
1384 ShouldCheckConstantCond =
false;
1386 if (i != 0 && CaseVals[i].first == CaseVals[i-1].first) {
1389 StringRef PrevString, CurrString;
1392 if (
DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(PrevCase)) {
1393 PrevString = DeclRef->getDecl()->getName();
1395 if (
DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(CurrCase)) {
1396 CurrString = DeclRef->getDecl()->getName();
1399 CaseVals[i-1].first.toString(CaseValStr);
1401 if (PrevString == CurrString)
1402 Diag(CaseVals[i].second->getLHS()->getBeginLoc(),
1403 diag::err_duplicate_case)
1404 << (PrevString.empty() ? CaseValStr.str() : PrevString);
1406 Diag(CaseVals[i].second->getLHS()->getBeginLoc(),
1407 diag::err_duplicate_case_differing_expr)
1408 << (PrevString.empty() ? CaseValStr.str() : PrevString)
1409 << (CurrString.empty() ? CaseValStr.str() : CurrString)
1412 Diag(CaseVals[i - 1].second->getLHS()->getBeginLoc(),
1413 diag::note_duplicate_case_prev);
1416 CaseListIsErroneous =
true;
1423 if (!CaseRanges.empty()) {
1426 llvm::stable_sort(CaseRanges);
1429 std::vector<llvm::APSInt> HiVals;
1430 for (
unsigned i = 0, e = CaseRanges.size(); i != e; ++i) {
1431 llvm::APSInt &LoVal = CaseRanges[i].first;
1432 CaseStmt *CR = CaseRanges[i].second;
1435 const Expr *HiBeforePromotion = Hi;
1442 CondWidthBeforePromotion, CondIsSignedBeforePromotion);
1448 if (LoVal > HiVal) {
1451 CaseRanges.erase(CaseRanges.begin()+i);
1457 if (ShouldCheckConstantCond &&
1458 LoVal <= ConstantCondValue &&
1459 ConstantCondValue <= HiVal)
1460 ShouldCheckConstantCond =
false;
1462 HiVals.push_back(HiVal);
1468 for (
unsigned i = 0, e = CaseRanges.size(); i != e; ++i) {
1469 llvm::APSInt &CRLo = CaseRanges[i].first;
1470 llvm::APSInt &CRHi = HiVals[i];
1471 CaseStmt *CR = CaseRanges[i].second;
1476 llvm::APSInt OverlapVal(32);
1480 CaseValsTy::iterator I =
1481 llvm::lower_bound(CaseVals, CRLo, CaseCompareFunctor());
1482 if (I != CaseVals.end() && I->first < CRHi) {
1483 OverlapVal = I->first;
1484 OverlapStmt = I->second;
1488 I = std::upper_bound(I, CaseVals.end(), CRHi, CaseCompareFunctor());
1489 if (I != CaseVals.begin() && (I-1)->first >= CRLo) {
1490 OverlapVal = (I-1)->first;
1491 OverlapStmt = (I-1)->second;
1496 if (i && CRLo <= HiVals[i-1]) {
1497 OverlapVal = HiVals[i-1];
1498 OverlapStmt = CaseRanges[i-1].second;
1506 diag::note_duplicate_case_prev);
1509 CaseListIsErroneous =
true;
1515 if (!CaseListIsErroneous && !CaseListIsIncomplete &&
1516 ShouldCheckConstantCond) {
1519 Diag(CondExpr->
getExprLoc(), diag::warn_missing_case_for_condition)
1532 if (!CaseListIsErroneous && !CaseListIsIncomplete && !HasConstantCond &&
1541 llvm::APSInt Val = EDI->getInitVal();
1543 EnumVals.push_back(std::make_pair(Val, EDI));
1546 auto EI = EnumVals.begin(), EIEnd =
1547 std::unique(EnumVals.begin(), EnumVals.end(),
EqEnumVals);
1550 for (CaseValsTy::const_iterator CI = CaseVals.begin();
1551 CI != CaseVals.end(); CI++) {
1552 Expr *CaseExpr = CI->second->getLHS();
1556 << CondTypeBeforePromotion;
1560 EI = EnumVals.begin();
1561 for (CaseRangesTy::const_iterator RI = CaseRanges.begin();
1562 RI != CaseRanges.end(); RI++) {
1563 Expr *CaseExpr = RI->second->getLHS();
1567 << CondTypeBeforePromotion;
1570 RI->second->getRHS()->EvaluateKnownConstInt(
Context);
1573 CaseExpr = RI->second->getRHS();
1577 << CondTypeBeforePromotion;
1581 auto CI = CaseVals.begin();
1582 auto RI = CaseRanges.begin();
1583 bool hasCasesNotInSwitch =
false;
1587 for (EI = EnumVals.begin(); EI != EIEnd; EI++) {
1589 switch (EI->second->getAvailability()) {
1602 if (EI->second->hasAttr<UnusedAttr>())
1606 while (CI != CaseVals.end() && CI->first < EI->first)
1609 if (CI != CaseVals.end() && CI->first == EI->first)
1613 for (; RI != CaseRanges.end(); RI++) {
1615 RI->second->getRHS()->EvaluateKnownConstInt(
Context);
1617 if (EI->first <= Hi)
1621 if (RI == CaseRanges.end() || EI->first < RI->first) {
1622 hasCasesNotInSwitch =
true;
1623 UnhandledNames.push_back(EI->second->getDeclName());
1627 if (TheDefaultStmt && UnhandledNames.empty() && ED->
isClosedNonFlag())
1631 if (!UnhandledNames.empty()) {
1633 ? diag::warn_def_missing_case
1634 : diag::warn_missing_case)
1637 for (
size_t I = 0, E = std::min(UnhandledNames.size(), (
size_t)3);
1639 DB << UnhandledNames[I];
1642 if (!hasCasesNotInSwitch)
1649 diag::warn_empty_switch_body);
1653 if (CaseListIsErroneous)
1676 const EnumDecl *ED = ET->getDecl();
1681 if (ED->
hasAttr<FlagEnumAttr>()) {
1693 llvm::APSInt Val = EDI->getInitVal();
1695 EnumVals.push_back(std::make_pair(Val, EDI));
1697 if (EnumVals.empty())
1700 EnumValsTy::iterator EIend =
1701 std::unique(EnumVals.begin(), EnumVals.end(),
EqEnumVals);
1704 EnumValsTy::const_iterator EI = EnumVals.begin();
1705 while (EI != EIend && EI->first < RhsVal)
1707 if (EI == EIend || EI->first != RhsVal) {
1722 auto CondVal = Cond.
get();
1723 CheckBreakContinueBinding(CondVal.second);
1725 if (CondVal.second &&
1726 !
Diags.
isIgnored(diag::warn_comma_operator, CondVal.second->getExprLoc()))
1727 CommaVisitor(*this).Visit(CondVal.second);
1729 if (isa<NullStmt>(Body))
1733 WhileLoc, LParenLoc, RParenLoc);
1740 assert(Cond &&
"ActOnDoStmt(): missing expression");
1742 CheckBreakContinueBinding(Cond);
1746 Cond = CondResult.
get();
1751 Cond = CondResult.
get();
1756 CommaVisitor(*this).Visit(Cond);
1758 return new (
Context)
DoStmt(Body, Cond, DoLoc, WhileLoc, CondRParen);
1769 DeclSetVector &Decls;
1775 DeclExtractor(
Sema &S, DeclSetVector &Decls,
1777 Inherited(S.Context),
1782 bool isSimple() {
return Simple; }
1791 void VisitStmt(
Stmt *S) { Simple =
false; }
1850 DeclSetVector &Decls;
1856 DeclMatcher(
Sema &S, DeclSetVector &Decls,
Stmt *Statement) :
1857 Inherited(S.Context), Decls(Decls), FoundDecl(
false) {
1858 if (!Statement)
return;
1882 void CheckLValueToRValueCast(
Expr *E) {
1885 if (isa<DeclRefExpr>(E)) {
1890 Visit(CO->getCond());
1891 CheckLValueToRValueCast(CO->getTrueExpr());
1892 CheckLValueToRValueCast(CO->getFalseExpr());
1897 dyn_cast<BinaryConditionalOperator>(E)) {
1898 CheckLValueToRValueCast(BCO->getOpaqueValue()->getSourceExpr());
1899 CheckLValueToRValueCast(BCO->getFalseExpr());
1908 if (Decls.count(VD))
1916 if (
auto *OVE = dyn_cast<OpaqueValueExpr>(S))
1918 Visit(OVE->getSourceExpr());
1924 bool FoundDeclInUse() {
return FoundDecl; }
1928 void CheckForLoopConditionalStatement(
Sema &S,
Expr *Second,
1931 if (!Second)
return;
1938 DeclSetVector Decls;
1940 DeclExtractor DE(S, Decls, Ranges);
1944 if (!DE.isSimple())
return;
1947 if (Decls.size() == 0)
return;
1950 for (
auto *VD : Decls)
1954 if (DeclMatcher(S, Decls, Second).FoundDeclInUse() ||
1955 DeclMatcher(S, Decls, Third).FoundDeclInUse() ||
1956 DeclMatcher(S, Decls, Body).FoundDeclInUse())
1960 if (Decls.size() > 4) {
1964 for (
auto *VD : Decls)
1968 for (
auto Range : Ranges)
1971 S.
Diag(Ranges.begin()->getBegin(), PDiag);
1976 bool ProcessIterationStmt(
Sema &S,
Stmt* Statement,
bool &Increment,
1978 if (
auto Cleanups = dyn_cast<ExprWithCleanups>(Statement))
1979 if (!Cleanups->cleanupsHaveSideEffects())
1982 if (
UnaryOperator *UO = dyn_cast<UnaryOperator>(Statement)) {
1983 switch (UO->getOpcode()) {
1984 default:
return false;
1994 DRE = dyn_cast<DeclRefExpr>(UO->getSubExpr());
2002 default:
return false;
2010 DRE = dyn_cast<DeclRefExpr>(
Call->getArg(0));
2022 bool InSwitch =
false;
2025 BreakContinueFinder(
Sema &S,
const Stmt* Body) :
2026 Inherited(S.Context) {
2036 void VisitBreakStmt(
const BreakStmt* E) {
2042 if (
const Stmt *
Init = S->getInit())
2044 if (
const Stmt *CondVar = S->getConditionVariableDeclStmt())
2046 if (
const Stmt *Cond = S->getCond())
2051 if (
const Stmt *Body = S->getBody())
2056 void VisitForStmt(
const ForStmt *S) {
2059 if (
const Stmt *
Init = S->getInit())
2063 void VisitWhileStmt(
const WhileStmt *) {
2068 void VisitDoStmt(
const DoStmt *) {
2076 if (
const Stmt *
Init = S->getInit())
2078 if (
const Stmt *Range = S->getRangeStmt())
2080 if (
const Stmt *
Begin = S->getBeginStmt())
2082 if (
const Stmt *End = S->getEndStmt())
2089 if (
const Stmt *Element = S->getElement())
2091 if (
const Stmt *Collection = S->getCollection())
2095 bool ContinueFound() {
return ContinueLoc.
isValid(); }
2096 bool BreakFound() {
return BreakLoc.
isValid(); }
2107 void CheckForRedundantIteration(
Sema &S,
Expr *Third,
Stmt *Body) {
2109 if (!Body || !Third)
return;
2119 if (!LastStmt)
return;
2121 bool LoopIncrement, LastIncrement;
2124 if (!ProcessIterationStmt(S, Third, LoopIncrement, LoopDRE))
return;
2125 if (!ProcessIterationStmt(S, LastStmt, LastIncrement, LastDRE))
return;
2129 if (LoopIncrement != LastIncrement ||
2132 if (BreakContinueFinder(S, Body).ContinueFound())
return;
2135 << LastDRE->
getDecl() << LastIncrement;
2143void Sema::CheckBreakContinueBinding(
Expr *E) {
2146 BreakContinueFinder BCFinder(*
this, E);
2148 if (BCFinder.BreakFound() && BreakParent) {
2150 Diag(BCFinder.GetBreakLoc(), diag::warn_break_binds_to_switch);
2152 Diag(BCFinder.GetBreakLoc(), diag::warn_loop_ctrl_binds_to_inner)
2156 Diag(BCFinder.GetContinueLoc(), diag::warn_loop_ctrl_binds_to_inner)
2173 const Decl *NonVarSeen =
nullptr;
2174 bool VarDeclSeen =
false;
2175 for (
auto *DI : DS->decls()) {
2176 if (
VarDecl *VD = dyn_cast<VarDecl>(DI)) {
2179 Diag(DI->getLocation(), diag::err_non_local_variable_decl_in_for);
2180 DI->setInvalidDecl();
2182 }
else if (!NonVarSeen) {
2192 if (NonVarSeen && !VarDeclSeen)
2197 CheckBreakContinueBinding(Second.
get().second);
2198 CheckBreakContinueBinding(third.
get());
2200 if (!Second.
get().first)
2201 CheckForLoopConditionalStatement(*
this, Second.
get().second, third.
get(),
2203 CheckForRedundantIteration(*
this, third.
get(), Body);
2205 if (Second.
get().second &&
2207 Second.
get().second->getExprLoc()))
2208 CommaVisitor(*this).Visit(Second.
get().second);
2211 if (isa<NullStmt>(Body))
2216 Body, ForLoc, LParenLoc, RParenLoc);
2244 collection = result.
get();
2253 collection = result.
get();
2260 return Diag(forLoc, diag::err_collection_expr_type)
2273 diag::err_arc_collection_forward, collection)
2277 }
else if (iface || !objectType->
qual_empty()) {
2300 Diag(forLoc, diag::warn_collection_expr_type)
2323 if (!DS->isSingleDecl())
2325 diag::err_toomany_element_decls));
2327 VarDecl *D = dyn_cast<VarDecl>(DS->getSingleDecl());
2337 diag::err_non_local_variable_decl_in_for));
2343 Expr *DeducedInit = &OpaqueId;
2351 if (FirstType.
isNull()) {
2361 Diag(Loc, diag::warn_auto_var_is_id)
2370 Diag(
First->getBeginLoc(), diag::err_selector_element_not_lvalue)
2371 <<
First->getSourceRange());
2373 FirstType =
static_cast<Expr*
>(
First)->getType();
2375 Diag(ForLoc, diag::err_selector_element_const_type)
2376 << FirstType <<
First->getSourceRange();
2381 return StmtError(
Diag(ForLoc, diag::err_selector_element_type)
2382 << FirstType <<
First->getSourceRange());
2388 CollectionExprResult =
2394 nullptr, ForLoc, RParenLoc);
2401 if (
Decl->getType()->isUndeducedType()) {
2413 if (!isa<InitListExpr>(
Init) &&
Init->getType()->isVoidType()) {
2414 SemaRef.
Diag(Loc, DiagID) <<
Init->getType();
2418 Decl->getTypeSourceInfo()->getTypeLoc(),
Init, InitType, Info);
2421 SemaRef.
Diag(Loc, DiagID) <<
Init->getType();
2428 Decl->setType(InitType);
2446enum BeginEndFunction {
2455void NoteForRangeBeginEndFunction(
Sema &SemaRef,
Expr *E,
2456 BeginEndFunction BEF) {
2457 CallExpr *CE = dyn_cast<CallExpr>(E);
2465 std::string Description;
2466 bool IsTemplate =
false;
2473 SemaRef.
Diag(Loc, diag::note_for_range_begin_end)
2474 << BEF << IsTemplate << Description << E->
getType();
2526 return Diag(InitStmt->
getBeginLoc(), diag::err_objc_for_range_init_stmt)
2532 assert(DS &&
"first part of for range not a decl stmt");
2559 const auto DepthStr = std::to_string(S->getDepth() / 2);
2561 VarDecl *RangeVar = BuildForRangeVarDecl(*
this, RangeLoc,
2563 std::string(
"__range") + DepthStr);
2565 diag::err_for_range_deduction_failure)) {
2580 ForLoc, CoawaitLoc, InitStmt, ColonLoc, RangeDecl.
get(),
2582 nullptr,
nullptr, DS, RParenLoc, Kind,
2583 LifetimeExtendTemps);
2606 ExprResult *EndExpr, BeginEndFunction *BEF) {
2616 auto BuildBegin = [&] {
2620 BeginMemberLookup, CandidateSet,
2621 BeginRange, BeginExpr);
2626 << ColonLoc << BEF_begin << BeginRange->
getType();
2639 diag::err_for_range_iter_deduction_failure)) {
2640 NoteForRangeBeginEndFunction(SemaRef, BeginExpr->
get(), *BEF);
2646 auto BuildEnd = [&] {
2650 EndMemberLookup, CandidateSet,
2655 << ColonLoc << BEF_end << EndRange->
getType();
2659 diag::err_for_range_iter_deduction_failure)) {
2660 NoteForRangeBeginEndFunction(SemaRef, EndExpr->
get(), *BEF);
2680 if (BeginMemberLookup.
empty() != EndMemberLookup.
empty()) {
2685 auto BuildNonmember = [&](
2695 switch (BuildFound()) {
2702 SemaRef.
PDiag(diag::err_for_range_invalid)
2703 << BeginRange->
getType() << BEFFound),
2710 diag::note_for_range_member_begin_end_ignored)
2711 << BeginRange->
getType() << BEFFound;
2715 llvm_unreachable(
"unexpected ForRangeStatus");
2717 if (BeginMemberLookup.
empty())
2718 return BuildNonmember(BEF_end, EndMemberLookup, BuildEnd, BuildBegin);
2719 return BuildNonmember(BEF_begin, BeginMemberLookup, BuildBegin, BuildEnd);
2751 AdjustedRange = SemaRef.
BuildUnaryOp(S, RangeLoc, UO_Deref, Range);
2756 S, ForLoc, CoawaitLoc, InitStmt, LoopVarDecl, ColonLoc,
2765 SemaRef.
Diag(RangeLoc, diag::err_for_range_dereference)
2768 S, ForLoc, CoawaitLoc, InitStmt, LoopVarDecl, ColonLoc,
2790 DeclStmt *RangeDS = cast<DeclStmt>(RangeDecl);
2794 DeclStmt *LoopVarDS = cast<DeclStmt>(LoopVarDecl);
2808 if (
auto *DD = dyn_cast<DecompositionDecl>(LoopVar))
2809 for (
auto *Binding : DD->bindings())
2813 }
else if (!BeginDeclStmt.
get()) {
2832 QualType RangeType = Range->getType();
2835 diag::err_for_range_incomplete_type))
2842 for (
auto *MTE : LifetimeExtendTemps)
2848 const auto DepthStr = std::to_string(S->getDepth() / 2);
2850 std::string(
"__begin") + DepthStr);
2852 std::string(
"__end") + DepthStr);
2863 BeginExpr = BeginRangeRef;
2870 diag::err_for_range_iter_deduction_failure)) {
2871 NoteForRangeBeginEndFunction(*
this, BeginExpr.
get(), BEF_begin);
2881 dyn_cast<VariableArrayType>(UnqAT)) {
2908 VAT->desugar(), RangeLoc))
2919 VAT->getElementType(), RangeLoc))
2927 SizeOfVLAExprR.
get(), SizeOfEachElementExprR.
get());
2934 llvm_unreachable(
"Unexpected array type in for-range");
2938 EndExpr =
ActOnBinOp(S, ColonLoc, tok::plus, EndRangeRef.
get(),
2943 diag::err_for_range_iter_deduction_failure)) {
2944 NoteForRangeBeginEndFunction(*
this, EndExpr.
get(), BEF_end);
2950 BeginEndFunction BEFFailure;
2952 *
this, BeginRangeRef.
get(), EndRangeRef.
get(), RangeType, BeginVar,
2953 EndVar, ColonLoc, CoawaitLoc, &CandidateSet, &BeginExpr, &EndExpr,
2957 BEFFailure == BEF_begin) {
2960 if (
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Range)) {
2962 QualType ArrayTy = PVD->getOriginalType();
2963 QualType PointerTy = PVD->getType();
2965 Diag(Range->getBeginLoc(), diag::err_range_on_array_parameter)
2966 << RangeLoc << PVD << ArrayTy << PointerTy;
2967 Diag(PVD->getLocation(), diag::note_declared_at);
2976 CoawaitLoc, InitStmt,
2977 LoopVarDecl, ColonLoc,
2986 Expr *Range = BEFFailure ? EndRangeRef.
get() : BeginRangeRef.
get();
2989 PDiag(diag::err_for_range_invalid)
2990 << RangeLoc << Range->getType()
3000 "invalid range expression in for loop");
3007 ? diag::warn_for_range_begin_end_types_differ
3008 : diag::ext_for_range_begin_end_types_differ)
3009 << BeginType << EndType;
3010 NoteForRangeBeginEndFunction(*
this, BeginExpr.
get(), BEF_begin);
3011 NoteForRangeBeginEndFunction(*
this, EndExpr.
get(), BEF_end);
3031 NotEqExpr =
ActOnBinOp(S, ColonLoc, tok::exclaimequal,
3032 BeginRef.
get(), EndRef.
get());
3039 Diag(RangeLoc, diag::note_for_range_invalid_iterator)
3040 << RangeLoc << 0 << BeginRangeRef.
get()->
getType();
3041 NoteForRangeBeginEndFunction(*
this, BeginExpr.
get(), BEF_begin);
3043 NoteForRangeBeginEndFunction(*
this, EndExpr.
get(), BEF_end);
3054 if (!IncrExpr.isInvalid() && CoawaitLoc.
isValid())
3059 if (!IncrExpr.isInvalid())
3061 if (IncrExpr.isInvalid()) {
3062 Diag(RangeLoc, diag::note_for_range_invalid_iterator)
3063 << RangeLoc << 2 << BeginRangeRef.
get()->
getType() ;
3064 NoteForRangeBeginEndFunction(*
this, BeginExpr.
get(), BEF_begin);
3076 Diag(RangeLoc, diag::note_for_range_invalid_iterator)
3077 << RangeLoc << 1 << BeginRangeRef.
get()->
getType();
3078 NoteForRangeBeginEndFunction(*
this, BeginExpr.
get(), BEF_begin);
3088 NoteForRangeBeginEndFunction(*
this, BeginExpr.
get(), BEF_begin);
3103 InitStmt, RangeDS, cast_or_null<DeclStmt>(BeginDeclStmt.
get()),
3104 cast_or_null<DeclStmt>(EndDeclStmt.
get()), NotEqExpr.
get(),
3105 IncrExpr.get(), LoopVarDS,
nullptr, ForLoc, CoawaitLoc,
3106 ColonLoc, RParenLoc);
3136 if (
auto Cleanups = dyn_cast<ExprWithCleanups>(InitExpr))
3137 if (!Cleanups->cleanupsHaveSideEffects())
3138 InitExpr = Cleanups->getSubExpr();
3141 dyn_cast<MaterializeTemporaryExpr>(InitExpr);
3151 while (!isa<CXXOperatorCallExpr>(E) && !isa<UnaryOperator>(E)) {
3165 if (isa<UnaryOperator>(E)) {
3172 ReferenceReturnType = ReturnType;
3175 if (!ReferenceReturnType.
isNull()) {
3180 diag::warn_for_range_const_ref_binds_temp_built_from_ref)
3181 << VD << VariableType << ReferenceReturnType;
3194 SemaRef.
Diag(VD->
getLocation(), diag::warn_for_range_ref_binds_ret_temp)
3195 << VD << RangeInitType;
3208 return RD->hasAttr<TrivialABIAttr>();
3225 if (!CE->getConstructor()->isCopyConstructor())
3227 }
else if (
const CastExpr *CE = dyn_cast<CastExpr>(InitExpr)) {
3228 if (CE->getCastKind() != CK_LValueToRValue)
3246 << VD << VariableType;
3267 diag::warn_for_range_const_ref_binds_temp_built_from_ref,
3294 ForStmt->getRangeInit()->getType());
3308 if (isa<ObjCForCollectionStmt>(S))
3315 diag::warn_empty_range_based_for_body);
3329 if (
getCurScope()->isInOpenACCComputeConstructScope())
3362 if (
getCurScope()->isInOpenACCComputeConstructScope())
3369 const Scope &DestScope) {
3372 S.
Diag(Loc, diag::warn_jump_out_of_seh_finally);
3381 return StmtError(
Diag(ContinueLoc, diag::err_continue_not_in_loop));
3383 if (S->isConditionVarScope()) {
3387 return StmtError(
Diag(ContinueLoc, diag::err_continue_from_cond_var_init));
3393 if (S->isOpenACCComputeConstructScope())
3395 Diag(ContinueLoc, diag::err_acc_branch_in_out_compute_construct)
3408 return StmtError(
Diag(BreakLoc, diag::err_break_not_in_loop_or_switch));
3410 if (S->isOpenMPLoopScope())
3411 return StmtError(
Diag(BreakLoc, diag::err_omp_loop_cannot_use_stmt)
3421 if (S->isOpenACCComputeConstructScope() ||
3422 (S->isLoopScope() && S->getParent() &&
3423 S->getParent()->isOpenACCComputeConstructScope()))
3425 Diag(BreakLoc, diag::err_acc_branch_in_out_compute_construct)
3453 const auto *DR = dyn_cast<DeclRefExpr>(E->
IgnoreParens());
3454 if (!DR || DR->refersToEnclosingVariableOrCapture())
3456 const auto *VD = dyn_cast<VarDecl>(DR->getDecl());
3487 if (VD->
getKind() == Decl::ParmVar)
3489 else if (VD->
getKind() != Decl::Var)
3502 if (VD->
hasAttr<BlocksAttr>())
3547 auto invalidNRVO = [&] {
3556 if ((ReturnType->
getTypeClass() == Type::TypeClass::Auto &&
3559 return invalidNRVO();
3565 return invalidNRVO();
3585 const auto *Step = llvm::find_if(
Seq.steps(), [](
const auto &Step) {
3586 return Step.Kind == InitializationSequence::SK_ConstructorInitialization ||
3587 Step.Kind == InitializationSequence::SK_UserConversion;
3589 if (Step !=
Seq.step_end()) {
3590 const auto *FD = Step->Function.Function;
3591 if (isa<CXXConstructorDecl>(FD)
3593 : cast<CXXMethodDecl>(FD)->getRefQualifier() ==
RQ_None)
3607 bool SupressSimplerImplicitMoves) {
3613 Expr *InitExpr = &AsRvalue;
3615 Value->getBeginLoc());
3617 auto Res =
Seq.getFailedOverloadResult();
3628 return Seq.Perform(*
this, Entity, Kind,
Value);
3651 bool SupressSimplerImplicitMoves) {
3659 bool HasDeducedReturnType =
3669 RetValExp = ER.
get();
3675 if (HasDeducedReturnType) {
3688 assert(AT &&
"lost auto type from lambda return type");
3700 if (RetValExp && !isa<InitListExpr>(RetValExp)) {
3704 RetValExp =
Result.get();
3719 Diag(ReturnLoc, diag::err_lambda_return_init_list)
3733 if (
auto *CurBlock = dyn_cast<BlockScopeInfo>(CurCap)) {
3735 Diag(ReturnLoc, diag::err_noreturn_block_has_return_expr);
3738 }
else if (
auto *CurRegion = dyn_cast<CapturedRegionScopeInfo>(CurCap)) {
3739 Diag(ReturnLoc, diag::err_return_in_captured_stmt) << CurRegion->getRegionName();
3742 assert(CurLambda &&
"unknown kind of captured scope");
3746 Diag(ReturnLoc, diag::err_noreturn_lambda_has_return_expr);
3758 if (RetValExp && !isa<InitListExpr>(RetValExp) &&
3764 Diag(ReturnLoc, diag::ext_return_has_void_expr) <<
"literal" << 2;
3766 Diag(ReturnLoc, diag::err_return_block_has_expr);
3767 RetValExp =
nullptr;
3770 }
else if (!RetValExp) {
3771 return StmtError(
Diag(ReturnLoc, diag::err_block_return_missing_expr));
3784 Entity, NRInfo, RetValExp, SupressSimplerImplicitMoves);
3789 RetValExp = Res.
get();
3790 CheckReturnValExpr(RetValExp, FnRetType, ReturnLoc);
3798 RetValExp = ER.
get();
3812 if (
auto *CurBlock = dyn_cast<BlockScopeInfo>(CurCap);
3815 CurBlock->TheDecl->setInvalidDecl();
3833class LocalTypedefNameReferencer
3836 LocalTypedefNameReferencer(
Sema &S) : S(S) {}
3841bool LocalTypedefNameReferencer::VisitRecordType(
const RecordType *RT) {
3842 auto *R = dyn_cast<CXXRecordDecl>(RT->
getDecl());
3843 if (!R || !R->isLocalClass() || !R->isLocalClass()->isExternallyVisible() ||
3844 R->isDependentType())
3846 for (
auto *TmpD : R->decls())
3847 if (
auto *T = dyn_cast<TypedefNameDecl>(TmpD))
3848 if (T->getAccess() !=
AS_private || R->hasFriends())
3872 if (RetExpr && isa<InitListExpr>(RetExpr)) {
3877 : diag::err_auto_fn_return_init_list)
3887 assert(AT->
isDeduced() &&
"should have deduced to dependent type");
3901 Diag(ReturnLoc, diag::err_auto_fn_return_void_but_not_auto)
3917 if (FindResult.Expression)
3918 TemplateSpecLoc = FindResult.Expression->getNameLoc();
3922 OrigResultType, RetExpr, Deduced, Info,
false,
3938 Diag(ReturnLoc, diag::err_typecheck_missing_return_type_incompatible)
3941 Diag(ReturnLoc, diag::err_auto_fn_different_deductions)
3956 LocalTypedefNameReferencer(*this).TraverseType(RetExpr->
getType());
3979 RetValExp,
nullptr,
true);
3983 if (
getCurScope()->isInOpenACCComputeConstructScope())
3985 Diag(ReturnLoc, diag::err_acc_branch_in_out_compute_construct)
3994 const_cast<VarDecl *
>(cast<ReturnStmt>(R.
get())->getNRVOCandidate());
4018 bool AllowRecovery) {
4026 bool SupressSimplerImplicitMoves =
4034 SupressSimplerImplicitMoves);
4038 const AttrVec *Attrs =
nullptr;
4039 bool isObjCMethod =
false;
4046 Diag(ReturnLoc, diag::warn_noreturn_function_has_return_expr) << FD;
4047 if (FD->
isMain() && RetValExp)
4048 if (isa<CXXBoolLiteralExpr>(RetValExp))
4049 Diag(ReturnLoc, diag::warn_main_returns_bool_literal)
4051 if (FD->
hasAttr<CmseNSEntryAttr>() && RetValExp) {
4058 FnRetType = MD->getReturnType();
4059 isObjCMethod =
true;
4061 Attrs = &MD->getAttrs();
4062 if (MD->hasRelatedResultType() && MD->getClassInterface()) {
4073 const auto *ATy = dyn_cast<ArrayType>(RetValExp->
getType());
4074 if (ATy && ATy->getElementType().isWebAssemblyReferenceType()) {
4075 Diag(ReturnLoc, diag::err_wasm_table_art) << 1;
4089 RetValExp = ER.
get();
4115 AT->isDeduced() ? FnRetType :
QualType());
4116 if (Recovery.isInvalid())
4118 RetValExp = Recovery.get();
4134 if (
auto *ILE = dyn_cast<InitListExpr>(RetValExp)) {
4139 int FunctionKind = 0;
4140 if (isa<ObjCMethodDecl>(CurDecl))
4142 else if (isa<CXXConstructorDecl>(CurDecl))
4144 else if (isa<CXXDestructorDecl>(CurDecl))
4147 Diag(ReturnLoc, diag::err_return_init_list)
4151 RetValExp = AllowRecovery
4153 ILE->getRBraceLoc(), ILE->inits())
4158 unsigned D = diag::ext_return_has_expr;
4161 if (isa<CXXConstructorDecl>(CurDecl) ||
4162 isa<CXXDestructorDecl>(CurDecl))
4163 D = diag::err_ctor_dtor_returns_void;
4165 D = diag::ext_return_has_void_expr;
4172 RetValExp =
Result.get();
4177 if (D == diag::err_ctor_dtor_returns_void) {
4179 Diag(ReturnLoc, D) << CurDecl << isa<CXXDestructorDecl>(CurDecl)
4183 else if (D != diag::ext_return_has_void_expr ||
4187 int FunctionKind = 0;
4188 if (isa<ObjCMethodDecl>(CurDecl))
4190 else if (isa<CXXConstructorDecl>(CurDecl))
4192 else if (isa<CXXDestructorDecl>(CurDecl))
4205 RetValExp = ER.
get();
4211 }
else if (!RetValExp && !HasDependentReturnType) {
4218 Diag(ReturnLoc, diag::err_constexpr_return_missing_expr)
4224 unsigned DiagID =
getLangOpts().C99 ? diag::ext_return_missing_expr
4225 : diag::warn_return_missing_expr;
4229 "Not in a FunctionDecl or ObjCMethodDecl?");
4230 bool IsMethod = FD ==
nullptr;
4233 Diag(ReturnLoc, DiagID) << ND << IsMethod;
4239 assert(RetValExp || HasDependentReturnType);
4240 QualType RetType = RelatedRetType.
isNull() ? FnRetType : RelatedRetType;
4253 Entity, NRInfo, RetValExp, SupressSimplerImplicitMoves);
4256 RetValExp->
getEndLoc(), RetValExp, RetType);
4267 if (!RelatedRetType.
isNull()) {
4278 CheckReturnValExpr(RetValExp, FnRetType, ReturnLoc, isObjCMethod, Attrs,
4287 RetValExp = ER.
get();
4294 if (
Result->getNRVOCandidate())
4307 VarDecl *Var = cast_or_null<VarDecl>(Parm);
4323 Diag(AtLoc, diag::err_objc_exceptions_disabled) <<
"@try";
4328 Diag(AtLoc, diag::err_mixing_cxx_try_seh_try) << 1;
4333 unsigned NumCatchStmts = CatchStmts.size();
4335 NumCatchStmts, Finally);
4355 return StmtError(
Diag(AtLoc, diag::err_objc_throw_expects_object)
4367 Diag(AtLoc, diag::err_objc_exceptions_disabled) <<
"@throw";
4372 Scope *AtCatchParent = CurScope;
4374 AtCatchParent = AtCatchParent->
getParent();
4376 return StmtError(
Diag(AtLoc, diag::err_rethrow_used_outside_catch));
4386 operand = result.
get();
4390 if (!
type->isDependentType() &&
4391 !
type->isObjCObjectPointerType()) {
4396 diag::err_incomplete_receiver_type))
4397 return Diag(atLoc, diag::err_objc_synchronized_expects_object)
4404 return Diag(atLoc, diag::err_objc_synchronized_expects_object)
4407 operand = result.
get();
4409 return Diag(atLoc, diag::err_objc_synchronized_expects_object)
4431 Stmt *HandlerBlock) {
4434 CXXCatchStmt(CatchLoc, cast_or_null<VarDecl>(ExDecl), HandlerBlock);
4444class CatchHandlerType {
4446 LLVM_PREFERRED_TYPE(
bool)
4447 unsigned IsPointer : 1;
4451 friend struct llvm::DenseMapInfo<CatchHandlerType>;
4452 enum Unique { ForDenseMap };
4453 CatchHandlerType(
QualType QT, Unique) : QT(QT), IsPointer(
false) {}
4471 CatchHandlerType(
QualType QT,
bool IsPointer)
4472 : QT(QT), IsPointer(IsPointer) {}
4474 QualType underlying()
const {
return QT; }
4475 bool isPointer()
const {
return IsPointer; }
4477 friend bool operator==(
const CatchHandlerType &LHS,
4478 const CatchHandlerType &RHS) {
4480 if (LHS.IsPointer != RHS.IsPointer)
4483 return LHS.QT == RHS.QT;
4489template <>
struct DenseMapInfo<CatchHandlerType> {
4491 return CatchHandlerType(DenseMapInfo<QualType>::getEmptyKey(),
4492 CatchHandlerType::ForDenseMap);
4496 return CatchHandlerType(DenseMapInfo<QualType>::getTombstoneKey(),
4497 CatchHandlerType::ForDenseMap);
4501 return DenseMapInfo<QualType>::getHashValue(
Base.underlying());
4505 const CatchHandlerType &RHS) {
4512class CatchTypePublicBases {
4513 const llvm::DenseMap<QualType, CXXCatchStmt *> &TypesToCheck;
4520 CatchTypePublicBases(
const llvm::DenseMap<QualType, CXXCatchStmt *> &T,
4522 : TypesToCheck(T), FoundHandler(nullptr), TestAgainstType(QT) {}
4524 CXXCatchStmt *getFoundHandler()
const {
return FoundHandler; }
4525 QualType getFoundHandlerType()
const {
return FoundHandlerType; }
4528 if (S->getAccessSpecifier() == AccessSpecifier::AS_public) {
4529 QualType Check = S->getType().getCanonicalType();
4530 const auto &M = TypesToCheck;
4531 auto I = M.find(Check);
4543 if (I->second->getCaughtType()->isPointerType() ==
4545 FoundHandler = I->second;
4546 FoundHandlerType = Check;
4561 const bool IsOpenMPGPUTarget =
4562 getLangOpts().OpenMPIsTargetDevice && (T.isNVPTX() || T.isAMDGCN());
4565 if (!IsOpenMPGPUTarget && !
getLangOpts().CXXExceptions &&
4568 targetDiag(TryLoc, diag::err_exceptions_disabled) <<
"try";
4573 if (IsOpenMPGPUTarget)
4574 targetDiag(TryLoc, diag::warn_try_not_valid_on_target) << T.str();
4582 Diag(TryLoc, diag::err_omp_simd_region_cannot_use_stmt) <<
"try";
4588 Diag(TryLoc, diag::err_mixing_cxx_try_seh_try) << 0;
4592 const unsigned NumHandlers = Handlers.size();
4593 assert(!Handlers.empty() &&
4594 "The parser shouldn't call this if there are no handlers.");
4596 llvm::DenseMap<QualType, CXXCatchStmt *> HandledBaseTypes;
4597 llvm::DenseMap<CatchHandlerType, CXXCatchStmt *> HandledTypes;
4598 for (
unsigned i = 0; i < NumHandlers; ++i) {
4605 if (i < NumHandlers - 1)
4619 QualType Underlying = HandlerCHT.underlying();
4621 if (!RD->hasDefinition())
4629 Paths.setOrigin(RD);
4630 CatchTypePublicBases CTPB(HandledBaseTypes,
4632 if (RD->lookupInBases(CTPB, Paths)) {
4634 if (!Paths.isAmbiguous(
4637 diag::warn_exception_caught_by_earlier_handler)
4640 diag::note_previous_exception_handler)
4652 auto R = HandledTypes.insert(
4657 diag::warn_exception_caught_by_earlier_handler)
4660 diag::note_previous_exception_handler)
4673 assert(TryBlock && Handler);
4700 Diag(TryLoc, diag::err_seh_try_outside_functions);
4704 Diag(TryLoc, diag::err_seh_try_unsupported);
4711 assert(FilterExpr &&
Block);
4715 Diag(FilterExpr->
getExprLoc(), diag::err_filter_expression_integral)
4737 Scope *SEHTryParent = CurScope;
4739 SEHTryParent = SEHTryParent->
getParent();
4741 return StmtError(
Diag(Loc, diag::err_ms___leave_not_in___try));
4754 QualifierLoc, NameInfo,
4755 cast<CompoundStmt>(Nested));
4772 unsigned NumParams) {
4790 assert(NumParams > 0 &&
"CapturedStmt requires context parameter");
4833 CaptureInits.push_back(
Init.get());
4840 unsigned NumParams) {
4871 unsigned OpenMPCaptureLevel) {
4877 bool ContextIsFound =
false;
4878 unsigned ParamNum = 0;
4881 I != E; ++I, ++ParamNum) {
4882 if (I->second.isNull()) {
4883 assert(!ContextIsFound &&
4884 "null type has been found already for '__context' parameter");
4894 ContextIsFound =
true;
4904 assert(ContextIsFound &&
"no null type for '__context' parameter");
4905 if (!ContextIsFound) {
4961 Captures, CaptureInits, CD, RD);
Defines the clang::ASTContext interface.
This file provides some common utility functions for processing Lambda related AST Constructs.
Defines the clang::Expr interface and subclasses for C++ expressions.
llvm::MachO::Record Record
Defines the clang::Preprocessor interface.
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
static bool CmpEnumVals(const std::pair< llvm::APSInt, EnumConstantDecl * > &lhs, const std::pair< llvm::APSInt, EnumConstantDecl * > &rhs)
CmpEnumVals - Comparison predicate for sorting enumeration values.
static bool FinishForRangeVarDecl(Sema &SemaRef, VarDecl *Decl, Expr *Init, SourceLocation Loc, int DiagID)
Finish building a variable declaration for a for-range statement.
static bool CmpCaseVals(const std::pair< llvm::APSInt, CaseStmt * > &lhs, const std::pair< llvm::APSInt, CaseStmt * > &rhs)
CmpCaseVals - Comparison predicate for sorting case values.
SmallVector< std::pair< llvm::APSInt, EnumConstantDecl * >, 64 > EnumValsTy
static bool ShouldDiagnoseSwitchCaseNotInEnum(const Sema &S, const EnumDecl *ED, const Expr *CaseExpr, EnumValsTy::iterator &EI, EnumValsTy::iterator &EIEnd, const llvm::APSInt &Val)
Returns true if we should emit a diagnostic about this case expression not being a part of the enum u...
static bool DiagnoseUnusedComparison(Sema &S, const Expr *E)
Diagnose unused comparisons, both builtin and overloaded operators.
static bool EqEnumVals(const std::pair< llvm::APSInt, EnumConstantDecl * > &lhs, const std::pair< llvm::APSInt, EnumConstantDecl * > &rhs)
EqEnumVals - Comparison preficate for uniqing enumeration values.
static bool hasDeducedReturnType(FunctionDecl *FD)
Determine whether the declared return type of the specified function contains 'auto'.
static bool ObjCEnumerationCollection(Expr *Collection)
static void DiagnoseForRangeConstVariableCopies(Sema &SemaRef, const VarDecl *VD)
static StmtResult RebuildForRangeWithDereference(Sema &SemaRef, Scope *S, SourceLocation ForLoc, SourceLocation CoawaitLoc, Stmt *InitStmt, Stmt *LoopVarDecl, SourceLocation ColonLoc, Expr *Range, SourceLocation RangeLoc, SourceLocation RParenLoc)
Speculatively attempt to dereference an invalid range expression.
static void checkEnumTypesInSwitchStmt(Sema &S, const Expr *Cond, const Expr *Case)
static void DiagnoseForRangeReferenceVariableCopies(Sema &SemaRef, const VarDecl *VD, QualType RangeInitType)
static void DiagnoseForRangeVariableCopies(Sema &SemaRef, const CXXForRangeStmt *ForStmt)
DiagnoseForRangeVariableCopies - Diagnose three cases and fixes for them.
static bool CheckSimplerImplicitMovesMSVCWorkaround(const Sema &S, const Expr *E)
static bool VerifyInitializationSequenceCXX98(const Sema &S, const InitializationSequence &Seq)
Verify that the initialization sequence that was picked for the first overload resolution is permissi...
static QualType GetTypeBeforeIntegralPromotion(const Expr *&E)
GetTypeBeforeIntegralPromotion - Returns the pre-promotion type of potentially integral-promoted expr...
static Sema::ForRangeStatus BuildNonArrayForRange(Sema &SemaRef, Expr *BeginRange, Expr *EndRange, QualType RangeType, VarDecl *BeginVar, VarDecl *EndVar, SourceLocation ColonLoc, SourceLocation CoawaitLoc, OverloadCandidateSet *CandidateSet, ExprResult *BeginExpr, ExprResult *EndExpr, BeginEndFunction *BEF)
Create the initialization, compare, and increment steps for the range-based for loop expression.
static bool DiagnoseNoDiscard(Sema &S, const WarnUnusedResultAttr *A, SourceLocation Loc, SourceRange R1, SourceRange R2, bool IsCtor)
static bool hasTrivialABIAttr(QualType VariableType)
Determines whether the VariableType's declaration is a record with the clang::trivial_abi attribute.
static void AdjustAPSInt(llvm::APSInt &Val, unsigned BitWidth, bool IsSigned)
static bool buildCapturedStmtCaptureList(Sema &S, CapturedRegionScopeInfo *RSI, SmallVectorImpl< CapturedStmt::Capture > &Captures, SmallVectorImpl< Expr * > &CaptureInits)
static void checkCaseValue(Sema &S, SourceLocation Loc, const llvm::APSInt &Val, unsigned UnpromotedWidth, bool UnpromotedSign)
Check the specified case value is in range for the given unpromoted switch type.
static void CheckJumpOutOfSEHFinally(Sema &S, SourceLocation Loc, const Scope &DestScope)
Defines the Objective-C statement AST node classes.
enum clang::format::@1245::AnnotatingParser::Context::@328 ContextType
Defines the clang::TypeLoc interface and its subclasses.
Allows QualTypes to be sorted and hence used in maps and sets.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
SourceManager & getSourceManager()
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
unsigned getIntWidth(QualType T) const
bool hasSimilarType(QualType T1, QualType T2)
Determine if two types are similar, according to the C++ rules.
QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl, ObjCInterfaceDecl *PrevDecl=nullptr) const
getObjCInterfaceType - Return the unique reference to the type for the specified ObjC interface decl.
QualType getAutoRRefDeductType() const
C++11 deduction pattern for 'auto &&' type.
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
SelectorTable & Selectors
QualType getPointerDiffType() const
Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const
Return a conservative estimate of the alignment of the specified decl D.
QualType getObjCIdType() const
Represents the Objective-CC id type.
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
const TargetInfo & getTargetInfo() const
QualType getAutoDeductType() const
C++11 deduction pattern for 'auto' type.
void adjustDeducedFunctionResultType(FunctionDecl *FD, QualType ResultType)
Change the result type of a function type once it is deduced.
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Attr - This represents one attribute.
SourceLocation getLocation() const
SourceRange getRange() const
static AttributedStmt * Create(const ASTContext &C, SourceLocation Loc, ArrayRef< const Attr * > Attrs, Stmt *SubStmt)
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
bool isDecltypeAuto() const
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
Expr * getFalseExpr() const
getFalseExpr - Return the subexpression which will be evaluated if the condnition evaluates to false;...
OpaqueValueExpr * getOpaqueValue() const
getOpaqueValue - Return the opaque value placeholder.
A builtin binary operation expression such as "x + y" or "x <= y".
SourceLocation getExprLoc() const
BreakStmt - This represents a break.
SourceLocation getBreakLoc() const
CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++ [expr....
Represents a path from a specific derived class (which is not represented as part of the path) to a p...
BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases...
Represents a base class of a C++ class.
Represents binding an expression to a temporary.
A boolean literal, per ([C++ lex.bool] Boolean literals).
CXXCatchStmt - This represents a C++ catch block.
SourceLocation getBeginLoc() const LLVM_READONLY
VarDecl * getExceptionDecl() const
QualType getCaughtType() const
Represents a call to a C++ constructor.
Represents a C++ constructor within a class.
Represents a C++ conversion function within a class.
CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for statement, represented as 'for (ra...
Represents an explicit C++ type conversion that uses "functional" notation (C++ [expr....
Represents a call to a member function that may be written either with member call syntax (e....
Represents a static or instance method of a struct/union/class.
A call to an overloaded operator written using operator syntax.
Represents a C++ struct/union/class.
static CXXRecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, CXXRecordDecl *PrevDecl=nullptr, bool DelayTypeCreation=false)
An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type.
Represents a C++ nested-name-specifier or a global scope specifier.
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context.
static CXXTryStmt * Create(const ASTContext &C, SourceLocation tryLoc, CompoundStmt *tryBlock, ArrayRef< Stmt * > handlers)
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
static CanQual< Type > CreateUnsafe(QualType Other)
Builds a canonical type from a QualType.
QualType withConst() const
Retrieves a version of this type with const applied.
Represents the body of a CapturedStmt, and serves as its DeclContext.
static DeclContext * castToDeclContext(const CapturedDecl *D)
void setContextParam(unsigned i, ImplicitParamDecl *P)
void setParam(unsigned i, ImplicitParamDecl *P)
static CapturedDecl * Create(ASTContext &C, DeclContext *DC, unsigned NumParams)
Describes the capture of either a variable, or 'this', or variable-length array type.
This captures a statement into a function.
Stmt * getCapturedStmt()
Retrieve the statement being captured.
static CapturedStmt * Create(const ASTContext &Context, Stmt *S, CapturedRegionKind Kind, ArrayRef< Capture > Captures, ArrayRef< Expr * > CaptureInits, CapturedDecl *CD, RecordDecl *RD)
CaseStmt - Represent a case statement.
static CaseStmt * Create(const ASTContext &Ctx, Expr *lhs, Expr *rhs, SourceLocation caseLoc, SourceLocation ellipsisLoc, SourceLocation colonLoc)
Build a case statement.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
CastKind getCastKind() const
CompoundStmt - This represents a group of statements like { stmt stmt }.
static CompoundStmt * Create(const ASTContext &C, ArrayRef< Stmt * > Stmts, FPOptionsOverride FPFeatures, SourceLocation LB, SourceLocation RB)
ConditionalOperator - The ?: ternary operator.
Expr * getFalseExpr() const
getFalseExpr - Return the subexpression representing the value of the expression if the condition eva...
Expr * getCond() const
getCond - Return the expression representing the condition for the ?: operator.
Expr * getTrueExpr() const
getTrueExpr - Return the subexpression representing the value of the expression if the condition eval...
ConstEvaluatedExprVisitor - This class visits 'const Expr *'s.
Represents the canonical version of C arrays with a specified constant size.
ContinueStmt - This represents a continue.
SourceLocation getContinueLoc() const
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
bool isFileContext() const
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
void addDecl(Decl *D)
Add the declaration D into this context.
bool isStdNamespace() const
bool isFunctionOrMethod() const
void addHiddenDecl(Decl *D)
Add the declaration D to this context without modifying any lookup tables.
bool isSingleDecl() const
A reference to a declared variable, function, enum, etc.
SourceLocation getLocation() const
DeclStmt - Adaptor class for mixing declarations with statements and expressions.
bool isSingleDecl() const
isSingleDecl - This method returns true if this DeclStmt refers to a single Decl.
const Decl * getSingleDecl() const
SourceLocation getBeginLoc() const LLVM_READONLY
Decl - This represents one declaration (or definition), e.g.
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
void markUsed(ASTContext &C)
Mark the declaration used, in the sense of odr-use.
static Decl * castFromDeclContext(const DeclContext *)
bool isInvalidDecl() const
SourceLocation getLocation() const
void setImplicit(bool I=true)
void setLocation(SourceLocation L)
DeclContext * getDeclContext()
SourceLocation getTypeSpecEndLoc() const
SourceLocation getTypeSpecStartLoc() const
SourceLocation getBeginLoc() const LLVM_READONLY
TypeSourceInfo * getTypeSourceInfo() const
QualType getDeducedType() const
Get the type deduced for this placeholder type, or null if it has not been deduced.
SourceLocation getDefaultLoc() const
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
DoStmt - This represents a 'do/while' stmt.
enumerator_range enumerators() const
bool isClosed() const
Returns true if this enum is either annotated with enum_extensibility(closed) or isn't annotated with...
bool isClosedNonFlag() const
Returns true if this enum is annotated with neither flag_enum nor enum_extensibility(open).
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
EnumDecl * getDecl() const
EvaluatedExprVisitor - This class visits 'Expr *'s.
This represents one expression.
bool EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer,...
@ SE_AllowSideEffects
Allow any unmodeled side effect.
Expr * IgnoreParenCasts() LLVM_READONLY
Skip past any parentheses and casts which might surround this expression until reaching a fixed point...
bool isUnusedResultAWarning(const Expr *&WarnExpr, SourceLocation &Loc, SourceRange &R1, SourceRange &R2, ASTContext &Ctx) const
isUnusedResultAWarning - Return true if this immediate expression should be warned about if the resul...
bool isValueDependent() const
Determines whether the value of this expression depends on.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
bool containsErrors() const
Whether this expression contains subexpressions which had errors, e.g.
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language.
Decl * getReferencedDeclOfCallee()
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on.
bool isIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
Expr * IgnoreImpCasts() LLVM_READONLY
Skip past any implicit casts which might surround this expression until reaching a fixed point.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
bool isKnownToHaveBooleanValue(bool Semantic=true) const
isKnownToHaveBooleanValue - Return true if this is an integer expression that is known to return 0 or...
Represents difference between two FPOptions values.
FPOptionsOverride getChangesFrom(const FPOptions &Base) const
Return difference with the given option set.
Represents a member of a struct/union/class.
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
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.
ForStmt - This represents a 'for (init;cond;inc)' stmt.
SourceLocation getRParenLoc() const
SourceLocation getBeginLoc() const
FullExpr - Represents a "full-expression" node.
Represents a function declaration or definition.
const ParmVarDecl * getParamDecl(unsigned i) const
void setUsesSEHTry(bool UST)
bool isNoReturn() const
Determines whether this function is known to be 'noreturn', through an attribute on its declaration o...
QualType getReturnType() const
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
bool isMain() const
Determines whether this function is "main", which is the entry point into an executable program.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
bool isOverloadedOperator() const
Whether this function declaration represents an C++ overloaded operator, e.g., "operator+".
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any.
Represents a prototype with parameter type info, e.g.
Declaration of a template function.
FunctionType - C99 6.7.5.3 - Function Declarators.
static StringRef getNameForCallConv(CallingConv CC)
bool getNoReturnAttr() const
Determine whether this function type includes the GNU noreturn attribute.
QualType getReturnType() const
GNUNullExpr - Implements the GNU __null extension, which is a name for a null pointer constant that h...
GotoStmt - This represents a direct goto.
One of these records is kept for each identifier that is lexed.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
static IfStmt * Create(const ASTContext &Ctx, SourceLocation IL, IfStatementKind Kind, Stmt *Init, VarDecl *Var, Expr *Cond, SourceLocation LPL, SourceLocation RPL, Stmt *Then, SourceLocation EL=SourceLocation(), Stmt *Else=nullptr)
Create an IfStmt.
ImaginaryLiteral - We support imaginary integer and floating point literals, like "1....
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat, FPOptionsOverride FPO)
static ImplicitParamDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, ImplicitParamKind ParamKind)
Create implicit parameter.
IndirectGotoStmt - This represents an indirect goto.
static InitializationKind CreateCopy(SourceLocation InitLoc, SourceLocation EqualLoc, bool AllowExplicitConvs=false)
Create a copy initialization.
Describes the sequence of initializations required to initialize a given object or reference with a s...
Describes an entity that is being initialized.
static InitializedEntity InitializeResult(SourceLocation ReturnLoc, QualType Type)
Create the initialization entity for the result of a function.
static InitializedEntity InitializeRelatedResult(ObjCMethodDecl *MD, QualType Type)
Create the initialization entity for a related result.
unsigned allocateManglingNumber() const
static InitializedEntity InitializeVariable(VarDecl *Var)
Create the initialization entity for a variable.
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
Represents the declaration of a label.
void setLocStart(SourceLocation L)
LabelStmt * getStmt() const
void setStmt(LabelStmt *T)
bool isMSAsmLabel() const
LabelStmt - Represents a label, which has a substatement.
Represents the results of name lookup.
bool empty() const
Return true if no decls were found.
Representation of a Microsoft __if_exists or __if_not_exists statement with a dependent name.
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
Expr * getSubExpr() const
Retrieve the temporary-generating subexpression whose value will be materialized into a glvalue.
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
A pointer to member type per C++ 8.3.3 - Pointers to members.
This represents a decl that may have a name.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
ReservedIdentifierStatus isReserved(const LangOptions &LangOpts) const
Determine if the declaration obeys the reserved identifier rules of the given language.
A C++ nested-name-specifier augmented with source location information.
NullStmt - This is the null statement ";": C99 6.8.3p3.
Represents Objective-C's @catch statement.
Represents Objective-C's @finally statement.
Represents Objective-C's @synchronized statement.
Represents Objective-C's @throw statement.
static ObjCAtTryStmt * Create(const ASTContext &Context, SourceLocation atTryLoc, Stmt *atTryStmt, Stmt **CatchStmts, unsigned NumCatchStmts, Stmt *atFinallyStmt)
Represents Objective-C's @autoreleasepool Statement.
Represents Objective-C's collection statement.
Represents an ObjC class declaration.
ObjCMethodDecl * lookupInstanceMethod(Selector Sel) const
Lookup an instance method for a given selector.
ObjCMethodDecl * lookupPrivateMethod(const Selector &Sel, bool Instance=true) const
Lookup a method in the classes implementation hierarchy.
An expression that sends a message to the given Objective-C object or class.
ObjCMethodDecl - Represents an instance or class method declaration.
Represents a pointer to an Objective C object.
Represents a class type in Objective C.
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface.
Wrapper for void* pointer.
void * getAsOpaquePtr() const
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
Expr * getSourceExpr() const
The source expression of an opaque value expression is the expression which originally generated the ...
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13....
@ CSK_Normal
Normal lookup.
void NoteCandidates(PartialDiagnosticAt PA, Sema &S, OverloadCandidateDisplayKind OCD, ArrayRef< Expr * > Args, StringRef Opc="", SourceLocation Loc=SourceLocation(), llvm::function_ref< bool(OverloadCandidate &)> Filter=[](OverloadCandidate &) { return true;})
When overload resolution fails, prints diagnostic messages containing the candidates in the candidate...
static FindResult find(Expr *E)
Finds the overloaded expression in the given expression E of OverloadTy.
ParenExpr - This represents a parethesized expression, e.g.
const Expr * getSubExpr() const
Represents a parameter to a function.
ParsedAttributes - A collection of parsed attributes.
Wrapper for source info for pointers.
SourceLocation getStarLoc() const
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
IdentifierTable & getIdentifierTable()
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
ArrayRef< Expr * > semantics()
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
QualType withRestrict() const
QualType withConst() const
bool isTriviallyCopyConstructibleType(const ASTContext &Context) const
Return true if this is a trivially copyable type.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
QualType getCanonicalType() const
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
bool isConstQualified() const
Determine whether this type is const-qualified.
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
Represents a struct/union/class.
static RecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, RecordDecl *PrevDecl=nullptr)
bool isOrContainsUnion() const
Returns whether this record is a union, or contains (at any nesting level) a union member.
virtual void completeDefinition()
Note that the definition of this type is now complete.
void setCapturedRecord()
Mark the record as a record for captured variables in CapturedStmt construct.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
RecordDecl * getDecl() const
A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...
ReturnStmt - This represents a return, optionally of an expression: return; return 4;.
void setRetValue(Expr *E)
static ReturnStmt * Create(const ASTContext &Ctx, SourceLocation RL, Expr *E, const VarDecl *NRVOCandidate)
Create a return statement.
static SEHExceptStmt * Create(const ASTContext &C, SourceLocation ExceptLoc, Expr *FilterExpr, Stmt *Block)
static SEHFinallyStmt * Create(const ASTContext &C, SourceLocation FinallyLoc, Stmt *Block)
Represents a __leave statement.
static SEHTryStmt * Create(const ASTContext &C, bool isCXXTry, SourceLocation TryLoc, Stmt *TryBlock, Stmt *Handler)
Scope - A scope is a transient data structure that is used while parsing the program.
const Scope * getFnParent() const
getFnParent - Return the closest scope that is a function body.
bool isAtCatchScope() const
isAtCatchScope - Return true if this scope is @catch.
bool Contains(const Scope &rhs) const
Returns if rhs has a higher scope depth than this.
unsigned getFlags() const
getFlags - Return the flags for this scope.
Scope * getContinueParent()
getContinueParent - Return the closest scope that a continue statement would be affected by.
bool isSEHTryScope() const
Determine whether this scope is a SEH '__try' block.
Scope * getBreakParent()
getBreakParent - Return the closest scope that a break statement would be affected by.
const Scope * getParent() const
getParent - Return the scope that this is nested in.
void updateNRVOCandidate(VarDecl *VD)
@ SwitchScope
This is a scope that corresponds to a switch statement.
Selector getSelector(unsigned NumArgs, IdentifierInfo **IIV)
Can create any sort of selector.
Smart pointer class that efficiently represents Objective-C method names.
std::pair< VarDecl *, Expr * > get() const
RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...
A generic diagnostic builder for errors which may or may not be deferred.
Sema - This implements semantic analysis and AST building for C.
ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo)
Package the given type and TSI into a ParsedType.
ExprResult PerformContextuallyConvertToObjCPointer(Expr *From)
PerformContextuallyConvertToObjCPointer - Perform a contextual conversion of the expression From to a...
SmallVector< Scope *, 2 > CurrentSEHFinally
Stack of active SEH __finally scopes. Can be empty.
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
Scope * getCurScope() const
Retrieve the parser's current scope.
void ProcessStmtAttributes(Stmt *Stmt, const ParsedAttributes &InAttrs, SmallVectorImpl< const Attr * > &OutAttrs)
Process the attributes before creating an attributed statement.
ExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc, tok::TokenKind Op, Expr *Input, bool IsAfterAmp=false)
StmtResult BuildMSDependentExistsStmt(SourceLocation KeywordLoc, bool IsIfExists, NestedNameSpecifierLoc QualifierLoc, DeclarationNameInfo NameInfo, Stmt *Nested)
ExprResult IgnoredValueConversions(Expr *E)
IgnoredValueConversions - Given that an expression's result is syntactically ignored,...
@ LookupMemberName
Member name lookup, which finds the names of class/struct/union members.
ExprResult ActOnObjCAtSynchronizedOperand(SourceLocation atLoc, Expr *operand)
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
bool ActOnCoroutineBodyStart(Scope *S, SourceLocation KwLoc, StringRef Keyword)
void ActOnOpenMPLoopInitialization(SourceLocation ForLoc, Stmt *Init)
Check if the current region is an OpenMP loop region and if it is, mark loop control variable,...
StmtResult BuildAttributedStmt(SourceLocation AttrsLoc, ArrayRef< const Attr * > Attrs, Stmt *SubStmt)
StmtResult ActOnSEHLeaveStmt(SourceLocation Loc, Scope *CurScope)
StmtResult ActOnObjCForCollectionStmt(SourceLocation ForColLoc, Stmt *First, Expr *collection, SourceLocation RParenLoc)
StmtResult ActOnForEachLValueExpr(Expr *E)
In an Objective C collection iteration statement: for (x in y) x can be an arbitrary l-value expressi...
void ActOnForEachDeclStmt(DeclGroupPtrTy Decl)
void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl=nullptr, ExpressionEvaluationContextRecord::ExpressionKind Type=ExpressionEvaluationContextRecord::EK_Other)
ExprResult CheckBooleanCondition(SourceLocation Loc, Expr *E, bool IsConstexpr=false)
CheckBooleanCondition - Diagnose problems involving the use of the given expression as a boolean cond...
@ Switch
An integral condition for a 'switch' statement.
SmallVector< sema::FunctionScopeInfo *, 4 > FunctionScopes
Stack containing information about each of the nested function, block, and method scopes that are cur...
PoppedFunctionScopePtr PopFunctionScopeInfo(const sema::AnalysisBasedWarnings::Policy *WP=nullptr, const Decl *D=nullptr, QualType BlockType=QualType())
Pop a function (or block or lambda or captured region) scope from the stack.
bool checkAndRewriteMustTailAttr(Stmt *St, const Attr &MTA)
Check whether the given statement can have musttail applied to it, issuing a diagnostic and returning...
StmtResult ActOnGotoStmt(SourceLocation GotoLoc, SourceLocation LabelLoc, LabelDecl *TheDecl)
StmtResult ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp, Scope *CurScope)
void setFunctionHasBranchIntoScope()
ExprResult ActOnCaseExpr(SourceLocation CaseLoc, ExprResult Val)
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, AllowFoldKind CanFold=NoFold)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
StmtResult ActOnExprStmt(ExprResult Arg, bool DiscardedValue=true)
FieldDecl * BuildCaptureField(RecordDecl *RD, const sema::Capture &Capture)
Build a FieldDecl suitable to hold the given capture.
ObjCMethodDecl * LookupMethodInQualifiedType(Selector Sel, const ObjCObjectPointerType *OPT, bool IsInstance)
LookupMethodInQualifiedType - Lookups up a method in protocol qualifier list of a qualified objective...
StmtResult BuildIfStmt(SourceLocation IfLoc, IfStatementKind StatementKind, SourceLocation LParenLoc, Stmt *InitStmt, ConditionResult Cond, SourceLocation RParenLoc, Stmt *ThenVal, SourceLocation ElseLoc, Stmt *ElseVal)
FunctionDecl * getCurFunctionDecl(bool AllowLambda=false) const
Returns a pointer to the innermost enclosing function, or nullptr if the current context is not insid...
ExprResult PerformContextualImplicitConversion(SourceLocation Loc, Expr *FromE, ContextualImplicitConverter &Converter)
Perform a contextual implicit conversion.
StmtResult BuildObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw)
ExprResult UsualUnaryConversions(Expr *E)
UsualUnaryConversions - Performs various conversions that are common to most operators (C99 6....
void DiagnoseCommaOperator(const Expr *LHS, SourceLocation Loc)
ExprResult CheckSwitchCondition(SourceLocation SwitchLoc, Expr *Cond)
bool DiagIfReachable(SourceLocation Loc, ArrayRef< const Stmt * > Stmts, const PartialDiagnostic &PD)
Conditionally issue a diagnostic based on the statements's reachability analysis.
void FinalizeDeclaration(Decl *D)
FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform any semantic actions neces...
void ActOnCapturedRegionError()
StmtResult ActOnObjCAutoreleasePoolStmt(SourceLocation AtLoc, Stmt *Body)
DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType=nullptr)
ExprResult DefaultFunctionArrayLvalueConversion(Expr *E, bool Diagnose=true)
ASTContext & getASTContext() const
ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *Input, bool IsAfterAmp=false)
void PopExpressionEvaluationContext()
StmtResult ActOnSEHTryBlock(bool IsCXXTry, SourceLocation TryLoc, Stmt *TryBlock, Stmt *Handler)
ObjCMethodDecl * getCurMethodDecl()
getCurMethodDecl - If inside of a method body, this returns a pointer to the method decl for the meth...
DeclRefExpr * BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, SourceLocation Loc, const CXXScopeSpec *SS=nullptr)
ExprResult CheckConvertedConstantExpression(Expr *From, QualType T, llvm::APSInt &Value, CCEKind CCE)
void setFunctionHasIndirectGoto()
ExprResult BuildCaptureInit(const sema::Capture &Capture, SourceLocation ImplicitCaptureLoc, bool IsOpenMPMapping=false)
Initialize the given capture with a suitable expression.
StmtResult ActOnFinishSwitchStmt(SourceLocation SwitchLoc, Stmt *Switch, Stmt *Body)
NamedReturnInfo getNamedReturnInfo(Expr *&E, SimplerImplicitMoveMode Mode=SimplerImplicitMoveMode::Normal)
Determine whether the given expression might be move-eligible or copy-elidable in either a (co_)retur...
ExprResult CheckObjCForCollectionOperand(SourceLocation forLoc, Expr *collection)
std::unique_ptr< sema::FunctionScopeInfo, PoppedFunctionScopeDeleter > PoppedFunctionScopePtr
void DiagnoseUnusedExprResult(const Stmt *S, unsigned DiagID)
DiagnoseUnusedExprResult - If the statement passed in is an expression whose result is unused,...
FPOptions & getCurFPFeatures()
@ UPPC_Expression
An arbitrary expression.
StmtResult ActOnObjCAtTryStmt(SourceLocation AtLoc, Stmt *Try, MultiStmtArg Catch, Stmt *Finally)
const LangOptions & getLangOpts() const
StmtResult ActOnWhileStmt(SourceLocation WhileLoc, SourceLocation LParenLoc, ConditionResult Cond, SourceLocation RParenLoc, Stmt *Body)
SemaDiagnosticBuilder CUDADiagIfDeviceCode(SourceLocation Loc, unsigned DiagID)
Creates a SemaDiagnosticBuilder that emits the diagnostic if the current context is "used as device c...
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CCK_ImplicitConversion)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
const LangOptions & LangOpts
StmtResult FinishObjCForCollectionStmt(Stmt *ForCollection, Stmt *Body)
FinishObjCForCollectionStmt - Attach the body to a objective-C foreach statement.
sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)
Retrieve the current lambda scope info, if any.
void ActOnStartOfCompoundStmt(bool IsStmtExpr)
bool DeduceFunctionTypeFromReturnExpr(FunctionDecl *FD, SourceLocation ReturnLoc, Expr *RetExpr, const AutoType *AT)
Deduce the return type for a function from a returned expression, per C++1y [dcl.spec....
void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse)
Perform marking for a reference to an arbitrary declaration.
void setOpenMPCaptureKind(FieldDecl *FD, const ValueDecl *D, unsigned Level)
Sets OpenMP capture kind (OMPC_private, OMPC_firstprivate, OMPC_map etc.) for FD based on DSA for the...
TypeLoc getReturnTypeLoc(FunctionDecl *FD) const
StmtResult ActOnExprStmtError()
const VarDecl * getCopyElisionCandidate(NamedReturnInfo &Info, QualType ReturnType)
Updates given NamedReturnInfo's move-eligible and copy-elidable statuses, considering the function re...
NamedDecl * getCurFunctionOrMethodDecl() const
getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method or C function we're in,...
StmtResult ActOnNullStmt(SourceLocation SemiLoc, bool HasLeadingEmptyMacro=false)
RecordDecl * CreateCapturedStmtRecordDecl(CapturedDecl *&CD, SourceLocation Loc, unsigned NumParams)
void ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope, CapturedRegionKind Kind, unsigned NumParams)
sema::FunctionScopeInfo * getCurFunction() const
void PushCompoundScope(bool IsStmtExpr)
DeclGroupPtrTy BuildDeclaratorGroup(MutableArrayRef< Decl * > Group)
BuildDeclaratorGroup - convert a list of declarations into a declaration group, performing any necess...
AssignConvertType CheckSingleAssignmentConstraints(QualType LHSType, ExprResult &RHS, bool Diagnose=true, bool DiagnoseCFAudited=false, bool ConvertRHS=true)
Check assignment constraints for an assignment of RHS to LHSType.
void DiagnoseAssignmentEnum(QualType DstType, QualType SrcType, Expr *SrcExpr)
DiagnoseAssignmentEnum - Warn if assignment to enum is a constant integer not in the range of enum va...
ExprResult ActOnCoawaitExpr(Scope *S, SourceLocation KwLoc, Expr *E)
std::optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
bool findMacroSpelling(SourceLocation &loc, StringRef name)
Looks through the macro-expansion chain for the given location, looking for a macro expansion with th...
void DiagnoseEmptyStmtBody(SourceLocation StmtLoc, const Stmt *Body, unsigned DiagID)
Emit DiagID if statement located on StmtLoc has a suspicious null statement as a Body,...
void DiagnoseEmptyLoopBody(const Stmt *S, const Stmt *PossibleBody)
Warn if a for/while loop statement S, which is followed by PossibleBody, has a suspicious null statem...
ExprResult DefaultLvalueConversion(Expr *E)
void DiagnoseAutoDeductionFailure(VarDecl *VDecl, Expr *Init)
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name)
Retrieves the declaration name from a parsed unqualified-id.
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5.
StmtResult ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp, NamedReturnInfo &NRInfo, bool SupressSimplerImplicitMoves)
ActOnCapScopeReturnStmt - Utility routine to type-check return statements for capturing scopes.
AssignConvertType
AssignConvertType - All of the 'assignment' semantic checks return this enum to indicate whether the ...
StmtResult ActOnCapturedRegionEnd(Stmt *S)
StmtResult ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc, Stmt *First, ConditionResult Second, FullExprArg Third, SourceLocation RParenLoc, Stmt *Body)
StmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc, SourceLocation StarLoc, Expr *DestExp)
ExprResult CheckPlaceholderExpr(Expr *E)
Check for operands with placeholder types and complain if found.
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
SourceManager & getSourceManager() const
StmtResult ActOnObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw, Scope *CurScope)
ExprResult PerformMoveOrCopyInitialization(const InitializedEntity &Entity, const NamedReturnInfo &NRInfo, Expr *Value, bool SupressSimplerImplicitMoves=false)
Perform the initialization of a potentially-movable value, which is the result of return value.
void ActOnInitializerError(Decl *Dcl)
ActOnInitializerError - Given that there was an error parsing an initializer for the given declaratio...
StmtResult ActOnCXXForRangeStmt(Scope *S, SourceLocation ForLoc, SourceLocation CoawaitLoc, Stmt *InitStmt, Stmt *LoopVar, SourceLocation ColonLoc, Expr *Collection, SourceLocation RParenLoc, BuildForRangeKind Kind, ArrayRef< MaterializeTemporaryExpr * > LifetimeExtendTemps={})
ActOnCXXForRangeStmt - Check and build a C++11 for-range statement.
StmtResult ActOnObjCAtFinallyStmt(SourceLocation AtLoc, Stmt *Body)
StmtResult BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp, bool AllowRecovery=false)
bool isCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind=CompleteTypeKind::Default)
ExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc, tok::TokenKind Kind, Expr *LHSExpr, Expr *RHSExpr)
void PushCapturedRegionScope(Scope *RegionScope, CapturedDecl *CD, RecordDecl *RD, CapturedRegionKind K, unsigned OpenMPCaptureLevel=0)
void setFunctionHasMustTail()
void setFunctionHasBranchProtectedScope()
StmtResult ActOnFinishSEHFinallyBlock(SourceLocation Loc, Stmt *Block)
StmtResult ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope)
@ CCEK_CaseValue
Expression in a case label.
StmtResult BuildCXXForRangeStmt(SourceLocation ForLoc, SourceLocation CoawaitLoc, Stmt *InitStmt, SourceLocation ColonLoc, Stmt *RangeDecl, Stmt *Begin, Stmt *End, Expr *Cond, Expr *Inc, Stmt *LoopVarDecl, SourceLocation RParenLoc, BuildForRangeKind Kind, ArrayRef< MaterializeTemporaryExpr * > LifetimeExtendTemps={})
BuildCXXForRangeStmt - Build or instantiate a C++11 for-range statement.
StmtResult ActOnDoStmt(SourceLocation DoLoc, Stmt *Body, SourceLocation WhileLoc, SourceLocation CondLParen, Expr *Cond, SourceLocation CondRParen)
StmtResult ActOnStartOfSwitchStmt(SourceLocation SwitchLoc, SourceLocation LParenLoc, Stmt *InitStmt, ConditionResult Cond, SourceLocation RParenLoc)
StmtResult ActOnMSDependentExistsStmt(SourceLocation KeywordLoc, bool IsIfExists, CXXScopeSpec &SS, UnqualifiedId &Name, Stmt *Nested)
bool inferObjCARCLifetime(ValueDecl *decl)
@ PotentiallyEvaluated
The current expression is potentially evaluated at run time, which means that code may be generated t...
@ ImmediateFunctionContext
In addition of being constant evaluated, the current expression occurs in an immediate function conte...
CUDAFunctionTarget CurrentCUDATarget()
Gets the CUDA target for the current context.
StmtResult ActOnSEHExceptBlock(SourceLocation Loc, Expr *FilterExpr, Stmt *Block)
void ActOnAfterCompoundStatementLeadingPragmas()
StmtResult ActOnDeclStmt(DeclGroupPtrTy Decl, SourceLocation StartLoc, SourceLocation EndLoc)
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.
void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl, ArrayRef< Decl * > Fields, SourceLocation LBrac, SourceLocation RBrac, const ParsedAttributesView &AttrList)
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
void DiscardCleanupsInEvaluationContext()
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
void PushDeclContext(Scope *S, DeclContext *DC)
Set the current declaration context until it gets popped.
StmtResult ActOnAttributedStmt(const ParsedAttributes &AttrList, Stmt *SubStmt)
SourceManager & SourceMgr
DiagnosticsEngine & Diags
StmtResult ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope)
void ActOnStartSEHFinallyBlock()
ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)
void ActOnAbortSEHFinallyBlock()
QualType SubstAutoTypeDependent(QualType TypeWithAuto)
@ BFRK_Check
Determining whether a for-range statement could be built.
@ BFRK_Build
Initial building of a for-range statement.
@ BFRK_Rebuild
Instantiation or recovery rebuild of a for-range statement.
StmtResult ActOnCXXCatchBlock(SourceLocation CatchLoc, Decl *ExDecl, Stmt *HandlerBlock)
ActOnCXXCatchBlock - Takes an exception declaration and a handler block and creates a proper catch ha...
void ActOnCaseStmtBody(Stmt *CaseStmt, Stmt *SubStmt)
ActOnCaseStmtBody - This installs a statement as the body of a case.
void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit)
AddInitializerToDecl - Adds the initializer Init to the declaration dcl.
bool DiagnoseAssignmentResult(AssignConvertType ConvTy, SourceLocation Loc, QualType DstType, QualType SrcType, Expr *SrcExpr, AssignmentAction Action, bool *Complained=nullptr)
DiagnoseAssignmentResult - Emit a diagnostic, if required, for the assignment conversion type specifi...
SemaDiagnosticBuilder targetDiag(SourceLocation Loc, unsigned DiagID, const FunctionDecl *FD=nullptr)
ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End, ArrayRef< Expr * > SubExprs, QualType T=QualType())
Attempts to produce a RecoveryExpr after some AST node cannot be created.
StmtResult ActOnObjCAtCatchStmt(SourceLocation AtLoc, SourceLocation RParen, Decl *Parm, Stmt *Body)
StmtResult ActOnIfStmt(SourceLocation IfLoc, IfStatementKind StatementKind, SourceLocation LParenLoc, Stmt *InitStmt, ConditionResult Cond, SourceLocation RParenLoc, Stmt *ThenVal, SourceLocation ElseLoc, Stmt *ElseVal)
std::string getTemplateArgumentBindingsText(const TemplateParameterList *Params, const TemplateArgumentList &Args)
Produces a formatted string that describes the binding of template parameters to template arguments.
ExprResult ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc, UnaryExprOrTypeTrait ExprKind, bool IsType, void *TyOrEx, SourceRange ArgRange)
ActOnUnaryExprOrTypeTraitExpr - Handle sizeof(type) and sizeof expr and the same for alignof and __al...
ForRangeStatus BuildForRangeBeginEndCall(SourceLocation Loc, SourceLocation RangeLoc, const DeclarationNameInfo &NameInfo, LookupResult &MemberLookup, OverloadCandidateSet *CandidateSet, Expr *Range, ExprResult *CallExpr)
Build a call to 'begin' or 'end' for a C++11 for-range statement.
sema::CompoundScopeInfo & getCurCompoundScope() const
TemplateDeductionResult DeduceAutoType(TypeLoc AutoTypeLoc, Expr *Initializer, QualType &Result, sema::TemplateDeductionInfo &Info, bool DependentDeduction=false, bool IgnoreConstraints=false, TemplateSpecCandidateSet *FailedTSC=nullptr)
Deduce the type for an auto type-specifier (C++11 [dcl.spec.auto]p6)
void ActOnFinishOfCompoundStmt()
StmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R, ArrayRef< Stmt * > Elts, bool isStmtExpr)
StmtResult ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc, Expr *SynchExpr, Stmt *SynchBody)
bool IsValueInFlagEnum(const EnumDecl *ED, const llvm::APInt &Val, bool AllowMask) const
IsValueInFlagEnum - Determine if a value is allowed as part of a flag enum.
StmtResult ActOnLabelStmt(SourceLocation IdentLoc, LabelDecl *TheDecl, SourceLocation ColonLoc, Stmt *SubStmt)
StmtResult ActOnCXXTryBlock(SourceLocation TryLoc, Stmt *TryBlock, ArrayRef< Stmt * > Handlers)
ActOnCXXTryBlock - Takes a try compound-statement and a number of handlers and creates a try statemen...
StmtResult ActOnDefaultStmt(SourceLocation DefaultLoc, SourceLocation ColonLoc, Stmt *SubStmt, Scope *CurScope)
StmtResult ActOnCaseStmt(SourceLocation CaseLoc, ExprResult LHS, SourceLocation DotDotDotLoc, ExprResult RHS, SourceLocation ColonLoc)
StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body)
FinishCXXForRangeStmt - Attach the body to a C++0x for-range statement.
ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, bool RecoverUncorrectedTypos=false, llvm::function_ref< ExprResult(Expr *)> Filter=[](Expr *E) -> ExprResult { return E;})
Process any TypoExprs in the given Expr and its children, generating diagnostics as appropriate and r...
ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
SourceLocation getLocWithOffset(IntTy Offset) const
Return a source location with the specified offset from this SourceLocation.
bool isMacroBodyExpansion(SourceLocation Loc) const
Tests whether the given source location represents the expansion of a macro body.
bool isInSystemMacro(SourceLocation loc) const
Returns whether Loc is expanded from a macro in a system header.
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.
SourceLocation getEndLoc() const LLVM_READONLY
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
static std::tuple< bool, const Attr *, const Attr * > determineLikelihoodConflict(const Stmt *Then, const Stmt *Else)
static const Attr * getLikelihoodAttr(const Stmt *S)
SourceLocation getBeginLoc() const LLVM_READONLY
const SwitchCase * getNextSwitchCase() const
SwitchStmt - This represents a 'switch' stmt.
static SwitchStmt * Create(const ASTContext &Ctx, Stmt *Init, VarDecl *Var, Expr *Cond, SourceLocation LParenLoc, SourceLocation RParenLoc)
Create a switch statement.
SwitchCase * getSwitchCaseList()
void setAllEnumCasesCovered()
Set a flag in the SwitchStmt indicating that if the 'switch (X)' is a switch over an enum value then ...
Represents the declaration of a struct/union/class/enum.
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
TypedefNameDecl * getTypedefNameForAnonDecl() const
void startDefinition()
Starts the definition of this tag declaration.
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
bool isSEHTrySupported() const
Whether the target supports SEH __try.
TemplateSpecCandidateSet - A set of generalized overload candidates, used in template specializations...
void NoteCandidates(Sema &S, SourceLocation Loc)
NoteCandidates - When no template specialization match is found, prints diagnostic messages containin...
Base wrapper for a particular "section" of type source info.
QualType getType() const
Get the type for which this source info wrapper provides information.
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type.
T getAsAdjusted() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
SourceLocation getBeginLoc() const
Get the begin source location.
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
The base class of the type hierarchy.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isBlockPointerType() const
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
bool isRValueReferenceType() const
bool isPointerType() const
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
bool isEnumeralType() const
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type.
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool containsErrors() const
Whether this type is an error type.
const ArrayType * getAsArrayTypeUnsafe() const
A variant of getAs<> for array types which silently discards qualifiers from the outermost type.
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
bool isObjectType() const
Determine whether this type is an object type.
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isObjCObjectPointerType() const
TypeClass getTypeClass() const
bool isCanonicalUnqualified() const
Determines if this type would be canonical if it had no further qualification.
const T * getAs() const
Member-template getAs<specific type>'.
bool isRecordType() const
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Expr * getSubExpr() const
Represents a C++ unqualified-id that has been parsed.
void setType(QualType newType)
Represents a variable declaration or definition.
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
void setARCPseudoStrong(bool PS)
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
bool hasGlobalStorage() const
Returns true for all variables that do not have local storage.
bool isExceptionVariable() const
Determine whether this variable is the exception variable in a C++ catch statememt or an Objective-C ...
const Expr * getInit() const
bool hasLocalStorage() const
Returns true if a variable with function scope is a non-static local variable.
bool isLocalVarDecl() const
Returns true for local variable declarations other than parameters.
bool hasDependentAlignment() const
Determines if this variable's alignment is dependent.
Represents a C array with a specified size that is not an integer-constant-expression.
WhileStmt - This represents a 'while' stmt.
static WhileStmt * Create(const ASTContext &Ctx, VarDecl *Var, Expr *Cond, Stmt *Body, SourceLocation WL, SourceLocation LParenLoc, SourceLocation RParenLoc)
Create a while statement.
ValueDecl * getVariable() const
bool isVariableCapture() const
SourceLocation getLocation() const
Retrieve the location at which this variable was captured.
bool isVLATypeCapture() const
bool isThisCapture() const
bool isReferenceCapture() const
Retains information about a captured region.
unsigned short OpenMPLevel
unsigned short CapRegionKind
The kind of captured region.
RecordDecl * TheRecordDecl
The captured record type.
CapturedDecl * TheCapturedDecl
The CapturedDecl for this statement.
QualType ReturnType
ReturnType - The target type of return statements in this context, or null if unknown.
SmallVector< Capture, 4 > Captures
Captures - The captures.
bool HasImplicitReturnType
Contains information about the compound statement currently being parsed.
FPOptions InitialFPFeatures
FP options at the beginning of the compound statement, prior to any pragma.
void setHasEmptyLoopBodies()
Retains information about a function, method, or block that is currently being parsed.
llvm::PointerIntPair< SwitchStmt *, 1, bool > SwitchInfo
A SwitchStmt, along with a flag indicating if its list of case statements is incomplete (because we d...
void setHasObjCTry(SourceLocation TryLoc)
SourceLocation FirstCXXOrObjCTryLoc
First C++ 'try' or ObjC @try statement in the current function.
SourceLocation FirstSEHTryLoc
First SEH '__try' statement in the current function.
void setHasCXXTry(SourceLocation TryLoc)
SmallVector< CompoundScopeInfo, 4 > CompoundScopes
The stack of currently active compound statement scopes in the function.
void setHasSEHTry(SourceLocation TryLoc)
enum clang::sema::FunctionScopeInfo::@238 FirstTryType
SmallVector< SwitchInfo, 8 > SwitchStack
SwitchStack - This is the current set of active switch statements in the block.
CXXMethodDecl * CallOperator
The lambda's compiler-generated operator().
Provides information about an attempted template argument deduction, whose success or failure was des...
TemplateArgument SecondArg
The second template argument to which the template argument deduction failure refers.
TemplateArgument FirstArg
The first template argument to which the template argument deduction failure refers.
Defines the clang::TargetInfo interface.
const AstTypeMatcher< PointerType > pointerType
Matches pointer types, but does not match Objective-C object pointer types.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
bool This(InterpState &S, CodePtr OpPC)
The JSON file list parser is used to communicate input to InstallAPI.
@ Seq
'seq' clause, allowed on 'loop' and 'routine' directives.
Expr * IgnoreElidableImplicitConstructorSingleStep(Expr *E)
@ OR_Deleted
Succeeded, but refers to a deleted function.
@ OR_Success
Overload resolution succeeded.
bool isReservedInAllContexts(ReservedIdentifierStatus Status)
Determine whether an identifier is reserved in all contexts.
IfStatementKind
In an if statement, this denotes whether the statement is a constexpr or consteval if statement.
Expr * IgnoreExprNodes(Expr *E, FnTys &&... Fns)
Given an expression E and functions Fn_1,...,Fn_n : Expr * -> Expr *, Recursively apply each of the f...
@ RQ_None
No ref-qualifier was provided.
@ OCD_AllCandidates
Requests that all candidates be shown.
bool operator==(const CallGraphNode::CallRecord &LHS, const CallGraphNode::CallRecord &RHS)
CapturedRegionKind
The different kinds of captured statement.
@ Result
The result type of a method or function.
ActionResult< Expr * > ExprResult
@ Struct
The "struct" keyword.
bool isLambdaConversionOperator(CXXConversionDecl *C)
ActionResult< Stmt * > StmtResult
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
@ VK_XValue
An x-value expression is a reference to an object with independent storage but which can be "moved",...
@ VK_LValue
An l-value expression is a reference to an object with independent storage.
Expr * IgnoreParensSingleStep(Expr *E)
Expr * IgnoreImplicitAsWrittenSingleStep(Expr *E)
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
TemplateDeductionResult
Describes the result of template argument deduction.
@ Success
Template argument deduction was successful.
@ Inconsistent
Template argument deduction produced inconsistent deduced values for the given template parameter.
@ AlreadyDiagnosed
Some error which was already diagnosed.
@ CapturedContext
Parameter for captured context.
YAML serialization mapping.
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
EvalResult is a struct with detailed info about an evaluated expression.
@ MoveEligibleAndCopyElidable
bool isMoveEligible() const
bool isCopyElidable() const
const VarDecl * Candidate
static CatchHandlerType getEmptyKey()
static CatchHandlerType getTombstoneKey()
static unsigned getHashValue(const CatchHandlerType &Base)
static bool isEqual(const CatchHandlerType &LHS, const CatchHandlerType &RHS)