39#include "llvm/ADT/ArrayRef.h"
40#include "llvm/ADT/DenseMap.h"
41#include "llvm/ADT/STLExtras.h"
42#include "llvm/ADT/STLForwardCompat.h"
43#include "llvm/ADT/SmallVector.h"
44#include "llvm/ADT/StringExtras.h"
72 bool HasLeadingEmptyMacro) {
101 Diag(
decl->getLocation(), diag::err_non_variable_decl_in_for);
102 decl->setInvalidDecl();
108 var->setInit(
nullptr);
121 var->setType(
type.withConst());
122 var->setARCPseudoStrong(
true);
135 enum { Equality, Inequality, Relational, ThreeWay } Kind;
138 if (!Op->isComparisonOp())
141 if (Op->getOpcode() == BO_EQ)
143 else if (Op->getOpcode() == BO_NE)
145 else if (Op->getOpcode() == BO_Cmp)
148 assert(Op->isRelationalOp());
151 Loc = Op->getOperatorLoc();
152 CanAssign = Op->getLHS()->IgnoreParenImpCasts()->isLValue();
154 switch (Op->getOperator()) {
158 case OO_ExclaimEqual:
163 case OO_GreaterEqual:
174 Loc = Op->getOperatorLoc();
175 CanAssign = Op->getArg(0)->IgnoreParenImpCasts()->isLValue();
186 S.
Diag(
Loc, diag::warn_unused_comparison)
192 if (Kind == Inequality)
193 S.
Diag(
Loc, diag::note_inequality_comparison_to_or_assign)
195 else if (Kind == Equality)
196 S.
Diag(
Loc, diag::note_equality_comparison_to_assign)
208 StringRef Msg = A->getMessage();
212 return S.
Diag(
Loc, diag::warn_unused_return_type)
213 << IsCtor << A << OffendingDecl <<
false << R1 << R2;
215 return S.
Diag(
Loc, diag::warn_unused_constructor)
216 << A <<
false << R1 << R2;
217 return S.
Diag(
Loc, diag::warn_unused_result) << A <<
false << R1 << R2;
221 return S.
Diag(
Loc, diag::warn_unused_return_type)
222 << IsCtor << A << OffendingDecl <<
true << Msg << R1 << R2;
224 return S.
Diag(
Loc, diag::warn_unused_constructor)
225 << A <<
true << Msg << R1 << R2;
226 return S.
Diag(
Loc, diag::warn_unused_result) << A <<
true << Msg << R1 << R2;
235void DiagnoseUnused(
Sema &S,
const Expr *
E, std::optional<unsigned> DiagID) {
236 bool NoDiscardOnly = !DiagID.has_value();
252 const Expr *WarnExpr;
258 if (!NoDiscardOnly) {
279 if (
const FullExpr *Temps = dyn_cast<FullExpr>(
E))
280 E = Temps->getSubExpr();
282 E = TempExpr->getSubExpr();
288 if (
const auto *Cast = dyn_cast<CastExpr>(
E))
289 if (
Cast->getCastKind() == CK_NoOp ||
290 Cast->getCastKind() == CK_ConstructorConversion ||
291 Cast->getCastKind() == CK_IntegralCast)
292 E =
Cast->getSubExpr()->IgnoreImpCasts();
294 if (
const CallExpr *CE = dyn_cast<CallExpr>(
E)) {
298 auto [OffendingDecl, A] = CE->getUnusedResultAttr(S.
Context);
300 cast_or_null<WarnUnusedResultAttr>(A),
Loc, R1, R2,
308 if (
const Decl *FD = CE->getCalleeDecl()) {
311 if (FD->hasAttr<PureAttr>()) {
312 S.
Diag(
Loc, diag::warn_unused_call) << R1 << R2 <<
"pure";
315 if (FD->hasAttr<ConstAttr>()) {
316 S.
Diag(
Loc, diag::warn_unused_call) << R1 << R2 <<
"const";
320 }
else if (
const auto *CE = dyn_cast<CXXConstructExpr>(
E)) {
322 const NamedDecl *OffendingDecl =
nullptr;
323 const auto *A = Ctor->
getAttr<WarnUnusedResultAttr>();
325 OffendingDecl = Ctor->getParent();
326 A = OffendingDecl->
getAttr<WarnUnusedResultAttr>();
332 }
else if (
const auto *ILE = dyn_cast<InitListExpr>(
E)) {
333 if (
const TagDecl *TD = ILE->getType()->getAsTagDecl()) {
339 }
else if (ShouldSuppress)
344 if (S.
getLangOpts().ObjCAutoRefCount && ME->isDelegateInitCall()) {
345 S.
Diag(
Loc, diag::err_arc_unused_init_message) << R1;
356 const Expr *Source = POE->getSyntacticForm();
358 if (S.
LangOpts.OpenMP && isa<CallExpr>(Source) &&
359 POE->getNumSemanticExprs() == 1 &&
360 isa<CallExpr>(POE->getSemanticExpr(0)))
361 return DiagnoseUnused(S, POE->getSemanticExpr(0), DiagID);
362 if (isa<ObjCSubscriptRefExpr>(Source))
363 DiagID = diag::warn_unused_container_subscript_expr;
364 else if (isa<ObjCPropertyRefExpr>(Source))
365 DiagID = diag::warn_unused_property_expr;
367 = dyn_cast<CXXFunctionalCastExpr>(
E)) {
368 const Expr *
E = FC->getSubExpr();
370 E = TE->getSubExpr();
371 if (isa<CXXTemporaryObjectExpr>(
E))
374 if (
const CXXRecordDecl *RD = CE->getType()->getAsCXXRecordDecl())
375 if (!RD->getAttr<WarnUnusedAttr>())
391 S.
Diag(
Loc, diag::warn_unused_voidptr)
401 S.
Diag(
Loc, diag::warn_unused_volatile) << R1 << R2;
408 if (DiagID == diag::warn_unused_comma_left_operand && S.
isSFINAEContext())
412 S.
PDiag(*DiagID) << R1 << R2);
417 DiagnoseUnused(*
this,
E, std::nullopt);
422 S =
Label->getSubStmt();
424 const Expr *
E = dyn_cast_if_present<Expr>(S);
428 DiagnoseUnused(*
this,
E, DiagID);
453 const unsigned NumElts = Elts.size();
458 const unsigned MixedDeclsCodeID =
getLangOpts().C99
459 ? diag::warn_mixed_decls_code
460 : diag::ext_mixed_decls_code;
465 for (; i != NumElts && isa<DeclStmt>(Elts[i]); ++i)
469 for (; i != NumElts && !isa<DeclStmt>(Elts[i]); ++i)
473 Decl *
D = *cast<DeclStmt>(Elts[i])->decl_begin();
483 for (
unsigned i = 0; i != NumElts - 1; ++i)
519 auto CheckAndFinish = [&](
Expr *
E) {
526 llvm::APSInt TempVal;
546 if (Converted.
get() == Val.
get())
547 Converted = CheckAndFinish(Val.
get());
555 assert((LHSVal.
isInvalid() || LHSVal.
get()) &&
"missing LHS value");
558 "missing RHS value");
561 Diag(CaseLoc, diag::err_case_not_in_switch);
572 Diag(CaseLoc, diag::err_acc_branch_in_out_compute_construct)
578 CaseLoc, DotDotDotLoc, ColonLoc);
584 cast<CaseStmt>(S)->setSubStmt(SubStmt);
591 Diag(DefaultLoc, diag::err_default_not_in_switch);
597 Diag(DefaultLoc, diag::err_acc_branch_in_out_compute_construct)
612 Diag(IdentLoc, diag::err_redefinition_of_label) << TheDecl->
getDeclName();
620 Diag(IdentLoc, diag::warn_reserved_extern_symbol)
621 << TheDecl << static_cast<int>(Status);
625 if (
getCurScope()->isInOpenACCComputeConstructScope())
632 if (isa<OpenACCUpdateConstruct>(SubStmt)) {
656 for (
const auto *A : Attrs) {
657 if (A->getKind() == attr::MustTail) {
672 if (!SemanticAttrs.empty())
688 if (!checkMustTailAttr(St, MTA))
694 auto IgnoreImplicitAsWritten = [](
Expr *
E) ->
Expr * {
705bool Sema::checkMustTailAttr(
const Stmt *St,
const Attr &MTA) {
707 "musttail cannot be checked from a dependent context");
710 auto IgnoreParenImplicitAsWritten = [](
const Expr *
E) ->
const Expr * {
716 const Expr *
E = cast<ReturnStmt>(St)->getRetValue();
717 const auto *CE = dyn_cast_or_null<CallExpr>(IgnoreParenImplicitAsWritten(
E));
724 if (
const auto *EWC = dyn_cast<ExprWithCleanups>(
E)) {
725 if (EWC->cleanupsHaveSideEffects()) {
726 Diag(St->
getBeginLoc(), diag::err_musttail_needs_trivial_args) << &MTA;
737 ft_non_static_member,
738 ft_pointer_to_member,
739 } MemberType = ft_non_member;
744 } CallerType, CalleeType;
747 bool IsCallee) ->
bool {
748 if (isa<CXXConstructorDecl, CXXDestructorDecl>(CMD)) {
750 << IsCallee << isa<CXXDestructorDecl>(CMD);
752 Diag(CMD->getBeginLoc(), diag::note_musttail_structors_forbidden)
753 << isa<CXXDestructorDecl>(CMD);
758 Type.MemberType = FuncType::ft_static_member;
760 Type.This = CMD->getFunctionObjectParameterType();
761 Type.MemberType = FuncType::ft_non_static_member;
767 const auto *CallerDecl = dyn_cast<FunctionDecl>(
CurContext);
778 Diag(St->
getBeginLoc(), diag::err_musttail_forbidden_from_this_context)
781 }
else if (
const auto *CMD = dyn_cast<CXXMethodDecl>(
CurContext)) {
783 if (!GetMethodType(CMD, CallerType,
false))
791 const auto *CalleeBinOp = dyn_cast<BinaryOperator>(CalleeExpr);
793 ? CE->getCalleeDecl()->getBeginLoc()
798 dyn_cast_or_null<CXXMethodDecl>(CE->getCalleeDecl())) {
800 if (!GetMethodType(CMD, CalleeType,
true))
802 }
else if (CalleeBinOp && CalleeBinOp->isPtrMemOp()) {
806 CalleeType.This =
QualType(MPT->getClass(), 0);
808 CalleeType.MemberType = FuncType::ft_pointer_to_member;
809 }
else if (isa<CXXPseudoDestructorExpr>(CalleeExpr)) {
821 if (!CalleeType.Func || !CallerType.Func) {
823 if (!CalleeType.Func && CE->getDirectCallee()) {
824 Diag(CE->getDirectCallee()->getBeginLoc(),
825 diag::note_musttail_fix_non_prototype);
827 if (!CallerType.Func)
828 Diag(CallerDecl->getBeginLoc(), diag::note_musttail_fix_non_prototype);
839 if (CallerType.Func->getCallConv() != CalleeType.Func->getCallConv()) {
840 if (
const auto *ND = dyn_cast_or_null<NamedDecl>(CE->getCalleeDecl()))
842 <<
true << ND->getDeclName();
844 Diag(St->
getBeginLoc(), diag::err_musttail_callconv_mismatch) <<
false;
845 Diag(CalleeLoc, diag::note_musttail_callconv_mismatch)
852 if (CalleeType.Func->isVariadic() || CallerType.Func->isVariadic()) {
857 const auto *CalleeDecl = CE->getCalleeDecl();
858 if (CalleeDecl && CalleeDecl->hasAttr<CXX11NoReturnAttr>()) {
864 if (CallerType.This.isNull() != CalleeType.This.isNull()) {
865 if (
const auto *ND = dyn_cast_or_null<NamedDecl>(CE->getCalleeDecl())) {
867 << CallerType.MemberType << CalleeType.MemberType <<
true
868 << ND->getDeclName();
869 Diag(CalleeLoc, diag::note_musttail_callee_defined_here)
870 << ND->getDeclName();
873 << CallerType.MemberType << CalleeType.MemberType <<
false;
878 auto CheckTypesMatch = [
this](FuncType CallerType, FuncType CalleeType,
888 unsigned Select) ->
bool {
896 if (!CallerType.This.isNull() &&
900 if (!DoTypesMatch(CallerType.Func->getReturnType(),
904 if (CallerType.Func->getNumParams() != CalleeType.Func->getNumParams()) {
906 << CalleeType.Func->getNumParams();
912 size_t N = CallerType.Func->getNumParams();
913 for (
size_t I = 0; I < N; I++) {
914 if (!DoTypesMatch(CalleeParams[I], CallerParams[I],
916 PD << static_cast<int>(I) + 1;
925 if (!CheckTypesMatch(CallerType, CalleeType, PD)) {
926 if (
const auto *ND = dyn_cast_or_null<NamedDecl>(CE->getCalleeDecl()))
928 <<
true << ND->getDeclName();
939 for (
auto ArgExpr : CE->arguments()) {
941 Context, ArgExpr->getType(),
false);
953 CommaVisitor(
Sema &SemaRef) : Inherited(SemaRef.Context), SemaRef(SemaRef) {}
955 if (
E->getOpcode() == BO_Comma)
971 bool ConstevalOrNegatedConsteval =
975 Expr *CondExpr = Cond.
get().second;
976 assert((CondExpr || ConstevalOrNegatedConsteval) &&
977 "If statement: missing condition");
981 CommaVisitor(*this).Visit(CondExpr);
983 if (!ConstevalOrNegatedConsteval && !elseStmt)
986 if (ConstevalOrNegatedConsteval ||
988 auto DiagnoseLikelihood = [&](
const Stmt *S) {
991 diag::warn_attribute_has_no_effect_on_compile_time_if)
992 << A << ConstevalOrNegatedConsteval << A->getRange();
994 diag::note_attribute_has_no_effect_on_compile_time_if_here)
995 << ConstevalOrNegatedConsteval
1002 DiagnoseLikelihood(thenStmt);
1003 DiagnoseLikelihood(elseStmt);
1005 std::tuple<bool, const Attr *, const Attr *> LHC =
1007 if (std::get<0>(LHC)) {
1008 const Attr *ThenAttr = std::get<1>(LHC);
1009 const Attr *ElseAttr = std::get<2>(LHC);
1011 diag::warn_attributes_likelihood_ifstmt_conflict)
1012 << ThenAttr << ThenAttr->
getRange();
1014 << ElseAttr << ElseAttr->
getRange();
1018 if (ConstevalOrNegatedConsteval) {
1024 if (FD && FD->isImmediateFunction())
1028 Diags.
Report(IfLoc, diag::warn_consteval_if_always_true) << Immediate;
1035 if (isa<OpenACCUpdateConstruct>(thenStmt)) {
1040 return BuildIfStmt(IfLoc, StatementKind, LParenLoc, InitStmt, Cond, RParenLoc,
1041 thenStmt, ElseLoc, elseStmt);
1054 isa<ObjCAvailabilityCheckExpr>(Cond.
get().second))
1058 Cond.
get().first, Cond.
get().second, LParenLoc,
1059 RParenLoc, thenStmt, ElseLoc, elseStmt);
1063 struct CaseCompareFunctor {
1064 bool operator()(
const std::pair<llvm::APSInt, CaseStmt*> &LHS,
1065 const llvm::APSInt &RHS) {
1066 return LHS.first < RHS;
1068 bool operator()(
const std::pair<llvm::APSInt, CaseStmt*> &LHS,
1069 const std::pair<llvm::APSInt, CaseStmt*> &RHS) {
1070 return LHS.first < RHS.first;
1072 bool operator()(
const llvm::APSInt &LHS,
1073 const std::pair<llvm::APSInt, CaseStmt*> &RHS) {
1074 return LHS < RHS.first;
1082 const std::pair<llvm::APSInt, CaseStmt*>& rhs) {
1083 if (lhs.first < rhs.first)
1086 if (lhs.first == rhs.first &&
1087 lhs.second->getCaseLoc() < rhs.second->getCaseLoc())
1094static bool CmpEnumVals(
const std::pair<llvm::APSInt, EnumConstantDecl*>& lhs,
1095 const std::pair<llvm::APSInt, EnumConstantDecl*>& rhs)
1097 return lhs.first < rhs.first;
1102static bool EqEnumVals(
const std::pair<llvm::APSInt, EnumConstantDecl*>& lhs,
1103 const std::pair<llvm::APSInt, EnumConstantDecl*>& rhs)
1105 return lhs.first == rhs.first;
1111 if (
const auto *FE = dyn_cast<FullExpr>(
E))
1112 E = FE->getSubExpr();
1113 while (
const auto *ImpCast = dyn_cast<ImplicitCastExpr>(
E)) {
1114 if (ImpCast->getCastKind() != CK_IntegralCast)
break;
1115 E = ImpCast->getSubExpr();
1125 SwitchConvertDiagnoser(
Expr *Cond)
1131 return S.
Diag(
Loc, diag::err_typecheck_statement_requires_integer) <<
T;
1136 return S.
Diag(
Loc, diag::err_switch_incomplete_class_type)
1142 return S.
Diag(
Loc, diag::err_switch_explicit_conversion) <<
T << ConvTy;
1153 return S.
Diag(
Loc, diag::err_switch_multiple_conversions) <<
T;
1164 llvm_unreachable(
"conversion functions are permitted");
1166 } SwitchDiagnoser(Cond);
1175 Cond = CondResult.
get();
1188 Expr *CondExpr = Cond.
get().second;
1189 assert((Cond.
isInvalid() || CondExpr) &&
"switch with no condition");
1202 Diag(SwitchLoc, diag::warn_bool_switch_condition)
1210 LParenLoc, RParenLoc);
1216static void AdjustAPSInt(llvm::APSInt &Val,
unsigned BitWidth,
bool IsSigned) {
1217 Val = Val.extOrTrunc(BitWidth);
1218 Val.setIsSigned(IsSigned);
1224 unsigned UnpromotedWidth,
bool UnpromotedSign) {
1232 if (UnpromotedWidth < Val.getBitWidth()) {
1233 llvm::APSInt ConvVal(Val);
1234 AdjustAPSInt(ConvVal, UnpromotedWidth, UnpromotedSign);
1235 AdjustAPSInt(ConvVal, Val.getBitWidth(), Val.isSigned());
1251 const Expr *CaseExpr,
1252 EnumValsTy::iterator &EI,
1253 EnumValsTy::iterator &EIEnd,
1254 const llvm::APSInt &Val) {
1260 if (
const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
1269 if (ED->
hasAttr<FlagEnumAttr>())
1272 while (EI != EIEnd && EI->first < Val)
1275 if (EI != EIEnd && EI->first == Val)
1288 if (!CondEnumType || !CaseEnumType)
1295 if (!CaseEnumType->getDecl()->getIdentifier() &&
1296 !CaseEnumType->getDecl()->getTypedefNameForAnonDecl())
1302 S.
Diag(Case->
getExprLoc(), diag::warn_comparison_of_mixed_enum_types_switch)
1312 assert(SS ==
getCurFunction()->SwitchStack.back().getPointer() &&
1313 "switch stack missing push/pop!");
1323 if (isa<OpenACCUpdateConstruct>(BodyStmt)) {
1328 SS->
setBody(BodyStmt, SwitchLoc);
1342 const Expr *CondExprBeforePromotion = CondExpr;
1348 bool HasDependentValue
1357 unsigned CondWidthBeforePromotion
1359 bool CondIsSignedBeforePromotion
1366 CaseValsTy CaseVals;
1369 typedef std::vector<std::pair<llvm::APSInt, CaseStmt*> > CaseRangesTy;
1370 CaseRangesTy CaseRanges;
1374 bool CaseListIsErroneous =
false;
1382 if (
DefaultStmt *DS = dyn_cast<DefaultStmt>(SC)) {
1383 if (TheDefaultStmt) {
1384 Diag(DS->getDefaultLoc(), diag::err_multiple_default_labels_defined);
1391 CaseListIsErroneous =
true;
1393 TheDefaultStmt = DS;
1401 HasDependentValue =
true;
1407 const Expr *LoBeforePromotion = Lo;
1414 CondIsSignedBeforePromotion);
1426 HasDependentValue =
true;
1429 CaseRanges.push_back(std::make_pair(LoVal, CS));
1431 CaseVals.push_back(std::make_pair(LoVal, CS));
1435 if (!HasDependentValue) {
1438 llvm::APSInt ConstantCondValue;
1439 bool HasConstantCond =
false;
1440 if (!TheDefaultStmt) {
1445 ConstantCondValue =
Result.Val.getInt();
1446 assert(!HasConstantCond ||
1447 (ConstantCondValue.getBitWidth() == CondWidth &&
1448 ConstantCondValue.isSigned() == CondIsSigned));
1449 Diag(SwitchLoc, diag::warn_switch_default);
1451 bool ShouldCheckConstantCond = HasConstantCond;
1456 if (!CaseVals.empty()) {
1457 for (
unsigned i = 0, e = CaseVals.size(); i != e; ++i) {
1458 if (ShouldCheckConstantCond &&
1459 CaseVals[i].first == ConstantCondValue)
1460 ShouldCheckConstantCond =
false;
1462 if (i != 0 && CaseVals[i].first == CaseVals[i-1].first) {
1465 StringRef PrevString, CurrString;
1468 if (
DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(PrevCase)) {
1469 PrevString = DeclRef->getDecl()->getName();
1471 if (
DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(CurrCase)) {
1472 CurrString = DeclRef->getDecl()->getName();
1475 CaseVals[i-1].first.toString(CaseValStr);
1477 if (PrevString == CurrString)
1478 Diag(CaseVals[i].second->getLHS()->getBeginLoc(),
1479 diag::err_duplicate_case)
1480 << (PrevString.empty() ? CaseValStr.str() : PrevString);
1482 Diag(CaseVals[i].second->getLHS()->getBeginLoc(),
1483 diag::err_duplicate_case_differing_expr)
1484 << (PrevString.empty() ? CaseValStr.str() : PrevString)
1485 << (CurrString.empty() ? CaseValStr.str() : CurrString)
1488 Diag(CaseVals[i - 1].second->getLHS()->getBeginLoc(),
1489 diag::note_duplicate_case_prev);
1492 CaseListIsErroneous =
true;
1499 if (!CaseRanges.empty()) {
1502 llvm::stable_sort(CaseRanges);
1505 std::vector<llvm::APSInt> HiVals;
1506 for (
unsigned i = 0, e = CaseRanges.size(); i != e; ++i) {
1507 llvm::APSInt &LoVal = CaseRanges[i].first;
1508 CaseStmt *CR = CaseRanges[i].second;
1511 const Expr *HiBeforePromotion = Hi;
1518 CondWidthBeforePromotion, CondIsSignedBeforePromotion);
1524 if (LoVal > HiVal) {
1527 CaseRanges.erase(CaseRanges.begin()+i);
1533 if (ShouldCheckConstantCond &&
1534 LoVal <= ConstantCondValue &&
1535 ConstantCondValue <= HiVal)
1536 ShouldCheckConstantCond =
false;
1538 HiVals.push_back(HiVal);
1544 for (
unsigned i = 0, e = CaseRanges.size(); i != e; ++i) {
1545 llvm::APSInt &CRLo = CaseRanges[i].first;
1546 llvm::APSInt &CRHi = HiVals[i];
1547 CaseStmt *CR = CaseRanges[i].second;
1552 llvm::APSInt OverlapVal(32);
1556 CaseValsTy::iterator I =
1557 llvm::lower_bound(CaseVals, CRLo, CaseCompareFunctor());
1558 if (I != CaseVals.end() && I->first < CRHi) {
1559 OverlapVal = I->first;
1560 OverlapStmt = I->second;
1564 I = std::upper_bound(I, CaseVals.end(), CRHi, CaseCompareFunctor());
1565 if (I != CaseVals.begin() && (I-1)->first >= CRLo) {
1566 OverlapVal = (I-1)->first;
1567 OverlapStmt = (I-1)->second;
1572 if (i && CRLo <= HiVals[i-1]) {
1573 OverlapVal = HiVals[i-1];
1574 OverlapStmt = CaseRanges[i-1].second;
1582 diag::note_duplicate_case_prev);
1585 CaseListIsErroneous =
true;
1591 if (!CaseListIsErroneous && !CaseListIsIncomplete &&
1592 ShouldCheckConstantCond) {
1595 Diag(CondExpr->
getExprLoc(), diag::warn_missing_case_for_condition)
1608 if (!CaseListIsErroneous && !CaseListIsIncomplete && !HasConstantCond &&
1617 llvm::APSInt Val = EDI->getInitVal();
1619 EnumVals.push_back(std::make_pair(Val, EDI));
1622 auto EI = EnumVals.begin(), EIEnd =
1623 std::unique(EnumVals.begin(), EnumVals.end(),
EqEnumVals);
1626 for (CaseValsTy::const_iterator CI = CaseVals.begin();
1627 CI != CaseVals.end(); CI++) {
1628 Expr *CaseExpr = CI->second->getLHS();
1632 << CondTypeBeforePromotion;
1636 EI = EnumVals.begin();
1637 for (CaseRangesTy::const_iterator RI = CaseRanges.begin();
1638 RI != CaseRanges.end(); RI++) {
1639 Expr *CaseExpr = RI->second->getLHS();
1643 << CondTypeBeforePromotion;
1646 RI->second->getRHS()->EvaluateKnownConstInt(
Context);
1649 CaseExpr = RI->second->getRHS();
1653 << CondTypeBeforePromotion;
1657 auto CI = CaseVals.begin();
1658 auto RI = CaseRanges.begin();
1659 bool hasCasesNotInSwitch =
false;
1663 for (EI = EnumVals.begin(); EI != EIEnd; EI++) {
1665 switch (EI->second->getAvailability()) {
1678 if (EI->second->hasAttr<UnusedAttr>())
1682 while (CI != CaseVals.end() && CI->first < EI->first)
1685 if (CI != CaseVals.end() && CI->first == EI->first)
1689 for (; RI != CaseRanges.end(); RI++) {
1691 RI->second->getRHS()->EvaluateKnownConstInt(
Context);
1693 if (EI->first <= Hi)
1697 if (RI == CaseRanges.end() || EI->first < RI->first) {
1698 hasCasesNotInSwitch =
true;
1699 UnhandledNames.push_back(EI->second->getDeclName());
1703 if (TheDefaultStmt && UnhandledNames.empty() && ED->
isClosedNonFlag())
1707 if (!UnhandledNames.empty()) {
1709 ? diag::warn_def_missing_case
1710 : diag::warn_missing_case)
1713 for (
size_t I = 0,
E = std::min(UnhandledNames.size(), (
size_t)3);
1715 DB << UnhandledNames[I];
1718 if (!hasCasesNotInSwitch)
1725 diag::warn_empty_switch_body);
1729 if (CaseListIsErroneous)
1752 const EnumDecl *ED = ET->getDecl();
1757 if (ED->
hasAttr<FlagEnumAttr>()) {
1769 llvm::APSInt Val = EDI->getInitVal();
1771 EnumVals.push_back(std::make_pair(Val, EDI));
1773 if (EnumVals.empty())
1776 EnumValsTy::iterator EIend =
1777 std::unique(EnumVals.begin(), EnumVals.end(),
EqEnumVals);
1780 EnumValsTy::const_iterator EI = EnumVals.begin();
1781 while (EI != EIend && EI->first < RhsVal)
1783 if (EI == EIend || EI->first != RhsVal) {
1798 auto CondVal = Cond.
get();
1799 CheckBreakContinueBinding(CondVal.second);
1801 if (CondVal.second &&
1802 !
Diags.
isIgnored(diag::warn_comma_operator, CondVal.second->getExprLoc()))
1803 CommaVisitor(*this).Visit(CondVal.second);
1809 if (isa<OpenACCUpdateConstruct>(Body)) {
1814 if (isa<NullStmt>(Body))
1818 WhileLoc, LParenLoc, RParenLoc);
1825 assert(Cond &&
"ActOnDoStmt(): missing expression");
1827 CheckBreakContinueBinding(Cond);
1831 Cond = CondResult.
get();
1836 Cond = CondResult.
get();
1841 CommaVisitor(*this).Visit(Cond);
1847 if (isa<OpenACCUpdateConstruct>(Body)) {
1852 return new (
Context)
DoStmt(Body, Cond, DoLoc, WhileLoc, CondRParen);
1863 DeclSetVector &Decls;
1869 DeclExtractor(
Sema &S, DeclSetVector &Decls,
1871 Inherited(S.Context),
1876 bool isSimple() {
return Simple; }
1885 void VisitStmt(
Stmt *S) { Simple =
false; }
1893 Visit(
E->getSubExpr());
1898 if (
E->getOpcode() == UO_Deref)
1901 Visit(
E->getSubExpr());
1905 Visit(
E->getCond());
1906 Visit(
E->getTrueExpr());
1907 Visit(
E->getFalseExpr());
1911 Visit(
E->getSubExpr());
1915 Visit(
E->getOpaqueValue()->getSourceExpr());
1916 Visit(
E->getFalseExpr());
1927 VarDecl *VD = dyn_cast<VarDecl>(
E->getDecl());
1944 DeclSetVector &Decls;
1950 DeclMatcher(
Sema &S, DeclSetVector &Decls,
Stmt *Statement) :
1951 Inherited(S.Context), Decls(Decls), FoundDecl(
false) {
1952 if (!Statement)
return;
1970 if (
E->getCastKind() == CK_LValueToRValue)
1971 CheckLValueToRValueCast(
E->getSubExpr());
1973 Visit(
E->getSubExpr());
1976 void CheckLValueToRValueCast(
Expr *
E) {
1979 if (isa<DeclRefExpr>(
E)) {
1984 Visit(CO->getCond());
1985 CheckLValueToRValueCast(CO->getTrueExpr());
1986 CheckLValueToRValueCast(CO->getFalseExpr());
1991 dyn_cast<BinaryConditionalOperator>(
E)) {
1992 CheckLValueToRValueCast(BCO->getOpaqueValue()->getSourceExpr());
1993 CheckLValueToRValueCast(BCO->getFalseExpr());
2001 if (
VarDecl *VD = dyn_cast<VarDecl>(
E->getDecl()))
2002 if (Decls.count(VD))
2010 if (
auto *OVE = dyn_cast<OpaqueValueExpr>(S))
2012 Visit(OVE->getSourceExpr());
2018 bool FoundDeclInUse() {
return FoundDecl; }
2022 void CheckForLoopConditionalStatement(
Sema &S,
Expr *Second,
2025 if (!Second)
return;
2032 DeclSetVector Decls;
2034 DeclExtractor DE(S, Decls, Ranges);
2038 if (!DE.isSimple())
return;
2041 if (Decls.size() == 0)
return;
2044 for (
auto *VD : Decls)
2048 if (DeclMatcher(S, Decls, Second).FoundDeclInUse() ||
2049 DeclMatcher(S, Decls, Third).FoundDeclInUse() ||
2050 DeclMatcher(S, Decls, Body).FoundDeclInUse())
2054 if (Decls.size() > 4) {
2058 for (
auto *VD : Decls)
2062 for (
auto Range : Ranges)
2065 S.
Diag(Ranges.begin()->getBegin(), PDiag);
2070 bool ProcessIterationStmt(
Sema &S,
Stmt* Statement,
bool &Increment,
2072 if (
auto Cleanups = dyn_cast<ExprWithCleanups>(Statement))
2073 if (!Cleanups->cleanupsHaveSideEffects())
2076 if (
UnaryOperator *UO = dyn_cast<UnaryOperator>(Statement)) {
2077 switch (UO->getOpcode()) {
2078 default:
return false;
2088 DRE = dyn_cast<DeclRefExpr>(UO->getSubExpr());
2096 default:
return false;
2104 DRE = dyn_cast<DeclRefExpr>(
Call->getArg(0));
2116 bool InSwitch =
false;
2119 BreakContinueFinder(
Sema &S,
const Stmt* Body) :
2120 Inherited(S.Context) {
2127 ContinueLoc =
E->getContinueLoc();
2132 BreakLoc =
E->getBreakLoc();
2136 if (
const Stmt *
Init = S->getInit())
2138 if (
const Stmt *CondVar = S->getConditionVariableDeclStmt())
2140 if (
const Stmt *Cond = S->getCond())
2145 if (
const Stmt *Body = S->getBody())
2150 void VisitForStmt(
const ForStmt *S) {
2153 if (
const Stmt *
Init = S->getInit())
2157 void VisitWhileStmt(
const WhileStmt *) {
2162 void VisitDoStmt(
const DoStmt *) {
2170 if (
const Stmt *
Init = S->getInit())
2172 if (
const Stmt *
Range = S->getRangeStmt())
2174 if (
const Stmt *
Begin = S->getBeginStmt())
2176 if (
const Stmt *End = S->getEndStmt())
2183 if (
const Stmt *Element = S->getElement())
2185 if (
const Stmt *Collection = S->getCollection())
2189 bool ContinueFound() {
return ContinueLoc.
isValid(); }
2190 bool BreakFound() {
return BreakLoc.
isValid(); }
2201 void CheckForRedundantIteration(
Sema &S,
Expr *Third,
Stmt *Body) {
2203 if (!Body || !Third)
return;
2213 if (!LastStmt)
return;
2215 bool LoopIncrement, LastIncrement;
2218 if (!ProcessIterationStmt(S, Third, LoopIncrement, LoopDRE))
return;
2219 if (!ProcessIterationStmt(S, LastStmt, LastIncrement, LastDRE))
return;
2223 if (LoopIncrement != LastIncrement ||
2226 if (BreakContinueFinder(S, Body).ContinueFound())
return;
2229 << LastDRE->
getDecl() << LastIncrement;
2237void Sema::CheckBreakContinueBinding(
Expr *
E) {
2240 BreakContinueFinder BCFinder(*
this,
E);
2242 if (BCFinder.BreakFound() && BreakParent) {
2244 Diag(BCFinder.GetBreakLoc(), diag::warn_break_binds_to_switch);
2246 Diag(BCFinder.GetBreakLoc(), diag::warn_loop_ctrl_binds_to_inner)
2250 Diag(BCFinder.GetContinueLoc(), diag::warn_loop_ctrl_binds_to_inner)
2267 const Decl *NonVarSeen =
nullptr;
2268 bool VarDeclSeen =
false;
2269 for (
auto *DI : DS->decls()) {
2270 if (
VarDecl *VD = dyn_cast<VarDecl>(DI)) {
2273 Diag(DI->getLocation(), diag::err_non_local_variable_decl_in_for);
2274 DI->setInvalidDecl();
2276 }
else if (!NonVarSeen) {
2286 if (NonVarSeen && !VarDeclSeen)
2291 CheckBreakContinueBinding(Second.
get().second);
2292 CheckBreakContinueBinding(third.
get());
2294 if (!Second.
get().first)
2295 CheckForLoopConditionalStatement(*
this, Second.
get().second, third.
get(),
2297 CheckForRedundantIteration(*
this, third.
get(), Body);
2299 if (Second.
get().second &&
2301 Second.
get().second->getExprLoc()))
2302 CommaVisitor(*this).Visit(Second.
get().second);
2305 if (isa<NullStmt>(Body))
2310 Body, ForLoc, LParenLoc, RParenLoc);
2330 if (
Decl->getType()->isUndeducedType()) {
2342 if (!isa<InitListExpr>(
Init) &&
Init->getType()->isVoidType()) {
2347 Decl->getTypeSourceInfo()->getTypeLoc(),
Init, InitType, Info);
2357 Decl->setType(InitType);
2375enum BeginEndFunction {
2384void NoteForRangeBeginEndFunction(
Sema &SemaRef,
Expr *
E,
2385 BeginEndFunction BEF) {
2394 std::string Description;
2395 bool IsTemplate =
false;
2398 FunTmpl->getTemplateParameters(), *
D->getTemplateSpecializationArgs());
2402 SemaRef.
Diag(
Loc, diag::note_for_range_begin_end)
2403 << BEF << IsTemplate << Description <<
E->
getType();
2437 return Diag(InitStmt->
getBeginLoc(), diag::err_objc_for_range_init_stmt)
2443 assert(DS &&
"first part of for range not a decl stmt");
2470 const auto DepthStr = std::to_string(S->getDepth() / 2);
2472 VarDecl *RangeVar = BuildForRangeVarDecl(*
this, RangeLoc,
2474 std::string(
"__range") + DepthStr);
2476 diag::err_for_range_deduction_failure)) {
2491 ForLoc, CoawaitLoc, InitStmt, ColonLoc, RangeDecl.
get(),
2493 nullptr,
nullptr, DS, RParenLoc, Kind,
2494 LifetimeExtendTemps);
2517 ExprResult *EndExpr, BeginEndFunction *BEF) {
2527 auto BuildBegin = [&] {
2531 BeginMemberLookup, CandidateSet,
2532 BeginRange, BeginExpr);
2537 << ColonLoc << BEF_begin << BeginRange->
getType();
2550 diag::err_for_range_iter_deduction_failure)) {
2551 NoteForRangeBeginEndFunction(SemaRef, BeginExpr->
get(), *BEF);
2557 auto BuildEnd = [&] {
2561 EndMemberLookup, CandidateSet,
2566 << ColonLoc << BEF_end << EndRange->
getType();
2570 diag::err_for_range_iter_deduction_failure)) {
2571 NoteForRangeBeginEndFunction(SemaRef, EndExpr->
get(), *BEF);
2591 if (BeginMemberLookup.
empty() != EndMemberLookup.
empty()) {
2596 auto BuildNonmember = [&](
2606 switch (BuildFound()) {
2613 SemaRef.
PDiag(diag::err_for_range_invalid)
2614 << BeginRange->
getType() << BEFFound),
2621 diag::note_for_range_member_begin_end_ignored)
2622 << BeginRange->
getType() << BEFFound;
2626 llvm_unreachable(
"unexpected ForRangeStatus");
2628 if (BeginMemberLookup.
empty())
2629 return BuildNonmember(BEF_end, EndMemberLookup, BuildEnd, BuildBegin);
2630 return BuildNonmember(BEF_begin, BeginMemberLookup, BuildBegin, BuildEnd);
2667 S, ForLoc, CoawaitLoc, InitStmt, LoopVarDecl, ColonLoc,
2676 SemaRef.
Diag(RangeLoc, diag::err_for_range_dereference)
2679 S, ForLoc, CoawaitLoc, InitStmt, LoopVarDecl, ColonLoc,
2700 DeclStmt *RangeDS = cast<DeclStmt>(RangeDecl);
2704 DeclStmt *LoopVarDS = cast<DeclStmt>(LoopVarDecl);
2718 if (
auto *DD = dyn_cast<DecompositionDecl>(LoopVar))
2719 for (
auto *Binding : DD->bindings())
2723 }
else if (!BeginDeclStmt.
get()) {
2745 diag::err_for_range_incomplete_type))
2752 for (
auto *MTE : LifetimeExtendTemps)
2758 const auto DepthStr = std::to_string(S->getDepth() / 2);
2760 std::string(
"__begin") + DepthStr);
2762 std::string(
"__end") + DepthStr);
2773 BeginExpr = BeginRangeRef;
2780 diag::err_for_range_iter_deduction_failure)) {
2781 NoteForRangeBeginEndFunction(*
this, BeginExpr.
get(), BEF_begin);
2791 dyn_cast<VariableArrayType>(UnqAT)) {
2818 VAT->desugar(), RangeLoc))
2829 VAT->getElementType(), RangeLoc))
2837 SizeOfVLAExprR.
get(), SizeOfEachElementExprR.
get());
2844 llvm_unreachable(
"Unexpected array type in for-range");
2848 EndExpr =
ActOnBinOp(S, ColonLoc, tok::plus, EndRangeRef.
get(),
2853 diag::err_for_range_iter_deduction_failure)) {
2854 NoteForRangeBeginEndFunction(*
this, EndExpr.
get(), BEF_end);
2860 BeginEndFunction BEFFailure;
2862 *
this, BeginRangeRef.
get(), EndRangeRef.
get(), RangeType, BeginVar,
2863 EndVar, ColonLoc, CoawaitLoc, &CandidateSet, &BeginExpr, &EndExpr,
2867 BEFFailure == BEF_begin) {
2872 QualType ArrayTy = PVD->getOriginalType();
2873 QualType PointerTy = PVD->getType();
2875 Diag(
Range->getBeginLoc(), diag::err_range_on_array_parameter)
2876 << RangeLoc << PVD << ArrayTy << PointerTy;
2877 Diag(PVD->getLocation(), diag::note_declared_at);
2886 CoawaitLoc, InitStmt,
2887 LoopVarDecl, ColonLoc,
2899 PDiag(diag::err_for_range_invalid)
2900 << RangeLoc <<
Range->getType()
2910 "invalid range expression in for loop");
2917 ? diag::warn_for_range_begin_end_types_differ
2918 : diag::ext_for_range_begin_end_types_differ)
2919 << BeginType << EndType;
2920 NoteForRangeBeginEndFunction(*
this, BeginExpr.
get(), BEF_begin);
2921 NoteForRangeBeginEndFunction(*
this, EndExpr.
get(), BEF_end);
2941 NotEqExpr =
ActOnBinOp(S, ColonLoc, tok::exclaimequal,
2942 BeginRef.
get(), EndRef.
get());
2949 Diag(RangeLoc, diag::note_for_range_invalid_iterator)
2950 << RangeLoc << 0 << BeginRangeRef.
get()->
getType();
2951 NoteForRangeBeginEndFunction(*
this, BeginExpr.
get(), BEF_begin);
2953 NoteForRangeBeginEndFunction(*
this, EndExpr.
get(), BEF_end);
2964 if (!IncrExpr.isInvalid() && CoawaitLoc.
isValid())
2969 if (!IncrExpr.isInvalid())
2971 if (IncrExpr.isInvalid()) {
2972 Diag(RangeLoc, diag::note_for_range_invalid_iterator)
2973 << RangeLoc << 2 << BeginRangeRef.
get()->
getType() ;
2974 NoteForRangeBeginEndFunction(*
this, BeginExpr.
get(), BEF_begin);
2986 Diag(RangeLoc, diag::note_for_range_invalid_iterator)
2987 << RangeLoc << 1 << BeginRangeRef.
get()->
getType();
2988 NoteForRangeBeginEndFunction(*
this, BeginExpr.
get(), BEF_begin);
2998 NoteForRangeBeginEndFunction(*
this, BeginExpr.
get(), BEF_begin);
3013 InitStmt, RangeDS, cast_or_null<DeclStmt>(BeginDeclStmt.
get()),
3014 cast_or_null<DeclStmt>(EndDeclStmt.
get()), NotEqExpr.
get(),
3015 IncrExpr.get(), LoopVarDS,
nullptr, ForLoc, CoawaitLoc,
3016 ColonLoc, RParenLoc);
3035 if (
auto Cleanups = dyn_cast<ExprWithCleanups>(InitExpr))
3036 if (!Cleanups->cleanupsHaveSideEffects())
3037 InitExpr = Cleanups->getSubExpr();
3040 dyn_cast<MaterializeTemporaryExpr>(InitExpr);
3050 while (!isa<CXXOperatorCallExpr>(
E) && !isa<UnaryOperator>(
E)) {
3064 if (isa<UnaryOperator>(
E)) {
3071 ReferenceReturnType = ReturnType;
3074 if (!ReferenceReturnType.
isNull()) {
3079 diag::warn_for_range_const_ref_binds_temp_built_from_ref)
3080 << VD << VariableType << ReferenceReturnType;
3093 SemaRef.
Diag(VD->
getLocation(), diag::warn_for_range_ref_binds_ret_temp)
3094 << VD << RangeInitType;
3107 return RD->hasAttr<TrivialABIAttr>();
3124 if (!CE->getConstructor()->isCopyConstructor())
3126 }
else if (
const CastExpr *CE = dyn_cast<CastExpr>(InitExpr)) {
3127 if (CE->getCastKind() != CK_LValueToRValue)
3145 << VD << VariableType;
3166 diag::warn_for_range_const_ref_binds_temp_built_from_ref,
3193 ForStmt->getRangeInit()->getType());
3203 if (isa<ObjCForCollectionStmt>(S))
3210 diag::warn_empty_range_based_for_body);
3224 if (
getCurScope()->isInOpenACCComputeConstructScope())
3258 if (
getCurScope()->isInOpenACCComputeConstructScope())
3265 const Scope &DestScope) {
3268 S.
Diag(
Loc, diag::warn_jump_out_of_seh_finally);
3277 return StmtError(
Diag(ContinueLoc, diag::err_continue_not_in_loop));
3279 if (S->isConditionVarScope()) {
3283 return StmtError(
Diag(ContinueLoc, diag::err_continue_from_cond_var_init));
3289 if (S->isOpenACCComputeConstructScope())
3291 Diag(ContinueLoc, diag::err_acc_branch_in_out_compute_construct)
3304 return StmtError(
Diag(BreakLoc, diag::err_break_not_in_loop_or_switch));
3306 if (S->isOpenMPLoopScope())
3307 return StmtError(
Diag(BreakLoc, diag::err_omp_loop_cannot_use_stmt)
3317 if (S->isOpenACCComputeConstructScope() ||
3318 (S->isLoopScope() && S->getParent() &&
3319 S->getParent()->isOpenACCComputeConstructScope()))
3321 Diag(BreakLoc, diag::err_acc_branch_in_out_compute_construct)
3336 if (!DR || DR->refersToEnclosingVariableOrCapture())
3338 const auto *VD = dyn_cast<VarDecl>(DR->getDecl());
3361 if (VD->
getKind() == Decl::ParmVar)
3363 else if (VD->
getKind() != Decl::Var)
3376 if (VD->
hasAttr<BlocksAttr>())
3412 auto invalidNRVO = [&] {
3421 if ((ReturnType->
getTypeClass() == Type::TypeClass::Auto &&
3424 return invalidNRVO();
3430 return invalidNRVO();
3450 const auto *Step = llvm::find_if(
Seq.steps(), [](
const auto &Step) {
3451 return Step.Kind == InitializationSequence::SK_ConstructorInitialization ||
3452 Step.Kind == InitializationSequence::SK_UserConversion;
3454 if (Step !=
Seq.step_end()) {
3455 const auto *FD = Step->Function.Function;
3456 if (isa<CXXConstructorDecl>(FD)
3458 : cast<CXXMethodDecl>(FD)->getRefQualifier() ==
RQ_None)
3466 bool SupressSimplerImplicitMoves) {
3472 Expr *InitExpr = &AsRvalue;
3474 Value->getBeginLoc());
3476 auto Res =
Seq.getFailedOverloadResult();
3487 return Seq.Perform(*
this, Entity, Kind,
Value);
3507 bool SupressSimplerImplicitMoves) {
3515 bool HasDeducedReturnType =
3525 RetValExp = ER.
get();
3531 if (HasDeducedReturnType) {
3544 assert(AT &&
"lost auto type from lambda return type");
3556 if (RetValExp && !isa<InitListExpr>(RetValExp)) {
3560 RetValExp =
Result.get();
3575 Diag(ReturnLoc, diag::err_lambda_return_init_list)
3589 if (
auto *CurBlock = dyn_cast<BlockScopeInfo>(CurCap)) {
3591 Diag(ReturnLoc, diag::err_noreturn_block_has_return_expr);
3594 }
else if (
auto *CurRegion = dyn_cast<CapturedRegionScopeInfo>(CurCap)) {
3595 Diag(ReturnLoc, diag::err_return_in_captured_stmt) << CurRegion->getRegionName();
3598 assert(CurLambda &&
"unknown kind of captured scope");
3602 Diag(ReturnLoc, diag::err_noreturn_lambda_has_return_expr);
3614 if (RetValExp && !isa<InitListExpr>(RetValExp) &&
3620 Diag(ReturnLoc, diag::ext_return_has_void_expr) <<
"literal" << 2;
3622 Diag(ReturnLoc, diag::err_return_block_has_expr);
3623 RetValExp =
nullptr;
3626 }
else if (!RetValExp) {
3627 return StmtError(
Diag(ReturnLoc, diag::err_block_return_missing_expr));
3640 Entity, NRInfo, RetValExp, SupressSimplerImplicitMoves);
3645 RetValExp = Res.
get();
3646 CheckReturnValExpr(RetValExp, FnRetType, ReturnLoc);
3654 RetValExp = ER.
get();
3668 if (
auto *CurBlock = dyn_cast<BlockScopeInfo>(CurCap);
3671 CurBlock->TheDecl->setInvalidDecl();
3691 LocalTypedefNameReferencer(
Sema &S) : S(S) {}
3692 bool VisitRecordType(
RecordType *RT)
override;
3697bool LocalTypedefNameReferencer::VisitRecordType(
RecordType *RT) {
3698 auto *R = dyn_cast<CXXRecordDecl>(RT->
getDecl());
3699 if (!R || !R->isLocalClass() || !R->isLocalClass()->isExternallyVisible() ||
3700 R->isDependentType())
3702 for (
auto *TmpD : R->decls())
3703 if (
auto *
T = dyn_cast<TypedefNameDecl>(TmpD))
3704 if (
T->getAccess() !=
AS_private || R->hasFriends())
3726 if (isa_and_nonnull<InitListExpr>(RetExpr)) {
3731 : diag::err_auto_fn_return_init_list)
3741 assert(AT->
isDeduced() &&
"should have deduced to dependent type");
3755 Diag(ReturnLoc, diag::err_auto_fn_return_void_but_not_auto)
3771 if (FindResult.Expression)
3772 TemplateSpecLoc = FindResult.Expression->getNameLoc();
3776 OrigResultType, RetExpr, Deduced, Info,
false,
3792 Diag(ReturnLoc, diag::err_typecheck_missing_return_type_incompatible)
3795 Diag(ReturnLoc, diag::err_auto_fn_different_deductions)
3810 LocalTypedefNameReferencer(*this).TraverseType(RetExpr->
getType());
3833 RetValExp,
nullptr,
true);
3837 if (
getCurScope()->isInOpenACCComputeConstructScope())
3839 Diag(ReturnLoc, diag::err_acc_branch_in_out_compute_construct)
3846 "first coroutine location not set");
3847 Diag(ReturnLoc, diag::err_return_in_coroutine);
3852 CheckInvalidBuiltinCountedByRef(RetVal.
get(), ReturnArgKind);
3860 const_cast<VarDecl *
>(cast<ReturnStmt>(R.
get())->getNRVOCandidate());
3884 bool AllowRecovery) {
3892 bool SupressSimplerImplicitMoves =
3900 SupressSimplerImplicitMoves);
3904 const AttrVec *Attrs =
nullptr;
3905 bool isObjCMethod =
false;
3912 Diag(ReturnLoc, diag::warn_noreturn_function_has_return_expr) << FD;
3913 if (FD->
isMain() && RetValExp)
3914 if (isa<CXXBoolLiteralExpr>(RetValExp))
3915 Diag(ReturnLoc, diag::warn_main_returns_bool_literal)
3917 if (FD->
hasAttr<CmseNSEntryAttr>() && RetValExp) {
3925 isObjCMethod =
true;
3939 const auto *ATy = dyn_cast<ArrayType>(RetValExp->
getType());
3940 if (ATy && ATy->getElementType().isWebAssemblyReferenceType()) {
3941 Diag(ReturnLoc, diag::err_wasm_table_art) << 1;
3955 RetValExp = ER.
get();
3981 AT->isDeduced() ? FnRetType :
QualType());
3982 if (Recovery.isInvalid())
3984 RetValExp = Recovery.get();
4000 if (
auto *ILE = dyn_cast<InitListExpr>(RetValExp)) {
4005 int FunctionKind = 0;
4006 if (isa<ObjCMethodDecl>(CurDecl))
4008 else if (isa<CXXConstructorDecl>(CurDecl))
4010 else if (isa<CXXDestructorDecl>(CurDecl))
4013 Diag(ReturnLoc, diag::err_return_init_list)
4017 RetValExp = AllowRecovery
4019 ILE->getRBraceLoc(), ILE->inits())
4024 unsigned D = diag::ext_return_has_expr;
4027 if (isa<CXXConstructorDecl>(CurDecl) ||
4028 isa<CXXDestructorDecl>(CurDecl))
4029 D = diag::err_ctor_dtor_returns_void;
4031 D = diag::ext_return_has_void_expr;
4038 RetValExp =
Result.get();
4043 if (
D == diag::err_ctor_dtor_returns_void) {
4045 Diag(ReturnLoc,
D) << CurDecl << isa<CXXDestructorDecl>(CurDecl)
4049 else if (
D != diag::ext_return_has_void_expr ||
4053 int FunctionKind = 0;
4054 if (isa<ObjCMethodDecl>(CurDecl))
4056 else if (isa<CXXConstructorDecl>(CurDecl))
4058 else if (isa<CXXDestructorDecl>(CurDecl))
4071 RetValExp = ER.
get();
4077 }
else if (!RetValExp && !HasDependentReturnType) {
4084 Diag(ReturnLoc, diag::err_constexpr_return_missing_expr)
4090 unsigned DiagID =
getLangOpts().C99 ? diag::ext_return_missing_expr
4091 : diag::warn_return_missing_expr;
4095 "Not in a FunctionDecl or ObjCMethodDecl?");
4096 bool IsMethod = FD ==
nullptr;
4099 Diag(ReturnLoc, DiagID) << ND << IsMethod;
4105 assert(RetValExp || HasDependentReturnType);
4106 QualType RetType = RelatedRetType.
isNull() ? FnRetType : RelatedRetType;
4119 Entity, NRInfo, RetValExp, SupressSimplerImplicitMoves);
4122 RetValExp->
getEndLoc(), RetValExp, RetType);
4133 if (!RelatedRetType.
isNull()) {
4144 CheckReturnValExpr(RetValExp, FnRetType, ReturnLoc, isObjCMethod, Attrs,
4153 RetValExp = ER.
get();
4160 if (
Result->getNRVOCandidate())
4171 Stmt *HandlerBlock) {
4174 CXXCatchStmt(CatchLoc, cast_or_null<VarDecl>(ExDecl), HandlerBlock);
4178class CatchHandlerType {
4180 LLVM_PREFERRED_TYPE(
bool)
4181 unsigned IsPointer : 1;
4185 friend struct llvm::DenseMapInfo<CatchHandlerType>;
4186 enum Unique { ForDenseMap };
4187 CatchHandlerType(
QualType QT, Unique) : QT(QT), IsPointer(
false) {}
4205 CatchHandlerType(
QualType QT,
bool IsPointer)
4206 : QT(QT), IsPointer(IsPointer) {}
4208 QualType underlying()
const {
return QT; }
4209 bool isPointer()
const {
return IsPointer; }
4211 friend bool operator==(
const CatchHandlerType &LHS,
4212 const CatchHandlerType &RHS) {
4214 if (LHS.IsPointer != RHS.IsPointer)
4217 return LHS.QT == RHS.QT;
4223template <>
struct DenseMapInfo<CatchHandlerType> {
4225 return CatchHandlerType(DenseMapInfo<QualType>::getEmptyKey(),
4226 CatchHandlerType::ForDenseMap);
4230 return CatchHandlerType(DenseMapInfo<QualType>::getTombstoneKey(),
4231 CatchHandlerType::ForDenseMap);
4235 return DenseMapInfo<QualType>::getHashValue(
Base.underlying());
4239 const CatchHandlerType &RHS) {
4246class CatchTypePublicBases {
4247 const llvm::DenseMap<QualType, CXXCatchStmt *> &TypesToCheck;
4254 CatchTypePublicBases(
const llvm::DenseMap<QualType, CXXCatchStmt *> &
T,
4256 : TypesToCheck(
T), FoundHandler(nullptr), TestAgainstType(QT) {}
4258 CXXCatchStmt *getFoundHandler()
const {
return FoundHandler; }
4259 QualType getFoundHandlerType()
const {
return FoundHandlerType; }
4262 if (S->getAccessSpecifier() == AccessSpecifier::AS_public) {
4263 QualType Check = S->getType().getCanonicalType();
4264 const auto &M = TypesToCheck;
4265 auto I = M.find(Check);
4277 if (I->second->getCaughtType()->isPointerType() ==
4279 FoundHandler = I->second;
4280 FoundHandlerType = Check;
4293 const bool IsOpenMPGPUTarget =
4294 getLangOpts().OpenMPIsTargetDevice && (
T.isNVPTX() ||
T.isAMDGCN());
4297 if (!IsOpenMPGPUTarget && !
getLangOpts().CXXExceptions &&
4300 targetDiag(TryLoc, diag::err_exceptions_disabled) <<
"try";
4305 if (IsOpenMPGPUTarget)
4306 targetDiag(TryLoc, diag::warn_try_not_valid_on_target) <<
T.str();
4311 <<
"try" << llvm::to_underlying(
CUDA().CurrentTarget());
4314 Diag(TryLoc, diag::err_omp_simd_region_cannot_use_stmt) <<
"try";
4320 Diag(TryLoc, diag::err_mixing_cxx_try_seh_try) << 0;
4324 const unsigned NumHandlers = Handlers.size();
4325 assert(!Handlers.empty() &&
4326 "The parser shouldn't call this if there are no handlers.");
4328 llvm::DenseMap<QualType, CXXCatchStmt *> HandledBaseTypes;
4329 llvm::DenseMap<CatchHandlerType, CXXCatchStmt *> HandledTypes;
4330 for (
unsigned i = 0; i < NumHandlers; ++i) {
4337 if (i < NumHandlers - 1)
4351 QualType Underlying = HandlerCHT.underlying();
4353 if (!RD->hasDefinition())
4361 Paths.setOrigin(RD);
4362 CatchTypePublicBases CTPB(HandledBaseTypes,
4364 if (RD->lookupInBases(CTPB, Paths)) {
4366 if (!Paths.isAmbiguous(
4369 diag::warn_exception_caught_by_earlier_handler)
4372 diag::note_previous_exception_handler)
4384 auto R = HandledTypes.insert(
4389 diag::warn_exception_caught_by_earlier_handler)
4392 diag::note_previous_exception_handler)
4405 assert(TryBlock && Handler);
4432 Diag(TryLoc, diag::err_seh_try_outside_functions);
4436 Diag(TryLoc, diag::err_seh_try_unsupported);
4443 assert(FilterExpr &&
Block);
4447 Diag(FilterExpr->
getExprLoc(), diag::err_filter_expression_integral)
4469 Scope *SEHTryParent = CurScope;
4471 SEHTryParent = SEHTryParent->
getParent();
4486 QualifierLoc, NameInfo,
4487 cast<CompoundStmt>(Nested));
4504 unsigned NumParams) {
4522 assert(NumParams > 0 &&
"CapturedStmt requires context parameter");
4566 CaptureInits.push_back(
Init.get());
4573 unsigned NumParams) {
4604 unsigned OpenMPCaptureLevel) {
4610 bool ContextIsFound =
false;
4611 unsigned ParamNum = 0;
4614 I !=
E; ++I, ++ParamNum) {
4615 if (I->second.isNull()) {
4616 assert(!ContextIsFound &&
4617 "null type has been found already for '__context' parameter");
4627 ContextIsFound =
true;
4637 assert(ContextIsFound &&
"no null type for '__context' parameter");
4638 if (!ContextIsFound) {
4694 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.
This file declares semantic analysis for CUDA constructs.
This file declares semantic analysis for Objective-C.
This file declares semantic analysis for OpenMP constructs and clauses.
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 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 bool DiagnoseNoDiscard(Sema &S, const NamedDecl *OffendingDecl, const WarnUnusedResultAttr *A, SourceLocation Loc, SourceRange R1, SourceRange R2, bool IsCtor)
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::@1335::AnnotatingParser::Context::@351 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
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.
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.
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.
bool hasSimilarType(QualType T1, QualType T2) const
Determine if two types are similar, according to the C++ rules.
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...
A builtin binary operation expression such as "x + y" or "x <= y".
BreakStmt - This represents a break.
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 an rvalue of a non-class type T.
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...
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.
ConstEvaluatedExprVisitor - This class visits 'const Expr *'s.
Represents the canonical version of C arrays with a specified constant size.
ContinueStmt - This represents a continue.
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.
Recursive AST visitor that supports extension via dynamic dispatch.
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.
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
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 InitializedEntity InitializeParameter(ASTContext &Context, ParmVarDecl *Parm)
Create the initialization entity for a parameter.
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 collection statement.
An expression that sends a message to the given Objective-C object or class.
ObjCMethodDecl - Represents an instance or class method declaration.
bool hasRelatedResultType() const
Determine whether this method has a result type that is related to the message receiver's type.
QualType getReturnType() const
ObjCInterfaceDecl * getClassInterface()
Represents a pointer to an Objective C object.
Wrapper for void* pointer.
void * getAsOpaquePtr() const
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 parenthesized expression, e.g.
Represents a parameter to a function.
ParsedAttributes - A collection of parsed attributes.
Wrapper for source info for pointers.
SourceLocation getStarLoc() 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
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 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.
A generic diagnostic builder for errors which may or may not be deferred.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
SemaDiagnosticBuilder DiagIfDeviceCode(SourceLocation Loc, unsigned DiagID)
Creates a SemaDiagnosticBuilder that emits the diagnostic if the current context is "used as device c...
StmtResult ActOnObjCForCollectionStmt(SourceLocation ForColLoc, Stmt *First, Expr *collection, SourceLocation RParenLoc)
StmtResult FinishObjCForCollectionStmt(Stmt *ForCollection, Stmt *Body)
FinishObjCForCollectionStmt - Attach the body to a objective-C foreach statement.
bool inferObjCARCLifetime(ValueDecl *decl)
void ActOnOpenMPLoopInitialization(SourceLocation ForLoc, Stmt *Init)
Check if the current region is an OpenMP loop region and if it is, mark loop control variable,...
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...
std::pair< VarDecl *, Expr * > get() const
RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...
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.
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 DiagnoseDiscardedExprMarkedNodiscard(const Expr *E)
DiagnoseDiscardedExprMarkedNodiscard - Given an expression that is semantically a discarded-value exp...
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)
Unary Operators. 'Tok' is the token for the operator.
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.
bool ActOnCoroutineBodyStart(Scope *S, SourceLocation KwLoc, StringRef Keyword)
StmtResult BuildAttributedStmt(SourceLocation AttrsLoc, ArrayRef< const Attr * > Attrs, Stmt *SubStmt)
StmtResult ActOnSEHLeaveStmt(SourceLocation Loc, Scope *CurScope)
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.
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.
ExprResult UsualUnaryConversions(Expr *E)
UsualUnaryConversions - Performs various conversions that are common to most operators (C99 6....
void DiagnoseCommaOperator(const Expr *LHS, SourceLocation Loc)
Look for instances where it is likely the comma operator is confused with another operator.
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()
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)
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
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...
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.
const LangOptions & getLangOpts() const
StmtResult ActOnWhileStmt(SourceLocation WhileLoc, SourceLocation LParenLoc, ConditionResult Cond, SourceLocation RParenLoc, Stmt *Body)
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
const LangOptions & LangOpts
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.
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)
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
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 BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp, bool AllowRecovery=false)
ExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc, tok::TokenKind Kind, Expr *LHSExpr, Expr *RHSExpr)
Binary Operators. 'Tok' is the token for the operator.
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)
@ 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...
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.
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 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)
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...
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 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,...
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),...
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)
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...
SourceLocation FirstCXXOrObjCTryLoc
First C++ 'try' or ObjC @try statement in the current function.
SourceLocation FirstCoroutineStmtLoc
First coroutine statement in the current function.
StringRef getFirstCoroutineStmtKeyword() const
SourceLocation FirstReturnLoc
First 'return' statement in the current function.
enum clang::sema::FunctionScopeInfo::@245 FirstTryType
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)
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 internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
bool This(InterpState &S, CodePtr OpPC)
bool Cast(InterpState &S, CodePtr OpPC)
void checkExprLifetimeMustTailArg(Sema &SemaRef, const InitializedEntity &Entity, Expr *Init)
Check that the lifetime of the given expr (and its subobjects) is sufficient, assuming that it is pas...
The JSON file list parser is used to communicate input to InstallAPI.
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.
@ Seq
'seq' clause, allowed on 'loop' and 'routine' directives.
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_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)
const FunctionProtoType * T
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.
Diagnostic wrappers for TextAPI types for error reporting.
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)