55#include "llvm/ADT/STLExtras.h"
56#include "llvm/ADT/StringExtras.h"
57#include "llvm/Support/Casting.h"
58#include "llvm/Support/ConvertUTF.h"
59#include "llvm/Support/SaveAndRestore.h"
60#include "llvm/Support/TypeSize.h"
86 if (TreatUnavailableAsInvalid &&
96 if (isa<UnresolvedUsingIfExistsDecl>(D))
104 if (
const auto *A = D->
getAttr<UnusedAttr>()) {
107 if (A->getSemanticSpelling() != UnusedAttr::CXX11_maybe_unused &&
108 A->getSemanticSpelling() != UnusedAttr::C23_maybe_unused) {
110 if (DC && !DC->
hasAttr<UnusedAttr>())
111 S.
Diag(Loc, diag::warn_used_but_marked_unused) << D;
120 if (
Decl->isDefaulted()) {
131 auto *Ctor = dyn_cast<CXXConstructorDecl>(
Decl);
132 if (Ctor && Ctor->isInheritingConstructor())
143 if (I->getStorageClass() !=
SC_None)
170 if (!Current->isInlined())
172 if (!Current->isExternallyVisible())
188 if (!DowngradeWarning && UsedFn)
191 S.
Diag(Loc, DowngradeWarning ? diag::ext_internal_in_extern_inline_quiet
192 : diag::ext_internal_in_extern_inline)
207 Diag(DeclBegin, diag::note_convert_inline_to_static)
226 bool ObjCPropertyAccess,
227 bool AvoidPartialAvailabilityChecks,
229 bool SkipTrailingRequiresClause) {
237 Diag(Suppressed.first, Suppressed.second);
248 if (cast<FunctionDecl>(D)->isMain())
249 Diag(Loc, diag::ext_main_used);
256 if (isa<BindingDecl>(D)) {
257 Diag(Loc, diag::err_binding_cannot_appear_in_own_initializer)
260 Diag(Loc, diag::err_auto_variable_cannot_appear_in_own_initializer)
261 << D->
getDeclName() << cast<VarDecl>(D)->getType();
268 if (FD->isDeleted()) {
269 auto *Ctor = dyn_cast<CXXConstructorDecl>(FD);
270 if (Ctor && Ctor->isInheritingConstructor())
271 Diag(Loc, diag::err_deleted_inherited_ctor_use)
273 << Ctor->getInheritedConstructor().getConstructor()->getParent();
275 Diag(Loc, diag::err_deleted_function_use);
288 if (!SkipTrailingRequiresClause && FD->getTrailingRequiresClause()) {
297 diag::err_reference_to_function_with_unsatisfied_constraints)
315 if (
auto *MD = dyn_cast<CXXMethodDecl>(D)) {
317 if (MD->getParent()->isLambda() &&
318 ((isa<CXXConstructorDecl>(MD) &&
319 cast<CXXConstructorDecl>(MD)->isDefaultConstructor()) ||
320 MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator())) {
321 Diag(Loc, diag::warn_cxx17_compat_lambda_def_ctor_assign)
322 << !isa<CXXConstructorDecl>(MD);
326 auto getReferencedObjCProp = [](
const NamedDecl *D) ->
328 if (
const auto *MD = dyn_cast<ObjCMethodDecl>(D))
343 auto *DRD = dyn_cast<OMPDeclareReductionDecl>(
CurContext);
346 Diag(Loc, diag::err_omp_wrong_var_in_declare_reduction)
357 if (
LangOpts.OpenMP && isa<VarDecl>(D) &&
359 Diag(Loc, diag::err_omp_declare_mapper_wrong_var)
365 if (
const auto *EmptyD = dyn_cast<UnresolvedUsingIfExistsDecl>(D)) {
366 Diag(Loc, diag::err_use_of_empty_using_if_exists);
367 Diag(EmptyD->getLocation(), diag::note_empty_using_if_exists_here);
372 AvoidPartialAvailabilityChecks, ClassReceiver);
378 if (D->
hasAttr<AvailableOnlyInDefaultEvalMethodAttr>()) {
384 diag::err_type_available_only_in_default_eval_method)
388 if (
auto *VD = dyn_cast<ValueDecl>(D))
394 if (
const auto *VD = dyn_cast<VarDecl>(D))
396 targetDiag(*Locs.begin(), diag::err_thread_unsupported);
399 if (isa<ParmVarDecl>(D) && isa<RequiresExprBodyDecl>(D->
getDeclContext()) &&
404 Diag(Loc, diag::err_requires_expr_parameter_referenced_in_evaluated_context)
419 const SentinelAttr *
Attr = D->
getAttr<SentinelAttr>();
424 unsigned NumFormalParams;
428 enum { CK_Function, CK_Method, CK_Block } CalleeKind;
430 if (
const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
431 NumFormalParams = MD->param_size();
432 CalleeKind = CK_Method;
433 }
else if (
const auto *FD = dyn_cast<FunctionDecl>(D)) {
434 NumFormalParams = FD->param_size();
435 CalleeKind = CK_Function;
436 }
else if (
const auto *VD = dyn_cast<VarDecl>(D)) {
443 CalleeKind = CK_Function;
446 CalleeKind = CK_Block;
451 if (
const auto *proto = dyn_cast<FunctionProtoType>(Fn))
452 NumFormalParams = proto->getNumParams();
463 unsigned NullPos =
Attr->getNullPos();
464 assert((NullPos == 0 || NullPos == 1) &&
"invalid null position on sentinel");
465 NumFormalParams = (NullPos > NumFormalParams ? 0 : NumFormalParams - NullPos);
468 unsigned NumArgsAfterSentinel =
Attr->getSentinel();
472 if (Args.size() < NumFormalParams + NumArgsAfterSentinel + 1) {
479 const Expr *SentinelExpr = Args[Args.size() - NumArgsAfterSentinel - 1];
492 std::string NullValue;
496 NullValue =
"nullptr";
500 NullValue =
"(void*) 0";
503 Diag(Loc, diag::warn_missing_sentinel) <<
int(CalleeKind);
505 Diag(MissingNilLoc, diag::warn_missing_sentinel)
530 assert(!Ty.
isNull() &&
"DefaultFunctionArrayConversion - missing type");
534 if (
auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl()))
539 CK_FunctionToPointerDecay).
get();
554 CK_ArrayToPointerDecay);
570 if (UO && UO->getOpcode() == UO_Deref &&
571 UO->getSubExpr()->getType()->isPointerType()) {
573 UO->getSubExpr()->getType()->getPointeeType().getAddressSpace();
576 UO->getSubExpr()->IgnoreParenCasts()->isNullPointerConstant(
578 !UO->getType().isVolatileQualified()) {
580 S.
PDiag(diag::warn_indirection_through_null)
581 << UO->getSubExpr()->getSourceRange());
583 S.
PDiag(diag::note_indirection_through_null));
615 if (ObjectSetClass) {
659 assert(!T.
isNull() &&
"r-value conversion on typeless expression?");
699 SourceRange(OISA->getOpLoc(), OISA->getIsaMemberLoc()),
")");
747 T =
Atomic->getValueType().getUnqualifiedType();
774 CK_FunctionToPointerDecay);
797 assert(!Ty.
isNull() &&
"UsualUnaryConversions - missing type");
804 switch (EvalMethod) {
806 llvm_unreachable(
"Unrecognized float evaluation method");
809 llvm_unreachable(
"Float evaluation method should be set by now");
817 CK_FloatingComplexCast)
826 CK_FloatingComplexCast)
874 assert(!Ty.
isNull() &&
"DefaultArgumentPromotion - missing type");
886 if (BTy && (BTy->
getKind() == BuiltinType::Half ||
887 BTy->
getKind() == BuiltinType::Float)) {
890 if (BTy->
getKind() == BuiltinType::Half) {
908 "Unexpected typesize for LongLongTy");
973 if (!
Record->hasNonTrivialCopyConstructor() &&
974 !
Record->hasNonTrivialMoveConstructor() &&
975 !
Record->hasNonTrivialDestructor())
1002 PDiag(diag::warn_cxx98_compat_pass_non_pod_arg_to_vararg) << Ty << CT);
1009 PDiag(diag::warn_pass_class_arg_to_vararg)
1017 PDiag(diag::warn_cannot_pass_non_pod_arg_to_vararg)
1024 diag::err_cannot_pass_non_trivial_c_struct_to_vararg)
1028 PDiag(diag::err_cannot_pass_objc_interface_to_vararg)
1032 << isa<InitListExpr>(E) << Ty << CT;
1043 if (PlaceholderTy->getKind() == BuiltinType::ARCUnbridgedCast &&
1045 (FDecl && FDecl->
hasAttr<CFAuditedTransferAttr>()))) {
1084 if (
Call.isInvalid())
1089 if (Comma.isInvalid())
1096 diag::err_call_incomplete_argument))
1114 if (SkipCast)
return false;
1121 CK_IntegralComplexToFloatingComplex);
1139 bool PromotePrecision) {
1144 if (PromotePrecision) {
1149 if (LongerIsComplex)
1161 QualType RHSType,
bool IsCompAssign) {
1186 bool ConvertFloat,
bool ConvertInt) {
1191 CK_IntegralToFloating);
1202 CK_IntegralComplexToFloatingComplex);
1207 CK_FloatingRealToComplex);
1216 QualType RHSType,
bool IsCompAssign) {
1226 else if (!IsCompAssign)
1228 return LHSFloat ? LHSType : RHSType;
1233 if (LHSFloat && RHSFloat) {
1240 assert(order < 0 &&
"illegal float comparison");
1274 QualType LHSElem = LHSComplex ? LHSComplex->getElementType() : LHSType;
1280 if ((&LHSSem != &llvm::APFloat::PPCDoubleDouble() ||
1281 &RHSSem != &llvm::APFloat::IEEEquad()) &&
1282 (&LHSSem != &llvm::APFloat::IEEEquad() ||
1283 &RHSSem != &llvm::APFloat::PPCDoubleDouble()))
1300 CK_IntegralComplexCast);
1306template <PerformCastFn doLHSCast, PerformCastFn doRHSCast>
1309 QualType RHSType,
bool IsCompAssign) {
1314 if (LHSSigned == RHSSigned) {
1317 RHS = (*doRHSCast)(S, RHS.
get(), LHSType);
1319 }
else if (!IsCompAssign)
1320 LHS = (*doLHSCast)(S, LHS.
get(), RHSType);
1322 }
else if (order != (LHSSigned ? 1 : -1)) {
1326 RHS = (*doRHSCast)(S, RHS.
get(), LHSType);
1328 }
else if (!IsCompAssign)
1329 LHS = (*doLHSCast)(S, LHS.
get(), RHSType);
1336 RHS = (*doRHSCast)(S, RHS.
get(), LHSType);
1338 }
else if (!IsCompAssign)
1339 LHS = (*doLHSCast)(S, LHS.
get(), RHSType);
1348 RHS = (*doRHSCast)(S, RHS.
get(), result);
1350 LHS = (*doLHSCast)(S, LHS.
get(), result);
1360 bool IsCompAssign) {
1364 if (LHSComplexInt && RHSComplexInt) {
1368 handleIntegerConversion<doComplexIntegralCast, doComplexIntegralCast>
1369 (S, LHS, RHS, LHSEltType, RHSEltType, IsCompAssign);
1374 if (LHSComplexInt) {
1377 handleIntegerConversion<doComplexIntegralCast, doIntegralCast>
1378 (S, LHS, RHS, LHSEltType, RHSType, IsCompAssign);
1381 CK_IntegralRealToComplex);
1386 assert(RHSComplexInt);
1390 handleIntegerConversion<doIntegralCast, doComplexIntegralCast>
1391 (S, LHS, RHS, LHSType, RHSEltType, IsCompAssign);
1396 CK_IntegralRealToComplex);
1405 assert(BTy &&
"Expected a builtin type.");
1407 switch (BTy->getKind()) {
1408 case BuiltinType::ShortFract:
1409 case BuiltinType::UShortFract:
1410 case BuiltinType::SatShortFract:
1411 case BuiltinType::SatUShortFract:
1413 case BuiltinType::Fract:
1414 case BuiltinType::UFract:
1415 case BuiltinType::SatFract:
1416 case BuiltinType::SatUFract:
1418 case BuiltinType::LongFract:
1419 case BuiltinType::ULongFract:
1420 case BuiltinType::SatLongFract:
1421 case BuiltinType::SatULongFract:
1423 case BuiltinType::ShortAccum:
1424 case BuiltinType::UShortAccum:
1425 case BuiltinType::SatShortAccum:
1426 case BuiltinType::SatUShortAccum:
1428 case BuiltinType::Accum:
1429 case BuiltinType::UAccum:
1430 case BuiltinType::SatAccum:
1431 case BuiltinType::SatUAccum:
1433 case BuiltinType::LongAccum:
1434 case BuiltinType::ULongAccum:
1435 case BuiltinType::SatLongAccum:
1436 case BuiltinType::SatULongAccum:
1439 if (BTy->isInteger())
1441 llvm_unreachable(
"Unexpected fixed point or integer type");
1453 "Expected at least one of the operands to be a fixed point type");
1456 "Special fixed point arithmetic operation conversions are only "
1457 "applied to ints or other fixed point types");
1479 QualType ResultTy = LHSTyRank > RHSTyRank ? LHSTy : RHSTy;
1502 REnum = R->isUnscopedEnumerationType();
1504 if ((!IsCompAssign && LEnum && R->isFloatingType()) ||
1507 ? diag::err_arith_conv_enum_float_cxx26
1509 ? diag::warn_arith_conv_enum_float_cxx20
1510 : diag::warn_arith_conv_enum_float)
1513 }
else if (!IsCompAssign && LEnum && REnum &&
1519 DiagID = diag::err_conv_mixed_enum_types_cxx26;
1521 !R->castAs<
EnumType>()->getDecl()->hasNameForLinkage()) {
1526 ? diag::warn_arith_conv_mixed_anon_enum_types_cxx20
1527 : diag::warn_arith_conv_mixed_anon_enum_types;
1532 ? diag::warn_conditional_mixed_enum_types_cxx20
1533 : diag::warn_conditional_mixed_enum_types;
1538 ? diag::warn_comparison_mixed_enum_types_cxx20
1539 : diag::warn_comparison_mixed_enum_types;
1542 ? diag::warn_arith_conv_mixed_enum_types_cxx20
1543 : diag::warn_arith_conv_mixed_enum_types;
1546 << (
int)ACK << L << R;
1576 LHSType = AtomicLHS->getValueType();
1588 QualType LHSUnpromotedType = LHSType;
1592 if (!LHSBitfieldPromoteTy.
isNull())
1593 LHSType = LHSBitfieldPromoteTy;
1627 return handleIntegerConversion<doIntegralCast, doIntegralCast>
1638 bool PredicateIsExpr,
void *ControllingExprOrType,
1640 unsigned NumAssocs = ArgTypes.size();
1641 assert(NumAssocs == ArgExprs.size());
1644 for (
unsigned i = 0; i < NumAssocs; ++i) {
1653 if (!PredicateIsExpr) {
1657 assert(ControllingType &&
"couldn't get the type out of the parser");
1658 ControllingExprOrType = ControllingType;
1662 KeyLoc, DefaultLoc, RParenLoc, PredicateIsExpr, ControllingExprOrType,
1670 bool PredicateIsExpr,
void *ControllingExprOrType,
1672 unsigned NumAssocs = Types.size();
1673 assert(NumAssocs == Exprs.size());
1674 assert(ControllingExprOrType &&
1675 "Must have either a controlling expression or a controlling type");
1677 Expr *ControllingExpr =
nullptr;
1679 if (PredicateIsExpr) {
1686 reinterpret_cast<Expr *
>(ControllingExprOrType));
1689 ControllingExpr = R.
get();
1692 ControllingType =
reinterpret_cast<TypeSourceInfo *
>(ControllingExprOrType);
1693 if (!ControllingType)
1697 bool TypeErrorFound =
false,
1698 IsResultDependent = ControllingExpr
1701 ContainsUnexpandedParameterPack =
1711 diag::warn_side_effects_unevaluated_context);
1713 for (
unsigned i = 0; i < NumAssocs; ++i) {
1714 if (Exprs[i]->containsUnexpandedParameterPack())
1715 ContainsUnexpandedParameterPack =
true;
1718 if (Types[i]->getType()->containsUnexpandedParameterPack())
1719 ContainsUnexpandedParameterPack =
true;
1721 if (Types[i]->getType()->isDependentType()) {
1722 IsResultDependent =
true;
1735 if (ControllingExpr && Types[i]->getType()->isIncompleteType())
1736 D = diag::err_assoc_type_incomplete;
1737 else if (ControllingExpr && !Types[i]->getType()->isObjectType())
1738 D = diag::err_assoc_type_nonobject;
1739 else if (Types[i]->getType()->isVariablyModifiedType())
1740 D = diag::err_assoc_type_variably_modified;
1741 else if (ControllingExpr) {
1760 unsigned Reason = 0;
1769 Diag(Types[i]->getTypeLoc().getBeginLoc(),
1770 diag::warn_unreachable_association)
1771 << QT << (Reason - 1);
1775 Diag(Types[i]->getTypeLoc().getBeginLoc(), D)
1776 << Types[i]->getTypeLoc().getSourceRange()
1777 << Types[i]->getType();
1778 TypeErrorFound =
true;
1783 for (
unsigned j = i+1; j < NumAssocs; ++j)
1784 if (Types[j] && !Types[j]->getType()->isDependentType() &&
1786 Types[j]->getType())) {
1787 Diag(Types[j]->getTypeLoc().getBeginLoc(),
1788 diag::err_assoc_compatible_types)
1789 << Types[j]->getTypeLoc().getSourceRange()
1790 << Types[j]->getType()
1791 << Types[i]->getType();
1792 Diag(Types[i]->getTypeLoc().getBeginLoc(),
1793 diag::note_compat_assoc)
1794 << Types[i]->getTypeLoc().getSourceRange()
1795 << Types[i]->getType();
1796 TypeErrorFound =
true;
1806 if (IsResultDependent) {
1807 if (ControllingExpr)
1809 Types, Exprs, DefaultLoc, RParenLoc,
1810 ContainsUnexpandedParameterPack);
1812 Exprs, DefaultLoc, RParenLoc,
1813 ContainsUnexpandedParameterPack);
1817 unsigned DefaultIndex = -1U;
1821 for (
unsigned i = 0; i < NumAssocs; ++i) {
1824 else if (ControllingExpr &&
1827 Types[i]->getType()))
1828 CompatIndices.push_back(i);
1829 else if (ControllingType &&
1832 Types[i]->getType()))
1833 CompatIndices.push_back(i);
1836 auto GetControllingRangeAndType = [](
Expr *ControllingExpr,
1840 if (ControllingExpr)
1849 return std::make_pair(SR, QT);
1855 if (CompatIndices.size() > 1) {
1856 auto P = GetControllingRangeAndType(ControllingExpr, ControllingType);
1859 << SR <<
P.second << (
unsigned)CompatIndices.size();
1860 for (
unsigned I : CompatIndices) {
1861 Diag(Types[I]->getTypeLoc().getBeginLoc(),
1862 diag::note_compat_assoc)
1863 << Types[I]->getTypeLoc().getSourceRange()
1864 << Types[I]->getType();
1872 if (DefaultIndex == -1U && CompatIndices.size() == 0) {
1873 auto P = GetControllingRangeAndType(ControllingExpr, ControllingType);
1875 Diag(SR.
getBegin(), diag::err_generic_sel_no_match) << SR <<
P.second;
1884 unsigned ResultIndex =
1885 CompatIndices.size() ? CompatIndices[0] : DefaultIndex;
1887 if (ControllingExpr) {
1889 Context, KeyLoc, ControllingExpr, Types, Exprs, DefaultLoc, RParenLoc,
1890 ContainsUnexpandedParameterPack, ResultIndex);
1893 Context, KeyLoc, ControllingType, Types, Exprs, DefaultLoc, RParenLoc,
1894 ContainsUnexpandedParameterPack, ResultIndex);
1900 llvm_unreachable(
"unexpected TokenKind");
1901 case tok::kw___func__:
1903 case tok::kw___FUNCTION__:
1905 case tok::kw___FUNCDNAME__:
1907 case tok::kw___FUNCSIG__:
1909 case tok::kw_L__FUNCTION__:
1911 case tok::kw_L__FUNCSIG__:
1913 case tok::kw___PRETTY_FUNCTION__:
1922 while (DC && !isa<BlockDecl, CapturedDecl, FunctionDecl, ObjCMethodDecl>(DC))
1924 return cast_or_null<Decl>(DC);
1942 assert(Args.size() <= 2 &&
"too many arguments for literal operator");
1945 for (
unsigned ArgIdx = 0; ArgIdx != Args.size(); ++ArgIdx) {
1946 ArgTy[ArgIdx] = Args[ArgIdx]->getType();
1947 if (ArgTy[ArgIdx]->isArrayType())
1968 std::vector<Token> ExpandedToks;
1974 if (Literal.hadError)
1978 for (
const Token &Tok : StringToks)
1979 StringTokLocs.push_back(Tok.getLocation());
1983 &StringTokLocs[0], StringTokLocs.size());
1985 if (!Literal.getUDSuffix().empty()) {
1988 Literal.getUDSuffixOffset());
1989 return ExprError(
Diag(UDSuffixLoc, diag::err_invalid_string_udl));
2011 std::vector<Token> ExpandedToks;
2012 ExpandedToks.reserve(Toks.size());
2013 for (
const Token &Tok : Toks) {
2016 ExpandedToks.emplace_back(Tok);
2019 if (isa<TranslationUnitDecl>(CurrentDecl))
2020 Diag(Tok.getLocation(), diag::ext_predef_outside_function);
2022 Diag(Tok.getLocation(), diag::ext_string_literal_from_predefined)
2025 llvm::raw_svector_ostream
OS(Str);
2026 Token &Exp = ExpandedToks.emplace_back();
2028 if (Tok.getKind() == tok::kw_L__FUNCTION__ ||
2029 Tok.getKind() == tok::kw_L__FUNCSIG__) {
2031 Exp.
setKind(tok::wide_string_literal);
2033 Exp.
setKind(tok::string_literal);
2041 return ExpandedToks;
2052 assert(!StringToks.empty() &&
"Must have at least one string!");
2055 std::vector<Token> ExpandedToks;
2060 if (Literal.hadError)
2064 for (
const Token &Tok : StringToks)
2065 StringTokLocs.push_back(Tok.getLocation());
2069 if (Literal.isWide()) {
2072 }
else if (Literal.isUTF8()) {
2076 }
else if (Literal.isUTF16()) {
2079 }
else if (Literal.isUTF32()) {
2082 }
else if (Literal.isPascal()) {
2090 Diag(StringTokLocs.front(), diag::warn_cxx20_compat_utf8_string);
2096 auto RemovalDiag =
PDiag(diag::note_cxx20_compat_utf8_string_remove_u8);
2098 for (
const Token &Tok : StringToks) {
2099 if (Tok.getKind() == tok::utf8_string_literal) {
2101 RemovalDiagLoc = Tok.getLocation();
2108 Diag(RemovalDiagLoc, RemovalDiag);
2116 Kind, Literal.Pascal, StrTy,
2118 StringTokLocs.size());
2119 if (Literal.getUDSuffix().empty())
2126 Literal.getUDSuffixOffset());
2130 return ExprError(
Diag(UDSuffixLoc, diag::err_invalid_string_udl));
2155 Expr *Args[] = { Lit, LenArg };
2166 StringTokLocs.back(), &ExplicitArgs);
2174 llvm::APSInt
Value(CharBits, CharIsUnsigned);
2180 for (
unsigned I = 0, N = Lit->
getLength(); I != N; ++I) {
2187 StringTokLocs.back(), &ExplicitArgs);
2191 llvm_unreachable(
"unexpected literal operator lookup result");
2195 llvm_unreachable(
"unexpected literal operator lookup result");
2227 auto *DRE = dyn_cast<DeclRefExpr>(VD->
getInit());
2230 auto *Referee = dyn_cast<VarDecl>(DRE->getDecl());
2231 if (!Referee || !Referee->hasGlobalStorage() ||
2232 Referee->hasAttr<CUDADeviceAttr>())
2238 auto *MD = dyn_cast_or_null<CXXMethodDecl>(S.
CurContext);
2239 if (MD && MD->getParent()->isLambda() &&
2240 MD->getOverloadedOperator() == OO_Call && MD->hasAttr<CUDADeviceAttr>() &&
2262 if (
VarDecl *VD = dyn_cast<VarDecl>(D)) {
2263 if (VD->getType()->isReferenceType() &&
2266 VD->isUsableInConstantExpressions(
Context))
2283 bool RefersToCapturedVariable = isa<VarDecl, BindingDecl>(D) &&
2287 Context, NNS, TemplateKWLoc, D, RefersToCapturedVariable, NameInfo, Ty,
2315 const auto *FD = dyn_cast<FieldDecl>(D);
2316 if (
const auto *IFD = dyn_cast<IndirectFieldDecl>(D))
2317 FD = IFD->getAnonField();
2321 if (FD->isBitField())
2327 if (
const auto *BD = dyn_cast<BindingDecl>(D))
2328 if (
const auto *BE = BD->getBinding())
2353 Id.TemplateId->NumArgs);
2359 TemplateArgs = &Buffer;
2362 TemplateArgs =
nullptr;
2369 unsigned DiagnosticID,
unsigned DiagnosticSuggestID) {
2376 SemaRef.
Diag(TypoLoc, diag::err_no_member) << Typo << Ctx
2379 SemaRef.
Diag(TypoLoc, DiagnosticID) << Typo;
2384 bool DroppedSpecifier =
2387 ? diag::note_implicit_param_decl
2388 : diag::note_previous_decl;
2391 SemaRef.
PDiag(NoteID));
2394 << Typo << Ctx << DroppedSpecifier
2396 SemaRef.
PDiag(NoteID));
2411 bool isDefaultArgument =
2415 const auto *CurMethod = dyn_cast<CXXMethodDecl>(
CurContext);
2416 bool isInstance = CurMethod && CurMethod->isInstance() &&
2425 unsigned DiagID = diag::err_found_in_dependent_base;
2426 unsigned NoteID = diag::note_member_declared_at;
2428 DiagID =
getLangOpts().MSVCCompat ? diag::ext_found_later_in_class
2429 : diag::err_found_later_in_class;
2431 DiagID = diag::ext_found_in_dependent_base;
2432 NoteID = diag::note_dependent_member_use;
2448 Diag(D->getLocation(), NoteID);
2457 if (isDefaultArgument && ((*R.
begin())->isCXXInstanceMember())) {
2476 unsigned diagnostic = diag::err_undeclared_var_use;
2477 unsigned diagnostic_suggest = diag::err_undeclared_var_use_suggest;
2481 diagnostic = diag::err_undeclared_use;
2482 diagnostic_suggest = diag::err_undeclared_use_suggest;
2492 if (isa<CXXRecordDecl>(DC)) {
2508 R.
addDecl(Best->FoundDecl.getDecl(), Best->FoundDecl.getAccess());
2525 assert(!ExplicitTemplateArgs &&
2526 "Diagnosing an empty lookup with explicit template args!");
2530 emitEmptyLookupTypoDiagnostic(TC, *this, SS, Name, TypoLoc, Args,
2531 diagnostic, diagnostic_suggest);
2536 }
else if (S && (Corrected =
2540 bool DroppedSpecifier =
2544 bool AcceptableWithRecovery =
false;
2545 bool AcceptableWithoutRecovery =
false;
2554 dyn_cast<FunctionTemplateDecl>(CD))
2558 else if (
FunctionDecl *FD = dyn_cast<FunctionDecl>(CD))
2559 if (!ExplicitTemplateArgs || ExplicitTemplateArgs->
size() == 0)
2565 ND = Best->FoundDecl;
2566 Corrected.setCorrectionDecl(ND);
2570 Corrected.setCorrectionDecl(ND);
2582 Record = cast<CXXRecordDecl>(
2588 AcceptableWithRecovery = isa<ValueDecl>(UnderlyingND) ||
2589 isa<FunctionTemplateDecl>(UnderlyingND);
2595 AcceptableWithoutRecovery = isa<TypeDecl>(UnderlyingND) ||
2597 isa<ObjCInterfaceDecl>(UnderlyingND);
2601 AcceptableWithoutRecovery =
true;
2604 if (AcceptableWithRecovery || AcceptableWithoutRecovery) {
2606 ? diag::note_implicit_param_decl
2607 : diag::note_previous_decl;
2610 PDiag(NoteID), AcceptableWithRecovery);
2614 << DroppedSpecifier << SS.
getRange(),
2615 PDiag(NoteID), AcceptableWithRecovery);
2618 return !AcceptableWithRecovery;
2654 else if (
auto *MD = dyn_cast<CXXMethodDecl>(S.
CurContext))
2662 auto DB = S.
Diag(Loc, diag::ext_undeclared_unqual_id_with_dependent_base);
2663 DB << NameInfo.
getName() << RD;
2665 if (!ThisType.
isNull()) {
2668 Context,
nullptr, ThisType,
true,
2670 nullptr, NameInfo, TemplateArgs);
2687 bool HasTrailingLParen,
bool IsAddressOfOperand,
2689 bool IsInlineAsmIdentifier,
Token *KeywordReplacement) {
2690 assert(!(IsAddressOfOperand && HasTrailingLParen) &&
2691 "cannot be direct & operand and have a trailing lparen");
2723 bool DependentID =
false;
2725 Name.getCXXNameType()->isDependentType()) {
2727 }
else if (SS.
isSet()) {
2738 IsAddressOfOperand, TemplateArgs);
2745 if (TemplateKWLoc.
isValid() || TemplateArgs) {
2751 bool MemberOfUnknownSpecialization;
2754 MemberOfUnknownSpecialization, TemplateKWLoc,
2758 if (MemberOfUnknownSpecialization ||
2761 IsAddressOfOperand, TemplateArgs);
2770 IsAddressOfOperand, TemplateArgs);
2774 if (IvarLookupFollowUp) {
2789 if (R.
empty() && HasTrailingLParen && II &&
2799 if (R.
empty() && !ADL) {
2802 TemplateKWLoc, TemplateArgs))
2807 if (IsInlineAsmIdentifier)
2817 "Typo correction callback misconfigured");
2828 std::nullopt,
nullptr, &TE)) {
2829 if (TE && KeywordReplacement) {
2831 auto BestTC = State.Consumer->getNextCorrection();
2832 if (BestTC.isKeyword()) {
2833 auto *II = BestTC.getCorrectionAsIdentifierInfo();
2834 if (State.DiagHandler)
2835 State.DiagHandler(BestTC);
2839 KeywordReplacement->
setLocation(BestTC.getCorrectionRange().getBegin());
2845 return (
Expr*)
nullptr;
2847 State.Consumer->resetCorrectionStream();
2852 assert(!R.
empty() &&
2853 "DiagnoseEmptyLookup returned false but added no results");
2870 assert(!R.
empty() || ADL);
2896 if (!R.
empty() && (*R.
begin())->isCXXClassMember()) {
2897 bool MightBeImplicitMember;
2898 if (!IsAddressOfOperand)
2899 MightBeImplicitMember =
true;
2901 MightBeImplicitMember =
false;
2903 MightBeImplicitMember =
false;
2905 MightBeImplicitMember =
true;
2907 MightBeImplicitMember = isa<FieldDecl>(R.
getFoundDecl()) ||
2911 if (MightBeImplicitMember)
2913 R, TemplateArgs, S);
2916 if (TemplateArgs || TemplateKWLoc.
isValid()) {
2924 "There should only be one declaration found.");
2967 if (
const auto *CD = dyn_cast<CXXRecordDecl>(DC))
2968 if (CD->isInvalidDecl())
2979 unsigned DiagID = diag::err_typename_missing;
2981 DiagID = diag::ext_typename_missing;
2983 auto D =
Diag(Loc, DiagID);
3014 if (!R.
empty() && (*R.
begin())->isCXXClassMember() && !IsAddressOfOperand)
3050 LookForIvars =
true;
3051 else if (IsClassMethod)
3052 LookForIvars =
false;
3063 if (IsClassMethod) {
3084 Diag(Loc, diag::warn_ivar_use_hidden) << IV->getDeclName();
3092 Diag(Loc, diag::err_ivar_use_in_class_method) << IV->getDeclName();
3105 "should not reference ivar from this context");
3108 assert(IFace &&
"should not reference ivar from this context");
3173 cast<ObjCIvarDecl>(Ivar.
get()));
3175 if (Lookup.
empty() && II && AllowBuiltinCreation)
3207 const auto *RD = dyn_cast<CXXRecordDecl>(
Member->getDeclContext());
3215 bool PointerConversions =
false;
3216 if (isa<FieldDecl>(
Member)) {
3220 DestRecordType, FromPtrType
3227 PointerConversions =
true;
3229 DestType = DestRecordType;
3230 FromRecordType = FromType;
3232 }
else if (
const auto *Method = dyn_cast<CXXMethodDecl>(
Member)) {
3233 if (!Method->isImplicitObjectMemberFunction())
3236 DestType = Method->getThisType().getNonReferenceType();
3237 DestRecordType = Method->getFunctionObjectParameterType();
3241 PointerConversions =
true;
3243 FromRecordType = FromType;
3244 DestType = DestRecordType;
3249 if (FromAS != DestAS) {
3254 if (PointerConversions)
3295 if (Qualifier && Qualifier->getAsType()) {
3297 assert(QType->
isRecordType() &&
"lookup done with non-record type");
3307 FromLoc, FromRange, &BasePath))
3310 if (PointerConversions)
3313 VK, &BasePath).
get();
3316 FromRecordType = QRecordType;
3327 FromLoc, FromRange, &BasePath,
3337 bool HasTrailingLParen) {
3339 if (!HasTrailingLParen)
3357 if (D->isCXXClassMember())
3366 if (isa<UsingShadowDecl>(D))
3367 D = cast<UsingShadowDecl>(D)->getTargetDecl();
3368 else if (D->getLexicalDeclContext()->isFunctionOrMethod())
3375 if (
const auto *FDecl = dyn_cast<FunctionDecl>(D)) {
3377 if (FDecl->getBuiltinID() && FDecl->isImplicit())
3379 }
else if (!isa<FunctionTemplateDecl>(D))
3392 bool AcceptInvalid) {
3396 if (isa<TypedefNameDecl>(D)) {
3401 if (isa<ObjCInterfaceDecl>(D)) {
3406 if (isa<NamespaceDecl>(D)) {
3418 const auto *FD = dyn_cast<FunctionDecl>(R.
getFoundDecl());
3420 (FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion());
3425 bool AcceptInvalidDecl) {
3466 bool AcceptInvalidDecl) {
3467 assert(D &&
"Cannot refer to a NULL declaration");
3468 assert(!isa<FunctionTemplateDecl>(D) &&
3469 "Cannot refer unambiguously to a function template");
3479 if (
TemplateDecl *Template = dyn_cast<TemplateDecl>(D)) {
3487 if (!isa<ValueDecl, UnresolvedUsingIfExistsDecl>(D)) {
3488 Diag(Loc, diag::err_ref_non_value) << D << SS.
getRange();
3500 auto *VD = cast<ValueDecl>(D);
3503 if (VD->isInvalidDecl() && !AcceptInvalidDecl)
3509 if (
auto *IndirectField = dyn_cast<IndirectFieldDecl>(VD);
3510 IndirectField && !IndirectField->isCXXClassMember())
3522 type =
type.getNonPackExpansionType();
3526#define ABSTRACT_DECL(kind)
3527#define VALUE(type, base)
3528#define DECL(type, base) case Decl::type:
3529#include "clang/AST/DeclNodes.inc"
3530 llvm_unreachable(
"invalid value decl kind");
3533 case Decl::ObjCAtDefsField:
3534 llvm_unreachable(
"forming non-member reference to ivar?");
3538 case Decl::EnumConstant:
3539 case Decl::UnresolvedUsingValue:
3540 case Decl::OMPDeclareReduction:
3541 case Decl::OMPDeclareMapper:
3550 case Decl::IndirectField:
3551 case Decl::ObjCIvar:
3562 case Decl::NonTypeTemplateParm: {
3564 type = reftype->getPointeeType();
3574 if (
type->isRecordType()) {
3575 type =
type.getUnqualifiedType().withConst();
3588 case Decl::VarTemplateSpecialization:
3589 case Decl::VarTemplatePartialSpecialization:
3590 case Decl::Decomposition:
3591 case Decl::OMPCapturedExpr:
3594 type->isVoidType()) {
3600 case Decl::ImplicitParam:
3601 case Decl::ParmVar: {
3611 if (!CapturedType.
isNull())
3612 type = CapturedType;
3624 case Decl::Function: {
3625 if (
unsigned BID = cast<FunctionDecl>(VD)->getBuiltinID()) {
3654 if (!cast<FunctionDecl>(VD)->hasPrototype() && isa<FunctionProtoType>(fty))
3663 case Decl::CXXDeductionGuide:
3664 llvm_unreachable(
"building reference to deduction guide");
3666 case Decl::MSProperty:
3668 case Decl::TemplateParamObject:
3674 case Decl::UnnamedGlobalConstant:
3678 case Decl::CXXMethod:
3683 dyn_cast<FunctionProtoType>(VD->getType()))
3691 if (cast<CXXMethodDecl>(VD)->isStatic()) {
3697 case Decl::CXXConversion:
3698 case Decl::CXXDestructor:
3699 case Decl::CXXConstructor:
3711 if (VD->isInvalidDecl() && E)
3718 Target.resize(CharByteWidth * (Source.size() + 1));
3719 char *ResultPtr = &
Target[0];
3720 const llvm::UTF8 *ErrorPtr;
3722 llvm::ConvertUTF8toWide(CharByteWidth, Source, ResultPtr, ErrorPtr);
3732 Diag(Loc, diag::ext_predef_outside_function);
3738 if (cast<DeclContext>(currentDecl)->isDependentContext())
3744 unsigned Length = Str.length();
3746 llvm::APInt LengthI(32, Length + 1);
3808 if (Literal.hadError())
3812 if (Literal.isWide())
3818 else if (Literal.isUTF16())
3820 else if (Literal.isUTF32())
3829 if (Literal.isWide())
3831 else if (Literal.isUTF16())
3833 else if (Literal.isUTF32())
3835 else if (Literal.isUTF8())
3841 if (Literal.getUDSuffix().empty())
3851 return ExprError(
Diag(UDSuffixLoc, diag::err_invalid_character_udl));
3869 using llvm::APFloat;
3870 APFloat Val(Format);
3872 APFloat::opStatus result = Literal.GetFloatValue(Val);
3876 if ((result & APFloat::opOverflow) ||
3877 ((result & APFloat::opUnderflow) && Val.isZero())) {
3878 unsigned diagnostic;
3880 if (result & APFloat::opOverflow) {
3881 diagnostic = diag::warn_float_overflow;
3882 APFloat::getLargest(Format).toString(buffer);
3884 diagnostic = diag::warn_float_underflow;
3885 APFloat::getSmallest(Format).toString(buffer);
3888 S.
Diag(Loc, diagnostic)
3890 << StringRef(buffer.data(), buffer.size());
3893 bool isExact = (result == APFloat::opOK);
3898 assert(E &&
"Invalid expression");
3905 Diag(E->
getExprLoc(), diag::err_pragma_loop_invalid_argument_type) << QT;
3909 llvm::APSInt ValueAPS;
3915 bool ValueIsPositive = ValueAPS.isStrictlyPositive();
3916 if (!ValueIsPositive || ValueAPS.getActiveBits() > 31) {
3917 Diag(E->
getExprLoc(), diag::err_pragma_loop_invalid_argument_value)
3918 <<
toString(ValueAPS, 10) << ValueIsPositive;
3938 SpellingBuffer.resize(Tok.
getLength() + 1);
3949 if (Literal.hadError)
3952 if (Literal.hasUDSuffix()) {
3960 return ExprError(
Diag(UDSuffixLoc, diag::err_invalid_numeric_udl));
3963 if (Literal.isFloatingLiteral()) {
3988 !Literal.isImaginary)) {
3997 if (Literal.isFloatingLiteral()) {
4001 if (Literal.GetIntegerValue(ResultVal))
4014 unsigned Length = Literal.getUDSuffixOffset();
4021 false, StrTy, &TokLoc, 1);
4032 bool CharIsUnsigned =
Context.
CharTy->isUnsignedIntegerType();
4033 llvm::APSInt
Value(CharBits, CharIsUnsigned);
4034 for (
unsigned I = 0, N = Literal.getUDSuffixOffset(); I != N; ++I) {
4035 Value = TokSpelling[I];
4044 llvm_unreachable(
"unexpected literal operator lookup result");
4050 if (Literal.isFixedPointLiteral()) {
4053 if (Literal.isAccum) {
4054 if (Literal.isHalf) {
4056 }
else if (Literal.isLong) {
4061 }
else if (Literal.isFract) {
4062 if (Literal.isHalf) {
4064 }
else if (Literal.isLong) {
4073 bool isSigned = !Literal.isUnsigned;
4077 llvm::APInt Val(bit_width, 0, isSigned);
4078 bool Overflowed = Literal.GetFixedPointValue(Val, scale);
4079 bool ValIsZero = Val.isZero() && !Overflowed;
4082 if (Literal.isFract && Val == MaxVal + 1 && !ValIsZero)
4088 else if (Val.ugt(MaxVal) || Overflowed)
4093 }
else if (Literal.isFloatingLiteral()) {
4095 if (Literal.isHalf){
4102 }
else if (Literal.isFloat)
4104 else if (Literal.isLong)
4106 else if (Literal.isFloat16)
4108 else if (Literal.isFloat128)
4128 }
else if (!Literal.isIntegerLiteral()) {
4134 if (Literal.isSizeT)
4137 ? diag::warn_cxx20_compat_size_t_suffix
4138 : diag::ext_cxx23_size_t_suffix
4139 : diag::err_cxx23_size_t_suffix);
4147 ? diag::warn_c23_compat_bitint_suffix
4148 : diag::ext_c23_bitint_suffix);
4157 unsigned BitsNeeded =
4158 Literal.isBitInt ? llvm::APInt::getSufficientBitsNeeded(
4159 Literal.getLiteralDigits(), Literal.getRadix())
4161 llvm::APInt ResultVal(BitsNeeded, 0);
4163 if (Literal.GetIntegerValue(ResultVal)) {
4169 "long long is not intmax_t?");
4176 bool AllowUnsigned = Literal.isUnsigned || Literal.getRadix() != 10;
4182 if (Literal.MicrosoftInteger) {
4183 if (Literal.MicrosoftInteger == 8 && !Literal.isUnsigned) {
4187 Width = Literal.MicrosoftInteger;
4189 !Literal.isUnsigned);
4195 if (Literal.isBitInt) {
4198 Width = std::max(ResultVal.getActiveBits(), 1u) +
4199 (Literal.isUnsigned ? 0u : 1u);
4203 unsigned int MaxBitIntWidth =
4205 if (Width > MaxBitIntWidth) {
4207 << Literal.isUnsigned;
4208 Width = MaxBitIntWidth;
4215 ResultVal = ResultVal.zextOrTrunc(Width);
4220 if (Literal.isSizeT) {
4221 assert(!Literal.MicrosoftInteger &&
4222 "size_t literals can't be Microsoft literals");
4227 if (ResultVal.isIntN(SizeTSize)) {
4229 if (!Literal.isUnsigned && ResultVal[SizeTSize - 1] == 0)
4231 else if (AllowUnsigned)
4237 if (Ty.
isNull() && !Literal.isLong && !Literal.isLongLong &&
4243 if (ResultVal.isIntN(IntSize)) {
4245 if (!Literal.isUnsigned && ResultVal[IntSize-1] == 0)
4247 else if (AllowUnsigned)
4254 if (Ty.
isNull() && !Literal.isLongLong && !Literal.isSizeT) {
4258 if (ResultVal.isIntN(LongSize)) {
4260 if (!Literal.isUnsigned && ResultVal[LongSize-1] == 0)
4262 else if (AllowUnsigned)
4267 const unsigned LongLongSize =
4272 ? diag::warn_old_implicitly_unsigned_long_cxx
4274 ext_old_implicitly_unsigned_long_cxx
4275 : diag::warn_old_implicitly_unsigned_long)
4276 << (LongLongSize > LongSize ? 0
4285 if (Ty.
isNull() && !Literal.isSizeT) {
4289 if (ResultVal.isIntN(LongLongSize)) {
4293 if (!Literal.isUnsigned && (ResultVal[LongLongSize-1] == 0 ||
4294 (
getLangOpts().MSVCCompat && Literal.isLongLong)))
4296 else if (AllowUnsigned)
4298 Width = LongLongSize;
4304 ? diag::warn_cxx98_compat_longlong
4305 : diag::ext_cxx11_longlong);
4315 if (Literal.isSizeT)
4317 << Literal.isUnsigned;
4320 diag::ext_integer_literal_too_large_for_signed);
4325 if (ResultVal.getBitWidth() != Width)
4326 ResultVal = ResultVal.trunc(Width);
4332 if (Literal.isImaginary) {
4342 assert(E &&
"ActOnParenExpr() missing expr");
4358 S.
Diag(Loc, diag::err_vecstep_non_scalar_vector_type)
4364 "Scalar types should always be complete");
4373 return S.
Diag(Loc, diag::err_builtin_non_vector_type)
4375 <<
"__builtin_vectorelements" << T << ArgRange;
4390 (TraitKind == UETT_SizeOf || TraitKind == UETT_AlignOf ||
4391 TraitKind == UETT_PreferredAlignOf)) {
4393 S.
Diag(Loc, diag::ext_sizeof_alignof_function_type)
4401 unsigned DiagID = S.
LangOpts.OpenCL ? diag::err_opencl_sizeof_alignof_type
4402 : diag::ext_sizeof_alignof_void_type;
4417 S.
Diag(Loc, diag::err_sizeof_nonfragile_interface)
4418 << T << (TraitKind == UETT_SizeOf)
4435 const auto *ICE = dyn_cast<ImplicitCastExpr>(E);
4436 if (!ICE || ICE->getCastKind() != CK_ArrayToPointerDecay)
4439 S.
Diag(Loc, diag::warn_sizeof_array_decay) << ICE->getSourceRange()
4441 << ICE->getSubExpr()->getType();
4456 bool IsUnevaluatedOperand =
4457 (ExprKind == UETT_SizeOf || ExprKind == UETT_DataSizeOf ||
4458 ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf ||
4459 ExprKind == UETT_VecStep);
4460 if (IsUnevaluatedOperand) {
4476 Diag(E->
getExprLoc(), diag::warn_side_effects_unevaluated_context);
4478 if (ExprKind == UETT_VecStep)
4482 if (ExprKind == UETT_VectorElements)
4504 if (ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf) {
4507 diag::err_sizeof_alignof_incomplete_or_sizeless_type,
4512 E, diag::err_sizeof_alignof_incomplete_or_sizeless_type,
4531 if (ExprKind == UETT_SizeOf) {
4532 if (
const auto *DeclRef = dyn_cast<DeclRefExpr>(E->
IgnoreParens())) {
4533 if (
const auto *PVD = dyn_cast<ParmVarDecl>(DeclRef->getFoundDecl())) {
4534 QualType OType = PVD->getOriginalType();
4539 Diag(PVD->getLocation(), diag::note_declared_at);
4547 if (
const auto *BO = dyn_cast<BinaryOperator>(E->
IgnoreParens())) {
4564 S.
Diag(E->
getExprLoc(), diag::err_sizeof_alignof_typeof_bitfield)
4571 if (
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Inner)) {
4573 }
else if (
MemberExpr *ME = dyn_cast<MemberExpr>(Inner)) {
4574 D = ME->getMemberDecl();
4594 if (
FieldDecl *FD = dyn_cast_or_null<FieldDecl>(D)) {
4597 if (!FD->getParent()->isCompleteDefinition()) {
4598 S.
Diag(E->
getExprLoc(), diag::err_alignof_member_of_incomplete_type)
4607 if (!FD->getType()->isReferenceType())
4627 assert(CSI !=
nullptr);
4633#define TYPE(Class, Base)
4634#define ABSTRACT_TYPE(Class, Base)
4635#define NON_CANONICAL_TYPE(Class, Base)
4636#define DEPENDENT_TYPE(Class, Base) case Type::Class:
4637#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base)
4638#include "clang/AST/TypeNodes.inc"
4645 case Type::ExtVector:
4646 case Type::ConstantMatrix:
4649 case Type::TemplateSpecialization:
4650 case Type::ObjCObject:
4651 case Type::ObjCInterface:
4652 case Type::ObjCObjectPointer:
4653 case Type::ObjCTypeParam:
4656 llvm_unreachable(
"type class is never variably-modified!");
4657 case Type::Elaborated:
4658 T = cast<ElaboratedType>(Ty)->getNamedType();
4660 case Type::Adjusted:
4661 T = cast<AdjustedType>(Ty)->getOriginalType();
4669 case Type::BlockPointer:
4672 case Type::LValueReference:
4673 case Type::RValueReference:
4676 case Type::MemberPointer:
4679 case Type::ConstantArray:
4680 case Type::IncompleteArray:
4682 T = cast<ArrayType>(Ty)->getElementType();
4684 case Type::VariableArray: {
4692 (isa<CapturedRegionScopeInfo>(CSI) || isa<LambdaScopeInfo>(CSI)))
4698 case Type::FunctionProto:
4699 case Type::FunctionNoProto:
4700 T = cast<FunctionType>(Ty)->getReturnType();
4704 case Type::UnaryTransform:
4705 case Type::Attributed:
4706 case Type::BTFTagAttributed:
4707 case Type::SubstTemplateTypeParm:
4708 case Type::MacroQualified:
4713 T = cast<TypedefType>(Ty)->desugar();
4715 case Type::Decltype:
4716 T = cast<DecltypeType>(Ty)->desugar();
4718 case Type::PackIndexing:
4719 T = cast<PackIndexingType>(Ty)->desugar();
4722 T = cast<UsingType>(Ty)->desugar();
4725 case Type::DeducedTemplateSpecialization:
4726 T = cast<DeducedType>(Ty)->getDeducedType();
4728 case Type::TypeOfExpr:
4729 T = cast<TypeOfExprType>(Ty)->getUnderlyingExpr()->getType();
4732 T = cast<AtomicType>(Ty)->getValueType();
4773 if (ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf ||
4774 ExprKind == UETT_OpenMPRequiredSimdAlign)
4777 if (ExprKind == UETT_VecStep)
4780 if (ExprKind == UETT_VectorElements)
4790 OpLoc, ExprType, diag::err_sizeof_alignof_incomplete_or_sizeless_type,
4795 Diag(OpLoc, diag::err_sizeof_alignof_function_type) << KWName << ExprRange;
4803 Diag(OpLoc, diag::err_wasm_table_invalid_uett_operand)
4817 auto *CSI = dyn_cast<CapturingScopeInfo>(*I);
4821 if (
auto *LSI = dyn_cast<LambdaScopeInfo>(CSI))
4822 DC = LSI->CallOperator;
4823 else if (
auto *CRSI = dyn_cast<CapturedRegionScopeInfo>(CSI))
4824 DC = CRSI->TheCapturedDecl;
4825 else if (
auto *BSI = dyn_cast<BlockScopeInfo>(CSI))
4880 }
else if (ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf) {
4882 }
else if (ExprKind == UETT_VecStep) {
4884 }
else if (ExprKind == UETT_OpenMPRequiredSimdAlign) {
4888 Diag(E->
getExprLoc(), diag::err_sizeof_alignof_typeof_bitfield) << 0;
4890 }
else if (ExprKind == UETT_VectorElements) {
4936 UETT_AlignOf, KWName);
4956 if (
V.get()->isTypeDependent())
4968 return CT->getElementType();
4971 if (
V.get()->getType()->isArithmeticType())
4972 return V.get()->getType();
4977 if (PR.
get() !=
V.get()) {
4983 S.
Diag(Loc, diag::err_realimag_invalid_type) <<
V.get()->getType()
4984 << (IsReal ?
"__real" :
"__imag");
4995 default: llvm_unreachable(
"Unknown unary op!");
4996 case tok::plusplus: Opc = UO_PostInc;
break;
4997 case tok::minusminus: Opc = UO_PostDec;
break;
5016 !S.
LangOpts.ObjCSubscriptingLegacyRuntime)
5019 S.
Diag(opLoc, diag::err_arithmetic_nonfragile_interface)
5026 auto *BaseNoParens =
Base->IgnoreParens();
5027 if (
auto *MSProp = dyn_cast<MSPropertyRefExpr>(BaseNoParens))
5028 return MSProp->getPropertyDecl()->getType()->isArrayType();
5029 return isa<MSPropertySubscriptExpr>(BaseNoParens);
5049 if (RTy->isIntegralOrUnscopedEnumerationType()) {
5051 Result = PT->getPointeeType();
5053 Result = AT->getElementType();
5056 Result = PT->getPointeeType();
5058 Result = AT->getElementType();
5076 if (isa<ParenListExpr>(base)) {
5080 base = result.
get();
5087 auto CheckAndReportCommaError = [
this, base, rbLoc](
Expr *E) {
5088 if (isa<BinaryOperator>(E) && cast<BinaryOperator>(E)->isCommaOp()) {
5089 Diag(E->getExprLoc(), diag::err_matrix_subscript_comma)
5099 !isa<MatrixSubscriptExpr>(base)) {
5100 Diag(base->
getExprLoc(), diag::err_matrix_separate_incomplete_index)
5106 auto *matSubscriptE = dyn_cast<MatrixSubscriptExpr>(base);
5107 if (matSubscriptE) {
5108 assert(ArgExprs.size() == 1);
5109 if (CheckAndReportCommaError(ArgExprs.front()))
5112 assert(matSubscriptE->isIncomplete() &&
5113 "base has to be an incomplete matrix subscript");
5115 matSubscriptE->getRowIdx(),
5116 ArgExprs.front(), rbLoc);
5129 bool IsMSPropertySubscript =
false;
5132 if (!IsMSPropertySubscript) {
5136 base = result.
get();
5142 assert(ArgExprs.size() == 1);
5143 if (CheckAndReportCommaError(ArgExprs.front()))
5151 Expr *idx = ArgExprs[0];
5152 if ((isa<BinaryOperator>(idx) && cast<BinaryOperator>(idx)->isCommaOp()) ||
5153 (isa<CXXOperatorCallExpr>(idx) &&
5154 cast<CXXOperatorCallExpr>(idx)->getOperator() == OO_Comma)) {
5160 if (ArgExprs.size() == 1 &&
5161 ArgExprs[0]->getType()->isNonOverloadPlaceholderType()) {
5165 ArgExprs[0] = result.
get();
5175 !isa<PackExpansionExpr>(ArgExprs[0])) {
5177 base, ArgExprs.front(),
5190 if (IsMSPropertySubscript) {
5191 assert(ArgExprs.size() == 1);
5209 (ArgExprs.size() != 1 || isa<PackExpansionExpr>(ArgExprs[0]) ||
5210 ArgExprs[0]->getType()->isRecordType())))) {
5217 if (!Res.
isInvalid() && isa<ArraySubscriptExpr>(Res.
get()))
5218 CheckSubscriptAccessOfNoDeref(cast<ArraySubscriptExpr>(Res.
get()));
5228 return InitSeq.
Perform(*
this, Entity, Kind, E);
5242 RowIdx = RowR.
get();
5257 ColumnIdx = ColumnR.
get();
5262 auto IsIndexValid = [&](
Expr *IndexExpr,
unsigned Dim,
5263 bool IsColumnIdx) ->
Expr * {
5271 if (std::optional<llvm::APSInt> Idx =
5273 if ((*Idx < 0 || *Idx >= Dim)) {
5275 << IsColumnIdx << Dim;
5283 "should be able to convert any integer type to size type");
5284 return ConvExpr.
get();
5288 RowIdx = IsIndexValid(RowIdx, MTy->getNumRows(),
false);
5289 ColumnIdx = IsIndexValid(ColumnIdx, MTy->getNumColumns(),
true);
5290 if (!RowIdx || !ColumnIdx)
5294 MTy->getElementType(), RBLoc);
5297void Sema::CheckAddressOfNoDeref(
const Expr *E) {
5304 while ((
Member = dyn_cast<MemberExpr>(StrippedExpr)) && !
Member->isArrow())
5305 StrippedExpr =
Member->getBase()->IgnoreParenImpCasts();
5307 LastRecord.PossibleDerefs.erase(StrippedExpr);
5318 if (isa<ArrayType>(ResultTy))
5321 if (ResultTy->
hasAttr(attr::NoDeref)) {
5322 LastRecord.PossibleDerefs.insert(E);
5330 if (!(isa<ArrayType>(BaseTy) || isa<PointerType>(BaseTy)))
5335 while ((
Member = dyn_cast<MemberExpr>(
Base->IgnoreParenCasts())) &&
5339 if (
const auto *Ptr = dyn_cast<PointerType>(
Base->getType())) {
5340 if (Ptr->getPointeeType()->hasAttr(attr::NoDeref))
5341 LastRecord.PossibleDerefs.insert(E);
5351 if (
Base->hasPlaceholderType() &&
5352 !
Base->hasPlaceholderType(BuiltinType::OMPArraySection)) {
5365 LowerBound =
Result.get();
5367 if (Length && Length->getType()->isNonOverloadPlaceholderType()) {
5387 if (
Base->isTypeDependent() ||
5390 (Length && (Length->isTypeDependent() || Length->isValueDependent())) ||
5394 OK_Ordinary, ColonLocFirst, ColonLocSecond, RBLoc);
5406 Diag(
Base->getExprLoc(), diag::err_omp_typecheck_section_value)
5407 <<
Base->getSourceRange());
5413 if (Res.isInvalid())
5415 diag::err_omp_typecheck_section_not_integer)
5417 LowerBound = Res.get();
5427 if (Res.isInvalid())
5429 diag::err_omp_typecheck_section_not_integer)
5430 << 1 << Length->getSourceRange());
5433 if (Length->getType()->isSpecificBuiltinType(BuiltinType::Char_S) ||
5434 Length->getType()->isSpecificBuiltinType(BuiltinType::Char_U))
5435 Diag(Length->getExprLoc(), diag::warn_omp_section_is_char)
5436 << 1 << Length->getSourceRange();
5443 diag::err_omp_typecheck_section_not_integer)
5458 Diag(
Base->getExprLoc(), diag::err_omp_section_function_type)
5459 << ResultTy <<
Base->getSourceRange();
5464 diag::err_omp_section_incomplete_type,
Base))
5472 llvm::APSInt LowerBoundValue =
Result.Val.getInt();
5473 if (LowerBoundValue.isNegative()) {
5474 Diag(LowerBound->
getExprLoc(), diag::err_omp_section_not_subset_of_array)
5486 llvm::APSInt LengthValue =
Result.Val.getInt();
5487 if (LengthValue.isNegative()) {
5488 Diag(Length->getExprLoc(), diag::err_omp_section_length_negative)
5490 << Length->getSourceRange();
5494 }
else if (ColonLocFirst.
isValid() &&
5500 Diag(ColonLocFirst, diag::err_omp_section_length_undefined)
5510 llvm::APSInt StrideValue =
Result.Val.getInt();
5511 if (!StrideValue.isStrictlyPositive()) {
5512 Diag(Stride->
getExprLoc(), diag::err_omp_section_stride_non_positive)
5520 if (!
Base->hasPlaceholderType(BuiltinType::OMPArraySection)) {
5528 OK_Ordinary, ColonLocFirst, ColonLocSecond, RBLoc);
5535 if (
Base->hasPlaceholderType()) {
5549 LParenLoc, RParenLoc, Dims, Brackets);
5551 (!
Base->isTypeDependent() &&
5554 diag::err_omp_non_pointer_type_array_shaping_base)
5555 <<
Base->getSourceRange());
5558 bool ErrorFound =
false;
5559 for (
Expr *Dim : Dims) {
5560 if (Dim->hasPlaceholderType()) {
5562 if (
Result.isInvalid()) {
5567 if (
Result.isInvalid()) {
5573 if (!Dim->isTypeDependent()) {
5576 if (
Result.isInvalid()) {
5578 Diag(Dim->getExprLoc(), diag::err_omp_typecheck_shaping_not_integer)
5579 << Dim->getSourceRange();
5584 if (!Dim->isValueDependent() && Dim->EvaluateAsInt(EvResult,
Context)) {
5589 if (!
Value.isStrictlyPositive()) {
5590 Diag(Dim->getExprLoc(), diag::err_omp_shaping_dimension_not_positive)
5592 << Dim->getSourceRange();
5598 NewDims.push_back(Dim);
5603 LParenLoc, RParenLoc, NewDims, Brackets);
5610 bool IsCorrect =
true;
5615 if (!D.Type.getAsOpaquePtr()) {
5620 StartLoc = D.DeclIdentLoc;
5626 bool IsDeclTyDependent = DeclTy->isDependentType() ||
5627 DeclTy->containsUnexpandedParameterPack() ||
5628 DeclTy->isInstantiationDependentType();
5629 if (!IsDeclTyDependent) {
5630 if (!DeclTy->isIntegralType(
Context) && !DeclTy->isAnyPointerType()) {
5633 Diag(StartLoc, diag::err_omp_iterator_not_integral_or_pointer)
5638 if (DeclTy.isConstant(
Context)) {
5641 Diag(StartLoc, diag::err_omp_iterator_not_integral_or_pointer)
5649 assert(D.DeclIdent &&
"Identifier expected.");
5653 D.DeclIdent, DeclTy, TInfo,
SC_None);
5667 Diag(D.DeclIdentLoc, diag::err_redefinition) << VD->getDeclName();
5680 if (!IsDeclTyDependent &&
Begin && !
Begin->isTypeDependent()) {
5685 Expr *End = D.Range.End;
5686 if (!IsDeclTyDependent && End && !End->isTypeDependent()) {
5690 Expr *Step = D.Range.Step;
5693 Diag(Step->
getExprLoc(), diag::err_omp_iterator_step_not_integral)
5698 std::optional<llvm::APSInt>
Result =
5704 Diag(Step->
getExprLoc(), diag::err_omp_iterator_step_constant_zero)
5710 if (!
Begin || !End || !IsCorrect) {
5726 if (
Decl *ID = D.IteratorDecl)
5727 ID->setInvalidDecl();
5770 D.Range.Begin, D.Range.End);
5822 D.IteratorDecl->getBeginLoc(),
nullptr,
5824 CounterVD->setImplicit();
5827 D.IteratorDecl->getBeginLoc());
5833 D.AssignmentLoc, BO_Mul,
5850 cast<VarDecl>(D.IteratorDecl)->getType(),
VK_LValue,
5851 D.IteratorDecl->getBeginLoc());
5866 if (!CounterUpdateRes.
isUsable()) {
5872 if (!CounterUpdateRes.
isUsable()) {
5883 Helpers.assign(ID.size(), {});
5888 if (
Decl *ID = D.IteratorDecl)
5889 ID->setInvalidDecl();
5894 LLoc, RLoc, ID, Helpers);
5909 for (
auto *Op : {LHSExp, RHSExp}) {
5910 Op = Op->IgnoreImplicit();
5911 if (Op->getType()->isArrayType() && !Op->isLValue())
5934 Expr *BaseExpr, *IndexExpr;
5969 Diag(LLoc, diag::err_subscript_nonfragile_interface)
5981 LHSExp = Materialized.
get();
5987 ResultType = VTy->getElementType();
5991 Qualifiers Combined = BaseQuals + MemberQuals;
5992 if (Combined != MemberQuals)
6007 LHSExp = Materialized.
get();
6018 Qualifiers Combined = BaseQuals + MemberQuals;
6019 if (Combined != MemberQuals)
6030 CK_ArrayToPointerDecay).
get();
6036 }
else if (RHSTy->isArrayType()) {
6041 CK_ArrayToPointerDecay).
get();
6048 return ExprError(
Diag(LLoc, diag::err_typecheck_subscript_value)
6053 return ExprError(
Diag(LLoc, diag::err_typecheck_subscript_not_integer)
6059 std::optional<llvm::APSInt> IntegerContantExpr =
6061 if (!IntegerContantExpr.has_value() ||
6062 IntegerContantExpr.value().isNegative())
6078 Diag(LLoc, diag::ext_gnu_subscript_void_type)
6089 diag::err_subscript_incomplete_or_sizeless_type, BaseExpr))
6102 auto *CSI = dyn_cast<CapturingScopeInfo>(*I);
6106 if (
auto *LSI = dyn_cast<LambdaScopeInfo>(CSI))
6107 DC = LSI->CallOperator;
6108 else if (
auto *CRSI = dyn_cast<CapturedRegionScopeInfo>(CSI))
6109 DC = CRSI->TheCapturedDecl;
6110 else if (
auto *BSI = dyn_cast<BlockScopeInfo>(CSI))
6128 bool SkipImmediateInvocations) {
6130 assert(!RewrittenInit &&
"Should not have a rewritten init expression yet");
6134 Diag(Param->
getBeginLoc(), diag::err_recursive_default_argument) << FD;
6135 Diag(CallLoc, diag::note_recursive_default_argument_used_here);
6140 Diag(CallLoc, diag::err_use_of_default_argument_to_function_declared_later)
6143 diag::note_default_argument_declared_here);
6148 assert(!RewrittenInit &&
"Should not have a rewitten init expression yet");
6154 assert(
Init &&
"default argument but no initializer?");
6163 if (
auto *InitWithCleanup = dyn_cast<ExprWithCleanups>(
Init)) {
6170 assert(!InitWithCleanup->getNumObjects() &&
6171 "default argument expression has capturing blocks?");
6184 SkipImmediateInvocations;
6195 bool HasImmediateCalls =
false;
6200 HasImmediateCalls |= FD->isImmediateFunction();
6206 HasImmediateCalls |= FD->isImmediateFunction();
6215 HasImmediateCalls =
true;
6230 return TraverseStmt(E->
getExpr());
6234 return TraverseStmt(E->
getExpr());
6259 assert(Param->
hasDefaultArg() &&
"can't build nonexistent default arg");
6263 std::optional<ExpressionEvaluationContextRecord::InitializationContext>
6264 InitializationContext =
6266 if (!InitializationContext.has_value())
6267 InitializationContext.emplace(CallLoc, Param,
CurContext);
6293 if (!NestedDefaultChecking)
6294 V.TraverseDecl(Param);
6298 if (
V.HasImmediateCalls || InLifetimeExtendingContext) {
6299 if (
V.HasImmediateCalls)
6309 Res = Immediate.TransformInitializer(Param->
getInit(),
6323 CallLoc, FD, Param,
Init,
6324 NestedDefaultChecking))
6328 Init, InitializationContext->Context);
6332 assert(Field->hasInClassInitializer());
6335 if (Field->isInvalidDecl())
6340 auto *ParentRD = cast<CXXRecordDecl>(Field->getParent());
6342 std::optional<ExpressionEvaluationContextRecord::InitializationContext>
6343 InitializationContext =
6345 if (!InitializationContext.has_value())
6346 InitializationContext.emplace(Loc, Field,
CurContext);
6355 if (!Field->getInClassInitializer()) {
6361 ClassPattern->
lookup(Field->getDeclName());
6364 for (
auto *L : Lookup) {
6365 if ((Pattern = dyn_cast<FieldDecl>(L)))
6368 assert(Pattern &&
"We must have set the Pattern!");
6372 Field->setInvalidDecl();
6384 if (!NestedDefaultChecking)
6385 V.TraverseDecl(Field);
6386 if (
V.HasImmediateCalls) {
6390 NestedDefaultChecking;
6395 Res = Immediate.TransformInitializer(Field->getInClassInitializer(),
6401 Field->setInvalidDecl();
6407 if (Field->getInClassInitializer()) {
6408 Expr *E =
Init ?
Init : Field->getInClassInitializer();
6409 if (!NestedDefaultChecking)
6417 if (Res.isInvalid()) {
6418 Field->setInvalidDecl();
6424 Field, InitializationContext->Context,
6443 Diag(Loc, diag::err_default_member_initializer_not_yet_parsed)
6444 << OutermostClass << Field;
6445 Diag(Field->getEndLoc(),
6446 diag::note_default_member_initializer_not_yet_parsed);
6449 Field->setInvalidDecl();
6457 if (isa_and_nonnull<CXXConstructorDecl>(FDecl))
6462 if (
CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl))
6463 if (Method->isInstance())
6478 FunctionName(FuncName) {}
6480 bool ValidateCandidate(
const TypoCorrection &candidate)
override {
6489 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
6490 return std::make_unique<FunctionCallCCC>(*
this);
6510 if (
NamedDecl *ND = Corrected.getFoundDecl()) {
6511 if (Corrected.isOverloaded()) {
6521 ND = Best->FoundDecl;
6522 Corrected.setCorrectionDecl(ND);
6528 ND = ND->getUnderlyingDecl();
6529 if (isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND))
6548 bool IsExecConfig) {
6557 bool HasExplicitObjectParameter =
6559 unsigned ExplicitObjectParameterOffset = HasExplicitObjectParameter ? 1 : 0;
6570 if (Args.size() < NumParams) {
6571 if (Args.size() < MinArgs) {
6576 ? diag::err_typecheck_call_too_few_args_suggest
6577 : diag::err_typecheck_call_too_few_args_at_least_suggest;
6580 << FnKind << MinArgs - ExplicitObjectParameterOffset
6581 <<
static_cast<unsigned>(Args.size()) -
6582 ExplicitObjectParameterOffset
6584 }
else if (MinArgs - ExplicitObjectParameterOffset == 1 && FDecl &&
6589 ? diag::err_typecheck_call_too_few_args_one
6590 : diag::err_typecheck_call_too_few_args_at_least_one)
6591 << FnKind << FDecl->
getParamDecl(ExplicitObjectParameterOffset)
6595 ? diag::err_typecheck_call_too_few_args
6596 : diag::err_typecheck_call_too_few_args_at_least)
6597 << FnKind << MinArgs - ExplicitObjectParameterOffset
6598 <<
static_cast<unsigned>(Args.size()) -
6599 ExplicitObjectParameterOffset
6603 if (!TC && FDecl && !FDecl->
getBuiltinID() && !IsExecConfig)
6611 assert((
Call->getNumArgs() == NumParams) &&
6612 "We should have reserved space for the default arguments before!");
6617 if (Args.size() > NumParams) {
6623 ? diag::err_typecheck_call_too_many_args_suggest
6624 : diag::err_typecheck_call_too_many_args_at_most_suggest;
6627 << FnKind << NumParams - ExplicitObjectParameterOffset
6628 <<
static_cast<unsigned>(Args.size()) -
6629 ExplicitObjectParameterOffset
6631 }
else if (NumParams - ExplicitObjectParameterOffset == 1 && FDecl &&
6634 Diag(Args[NumParams]->getBeginLoc(),
6635 MinArgs == NumParams
6636 ? diag::err_typecheck_call_too_many_args_one
6637 : diag::err_typecheck_call_too_many_args_at_most_one)
6638 << FnKind << FDecl->
getParamDecl(ExplicitObjectParameterOffset)
6639 <<
static_cast<unsigned>(Args.size()) -
6640 ExplicitObjectParameterOffset
6643 Args.back()->getEndLoc());
6645 Diag(Args[NumParams]->getBeginLoc(),
6646 MinArgs == NumParams
6647 ? diag::err_typecheck_call_too_many_args
6648 : diag::err_typecheck_call_too_many_args_at_most)
6649 << FnKind << NumParams - ExplicitObjectParameterOffset
6650 <<
static_cast<unsigned>(Args.size()) -
6651 ExplicitObjectParameterOffset
6654 Args.back()->getEndLoc());
6657 if (!TC && FDecl && !FDecl->
getBuiltinID() && !IsExecConfig)
6662 Call->shrinkNumArgs(NumParams);
6673 unsigned TotalNumArgs = AllArgs.size();
6674 for (
unsigned i = 0; i < TotalNumArgs; ++i)
6675 Call->setArg(i, AllArgs[i]);
6677 Call->computeDependence();
6686 bool IsListInitialization) {
6691 for (
unsigned i = FirstParam; i < NumParams; i++) {
6696 if (ArgIx < Args.size()) {
6697 Arg = Args[ArgIx++];
6700 diag::err_call_incomplete_argument, Arg))
6704 bool CFAudited =
false;
6706 FDecl && FDecl->
hasAttr<CFAuditedTransferAttr>() &&
6707 (!Param || !Param->
hasAttr<CFConsumedAttr>()))
6710 FDecl && FDecl->
hasAttr<CFAuditedTransferAttr>() &&
6711 (!Param || !Param->
hasAttr<CFConsumedAttr>()))
6717 BE->getBlockDecl()->setDoesNotEscape();
6730 Entity,
SourceLocation(), Arg, IsListInitialization, AllowExplicit);
6736 assert(Param &&
"can't use default arguments without a known callee");
6748 CheckArrayAccess(Arg);
6753 AllArgs.push_back(Arg);
6762 for (
Expr *A : Args.slice(ArgIx)) {
6766 AllArgs.push_back(arg.get());
6771 for (
Expr *A : Args.slice(ArgIx)) {
6774 AllArgs.push_back(Arg.
get());
6779 for (
Expr *A : Args.slice(ArgIx))
6780 CheckArrayAccess(A);
6788 TL = DTL.getOriginalLoc();
6791 << ATL.getLocalSourceRange();
6805 const Expr *ArgExpr) {
6835 Diag(CallLoc, diag::warn_static_array_too_small)
6844 std::optional<CharUnits> ArgSize =
6846 std::optional<CharUnits> ParmSize =
6848 if (ArgSize && ParmSize && *ArgSize < *ParmSize) {
6849 Diag(CallLoc, diag::warn_static_array_too_small)
6851 << (
unsigned)ParmSize->getQuantity() << 1;
6865 if (!placeholder)
return false;
6867 switch (placeholder->
getKind()) {
6869#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
6870 case BuiltinType::Id:
6871#include "clang/Basic/OpenCLImageTypes.def"
6872#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
6873 case BuiltinType::Id:
6874#include "clang/Basic/OpenCLExtensionTypes.def"
6877#define SVE_TYPE(Name, Id, SingletonId) \
6878 case BuiltinType::Id:
6879#include "clang/Basic/AArch64SVEACLETypes.def"
6880#define PPC_VECTOR_TYPE(Name, Id, Size) \
6881 case BuiltinType::Id:
6882#include "clang/Basic/PPCTypes.def"
6883#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
6884#include "clang/Basic/RISCVVTypes.def"
6885#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
6886#include "clang/Basic/WebAssemblyReferenceTypes.def"
6887#define PLACEHOLDER_TYPE(ID, SINGLETON_ID)
6888#define BUILTIN_TYPE(ID, SINGLETON_ID) case BuiltinType::ID:
6889#include "clang/AST/BuiltinTypes.def"
6894 case BuiltinType::Overload:
6899 case BuiltinType::ARCUnbridgedCast:
6903 case BuiltinType::PseudoObject:
6908 case BuiltinType::UnknownAny:
6912 case BuiltinType::BoundMember:
6913 case BuiltinType::BuiltinFn:
6914 case BuiltinType::IncompleteMatrixIdx:
6915 case BuiltinType::OMPArraySection:
6916 case BuiltinType::OMPArrayShaping:
6917 case BuiltinType::OMPIterator:
6921 llvm_unreachable(
"bad builtin type kind");
6927 bool hasInvalid =
false;
6928 for (
size_t i = 0, e = args.size(); i != e; i++) {
6931 if (result.
isInvalid()) hasInvalid =
true;
6932 else args[i] = result.
get();
6960 bool NeedsNewDecl =
false;
6973 if (!ParamType->isPointerType() || ParamType.hasAddressSpace() ||
6977 OverloadParams.push_back(ParamType);
6985 NeedsNewDecl =
true;
6998 OverloadParams, EPI);
7007 FT = cast<FunctionProtoType>(OverloadTy);
7008 for (
unsigned i = 0, e = FT->
getNumParams(); i != e; ++i) {
7015 Params.push_back(Parm);
7017 OverloadDecl->setParams(Params);
7019 return OverloadDecl;
7030 !Callee->isVariadic())
7032 if (Callee->getMinRequiredArguments() > ArgExprs.size())
7035 if (
const EnableIfAttr *
Attr =
7038 isa<CXXMethodDecl>(Callee)
7039 ? diag::err_ovl_no_viable_member_function_in_call
7040 : diag::err_ovl_no_viable_function_in_call)
7041 << Callee << Callee->getSourceRange();
7042 S.
Diag(Callee->getLocation(),
7043 diag::note_ovl_candidate_disabled_by_function_cond_attr)
7044 <<
Attr->getCond()->getSourceRange() <<
Attr->getMessage();
7052 const auto GetFunctionLevelDCIfCXXClass =
7060 if (
const auto *MD = dyn_cast<CXXMethodDecl>(DC))
7061 return MD->
getParent()->getCanonicalDecl();
7064 if (
const auto *RD = dyn_cast<CXXRecordDecl>(DC))
7065 return RD->getCanonicalDecl();
7072 const CXXRecordDecl *
const CurParentClass = GetFunctionLevelDCIfCXXClass(S);
7073 if (!CurParentClass)
7080 assert(NamingClass &&
"Must have naming class even for implicit access");
7086 return CurParentClass == NamingClass ||
7135 if (
Call->getNumArgs() != 1)
7138 const Expr *E =
Call->getCallee()->IgnoreParenImpCasts();
7139 if (!E || isa<UnresolvedLookupExpr>(E))
7141 const DeclRefExpr *DRE = dyn_cast_if_present<DeclRefExpr>(E);
7154 if (BuiltinID != Builtin::BImove && BuiltinID != Builtin::BIforward)
7157 S.
Diag(DRE->
getLocation(), diag::warn_unqualified_call_to_std_cast_function)
7168 if (
Call.isInvalid())
7173 if (
const auto *ULE = dyn_cast<UnresolvedLookupExpr>(Fn);
7174 ULE && ULE->hasExplicitTemplateArgs() &&
7175 ULE->decls_begin() == ULE->decls_end()) {
7177 ? diag::warn_cxx17_compat_adl_only_template_id
7178 : diag::ext_adl_only_template_id)
7186 if (
const auto *CE = dyn_cast<CallExpr>(
Call.get()))
7197 Expr *ExecConfig,
bool IsExecConfig,
7198 bool AllowRecovery) {
7209 if (isa<CXXPseudoDestructorExpr>(Fn)) {
7210 if (!ArgExprs.empty()) {
7215 ArgExprs.back()->getEndLoc()));
7232 cast<CallExpr>(ExecConfig), ArgExprs,
7238 *
this, dyn_cast<UnresolvedMemberExpr>(Fn->
IgnoreParens()),
7259 RParenLoc, ExecConfig, IsExecConfig,
7276 Scope, Fn, ULE, LParenLoc, ArgExprs, RParenLoc, ExecConfig,
7279 RParenLoc, ExecConfig, IsExecConfig,
7293 bool CallingNDeclIndirectly =
false;
7295 if (
UnaryOperator *UnOp = dyn_cast<UnaryOperator>(NakedFn)) {
7296 if (UnOp->getOpcode() == UO_AddrOf) {
7297 CallingNDeclIndirectly =
true;
7302 if (
auto *DRE = dyn_cast<DeclRefExpr>(NakedFn)) {
7303 NDecl = DRE->getDecl();
7316 nullptr, DRE->isNonOdrUse());
7319 }
else if (
auto *ME = dyn_cast<MemberExpr>(NakedFn))
7320 NDecl = ME->getMemberDecl();
7322 if (
FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(NDecl)) {
7336 FD->getBuiltinID()) {
7337 for (
unsigned Idx = 0; Idx < FD->param_size(); ++Idx) {
7340 !ArgExprs[Idx]->getType()->isPointerType())
7344 auto ArgTy = ArgExprs[Idx]->getType();
7345 auto ArgPtTy = ArgTy->getPointeeType();
7346 auto ArgAS = ArgPtTy.getAddressSpace();
7349 bool NeedImplicitASC =
7354 if (!NeedImplicitASC)
7358 if (ArgExprs[Idx]->isGLValue()) {
7360 Context, ArgExprs[Idx]->getType(), CK_NoOp, ArgExprs[Idx],
7365 Qualifiers ArgPtQuals = ArgPtTy.getQualifiers();
7375 CK_AddressSpaceConversion)
7385 llvm::any_of(ArgExprs,
7386 [](
clang::Expr *E) { return E->containsErrors(); })) &&
7387 "should only occur in error-recovery path.");
7392 ExecConfig, IsExecConfig);
7405 assert(BuiltInDecl &&
"failed to find builtin declaration");
7409 assert(DeclRef.
isUsable() &&
"Builtin reference cannot fail");
7414 assert(!
Call.isInvalid() &&
"Call to builtin cannot fail!");
7439 Diag(BuiltinLoc, diag::err_invalid_astype_of_different_size)
7468 FunctionDecl *FDecl = dyn_cast_or_null<FunctionDecl>(NDecl);
7469 unsigned BuiltinID = (FDecl ? FDecl->
getBuiltinID() : 0);
7472 if (FDecl && FDecl->
hasAttr<AnyX86InterruptAttr>()) {
7485 if (Caller->hasAttr<ARMInterruptAttr>()) {
7487 if (VFP && (!FDecl || !FDecl->
hasAttr<ARMInterruptAttr>())) {
7488 Diag(Fn->
getExprLoc(), diag::warn_arm_interrupt_calling_convention);
7493 if (Caller->hasAttr<AnyX86InterruptAttr>() ||
7494 Caller->hasAttr<AnyX86NoCallerSavedRegistersAttr>()) {
7496 bool HasNonGPRRegisters =
7498 if (HasNonGPRRegisters &&
7499 (!FDecl || !FDecl->
hasAttr<AnyX86NoCallerSavedRegistersAttr>())) {
7501 << (Caller->hasAttr<AnyX86InterruptAttr>() ? 0 : 1);
7541 return ExprError(
Diag(LParenLoc, diag::err_typecheck_call_not_function)
7556 return ExprError(
Diag(LParenLoc, diag::err_typecheck_call_not_function)
7564 const auto *Proto = dyn_cast_or_null<FunctionProtoType>(FuncT);
7565 unsigned NumParams = Proto ? Proto->getNumParams() : 0;
7569 assert(UsesADL == ADLCallKind::NotADL &&
7570 "CUDAKernelCallExpr should not use ADL");
7591 TheCall = dyn_cast<CallExpr>(
Result.get());
7592 bool CorrectedTypos = TheCall != TheOldCall;
7593 if (!TheCall)
return Result;
7600 if (CorrectedTypos && Args.size() < NumParams) {
7616 return CheckBuiltinFunctionCall(FDecl, BuiltinID, TheCall);
7621 if (FDecl && !FDecl->
hasAttr<CUDAGlobalAttr>())
7622 return ExprError(
Diag(LParenLoc,diag::err_kern_call_not_global_function)
7629 return ExprError(
Diag(LParenLoc, diag::err_kern_type_not_void_return)
7633 if (FDecl && FDecl->
hasAttr<CUDAGlobalAttr>())
7634 return ExprError(
Diag(LParenLoc, diag::err_global_call_not_config)
7650 for (
const Expr *Arg : Args) {
7651 if (Arg && Arg->getType()->isWebAssemblyTableType()) {
7653 diag::err_wasm_table_as_function_parameter));
7663 assert(isa<FunctionNoProtoType>(FuncT) &&
"Unknown FunctionType!");
7671 if (!Proto || !(Proto->isVariadic() && Args.size() >= Def->
param_size()))
7672 Diag(RParenLoc, diag::warn_call_wrong_number_of_arguments)
7692 if (!Proto && !Args.empty() &&
7696 Diag(LParenLoc, diag::warn_strict_uses_without_prototype)
7697 << (FDecl !=
nullptr) << FDecl;
7700 for (
unsigned i = 0, e = Args.size(); i != e; i++) {
7701 Expr *Arg = Args[i];
7703 if (Proto && i < Proto->getNumParams()) {
7705 Context, Proto->getParamType(i), Proto->isParamConsumed(i));
7723 diag::err_call_incomplete_argument, Arg))
7731 if (
CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl))
7732 if (Method->isImplicitObjectMemberFunction())
7733 return ExprError(
Diag(LParenLoc, diag::err_member_call_without_object)
7742 for (
unsigned i = 0, e = Args.size(); i != e; i++) {
7743 if (
const auto *RT =
7744 dyn_cast<RecordType>(Args[i]->getType().getCanonicalType())) {
7745 if (RT->getDecl()->isOrContainsUnion())
7746 Diag(Args[i]->getBeginLoc(), diag::warn_cmse_nonsecure_union)
7757 checkFortifiedBuiltinMemoryFunction(FDecl, TheCall);
7760 return CheckBuiltinFunctionCall(FDecl, BuiltinID, TheCall);
7762 if (CheckPointerCall(NDecl, TheCall, Proto))
7765 if (CheckOtherCall(TheCall, Proto))
7775 assert(Ty &&
"ActOnCompoundLiteral(): missing type");
7776 assert(InitExpr &&
"ActOnCompoundLiteral(): missing expression");
7794 diag::err_array_incomplete_or_sizeless_type,
7808 std::optional<unsigned> NumInits;
7809 if (
const auto *ILE = dyn_cast<InitListExpr>(LiteralExpr))
7810 NumInits = ILE->getNumInits();
7811 if ((
LangOpts.CPlusPlus || NumInits.value_or(0)) &&
7813 diag::err_variable_object_no_init))
7818 diag::err_typecheck_decl_incomplete_type,
7833 LiteralExpr =
Result.get();
7861 if (
auto ILE = dyn_cast<InitListExpr>(LiteralExpr))
7862 for (
unsigned i = 0, j = ILE->getNumInits(); i != j; i++) {
7868 VK, LiteralExpr, isFileScope);
7880 Diag(LParenLoc, diag::err_compound_literal_with_address_space)
7916 bool DiagnosedArrayDesignator =
false;
7917 bool DiagnosedNestedDesignator =
false;
7918 bool DiagnosedMixedDesignator =
false;
7922 for (
unsigned I = 0, E = InitArgList.size(); I != E; ++I) {
7923 if (
auto *DIE = dyn_cast<DesignatedInitExpr>(InitArgList[I])) {
7925 FirstDesignator = DIE->getBeginLoc();
7930 if (!DiagnosedNestedDesignator && DIE->size() > 1) {
7931 DiagnosedNestedDesignator =
true;
7932 Diag(DIE->getBeginLoc(), diag::ext_designated_init_nested)
7933 << DIE->getDesignatorsSourceRange();
7936 for (
auto &Desig : DIE->designators()) {
7937 if (!Desig.isFieldDesignator() && !DiagnosedArrayDesignator) {
7938 DiagnosedArrayDesignator =
true;
7939 Diag(Desig.getBeginLoc(), diag::ext_designated_init_array)
7940 << Desig.getSourceRange();
7944 if (!DiagnosedMixedDesignator &&
7945 !isa<DesignatedInitExpr>(InitArgList[0])) {
7946 DiagnosedMixedDesignator =
true;
7947 Diag(DIE->getBeginLoc(), diag::ext_designated_init_mixed)
7948 << DIE->getSourceRange();
7949 Diag(InitArgList[0]->getBeginLoc(), diag::note_designated_init_mixed)
7950 << InitArgList[0]->getSourceRange();
7953 isa<DesignatedInitExpr>(InitArgList[0])) {
7954 DiagnosedMixedDesignator =
true;
7955 auto *DIE = cast<DesignatedInitExpr>(InitArgList[0]);
7956 Diag(DIE->getBeginLoc(), diag::ext_designated_init_mixed)
7957 << DIE->getSourceRange();
7958 Diag(InitArgList[I]->getBeginLoc(), diag::note_designated_init_mixed)
7959 << InitArgList[I]->getSourceRange();
7963 if (FirstDesignator.
isValid()) {
7967 !DiagnosedNestedDesignator && !DiagnosedMixedDesignator) {
7969 ? diag::warn_cxx17_compat_designated_init
7970 : diag::ext_cxx_designated_init);
7972 Diag(FirstDesignator, diag::ext_designated_init);
7987 for (
unsigned I = 0, E = InitArgList.size(); I != E; ++I) {
7988 if (InitArgList[I]->getType()->isNonOverloadPlaceholderType()) {
7995 InitArgList[I] = result.
get();
8023 if (
type->isObjCObjectPointerType()) {
8025 }
else if (
type->isBlockPointerType()) {
8027 return CK_BlockPointerToObjCPointerCast;
8029 assert(
type->isPointerType());
8030 return CK_CPointerToObjCPointerCast;
8047 llvm_unreachable(
"member pointer type in C");
8056 if (SrcAS != DestAS)
8057 return CK_AddressSpaceConversion;
8064 ? CK_BitCast : CK_AnyPointerToBlockPointerCast);
8069 return CK_CPointerToObjCPointerCast;
8071 return CK_BlockPointerToObjCPointerCast;
8073 return CK_PointerToBoolean;
8075 return CK_PointerToIntegral;
8081 llvm_unreachable(
"illegal cast from pointer");
8083 llvm_unreachable(
"Should have returned before this");
8088 return CK_FixedPointCast;
8090 return CK_FixedPointToBoolean;
8092 return CK_FixedPointToIntegral;
8094 return CK_FixedPointToFloating;
8098 diag::err_unimplemented_conversion_with_fixed_point_type)
8100 return CK_IntegralCast;
8105 llvm_unreachable(
"illegal cast to pointer type");
8107 llvm_unreachable(
"Should have returned before this");
8117 return CK_NullToPointer;
8118 return CK_IntegralToPointer;
8120 return CK_IntegralToBoolean;
8122 return CK_IntegralCast;
8124 return CK_IntegralToFloating;
8129 return CK_IntegralRealToComplex;
8133 CK_IntegralToFloating);
8134 return CK_FloatingRealToComplex;
8136 llvm_unreachable(
"member pointer type in C");
8138 return CK_IntegralToFixedPoint;
8140 llvm_unreachable(
"Should have returned before this");
8145 return CK_FloatingCast;
8147 return CK_FloatingToBoolean;
8149 return CK_FloatingToIntegral;
8154 return CK_FloatingRealToComplex;
8158 CK_FloatingToIntegral);
8159 return CK_IntegralRealToComplex;
8163 llvm_unreachable(
"valid float->pointer cast?");
8165 llvm_unreachable(
"member pointer type in C");
8167 return CK_FloatingToFixedPoint;
8169 llvm_unreachable(
"Should have returned before this");
8174 return CK_FloatingComplexCast;
8176 return CK_FloatingComplexToIntegralComplex;
8180 return CK_FloatingComplexToReal;
8182 return CK_FloatingCast;
8185 return CK_FloatingComplexToBoolean;
8189 CK_FloatingComplexToReal);
8190 return CK_FloatingToIntegral;
8194 llvm_unreachable(
"valid complex float->pointer cast?");
8196 llvm_unreachable(
"member pointer type in C");
8199 diag::err_unimplemented_conversion_with_fixed_point_type)
8201 return CK_IntegralCast;
8203 llvm_unreachable(
"Should have returned before this");
8208 return CK_IntegralComplexToFloatingComplex;
8210 return CK_IntegralComplexCast;
8214 return CK_IntegralComplexToReal;
8216 return CK_IntegralCast;
8219 return CK_IntegralComplexToBoolean;
8223 CK_IntegralComplexToReal);
8224 return CK_IntegralToFloating;
8228 llvm_unreachable(
"valid complex int->pointer cast?");
8230 llvm_unreachable(
"member pointer type in C");
8233 diag::err_unimplemented_conversion_with_fixed_point_type)
8235 return CK_IntegralCast;
8237 llvm_unreachable(
"Should have returned before this");
8240 llvm_unreachable(
"Unhandled scalar cast");
8247 len = vecType->getNumElements();
8248 eltType = vecType->getElementType();
8255 if (!
type->isRealType())
return false;
8271 auto ValidScalableConversion = [](
QualType FirstType,
QualType SecondType) {
8275 const auto *VecTy = SecondType->getAs<
VectorType>();
8279 return ValidScalableConversion(srcTy, destTy) ||
8280 ValidScalableConversion(destTy, srcTy);
8292 auto ValidScalableConversion = [](
QualType FirstType,
QualType SecondType) {
8296 const auto *VecTy = SecondType->getAs<
VectorType>();
8300 return ValidScalableConversion(srcTy, destTy) ||
8301 ValidScalableConversion(destTy, srcTy);
8313 return matSrcType->
getNumRows() == matDestType->getNumRows() &&
8314 matSrcType->
getNumColumns() == matDestType->getNumColumns();
8320 uint64_t SrcLen, DestLen;
8333 return (SrcLen * SrcEltSize == DestLen * DestEltSize);
8339 "expected at least one type to be a vector here");
8341 bool IsSrcTyAltivec =
8357 return (IsSrcTyAltivec || IsDestTyAltivec);
8393 if (!Vec || !Vec->getElementType()->isIntegralOrEnumerationType())
8398 if (!Vec || !Vec->getElementType()->isIntegralOrEnumerationType())
8415 return Diag(R.
getBegin(), diag::err_invalid_conversion_between_matrixes)
8416 << DestTy << SrcTy << R;
8420 diag::err_invalid_conversion_between_matrix_and_type)
8421 << SrcTy << DestTy << R;
8424 diag::err_invalid_conversion_between_matrix_and_type)
8425 << DestTy << SrcTy << R;
8428 Kind = CK_MatrixCast;
8434 assert(VectorTy->
isVectorType() &&
"Not a vector type!");
8440 diag::err_invalid_conversion_between_vectors :
8441 diag::err_invalid_conversion_between_vector_and_integer)
8442 << VectorTy << Ty << R;
8445 diag::err_invalid_conversion_between_vector_and_scalar)
8446 << VectorTy << Ty << R;
8455 if (DestElemTy == SplattedExpr->
getType())
8456 return SplattedExpr;
8469 CK_BooleanToSignedIntegral);
8470 SplattedExpr = CastExprRes.
get();
8471 CK = CK_IntegralToFloating;
8473 CK = CK_BooleanToSignedIntegral;
8480 SplattedExpr = CastExprRes.
get();
8499 Diag(R.
getBegin(),diag::err_invalid_conversion_between_ext_vectors)
8500 << DestTy << SrcTy << R;
8512 diag::err_invalid_conversion_between_vector_and_scalar)
8513 << DestTy << SrcTy << R;
8515 Kind = CK_VectorSplat;
8524 "ActOnCastExpr(): missing type or expr");
8546 bool isVectorLiteral =
false;
8561 isVectorLiteral =
true;
8564 isVectorLiteral =
true;
8569 if (isVectorLiteral)
8575 if (isa<ParenListExpr>(
CastExpr)) {
8596 assert((isa<ParenListExpr>(E) || isa<ParenExpr>(E)) &&
8597 "Expected paren or paren list expression");
8604 LiteralLParenLoc = PE->getLParenLoc();
8605 LiteralRParenLoc = PE->getRParenLoc();
8606 exprs = PE->getExprs();
8607 numExprs = PE->getNumExprs();
8609 LiteralLParenLoc = cast<ParenExpr>(E)->getLParen();
8610 LiteralRParenLoc = cast<ParenExpr>(E)->getRParen();
8611 subExpr = cast<ParenExpr>(E)->getSubExpr();
8634 if (numExprs == 1) {
8637 if (Literal.isInvalid())
8643 else if (numExprs < numElems) {
8645 diag::err_incorrect_number_of_vector_initializers);
8649 initExprs.append(exprs, exprs + numExprs);
8658 if (Literal.isInvalid())
8665 initExprs.append(exprs, exprs + numExprs);
8670 initExprs, LiteralRParenLoc);
8705 const Expr *NullExpr = LHSExpr;
8706 const Expr *NonPointerExpr = RHSExpr;
8713 NonPointerExpr = LHSExpr;
8735 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands_null)
8736 << NonPointerExpr->
getType() << DiagType
8748 S.
Diag(QuestionLoc, diag::err_typecheck_cond_expect_nonfloat)
8756 S.
Diag(QuestionLoc, diag::err_typecheck_cond_expect_scalar)
8790 bool IsBlockPointer =
false;
8794 IsBlockPointer =
true;
8819 ResultAddrSpace = LAddrSpace;
8821 ResultAddrSpace = RAddrSpace;
8823 S.
Diag(Loc, diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
8830 auto LHSCastKind = CK_BitCast, RHSCastKind = CK_BitCast;
8845 LAddrSpace == ResultAddrSpace ? CK_BitCast : CK_AddressSpaceConversion;
8847 RAddrSpace == ResultAddrSpace ? CK_BitCast : CK_AddressSpaceConversion;
8855 lhptee, rhptee,
false,
false,
8858 if (CompositeTy.
isNull()) {
8875 S.
Diag(Loc, diag::ext_typecheck_cond_incompatible_pointers)
8886 QualType ResultTy = [&, ResultAddrSpace]() {
8892 .withCVRQualifiers(MergedCVRQual);
8921 S.
Diag(Loc, diag::err_typecheck_cond_incompatible_operands)
8974 bool IsIntFirstExpr) {
8979 Expr *Expr1 = IsIntFirstExpr ? Int.
get() : PointerExpr;
8980 Expr *Expr2 = IsIntFirstExpr ? PointerExpr : Int.
get();
8982 S.
Diag(Loc, diag::ext_typecheck_cond_pointer_integer_mismatch)
8986 CK_IntegralToPointer);
9020 S.
Diag(QuestionLoc, diag::err_typecheck_cond_expect_int_float)
9026 S.
Diag(QuestionLoc, diag::err_typecheck_cond_expect_int_float)
9032 if (LHSType == RHSType)
9041 return handleIntegerConversion<doIntegralCast, doIntegralCast>
9042 (S, LHS, RHS, LHSType, RHSType,
false);
9076 llvm::raw_svector_ostream OS(Str);
9077 OS <<
"(vector of " << NumElements <<
" '" << EleTyName <<
"' values)";
9078 S.
Diag(QuestionLoc, diag::err_conditional_vector_element_size)
9079 << CondTy << OS.str();
9100 S.
Diag(QuestionLoc, diag::err_typecheck_cond_expect_nonfloat)
9118 S.
Diag(QuestionLoc, diag::err_conditional_vector_size)
9119 << CondTy << VecResTy;
9124 QualType RVE = RV->getElementType();
9127 S.
Diag(QuestionLoc, diag::err_conditional_vector_element_size)
9128 << CondTy << VecResTy;
9154 bool IsBoolVecLang =
9178 if (
const CallExpr *CE = dyn_cast<CallExpr>(E)) {
9179 QualType Ty = CE->getCallee()->getType();
9217 "should only occur in error-recovery path.");
9252 Diag(QuestionLoc, diag::err_wasm_table_conditional_expression)
9261 diag::err_typecheck_cond_incompatible_operands) << LHSTy << RHSTy
9280 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
9296 if (LHSRT->getDecl() == RHSRT->getDecl())
9340 if (!compositeType.
isNull())
9341 return compositeType;
9375 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
9447 if (!(compositeType =
9455 RHSOPT->isObjCQualifiedIdType()) &&
9466 Diag(QuestionLoc, diag::ext_typecheck_cond_incompatible_operands)
9477 return compositeType;
9484 Diag(QuestionLoc, diag::err_cond_voidptr_arc) << LHSTy << RHSTy
9504 Diag(QuestionLoc, diag::err_cond_voidptr_arc) << LHSTy << RHSTy
9536 Self.Diag(Loc,
Note) << ParenRange;
9556 const Expr **RHSExprs) {
9561 if (
const auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E)) {
9562 E = MTE->getSubExpr();
9567 if (
const auto *OP = dyn_cast<BinaryOperator>(E);
9569 *Opcode = OP->getOpcode();
9570 *RHSExprs = OP->getRHS();
9575 if (
const auto *
Call = dyn_cast<CXXOperatorCallExpr>(E)) {
9576 if (
Call->getNumArgs() != 2)
9582 if (OO < OO_Plus || OO > OO_Arrow ||
9583 OO == OO_PlusPlus || OO == OO_MinusMinus)
9589 *RHSExprs =
Call->getArg(1);
9605 if (
const auto *OP = dyn_cast<BinaryOperator>(E))
9606 return OP->isComparisonOp() || OP->isLogicalOp();
9607 if (
const auto *OP = dyn_cast<UnaryOperator>(E))
9608 return OP->getOpcode() == UO_LNot;
9623 const Expr *RHSExpr) {
9625 const Expr *CondRHS;
9636 ? diag::warn_precedence_bitwise_conditional
9637 : diag::warn_precedence_conditional;
9639 Self.Diag(OpLoc, DiagID)
9645 Self.PDiag(diag::note_precedence_silence)
9650 Self.PDiag(diag::note_precedence_conditional_first),
9661 auto GetNullability = [](
QualType Ty) {
9662 std::optional<NullabilityKind> Kind = Ty->getNullability();
9672 auto LHSKind = GetNullability(LHSTy), RHSKind = GetNullability(RHSTy);
9680 MergedKind = RHSKind;
9687 MergedKind = RHSKind;
9689 MergedKind = LHSKind;
9695 if (GetNullability(ResTy) == MergedKind)
9732 CondExpr = CondResult.
get();
9733 LHSExpr = LHSResult.
get();
9734 RHSExpr = RHSResult.
get();
9740 Expr *commonExpr =
nullptr;
9742 commonExpr = CondExpr;
9749 commonExpr = result.
get();
9763 commonExpr = commonRes.
get();
9773 commonExpr = MatExpr.
get();
9781 LHSExpr = CondExpr = opaqueValue;
9787 ExprResult Cond = CondExpr, LHS = LHSExpr, RHS = RHSExpr;
9789 VK, OK, QuestionLoc);
9797 CheckBoolLikeConversion(Cond.
get(), QuestionLoc);
9805 RHS.get(), result, VK, OK);
9808 commonExpr, opaqueValue, Cond.
get(), LHS.get(), RHS.get(), QuestionLoc,
9809 ColonLoc, result, VK, OK);
9814 unsigned FromAttributes = 0, ToAttributes = 0;
9815 if (
const auto *FromFn =
9819 if (
const auto *ToFn =
9824 return FromAttributes != ToAttributes;
9832 if (
const auto *ToFn =
9834 if (
const auto *FromFn =
9853 assert(LHSType.
isCanonical() &&
"LHS not canonicalized!");
9854 assert(RHSType.
isCanonical() &&
"RHS not canonicalized!");
9857 const Type *lhptee, *rhptee;
9859 std::tie(lhptee, lhq) =
9860 cast<PointerType>(LHSType)->getPointeeType().split().asPair();
9861 std::tie(rhptee, rhq) =
9862 cast<PointerType>(RHSType)->getPointeeType().split().asPair();
9922 diag::warn_typecheck_convert_incompatible_function_pointer_strict,
9945 if (ltrans == rtrans) {
9959 if (isa<PointerType>(lhptee) && isa<PointerType>(rhptee)) {
9961 std::tie(lhptee, lhq) =
9962 cast<PointerType>(lhptee)->getPointeeType().split().asPair();
9963 std::tie(rhptee, rhq) =
9964 cast<PointerType>(rhptee)->getPointeeType().split().asPair();
9977 }
while (isa<PointerType>(lhptee) && isa<PointerType>(rhptee));
9979 if (lhptee == rhptee)
10005 assert(LHSType.
isCanonical() &&
"LHS not canonicalized!");
10006 assert(RHSType.
isCanonical() &&
"RHS not canonicalized!");
10027 if (LQuals != RQuals)
10056 assert(LHSType.
isCanonical() &&
"LHS was not canonicalized!");
10057 assert(RHSType.
isCanonical() &&
"RHS was not canonicalized!");
10105 return VT->getElementType().getCanonicalType() == ElementType;
10128 CastKind &Kind,
bool ConvertRHS) {
10138 if (LHSType == RHSType) {
10145 if (
const auto *AT = dyn_cast<AutoType>(LHSType)) {
10146 if (AT->isGNUAutoType()) {
10154 if (
const AtomicType *AtomicTy = dyn_cast<AtomicType>(LHSType)) {
10159 if (Kind != CK_NoOp && ConvertRHS)
10161 Kind = CK_NonAtomicToAtomic;
10174 Kind = CK_LValueBitCast;
10189 Kind = CK_VectorSplat;
10215 << RHSType << LHSType;
10234 << RHSType << LHSType;
10284 if (
const PointerType *LHSPointer = dyn_cast<PointerType>(LHSType)) {
10286 if (isa<PointerType>(RHSType)) {
10287 LangAS AddrSpaceL = LHSPointer->getPointeeType().getAddressSpace();
10289 if (AddrSpaceL != AddrSpaceR)
10290 Kind = CK_AddressSpaceConversion;
10301 Kind = CK_IntegralToPointer;
10307 if (isa<ObjCObjectPointerType>(RHSType)) {
10309 if (LHSPointer->getPointeeType()->isVoidType()) {
10328 if (LHSPointer->getPointeeType()->isVoidType()) {
10329 LangAS AddrSpaceL = LHSPointer->getPointeeType().getAddressSpace();
10332 .getAddressSpace();
10334 AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion : CK_BitCast;
10343 if (isa<BlockPointerType>(LHSType)) {
10348 .getAddressSpace();
10351 .getAddressSpace();
10352 Kind = AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion : CK_BitCast;
10358 Kind = CK_IntegralToPointer;
10364 Kind = CK_AnyPointerToBlockPointerCast;
10370 if (RHSPT->getPointeeType()->isVoidType()) {
10371 Kind = CK_AnyPointerToBlockPointerCast;
10379 if (isa<ObjCObjectPointerType>(LHSType)) {
10385 if (
getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
10394 Kind = CK_IntegralToPointer;
10400 if (isa<PointerType>(RHSType)) {
10401 Kind = CK_CPointerToObjCPointerCast;
10423 Kind = CK_BlockPointerToObjCPointerCast;
10435 Kind = CK_NullToPointer;
10440 if (isa<PointerType>(RHSType)) {
10443 Kind = CK_PointerToBoolean;
10449 Kind = CK_PointerToIntegral;
10457 if (isa<ObjCObjectPointerType>(RHSType)) {
10460 Kind = CK_PointerToBoolean;
10466 Kind = CK_PointerToIntegral;
10474 if (isa<TagType>(LHSType) && isa<TagType>(RHSType)) {
10482 Kind = CK_IntToOCLSampler;
10524 for (
auto *it : UD->
fields()) {
10525 if (it->getType()->isPointerType()) {
10564 bool DiagnoseCFAudited,
10568 assert((ConvertRHS || !
Diagnose) &&
"can't indicate whether we diagnosed");
10574 ExprResult &RHS = ConvertRHS ? CallerRHS : LocalRHS;
10578 if (RHSPtrType->getPointeeType()->hasAttr(attr::NoDeref) &&
10579 !LHSPtrType->getPointeeType()->hasAttr(attr::NoDeref)) {
10581 diag::warn_noderef_to_dereferenceable_pointer)
10600 AllowedExplicit::None,
10612 if (
getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
10627 RHS.
get(), LHSType,
false, DAP))
10718 if (
getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
10747struct OriginalOperand {
10748 explicit OriginalOperand(
Expr *Op) : Orig(Op), Conversion(nullptr) {
10749 if (
auto *MTE = dyn_cast<MaterializeTemporaryExpr>(Op))
10750 Op = MTE->getSubExpr();
10751 if (
auto *BTE = dyn_cast<CXXBindTemporaryExpr>(Op))
10752 Op = BTE->getSubExpr();
10753 if (
auto *ICE = dyn_cast<ImplicitCastExpr>(Op)) {
10754 Orig = ICE->getSubExprAsWritten();
10755 Conversion = ICE->getConversionFunction();
10759 QualType getType()
const {
return Orig->getType(); }
10768 OriginalOperand OrigLHS(LHS.
get()), OrigRHS(RHS.
get());
10770 Diag(Loc, diag::err_typecheck_invalid_operands)
10771 << OrigLHS.getType() << OrigRHS.getType()
10776 if (OrigLHS.Conversion) {
10777 Diag(OrigLHS.Conversion->getLocation(),
10778 diag::note_typecheck_invalid_operands_converted)
10781 if (OrigRHS.Conversion) {
10782 Diag(OrigRHS.Conversion->getLocation(),
10783 diag::note_typecheck_invalid_operands_converted)
10801 if (!(LHSNatVec && RHSNatVec)) {
10803 Expr *NonVector = !LHSNatVec ? LHS.
get() : RHS.
get();
10804 Diag(Loc, diag::err_typecheck_logical_vector_expr_gnu_cpp_restrict)
10806 <<
Vector->getSourceRange();
10810 Diag(Loc, diag::err_typecheck_logical_vector_expr_gnu_cpp_restrict)
10833 unsigned &DiagID) {
10842 DiagID = diag::err_opencl_scalar_type_rank_greater_than_vector_type;
10847 scalarCast = CK_IntegralCast;
10852 DiagID = diag::err_opencl_scalar_type_rank_greater_than_vector_type;
10855 scalarCast = CK_FloatingCast;
10858 scalarCast = CK_IntegralToFloating;
10867 if (scalarCast != CK_NoOp)
10878 assert(VecTy &&
"Expression E must be a vector");
10883 VecTy->getVectorKind());
10887 if (
auto *ICE = dyn_cast<ImplicitCastExpr>(E))
10888 if (ICE->getSubExpr()->getType() == NewVecTy)
10889 return ICE->getSubExpr();
10891 auto Cast = ElementType->
isIntegerType() ? CK_IntegralCast : CK_FloatingCast;
10914 unsigned NumBits = IntSigned
10916 :
Result.getActiveBits())
10917 :
Result.getActiveBits();
10924 return (IntSigned != OtherIntSigned &&
10930 return (Order < 0);
10954 llvm::APFloat::rmTowardZero);
10957 bool Ignored =
false;
10958 Float.convertToInteger(ConvertBack, llvm::APFloat::rmNearestTiesToEven,
10960 if (
Result != ConvertBack)
10966 unsigned FloatPrec = llvm::APFloat::semanticsPrecision(
10968 if (Bits > FloatPrec)
10981 QualType ScalarTy = Scalar->get()->getType().getUnqualifiedType();
10982 QualType VectorTy =
Vector->get()->getType().getUnqualifiedType();
10986 assert(!isa<ExtVectorType>(VT) &&
10987 "ExtVectorTypes should not be handled here!");
10988 VectorEltTy = VT->getElementType();
10993 llvm_unreachable(
"Only Fixed-Length and SVE Vector types are handled here");
11019 ScalarCast = CK_IntegralCast;
11023 ScalarCast = CK_FloatingToIntegral;
11031 llvm::APFloat
Result(0.0);
11037 bool CstScalar = Scalar->get()->isValueDependent() ||
11040 if (!CstScalar && Order < 0)
11046 bool Truncated =
false;
11048 llvm::APFloat::rmNearestTiesToEven, &Truncated);
11053 ScalarCast = CK_FloatingCast;
11058 ScalarCast = CK_IntegralToFloating;
11065 if (ScalarCast != CK_NoOp)
11073 bool AllowBothBool,
11074 bool AllowBoolConversions,
11075 bool AllowBoolOperation,
11076 bool ReportInvalid) {
11077 if (!IsCompAssign) {
11093 assert(LHSVecType || RHSVecType);
11097 if (!AllowBothBool && LHSVecType &&
11103 if (!AllowBoolOperation &&
11112 if (LHSVecType && RHSVecType &&
11114 if (isa<ExtVectorType>(LHSVecType)) {
11127 if (AllowBoolConversions && LHSVecType && RHSVecType &&
11137 if (!IsCompAssign &&
11140 RHSVecType->getElementType()->isIntegerType()) {
11149 unsigned &SVEorRVV) {
11167 if (IsSveRVVConversion(LHSType, RHSType, SVEorRVV) ||
11168 IsSveRVVConversion(RHSType, LHSType, SVEorRVV)) {
11169 Diag(Loc, diag::err_typecheck_sve_rvv_ambiguous)
11170 << SVEorRVV << LHSType << RHSType;
11177 unsigned &SVEorRVV) {
11182 if (FirstVecType && SecondVecType) {
11185 SecondVecType->getVectorKind() ==
11197 if (SecondVecType &&
11210 if (IsSveRVVGnuConversion(LHSType, RHSType, SVEorRVV) ||
11211 IsSveRVVGnuConversion(RHSType, LHSType, SVEorRVV)) {
11212 Diag(Loc, diag::err_typecheck_sve_rvv_gnu_ambiguous)
11213 << SVEorRVV << LHSType << RHSType;
11219 unsigned DiagID = diag::err_typecheck_vector_not_convertable;
11221 if (isa<ExtVectorType>(LHSVecType)) {
11232 if (isa<ExtVectorType>(RHSVecType)) {
11234 LHSType, RHSVecType->getElementType(),
11247 QualType VecType = LHSVecType ? LHSType : RHSType;
11248 const VectorType *VT = LHSVecType ? LHSVecType : RHSVecType;
11249 QualType OtherType = LHSVecType ? RHSType : LHSType;
11250 ExprResult *OtherExpr = LHSVecType ? &RHS : &LHS;
11255 Diag(Loc, diag::warn_deprecated_lax_vec_conv_all) << RHSType << LHSType;
11259 if (!IsCompAssign) {
11278 if ((!RHSVecType && !RHSType->
isRealType()) ||
11280 Diag(Loc, diag::err_typecheck_vector_not_convertable_non_scalar)
11281 << LHSType << RHSType
11291 RHSVecType && isa<ExtVectorType>(RHSVecType) &&
11292 LHSVecType && isa<ExtVectorType>(LHSVecType)) {
11293 Diag(Loc, diag::err_opencl_implicit_vector_conversion) << LHSType
11302 if ((RHSVecType && !isa<ExtVectorType>(RHSVecType)) ||
11303 (LHSVecType && !isa<ExtVectorType>(LHSVecType))) {
11304 QualType Scalar = LHSVecType ? RHSType : LHSType;
11306 unsigned ScalarOrVector = LHSVecType && RHSVecType ? 1 : 0;
11308 diag::err_typecheck_vector_not_convertable_implict_truncation)
11309 << ScalarOrVector << Scalar <<
Vector;
11316 << LHSType << RHSType
11325 if (!IsCompAssign) {
11340 unsigned DiagID = diag::err_typecheck_invalid_operands;
11342 ((LHSBuiltinTy && LHSBuiltinTy->
isSVEBool()) ||
11343 (RHSBuiltinTy && RHSBuiltinTy->isSVEBool()))) {
11364 Diag(Loc, diag::err_typecheck_vector_not_convertable_non_scalar)
11373 Diag(Loc, diag::err_typecheck_vector_lengths_not_equal)
11382 bool ScalarOrVector =
11385 Diag(Loc, diag::err_typecheck_vector_not_convertable_implict_truncation)
11386 << ScalarOrVector << Scalar <<
Vector;
11418 S.
Diag(Loc, diag::warn_null_in_arithmetic_operation)
11430 S.
Diag(Loc, diag::warn_null_in_comparison_operation)
11431 << LHSNull << NonNullType
11437 const auto *LUE = dyn_cast<UnaryExprOrTypeTraitExpr>(LHS);
11438 const auto *RUE = dyn_cast<UnaryExprOrTypeTraitExpr>(RHS);
11441 if (LUE->getKind() != UETT_SizeOf || LUE->isArgumentType() ||
11442 RUE->getKind() != UETT_SizeOf)
11449 if (RUE->isArgumentType())
11450 RHSTy = RUE->getArgumentType().getNonReferenceType();
11452 RHSTy = RUE->getArgumentExpr()->IgnoreParens()->getType();
11459 if (
const auto *DRE = dyn_cast<DeclRefExpr>(LHSArg)) {
11460 if (
const ValueDecl *LHSArgDecl = DRE->getDecl())
11461 S.
Diag(LHSArgDecl->getLocation(), diag::note_pointer_declared_here)
11465 QualType ArrayElemTy = ArrayTy->getElementType();
11471 S.
Diag(Loc, diag::warn_division_sizeof_array)
11473 if (
const auto *DRE = dyn_cast<DeclRefExpr>(LHSArg)) {
11474 if (
const ValueDecl *LHSArgDecl = DRE->getDecl())
11475 S.
Diag(LHSArgDecl->getLocation(), diag::note_array_declared_here)
11479 S.
Diag(Loc, diag::note_precedence_silence) << RHS;
11492 S.
PDiag(diag::warn_remainder_division_by_zero)
11498 bool IsCompAssign,
bool IsDiv) {
11576 ? diag::err_typecheck_pointer_arith_void_type
11577 : diag::ext_gnu_void_ptr)
11586 ? diag::err_typecheck_pointer_arith_void_type
11587 : diag::ext_gnu_void_ptr)
11588 << 0 <<
Pointer->getSourceRange();
11599 S.
Diag(Loc, diag::warn_gnu_null_ptr_arith)
11600 <<
Pointer->getSourceRange();
11602 S.
Diag(Loc, diag::warn_pointer_arith_null_ptr)
11619 S.
PDiag(diag::warn_pointer_sub_null_ptr)
11621 <<
Pointer->getSourceRange());
11630 ? diag::err_typecheck_pointer_arith_function_type
11631 : diag::ext_gnu_ptr_func_arith)
11643 assert(
Pointer->getType()->isAnyPointerType());
11645 ? diag::err_typecheck_pointer_arith_function_type
11646 : diag::ext_gnu_ptr_func_arith)
11647 << 0 <<
Pointer->getType()->getPointeeType()
11649 <<
Pointer->getSourceRange();
11657 QualType ResType = Operand->getType();
11659 ResType = ResAtomicType->getValueType();
11665 diag::err_typecheck_arithmetic_incomplete_or_sizeless_type,
11666 Operand->getSourceRange());
11679 QualType ResType = Operand->getType();
11681 ResType = ResAtomicType->getValueType();
11713 if (!isLHSPointer && !isRHSPointer)
return true;
11715 QualType LHSPointeeTy, RHSPointeeTy;
11720 if (isLHSPointer && isRHSPointer) {
11723 diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
11731 bool isLHSVoidPtr = isLHSPointer && LHSPointeeTy->
isVoidType();
11732 bool isRHSVoidPtr = isRHSPointer && RHSPointeeTy->
isVoidType();
11733 if (isLHSVoidPtr || isRHSVoidPtr) {
11741 bool isLHSFuncPtr = isLHSPointer && LHSPointeeTy->
isFunctionType();
11742 bool isRHSFuncPtr = isRHSPointer && RHSPointeeTy->
isFunctionType();
11743 if (isLHSFuncPtr || isRHSFuncPtr) {
11765 Expr* IndexExpr = RHSExpr;
11768 IndexExpr = LHSExpr;
11771 bool IsStringPlusInt = StrExpr &&
11777 Self.Diag(OpLoc, diag::warn_string_plus_int)
11781 if (IndexExpr == RHSExpr) {
11783 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence)
11788 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence);
11794 const Expr *StringRefExpr = LHSExpr;
11799 CharExpr = dyn_cast<CharacterLiteral>(LHSExpr->
IgnoreImpCasts());
11800 StringRefExpr = RHSExpr;
11803 if (!CharExpr || !StringRefExpr)
11823 Self.Diag(OpLoc, diag::warn_string_plus_char)
11824 << DiagRange << Ctx.
CharTy;
11826 Self.Diag(OpLoc, diag::warn_string_plus_char)
11827 << DiagRange << CharExpr->
getType();
11833 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence)
11838 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence);
11847 S.
Diag(Loc, diag::err_typecheck_sub_ptr_compatible)
11866 if (CompLHSTy) *CompLHSTy = compType;
11875 *CompLHSTy = compType;
11884 *CompLHSTy = compType;
11894 if (Opc == BO_Add) {
11901 if (CompLHSTy) *CompLHSTy = compType;
11915 std::swap(PExp, IExp);
11926 if (!IExp->getType()->isIntegerType())
11935 (!IExp->isValueDependent() &&
11936 (!IExp->EvaluateAsInt(KnownVal,
Context) ||
11940 Context, BO_Add, PExp, IExp);
11952 CheckArrayAccess(PExp, IExp);
11961 *CompLHSTy = LHSTy;
11981 if (CompLHSTy) *CompLHSTy = compType;
11990 *CompLHSTy = compType;
11999 *CompLHSTy = compType;
12012 if (CompLHSTy) *CompLHSTy = compType;
12046 CheckArrayAccess(LHS.
get(), RHS.
get(),
nullptr,
12049 if (CompLHSTy) *CompLHSTy = LHS.
get()->
getType();
12093 if (ElementSize.
isZero()) {
12094 Diag(Loc,diag::warn_sub_ptr_zero_size_types)
12100 if (CompLHSTy) *CompLHSTy = LHS.
get()->
getType();
12110 return ET->getDecl()->isScoped();
12127 llvm::APSInt Right = RHSResult.
Val.
getInt();
12129 if (Right.isNegative()) {
12131 S.
PDiag(diag::warn_shift_negative)
12142 LeftSize = FXSema.getWidth() - (
unsigned)FXSema.hasUnsignedPadding();
12144 if (Right.uge(LeftSize)) {
12146 S.
PDiag(diag::warn_shift_gt_typewidth)
12166 llvm::APSInt Left = LHSResult.
Val.
getInt();
12177 if (Left.isNegative()) {
12179 S.
PDiag(diag::warn_shift_lhs_negative)
12184 llvm::APInt ResultBits =
12185 static_cast<llvm::APInt &
>(Right) + Left.getSignificantBits();
12186 if (ResultBits.ule(LeftSize))
12188 llvm::APSInt
Result = Left.extend(ResultBits.getLimitedValue());
12194 Result.toString(HexResult, 16,
false,
true);
12200 if (ResultBits - 1 == LeftSize) {
12201 S.
Diag(Loc, diag::warn_shift_result_sets_sign_bit)
12202 << HexResult << LHSType
12207 S.
Diag(Loc, diag::warn_shift_result_gt_typewidth)
12208 << HexResult.str() <<
Result.getSignificantBits() << LHSType
12220 S.
Diag(Loc, diag::err_shift_rhs_only_vector)
12226 if (!IsCompAssign) {
12248 S.
Diag(Loc, diag::err_typecheck_invalid_operands)
12255 if (!LHSEleType->isIntegerType()) {
12256 S.
Diag(Loc, diag::err_typecheck_expect_int)
12261 if (!RHSEleType->isIntegerType()) {
12262 S.
Diag(Loc, diag::err_typecheck_expect_int)
12271 if (LHSEleType != RHSEleType) {
12273 LHSEleType = RHSEleType;
12279 }
else if (RHSVecTy) {
12284 S.
Diag(Loc, diag::err_typecheck_vector_lengths_not_equal)
12292 if (LHSBT != RHSBT &&
12294 S.
Diag(Loc, diag::warn_typecheck_vector_element_sizes_not_equal)
12311 bool IsCompAssign) {
12312 if (!IsCompAssign) {
12335 if ((LHSBuiltinTy && LHSBuiltinTy->
isSVEBool()) ||
12336 (RHSBuiltinTy && RHSBuiltinTy->
isSVEBool())) {
12337 S.
Diag(Loc, diag::err_typecheck_invalid_operands)
12342 if (!LHSEleType->isIntegerType()) {
12343 S.
Diag(Loc, diag::err_typecheck_expect_int)
12348 if (!RHSEleType->isIntegerType()) {
12349 S.
Diag(Loc, diag::err_typecheck_expect_int)
12357 S.
Diag(Loc, diag::err_typecheck_invalid_operands)
12367 if (LHSEleType != RHSEleType) {
12369 LHSEleType = RHSEleType;
12371 const llvm::ElementCount VecSize =
12380 S.
Diag(Loc, diag::err_typecheck_vector_lengths_not_equal)
12386 const llvm::ElementCount VecSize =
12388 if (LHSEleType != RHSEleType) {
12390 RHSEleType = LHSEleType;
12403 bool IsCompAssign) {
12437 if (IsCompAssign) LHS = OldLHS;
12468 S.
Diag(Loc, IsError ? diag::err_typecheck_comparison_of_distinct_pointers
12469 : diag::ext_typecheck_comparison_of_distinct_pointers)
12509 S.
Diag(Loc, IsError ? diag::err_typecheck_comparison_of_fptr_to_void
12510 : diag::ext_typecheck_comparison_of_fptr_to_void)
12517 case Stmt::ObjCArrayLiteralClass:
12518 case Stmt::ObjCDictionaryLiteralClass:
12519 case Stmt::ObjCStringLiteralClass:
12520 case Stmt::ObjCBoxedExprClass:
12579 case Stmt::ObjCStringLiteralClass:
12582 case Stmt::ObjCArrayLiteralClass:
12585 case Stmt::ObjCDictionaryLiteralClass:
12588 case Stmt::BlockExprClass:
12590 case Stmt::ObjCBoxedExprClass: {
12591 Expr *Inner = cast<ObjCBoxedExpr>(FromE)->getSubExpr()->IgnoreParens();
12592 switch (Inner->getStmtClass()) {
12593 case Stmt::IntegerLiteralClass:
12594 case Stmt::FloatingLiteralClass:
12595 case Stmt::CharacterLiteralClass:
12596 case Stmt::ObjCBoolLiteralExprClass:
12597 case Stmt::CXXBoolLiteralExprClass:
12600 case Stmt::ImplicitCastExprClass: {
12601 CastKind CK = cast<CastExpr>(Inner)->getCastKind();
12603 if (CK == CK_IntegralToBoolean || CK == CK_IntegralCast)
12622 Literal = LHS.
get();
12625 Literal = RHS.
get();
12641 llvm_unreachable(
"Unknown Objective-C object literal kind");
12645 S.
Diag(Loc, diag::warn_objc_string_literal_comparison)
12646 << Literal->getSourceRange();
12648 S.
Diag(Loc, diag::warn_objc_literal_comparison)
12649 << LiteralKind << Literal->getSourceRange();
12658 S.
Diag(Loc, diag::note_objc_literal_comparison_isequal)
12671 if (!UO || UO->
getOpcode() != UO_LNot)
return;
12681 bool IsBitwiseOp = Opc == BO_And || Opc == BO_Or || Opc == BO_Xor;
12683 << Loc << IsBitwiseOp;
12710 if (
const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(E)) {
12712 }
else if (
const MemberExpr *Mem = dyn_cast<MemberExpr>(E)) {
12713 if (Mem->isImplicitAccess())
12714 D = Mem->getMemberDecl();
12769 S.
Diag(Loc, diag::warn_depr_array_comparison)
12795 Result = AlwaysConstant;
12799 S.
PDiag(diag::warn_comparison_always)
12814 Result = AlwaysConstant;
12818 S.
PDiag(diag::warn_comparison_always)
12824 if (isa<CastExpr>(LHSStripped))
12826 if (isa<CastExpr>(RHSStripped))
12831 Expr *LiteralString =
nullptr;
12832 Expr *LiteralStringStripped =
nullptr;
12833 if ((isa<StringLiteral>(LHSStripped) || isa<ObjCEncodeExpr>(LHSStripped)) &&
12836 LiteralString = LHS;
12837 LiteralStringStripped = LHSStripped;
12838 }
else if ((isa<StringLiteral>(RHSStripped) ||
12839 isa<ObjCEncodeExpr>(RHSStripped)) &&
12842 LiteralString = RHS;
12843 LiteralStringStripped = RHSStripped;
12846 if (LiteralString) {
12848 S.
PDiag(diag::warn_stringcompare)
12849 << isa<ObjCEncodeExpr>(LiteralStringStripped)
12861 llvm_unreachable(
"unhandled cast kind");
12863 case CK_UserDefinedConversion:
12865 case CK_LValueToRValue:
12867 case CK_ArrayToPointerDecay:
12869 case CK_FunctionToPointerDecay:
12871 case CK_IntegralCast:
12873 case CK_FloatingCast:
12875 case CK_IntegralToFloating:
12876 case CK_FloatingToIntegral:
12878 case CK_IntegralComplexCast:
12879 case CK_FloatingComplexCast:
12880 case CK_FloatingComplexToIntegralComplex:
12881 case CK_IntegralComplexToFloatingComplex:
12883 case CK_FloatingComplexToReal:
12884 case CK_FloatingRealToComplex:
12885 case CK_IntegralComplexToReal:
12886 case CK_IntegralRealToComplex:
12899 if (
const auto *ICE = dyn_cast<ImplicitCastExpr>(E))
12926 << 0 << FromType << ToType;
12931 llvm_unreachable(
"unhandled case in switch");
12958 if (NumEnumArgs == 1) {
12960 QualType OtherTy = LHSIsEnum ? RHSStrippedType : LHSStrippedType;
12966 if (NumEnumArgs == 2) {
12975 LHSStrippedType->
castAs<
EnumType>()->getDecl()->getIntegerType();
12986 LHSType = RHSType = IntType;
12998 std::optional<ComparisonCategoryType> CCT =
13010 assert(!
Type.isNull() &&
"composite type for <=> has not been set");
13051 if (
const auto *CL = dyn_cast<CharacterLiteral>(E.
get())) {
13052 if (CL->getValue() == 0)
13056 NullValue ?
"NULL" :
"(void *)0");
13057 }
else if (
const auto *CE = dyn_cast<CStyleCastExpr>(E.
get())) {
13064 NullValue ?
"NULL" :
"(void *)0");
13074 bool IsThreeWay = Opc == BO_Cmp;
13075 bool IsOrdered = IsRelational || IsThreeWay;
13086 if (!IsThreeWay || IsAnyPointerType(LHS) || IsAnyPointerType(RHS)) {
13139 auto computeResultTy = [&]() {
13148 std::optional<ComparisonCategoryType> CCT =
13153 if (CompositeTy->
isPointerType() && LHSIsNull != RHSIsNull) {
13157 Diag(Loc, diag::err_typecheck_three_way_comparison_of_pointer_and_zero)
13167 if (!IsOrdered && LHSIsNull != RHSIsNull) {
13168 bool IsEquality = Opc == BO_EQ;
13180 bool IsError = Opc == BO_Cmp;
13182 IsError ? diag::err_typecheck_ordered_comparison_of_function_pointers
13184 ? diag::warn_typecheck_ordered_comparison_of_function_pointers
13185 : diag::ext_typecheck_ordered_comparison_of_function_pointers;
13214 return computeResultTy();
13230 (IsOrdered ? 2 : 1) &&
13235 return computeResultTy();
13249 if (IsRelational) {
13254 Diag(Loc, diag::ext_typecheck_compare_complete_incomplete_pointers)
13260 }
else if (!IsRelational &&
13264 && !LHSIsNull && !RHSIsNull)
13271 if (LCanPointeeTy != RCanPointeeTy) {
13276 diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
13277 << LHSType << RHSType << 0
13283 CastKind Kind = AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion
13285 if (LHSIsNull && !RHSIsNull)
13290 return computeResultTy();
13302 if (!IsOrdered && LHSIsNull && RHSIsNull) {
13305 return computeResultTy();
13309 return computeResultTy();
13320 return computeResultTy();
13324 return computeResultTy();
13333 return computeResultTy();
13338 return computeResultTy();
13342 if (IsRelational &&
13351 if (isa<FunctionDecl>(DC))
13353 if (
auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
13354 if (CTSD->isInStdNamespace() &&
13355 llvm::StringSwitch<bool>(CTSD->getName())
13356 .Cases(
"less",
"less_equal",
"greater",
"greater_equal",
true)
13362 return computeResultTy();
13375 return computeResultTy();
13385 if (!LHSIsNull && !RHSIsNull &&
13387 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks)
13392 return computeResultTy();
13399 if (!LHSIsNull && !RHSIsNull) {
13404 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks)
13408 if (LHSIsNull && !RHSIsNull)
13411 : CK_AnyPointerToBlockPointerCast);
13415 : CK_AnyPointerToBlockPointerCast);
13416 return computeResultTy();
13425 bool RPtrToVoid = RPT ? RPT->getPointeeType()->isVoidType() :
false;
13427 if (!LPtrToVoid && !RPtrToVoid &&
13435 if (LHSIsNull && !RHSIsNull) {
13441 RPT ? CK_BitCast :CK_CPointerToObjCPointerCast);
13450 LPT ? CK_BitCast :CK_CPointerToObjCPointerCast);
13452 return computeResultTy();
13462 if (LHSIsNull && !RHSIsNull)
13466 return computeResultTy();
13472 CK_BlockPointerToObjCPointerCast);
13473 return computeResultTy();
13474 }
else if (!IsOrdered &&
13478 CK_BlockPointerToObjCPointerCast);
13479 return computeResultTy();
13484 unsigned DiagID = 0;
13485 bool isError =
false;
13494 isError ? diag::err_typecheck_ordered_comparison_of_pointer_and_zero
13495 : diag::ext_typecheck_ordered_comparison_of_pointer_and_zero;
13498 DiagID = diag::err_typecheck_comparison_of_pointer_integer;
13500 }
else if (IsOrdered)
13501 DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_integer;
13503 DiagID = diag::ext_typecheck_comparison_of_pointer_integer;
13515 LHSIsNull ? CK_NullToPointer : CK_IntegralToPointer);
13518 RHSIsNull ? CK_NullToPointer : CK_IntegralToPointer);
13519 return computeResultTy();
13523 if (!IsOrdered && RHSIsNull
13526 return computeResultTy();
13528 if (!IsOrdered && LHSIsNull
13531 return computeResultTy();
13534 if (
getLangOpts().getOpenCLCompatibleVersion() >= 200) {
13536 return computeResultTy();
13540 return computeResultTy();
13543 if (LHSIsNull && RHSType->
isQueueT()) {
13545 return computeResultTy();
13548 if (LHSType->
isQueueT() && RHSIsNull) {
13550 return computeResultTy();
13566 if (isa<ExtVectorType>(VTy)) {
13580 "Unhandled vector element size in vector compare");
13600 "Unhandled vector element size in vector compare");
13624 if (Opc == BO_Cmp) {
13625 Diag(Loc, diag::err_three_way_vector_comparison);
13656 Diag(Loc, diag::warn_deprecated_altivec_src_compat);
13686 if (Opc == BO_Cmp) {
13687 Diag(Loc, diag::err_three_way_vector_comparison);
13715 if (LHSBuiltinTy && RHSBuiltinTy && LHSBuiltinTy->
isSVEBool() &&
13716 RHSBuiltinTy->isSVEBool())
13735 bool Negative =
false;
13736 bool ExplicitPlus =
false;
13737 const auto *LHSInt = dyn_cast<IntegerLiteral>(XorLHS.
get());
13738 const auto *RHSInt = dyn_cast<IntegerLiteral>(XorRHS.
get());
13744 if (
const auto *UO = dyn_cast<UnaryOperator>(XorRHS.
get())) {
13746 if (Opc != UO_Minus && Opc != UO_Plus)
13748 RHSInt = dyn_cast<IntegerLiteral>(UO->getSubExpr());
13751 Negative = (Opc == UO_Minus);
13752 ExplicitPlus = !Negative;
13758 const llvm::APInt &LeftSideValue = LHSInt->getValue();
13759 llvm::APInt RightSideValue = RHSInt->getValue();
13760 if (LeftSideValue != 2 && LeftSideValue != 10)
13763 if (LeftSideValue.getBitWidth() != RightSideValue.getBitWidth())
13768 llvm::StringRef ExprStr =
13773 llvm::StringRef XorStr =
13776 if (XorStr ==
"xor")
13787 RightSideValue = -RightSideValue;
13788 RHSStr =
"-" + RHSStr;
13789 }
else if (ExplicitPlus) {
13790 RHSStr =
"+" + RHSStr;
13793 StringRef LHSStrRef = LHSStr;
13794 StringRef RHSStrRef = RHSStr;
13797 if (LHSStrRef.starts_with(
"0b") || LHSStrRef.starts_with(
"0B") ||
13798 RHSStrRef.starts_with(
"0b") || RHSStrRef.starts_with(
"0B") ||
13799 LHSStrRef.starts_with(
"0x") || LHSStrRef.starts_with(
"0X") ||
13800 RHSStrRef.starts_with(
"0x") || RHSStrRef.starts_with(
"0X") ||
13801 (LHSStrRef.size() > 1 && LHSStrRef.starts_with(
"0")) ||
13802 (RHSStrRef.size() > 1 && RHSStrRef.starts_with(
"0")) ||
13803 LHSStrRef.contains(
'\'') || RHSStrRef.contains(
'\''))
13808 const llvm::APInt XorValue = LeftSideValue ^ RightSideValue;
13809 int64_t RightSideIntValue = RightSideValue.getSExtValue();
13810 if (LeftSideValue == 2 && RightSideIntValue >= 0) {
13811 std::string SuggestedExpr =
"1 << " + RHSStr;
13812 bool Overflow =
false;
13813 llvm::APInt One = (LeftSideValue - 1);
13814 llvm::APInt PowValue = One.sshl_ov(RightSideValue, Overflow);
13816 if (RightSideIntValue < 64)
13817 S.
Diag(Loc, diag::warn_xor_used_as_pow_base)
13818 << ExprStr <<
toString(XorValue, 10,
true) << (
"1LL << " + RHSStr)
13820 else if (RightSideIntValue == 64)
13821 S.
Diag(Loc, diag::warn_xor_used_as_pow)
13822 << ExprStr <<
toString(XorValue, 10,
true);
13826 S.
Diag(Loc, diag::warn_xor_used_as_pow_base_extra)
13827 << ExprStr <<
toString(XorValue, 10,
true) << SuggestedExpr
13830 ExprRange, (RightSideIntValue == 0) ?
"1" : SuggestedExpr);
13833 S.
Diag(Loc, diag::note_xor_used_as_pow_silence)
13834 << (
"0x2 ^ " + RHSStr) << SuggestXor;
13835 }
else if (LeftSideValue == 10) {
13836 std::string SuggestedValue =
"1e" + std::to_string(RightSideIntValue);
13837 S.
Diag(Loc, diag::warn_xor_used_as_pow_base)
13838 << ExprStr <<
toString(XorValue, 10,
true) << SuggestedValue
13840 S.
Diag(Loc, diag::note_xor_used_as_pow_silence)
13841 << (
"0xA ^ " + RHSStr) << SuggestXor;
13857 getLangOpts().getOpenCLCompatibleVersion() < 120 &&
13872 bool IsCompAssign) {
13873 if (!IsCompAssign) {
13889 assert((LHSMatType || RHSMatType) &&
"At least one operand must be a matrix");
13898 if (LHSMatType && !RHSMatType) {
13906 if (!LHSMatType && RHSMatType) {
13918 bool IsCompAssign) {
13919 if (!IsCompAssign) {
13930 assert((LHSMatType || RHSMatType) &&
"At least one operand must be a matrix");
13932 if (LHSMatType && RHSMatType) {
13933 if (LHSMatType->getNumColumns() != RHSMatType->
getNumRows())
13941 QualType LHSELTy = LHSMatType->getElementType(),
13972 bool IsCompAssign =
13973 Opc == BO_AndAssign || Opc == BO_OrAssign || Opc == BO_XorAssign;
13984 LegalBoolVecOperator,
14014 ExprResult LHSResult = LHS, RHSResult = RHS;
14017 if (LHSResult.
isInvalid() || RHSResult.isInvalid())
14019 LHS = LHSResult.
get();
14020 RHS = RHSResult.
get();
14039 bool EnumConstantInBoolContext =
false;
14041 if (
const auto *DREHS = dyn_cast<DeclRefExpr>(HS.get())) {
14042 const auto *ECDHS = dyn_cast<EnumConstantDecl>(DREHS->getDecl());
14043 if (ECDHS && ECDHS->getInitVal() != 0 && ECDHS->getInitVal() != 1)
14044 EnumConstantInBoolContext =
true;
14048 if (EnumConstantInBoolContext)
14049 Diag(Loc, diag::warn_enum_constant_in_bool_context);
14054 const auto *LHSATy = dyn_cast<ArrayType>(LHSTy);
14055 const auto *RHSATy = dyn_cast<ArrayType>(RHSTy);
14056 if ((LHSATy && LHSATy->getElementType().isWebAssemblyReferenceType()) ||
14057 (RHSATy && RHSATy->getElementType().isWebAssemblyReferenceType())) {
14079 Diag(Loc, diag::warn_logical_instead_of_bitwise)
14082 Diag(Loc, diag::note_logical_instead_of_bitwise_change_operator)
14083 << (Opc == BO_LAnd ?
"&" :
"|")
14086 Opc == BO_LAnd ?
"&" :
"|");
14087 if (Opc == BO_LAnd)
14089 Diag(Loc, diag::note_logical_instead_of_bitwise_remove_constant)
14145 const MemberExpr *ME = dyn_cast<MemberExpr>(E);
14146 if (!ME)
return false;
14150 if (!
Base)
return false;
14151 return Base->getMethodDecl() !=
nullptr;
14171 assert(var->
hasLocalStorage() &&
"capture added 'const' to non-local?");
14179 if (
auto *FD = dyn_cast<FunctionDecl>(DC))
14222 bool DiagnosticEmitted =
false;
14226 bool IsDereference =
false;
14227 bool NextIsDereference =
false;
14231 IsDereference = NextIsDereference;
14234 if (
const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
14235 NextIsDereference = ME->isArrow();
14236 const ValueDecl *VD = ME->getMemberDecl();
14237 if (
const FieldDecl *Field = dyn_cast<FieldDecl>(VD)) {
14239 if (Field->isMutable()) {
14240 assert(DiagnosticEmitted &&
"Expected diagnostic not emitted.");
14245 if (!DiagnosticEmitted) {
14246 S.
Diag(Loc, diag::err_typecheck_assign_const)
14248 << Field->getType();
14249 DiagnosticEmitted =
true;
14252 <<
ConstMember <<
false << Field << Field->getType()
14253 << Field->getSourceRange();
14257 }
else if (
const VarDecl *VDecl = dyn_cast<VarDecl>(VD)) {
14258 if (VDecl->getType().isConstQualified()) {
14259 if (!DiagnosticEmitted) {
14260 S.
Diag(Loc, diag::err_typecheck_assign_const)
14262 << VDecl->getType();
14263 DiagnosticEmitted =
true;
14266 <<
ConstMember <<
true << VDecl << VDecl->getType()
14267 << VDecl->getSourceRange();
14274 dyn_cast<ArraySubscriptExpr>(E)) {
14278 dyn_cast<ExtVectorElementExpr>(E)) {
14285 if (
const CallExpr *CE = dyn_cast<CallExpr>(E)) {
14289 if (!DiagnosticEmitted) {
14290 S.
Diag(Loc, diag::err_typecheck_assign_const) << ExprRange
14292 DiagnosticEmitted =
true;
14295 diag::note_typecheck_assign_const)
14299 }
else if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
14301 if (
const ValueDecl *VD = DRE->getDecl()) {
14303 if (!DiagnosticEmitted) {
14304 S.
Diag(Loc, diag::err_typecheck_assign_const)
14306 DiagnosticEmitted =
true;
14308 S.
Diag(VD->getLocation(), diag::note_typecheck_assign_const)
14309 <<
ConstVariable << VD << VD->getType() << VD->getSourceRange();
14312 }
else if (isa<CXXThisExpr>(E)) {
14314 if (
const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(DC)) {
14315 if (MD->isConst()) {
14316 if (!DiagnosticEmitted) {
14317 S.
Diag(Loc, diag::err_typecheck_assign_const) << ExprRange
14319 DiagnosticEmitted =
true;
14321 S.
Diag(MD->getLocation(), diag::note_typecheck_assign_const)
14328 if (DiagnosticEmitted)
14332 S.
Diag(Loc, diag::err_typecheck_assign_const) << ExprRange <<
ConstUnknown;
14345 bool &DiagnosticEmitted) {
14346 std::vector<const RecordType *> RecordTypeList;
14347 RecordTypeList.push_back(Ty);
14348 unsigned NextToCheckIndex = 0;
14351 while (RecordTypeList.size() > NextToCheckIndex) {
14352 bool IsNested = NextToCheckIndex > 0;
14354 RecordTypeList[NextToCheckIndex]->getDecl()->fields()) {
14356 QualType FieldTy = Field->getType();
14358 if (!DiagnosticEmitted) {
14359 S.
Diag(Loc, diag::err_typecheck_assign_const)
14361 << IsNested << Field;
14362 DiagnosticEmitted =
true;
14364 S.
Diag(Field->getLocation(), diag::note_typecheck_assign_const)
14366 << FieldTy << Field->getSourceRange();
14372 if (!llvm::is_contained(RecordTypeList, FieldRecTy))
14373 RecordTypeList.push_back(FieldRecTy);
14376 ++NextToCheckIndex;
14385 assert(Ty->
isRecordType() &&
"lvalue was not record?");
14388 bool DiagEmitted =
false;
14390 if (
const MemberExpr *ME = dyn_cast<MemberExpr>(E))
14393 else if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
14418 unsigned DiagID = 0;
14419 bool NeedType =
false;
14426 DiagID = diag::err_block_decl_ref_not_modifiable_lvalue;
14428 DiagID = diag::err_lambda_decl_ref_not_modifiable_lvalue;
14436 if (declRef && isa<VarDecl>(declRef->
getDecl())) {
14449 ? diag::err_typecheck_arc_assign_self_class_method
14450 : diag::err_typecheck_arc_assign_self;
14453 }
else if (var->
hasAttr<ObjCExternallyRetainedAttr>() ||
14454 isa<ParmVarDecl>(var)) {
14455 DiagID = diag::err_typecheck_arc_assign_externally_retained;
14459 DiagID = diag::err_typecheck_arr_assign_enumeration;
14463 if (Loc != OrigLoc)
14489 DiagID = diag::err_typecheck_array_not_modifiable_lvalue;
14493 DiagID = diag::err_typecheck_non_object_not_modifiable_lvalue;
14497 DiagID = diag::err_typecheck_lvalue_casts_not_supported;
14500 llvm_unreachable(
"did not take early return for MLV_Valid");
14504 DiagID = diag::err_typecheck_expression_not_modifiable_lvalue;
14509 diag::err_typecheck_incomplete_type_not_modifiable_lvalue, E);
14511 DiagID = diag::err_typecheck_duplicate_vector_components_not_mlvalue;
14514 llvm_unreachable(
"readonly properties should be processed differently");
14516 DiagID = diag::err_readonly_message_assignment;
14519 DiagID = diag::err_no_subobject_property_setting;
14524 if (Loc != OrigLoc)
14546 MemberExpr *ML = dyn_cast<MemberExpr>(LHSExpr);
14547 MemberExpr *MR = dyn_cast<MemberExpr>(RHSExpr);
14549 if (!(isa<CXXThisExpr>(ML->
getBase()) && isa<CXXThisExpr>(MR->
getBase())))
14555 if (LHSDecl != RHSDecl)
14560 if (RefTy->getPointeeType().isVolatileQualified())
14563 Sema.
Diag(Loc, diag::warn_identity_field_assign) << 0;
14573 Sema.
Diag(Loc, diag::warn_identity_field_assign) << 1;
14597 Diag(Loc, diag::err_opencl_half_load_store) << 1
14604 Diag(Loc, diag::err_wasm_table_art) << 0;
14609 if (CompoundType.
isNull()) {
14628 Diag(Loc, diag::err_objc_object_assignment)
14635 RHSCheck = ICE->getSubExpr();
14636 if (
UnaryOperator *UO = dyn_cast<UnaryOperator>(RHSCheck)) {
14637 if ((UO->getOpcode() == UO_Plus || UO->getOpcode() == UO_Minus) &&
14638 Loc.
isFileID() && UO->getOperatorLoc().isFileID() &&
14644 UO->getSubExpr()->getBeginLoc().
isFileID()) {
14645 Diag(Loc, diag::warn_not_compound_assign)
14646 << (UO->getOpcode() == UO_Plus ?
"+" :
"-")
14647 <<
SourceRange(UO->getOperatorLoc(), UO->getOperatorLoc());
14657 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InnerLHS);
14693 if (CompoundType.
isNull()) {
14719 if (
const CastExpr *CE = dyn_cast<CastExpr>(E)) {
14720 if (CE->getCastKind() == CK_ToVoid) {
14726 CE->getSubExpr()->getType()->isDependentType()) {
14731 if (
const auto *CE = dyn_cast<CallExpr>(E))
14732 return CE->getCallReturnType(Context)->isVoidType();
14755 const unsigned ForIncrementFlags =
14761 if ((ScopeFlags & ForIncrementFlags) == ForIncrementFlags ||
14762 (ScopeFlags & ForInitFlags) == ForInitFlags)
14767 while (
const BinaryOperator *BO = dyn_cast<BinaryOperator>(LHS)) {
14768 if (BO->getOpcode() != BO_Comma)
14770 LHS = BO->getRHS();
14777 Diag(Loc, diag::warn_comma_operator);
14781 LangOpts.CPlusPlus ?
"static_cast<void>("
14813 diag::err_incomplete_type);
14828 bool IsInc,
bool IsPrefix) {
14837 ResType = ResAtomicType->getValueType();
14839 assert(!ResType.
isNull() &&
"no type for increment/decrement expression");
14849 : diag::warn_increment_bool)
14853 S.
Diag(OpLoc, diag::err_increment_decrement_enum) << IsInc << ResType;
14869 S.
Diag(OpLoc, diag::ext_integer_increment_complex)
14886 S.
Diag(OpLoc, diag::err_typecheck_illegal_increment_decrement)
14897 S.
Diag(OpLoc, diag::warn_deprecated_increment_decrement_volatile)
14898 << IsInc << ResType;
14931 case Stmt::DeclRefExprClass:
14932 return cast<DeclRefExpr>(E)->getDecl();
14933 case Stmt::MemberExprClass:
14937 if (cast<MemberExpr>(E)->isArrow())
14941 case Stmt::ArraySubscriptExprClass: {
14944 Expr*
Base = cast<ArraySubscriptExpr>(E)->getBase();
14946 if (ICE->getSubExpr()->getType()->isArrayType())
14951 case Stmt::UnaryOperatorClass: {
14963 case Stmt::ParenExprClass:
14965 case Stmt::ImplicitCastExprClass:
14969 case Stmt::CXXUuidofExprClass:
14970 return cast<CXXUuidofExpr>(E)->getGuidDecl();
14979 AO_Vector_Element = 1,
14980 AO_Property_Expansion = 2,
14981 AO_Register_Variable = 3,
14982 AO_Matrix_Element = 4,
14997 const auto *DRE = cast<DeclRefExpr>(Op->
IgnoreParens());
15000 return Diag(OpLoc, diag::err_parens_pointer_member_function)
15004 if (isa<CXXDestructorDecl>(MD))
15005 return Diag(OpLoc, diag::err_typecheck_addrof_dtor)
15006 << DRE->getSourceRange();
15008 if (DRE->getQualifier())
15012 return Diag(OpLoc, diag::err_unqualified_pointer_member_function)
15013 << DRE->getSourceRange();
15017 return Diag(OpLoc, diag::err_unqualified_pointer_member_function)
15018 << DRE->getSourceRange()
15031 if (PTy->getKind() == BuiltinType::Overload) {
15033 if (!isa<OverloadExpr>(E)) {
15034 assert(cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf);
15035 Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof_addrof_function)
15041 if (isa<UnresolvedMemberExpr>(Ovl))
15043 Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
15051 if (PTy->getKind() == BuiltinType::UnknownAny)
15054 if (PTy->getKind() == BuiltinType::BoundMember) {
15055 Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
15078 auto* VarRef = dyn_cast<DeclRefExpr>(op);
15079 if (VarRef && VarRef->refersToEnclosingVariableOrCapture()) {
15080 Diag(op->
getExprLoc(), diag::err_opencl_taking_address_capture);
15088 if (uOp->getOpcode() == UO_Deref)
15091 return uOp->getSubExpr()->getType();
15098 if (
auto *FD = dyn_cast_or_null<FunctionDecl>(dcl))
15104 unsigned AddressOfError = AO_No_Error;
15109 : diag::ext_typecheck_addrof_temporary)
15116 }
else if (isa<ObjCSelectorExpr>(op)) {
15123 if (!isa<DeclRefExpr>(op)) {
15124 Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
15144 if (isa<PseudoObjectExpr>(op)) {
15145 AddressOfError = AO_Property_Expansion;
15147 Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof)
15151 }
else if (
const auto *DRE = dyn_cast<DeclRefExpr>(op)) {
15152 if (
const auto *MD = dyn_cast_or_null<CXXMethodDecl>(DRE->getDecl()))
15158 AddressOfError = AO_Bit_Field;
15161 AddressOfError = AO_Vector_Element;
15164 AddressOfError = AO_Matrix_Element;
15168 if (
const VarDecl *vd = dyn_cast<VarDecl>(dcl)) {
15173 AddressOfError = AO_Register_Variable;
15175 }
else if (isa<MSPropertyDecl>(dcl)) {
15176 AddressOfError = AO_Property_Expansion;
15177 }
else if (isa<FunctionTemplateDecl>(dcl)) {
15179 }
else if (isa<FieldDecl>(dcl) || isa<IndirectFieldDecl>(dcl)) {
15183 if (isa<DeclRefExpr>(op) && cast<DeclRefExpr>(op)->getQualifier()) {
15188 diag::err_cannot_form_pointer_to_member_of_reference_type)
15193 while (cast<RecordDecl>(Ctx)->isAnonymousStructOrUnion())
15207 llvm_unreachable(
"Unknown/unexpected decl type");
15210 if (AddressOfError != AO_No_Error) {
15230 Diag(OpLoc, diag::err_wasm_ca_reference)
15235 Diag(OpLoc, diag::err_wasm_table_pr)
15241 CheckAddressOfPackedMember(op);
15247 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Exp);
15253 const ParmVarDecl *Param = dyn_cast<ParmVarDecl>(D);
15257 if (!FD->hasAttr<NonNullAttr>() && !Param->
hasAttr<NonNullAttr>())
15260 FD->ModifiedNonNullParams.insert(Param);
15266 bool IsAfterAmp =
false) {
15273 Op = ConvResult.
get();
15277 if (isa<CXXReinterpretCastExpr>(Op)) {
15285 Result = PT->getPointeeType();
15289 Result = OPT->getPointeeType();
15293 if (PR.
get() != Op)
15298 S.
Diag(OpLoc, diag::err_typecheck_indirection_requires_pointer)
15303 if (
Result->isVoidType()) {
15309 S.
Diag(OpLoc, diag::err_typecheck_indirection_through_void_pointer_cpp)
15312 S.
Diag(OpLoc, diag::ext_typecheck_indirection_through_void_pointer)
15329 default: llvm_unreachable(
"Unknown binop!");
15330 case tok::periodstar: Opc = BO_PtrMemD;
break;
15331 case tok::arrowstar: Opc = BO_PtrMemI;
break;
15332 case tok::star: Opc = BO_Mul;
break;
15333 case tok::slash: Opc = BO_Div;
break;
15334 case tok::percent: Opc = BO_Rem;
break;
15335 case tok::plus: Opc = BO_Add;
break;
15336 case tok::minus: Opc = BO_Sub;
break;
15337 case tok::lessless: Opc = BO_Shl;
break;
15338 case tok::greatergreater: Opc = BO_Shr;
break;
15339 case tok::lessequal: Opc = BO_LE;
break;
15340 case tok::less: Opc = BO_LT;
break;
15341 case tok::greaterequal: Opc = BO_GE;
break;
15342 case tok::greater: Opc = BO_GT;
break;
15343 case tok::exclaimequal: Opc = BO_NE;
break;
15344 case tok::equalequal: Opc = BO_EQ;
break;
15345 case tok::spaceship: Opc = BO_Cmp;
break;
15346 case tok::amp: Opc = BO_And;
break;
15347 case tok::caret: Opc = BO_Xor;
break;
15348 case tok::pipe: Opc = BO_Or;
break;
15349 case tok::ampamp: Opc = BO_LAnd;
break;
15350 case tok::pipepipe: Opc = BO_LOr;
break;
15351 case tok::equal: Opc = BO_Assign;
break;
15352 case tok::starequal: Opc = BO_MulAssign;
break;
15353 case tok::slashequal: Opc = BO_DivAssign;
break;
15354 case tok::percentequal: Opc = BO_RemAssign;
break;
15355 case tok::plusequal: Opc = BO_AddAssign;
break;
15356 case tok::minusequal: Opc = BO_SubAssign;
break;
15357 case tok::lesslessequal: Opc = BO_ShlAssign;
break;
15358 case tok::greatergreaterequal: Opc = BO_ShrAssign;
break;
15359 case tok::ampequal: Opc = BO_AndAssign;
break;
15360 case tok::caretequal: Opc = BO_XorAssign;
break;
15361 case tok::pipeequal: Opc = BO_OrAssign;
break;
15362 case tok::comma: Opc = BO_Comma;
break;
15371 default: llvm_unreachable(
"Unknown unary op!");
15372 case tok::plusplus: Opc = UO_PreInc;
break;
15373 case tok::minusminus: Opc = UO_PreDec;
break;
15374 case tok::amp: Opc = UO_AddrOf;
break;
15375 case tok::star: Opc = UO_Deref;
break;
15376 case tok::plus: Opc = UO_Plus;
break;
15377 case tok::minus: Opc = UO_Minus;
break;
15378 case tok::tilde: Opc = UO_Not;
break;
15379 case tok::exclaim: Opc = UO_LNot;
break;
15380 case tok::kw___real: Opc = UO_Real;
break;
15381 case tok::kw___imag: Opc = UO_Imag;
break;
15382 case tok::kw___extension__: Opc = UO_Extension;
break;
15398 if (!isa<ParmVarDecl>(SelfAssigned))
15400 const auto *Method =
15414 llvm::find_if(
Parent->fields(),
15416 return F->getDeclName() == Name;
15418 return (Field !=
Parent->field_end()) ? *Field :
nullptr;
15433 const DeclRefExpr *LHSDeclRef = dyn_cast<DeclRefExpr>(LHSExpr);
15434 const DeclRefExpr *RHSDeclRef = dyn_cast<DeclRefExpr>(RHSExpr);
15435 if (!LHSDeclRef || !RHSDeclRef ||
15443 if (LHSDecl != RHSDecl)
15448 if (RefTy->getPointeeType().isVolatileQualified())
15451 auto Diag = S.
Diag(OpLoc, IsBuiltin ? diag::warn_self_assignment_builtin
15452 : diag::warn_self_assignment_overloaded)
15457 Diag << 1 << SelfAssignField
15470 const Expr *ObjCPointerExpr =
nullptr, *OtherExpr =
nullptr;
15475 ObjCPointerExpr = LHS;
15479 ObjCPointerExpr = RHS;
15487 if (ObjCPointerExpr && isa<IntegerLiteral>(OtherExpr->IgnoreParenCasts())) {
15488 unsigned Diag = diag::warn_objc_pointer_masking;
15496 StringRef SelArg0 = S.getNameForSlot(0);
15497 if (SelArg0.starts_with(
"performSelector"))
15498 Diag = diag::warn_objc_pointer_masking_performSelector;
15509 if (
auto *DRE = dyn_cast<DeclRefExpr>(E))
15510 return DRE->getDecl();
15511 if (
auto *ME = dyn_cast<MemberExpr>(E))
15512 return ME->getMemberDecl();
15513 if (
auto *IRE = dyn_cast<ObjCIvarRefExpr>(E))
15514 return IRE->getDecl();
15529 "Result must be a vector of half or short");
15532 "both operands expected to be a half vector");
15544 ResultTy, VK, OK, OpLoc, FPFeatures,
15545 BinOpResTy, BinOpResTy);
15549 BinOpResTy, VK, OK, OpLoc, FPFeatures);
15553static std::pair<ExprResult, ExprResult>
15563 RHS,
nullptr,
false,
15564 [Opc, LHS](
Expr *E) {
15565 if (Opc != BO_Assign)
15572 return std::make_pair(LHS, RHS);
15579 if (!OpRequiresConversion || Ctx.
getLangOpts().NativeHalfType ||
15583 auto HasVectorOfHalfType = [&Ctx](
Expr *E) {
15593 return VT->getElementType().getCanonicalType() == Ctx.
HalfTy;
15598 return HasVectorOfHalfType(E0) && (!E1 || HasVectorOfHalfType(E1));
15620 if (
Init.isInvalid())
15622 RHSExpr =
Init.get();
15632 bool ConvertHalfVec =
false;
15635 if (!LHS.
isUsable() || !RHS.isUsable())
15645 if (BO_Assign == Opc)
15646 Diag(OpLoc, diag::err_opencl_atomic_init) << 0 << SR;
15674 if (!ResultTy.
isNull()) {
15691 if (
auto *BE = dyn_cast<BlockExpr>(RHS.get()->IgnoreParens()))
15693 if (
auto *VD = dyn_cast<VarDecl>(DRE->getDecl()))
15694 if (VD->hasLocalStorage() &&
getCurScope()->isDeclScope(VD))
15695 BE->getBlockDecl()->setCanAvoidCopyToHeap();
15706 Opc == BO_PtrMemI);
15710 ConvertHalfVec =
true;
15718 ConvertHalfVec =
true;
15722 ConvertHalfVec =
true;
15733 ConvertHalfVec =
true;
15738 ConvertHalfVec =
true;
15742 ConvertHalfVec =
true;
15755 ConvertHalfVec =
true;
15760 ConvertHalfVec =
true;
15762 Opc == BO_DivAssign);
15763 CompLHSTy = CompResultTy;
15770 CompLHSTy = CompResultTy;
15776 ConvertHalfVec =
true;
15783 ConvertHalfVec =
true;
15792 CompLHSTy = CompResultTy;
15803 CompLHSTy = CompResultTy;
15811 VK = RHS.get()->getValueKind();
15812 OK = RHS.get()->getObjectKind();
15826 "both sides are half vectors or neither sides are");
15831 CheckArrayAccess(LHS.
get());
15832 CheckArrayAccess(RHS.get());
15838 if (ObjectSetClass && isa<ObjCIsaExpr>(LHS.
get())) {
15842 "object_setClass(")
15855 if (CompResultTy.
isNull()) {
15856 if (ConvertHalfVec)
15876 if (ConvertHalfVec)
15881 Context, LHS.
get(), RHS.get(), Opc, ResultTy, VK, OK, OpLoc,
15898 if (isLeftComp == isRightComp)
15903 bool isLeftBitwise = LHSBO && LHSBO->
isBitwiseOp();
15904 bool isRightBitwise = RHSBO && RHSBO->
isBitwiseOp();
15905 if (isLeftBitwise || isRightBitwise)
15917 Self.Diag(OpLoc, diag::warn_precedence_bitwise_rel)
15920 Self.PDiag(diag::note_precedence_silence) << OpStr,
15921 (isLeftComp ? LHSExpr : RHSExpr)->getSourceRange());
15923 Self.PDiag(diag::note_precedence_bitwise_first)
15938 Self.PDiag(diag::note_precedence_silence)
15947 if (Bop->getOpcode() == BO_LAnd) {
15950 if (!isa<StringLiteral>(Bop->getLHS()->IgnoreParenImpCasts()))
15952 }
else if (Bop->getOpcode() == BO_LOr) {
15953 if (
BinaryOperator *RBop = dyn_cast<BinaryOperator>(Bop->getRHS())) {
15956 if (RBop->getOpcode() == BO_LAnd &&
15957 isa<StringLiteral>(RBop->getRHS()->IgnoreParenImpCasts()))
15968 if (Bop->getOpcode() == BO_LAnd) {
15971 if (!isa<StringLiteral>(Bop->getRHS()->IgnoreParenImpCasts()))
15983 if (Bop->isBitwiseOp() && Bop->getOpcode() < Opc) {
15984 S.
Diag(Bop->getOperatorLoc(), diag::warn_bitwise_op_in_bitwise_op)
15986 << Bop->getSourceRange() << OpLoc;
15988 S.
PDiag(diag::note_precedence_silence)
15989 << Bop->getOpcodeStr(),
15990 Bop->getSourceRange());
15996 Expr *SubExpr, StringRef Shift) {
15998 if (Bop->getOpcode() == BO_Add || Bop->getOpcode() == BO_Sub) {
15999 StringRef Op = Bop->getOpcodeStr();
16000 S.
Diag(Bop->getOperatorLoc(), diag::warn_addition_in_bitshift)
16001 << Bop->getSourceRange() << OpLoc << Shift << Op;
16003 S.
PDiag(diag::note_precedence_silence) << Op,
16004 Bop->getSourceRange());
16020 if (Kind != OO_LessLess && Kind != OO_GreaterGreater)
16023 S.
Diag(OpLoc, diag::warn_overloaded_shift_in_comparison)
16025 << (Kind == OO_LessLess);
16027 S.
PDiag(diag::note_precedence_silence)
16028 << (Kind == OO_LessLess ?
"<<" :
">>"),
16031 S, OpLoc, S.
PDiag(diag::note_evaluate_comparison_first),
16045 if ((Opc == BO_Or || Opc == BO_Xor) &&
16053 if (Opc == BO_LOr && !OpLoc.
isMacroID()) {
16059 || Opc == BO_Shr) {
16076 assert(LHSExpr &&
"ActOnBinOp(): missing left expression");
16077 assert(RHSExpr &&
"ActOnBinOp(): missing right expression");
16082 return BuildBinOp(S, TokLoc, Opc, LHSExpr, RHSExpr);
16088 if (OverOp !=
OO_None && OverOp != OO_Equal)
16142 LHSExpr = LHS.
get();
16143 RHSExpr = RHS.
get();
16154 if (pty->getKind() == BuiltinType::PseudoObject &&
16167 RHSExpr = resolvedRHS.
get();
16181 (pty->getKind() == BuiltinType::BoundMember ||
16182 pty->getKind() == BuiltinType::Overload)) {
16183 auto *OE = dyn_cast<OverloadExpr>(LHSExpr);
16184 if (OE && !OE->hasTemplateKeyword() && !OE->hasExplicitTemplateArgs() &&
16185 llvm::any_of(OE->decls(), [](
NamedDecl *ND) {
16186 return isa<FunctionTemplateDecl>(ND);
16188 Diag(OE->getQualifier() ? OE->getQualifierLoc().getBeginLoc()
16189 : OE->getNameLoc(),
16190 diag::err_template_kw_missing)
16191 << OE->getName().getAsString() <<
"";
16198 LHSExpr = LHS.
get();
16205 if (Opc == BO_Assign && pty->getKind() == BuiltinType::Overload) {
16221 RHSExpr = resolvedRHS.
get();
16241 "Should only occur in error-recovery path.");
16247 Context, LHSExpr, RHSExpr, Opc,
16267 ResultType = RHSExpr->
getType();
16299 bool CanOverflow =
false;
16301 bool ConvertHalfVec =
false;
16310 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
16317 if (Opc == UO_AddrOf)
16318 return ExprError(
Diag(OpLoc, diag::err_hlsl_operator_unsupported) << 0);
16319 if (Opc == UO_Deref)
16320 return ExprError(
Diag(OpLoc, diag::err_hlsl_operator_unsupported) << 1);
16330 Opc == UO_PreInc ||
16332 Opc == UO_PreInc ||
16338 CheckAddressOfNoDeref(InputExpr);
16350 CanOverflow = Opc == UO_Minus &&
16361 if (ConvertHalfVec)
16381 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
16394 Diag(OpLoc, diag::ext_integer_complement_complex)
16403 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
16406 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
16426 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
16444 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
16454 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
16463 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
16470 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
16502 "the co_await expression must be non-dependant before "
16503 "building operator co_await");
16513 if (Opc != UO_AddrOf && Opc != UO_Deref)
16514 CheckArrayAccess(Input.
get());
16520 if (Opc == UO_Deref && UO->getType()->hasAttr(attr::NoDeref) &&
16521 !isa<ArrayType>(UO->getType().getDesugaredType(
Context)) &&
16526 if (ConvertHalfVec)
16535 if (
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
16536 if (!DRE->getQualifier())
16543 if (isa<FieldDecl>(VD) || isa<IndirectFieldDecl>(VD))
16546 return Method->isImplicitObjectMemberFunction();
16552 if (!ULE->getQualifier())
16557 if (Method->isImplicitObjectMemberFunction())
16578 if (pty->getKind() == BuiltinType::PseudoObject &&
16583 if (Opc == UO_Extension)
16588 if (Opc == UO_AddrOf &&
16589 (pty->getKind() == BuiltinType::Overload ||
16590 pty->getKind() == BuiltinType::UnknownAny ||
16591 pty->getKind() == BuiltinType::BoundMember))
16617 Expr *Input,
bool IsAfterAmp) {
16657 assert(SubStmt && isa<CompoundStmt>(SubStmt) &&
"Invalid action invocation!");
16663 "cleanups within StmtExpr not correctly bound!");
16673 bool StmtExprMayBindToTemp =
false;
16676 if (
const auto *LastStmt =
16678 if (
const Expr *
Value = LastStmt->getExprStmt()) {
16679 StmtExprMayBindToTemp =
true;
16687 Expr *ResStmtExpr =
16689 if (StmtExprMayBindToTemp)
16691 return ResStmtExpr;
16714 auto *Cast = dyn_cast<ImplicitCastExpr>(E);
16715 if (Cast && Cast->getCastKind() == CK_ARCConsumeObject)
16716 return Cast->getSubExpr();
16737 return ExprError(
Diag(BuiltinLoc, diag::err_offsetof_record_type)
16738 << ArgTy << TypeRange);
16744 diag::err_offsetof_incomplete_type, TypeRange))
16747 bool DidWarnAboutNonPOD =
false;
16752 if (OC.isBrackets) {
16757 return ExprError(
Diag(OC.LocEnd, diag::err_offsetof_array_type)
16777 Comps.push_back(
OffsetOfNode(OC.LocStart, Exprs.size(), OC.LocEnd));
16778 Exprs.push_back(Idx);
16786 Comps.push_back(
OffsetOfNode(OC.LocStart, OC.U.IdentInfo, OC.LocEnd));
16793 diag::err_offsetof_incomplete_type))
16799 return ExprError(
Diag(OC.LocEnd, diag::err_offsetof_record_type)
16811 bool IsSafe =
LangOpts.CPlusPlus11? CRD->isStandardLayout() : CRD->isPOD();
16813 LangOpts.CPlusPlus11? diag::ext_offsetof_non_standardlayout_type
16814 : diag::ext_offsetof_non_pod_type;
16817 Diag(BuiltinLoc, DiagID)
16818 <<
SourceRange(Components[0].LocStart, OC.LocEnd) << CurrentType;
16819 DidWarnAboutNonPOD =
true;
16830 MemberDecl = IndirectMemberDecl->getAnonField();
16838 Diag(BuiltinLoc, diag::err_no_member)
16839 << OC.U.IdentInfo << RD <<
SourceRange(OC.LocStart, OC.LocEnd);
16848 Diag(OC.LocEnd, diag::err_offsetof_bitfield)
16856 if (IndirectMemberDecl)
16857 Parent = cast<RecordDecl>(IndirectMemberDecl->getDeclContext());
16864 if (Paths.getDetectedVirtual()) {
16865 Diag(OC.LocEnd, diag::err_offsetof_field_of_virtual_base)
16876 if (IndirectMemberDecl) {
16877 for (
auto *FI : IndirectMemberDecl->chain()) {
16878 assert(isa<FieldDecl>(FI));
16880 cast<FieldDecl>(FI), OC.LocEnd));
16883 Comps.push_back(
OffsetOfNode(OC.LocStart, MemberDecl, OC.LocEnd));
16889 Comps, Exprs, RParenLoc);
16915 assert((CondExpr && LHSExpr && RHSExpr) &&
"Missing type argument(s)");
16920 bool CondIsTrue =
false;
16925 llvm::APSInt condEval(32);
16927 CondExpr, &condEval, diag::err_typecheck_choose_expr_requires_constant);
16930 CondExpr = CondICE.
get();
16931 CondIsTrue = condEval.getZExtValue();
16934 Expr *ActiveExpr = CondIsTrue ? LHSExpr : RHSExpr;
16936 resType = ActiveExpr->
getType();
16942 resType, VK, OK, RPLoc, CondIsTrue);
16955 Decl *ManglingContextDecl;
16956 std::tie(MCtx, ManglingContextDecl) =
16960 Block->setBlockMangling(ManglingNumber, ManglingContextDecl);
16982 "block-id should have no identifier!");
17004 "GetTypeForDeclarator made a non-function block signature");
17020 unsigned Size =
Result.getFullDataSize();
17032 QualType RetTy = Fn->getReturnType();
17034 (isa<FunctionProtoType>(Fn) && cast<FunctionProtoType>(Fn)->isVariadic());
17050 if (ExplicitSignature) {
17051 for (
unsigned I = 0, E = ExplicitSignature.
getNumParams(); I != E; ++I) {
17059 Params.push_back(Param);
17065 for (
const auto &I : Fn->param_types()) {
17068 Params.push_back(Param);
17073 if (!Params.empty()) {
17084 AI->setOwningFunction(CurBlock->
TheDecl);
17087 if (AI->getIdentifier()) {
17093 if (AI->isInvalidDecl())
17116 Diag(CaretLoc, diag::err_blocks_disable) <<
LangOpts.OpenCL;
17122 "cleanups within block not correctly bound!");
17135 bool NoReturn = BD->
hasAttr<NoReturnAttr>();
17143 if (NoReturn && !Ext.getNoReturn()) Ext = Ext.
withNoReturn(
true);
17146 if (isa<FunctionNoProtoType>(FTy)) {
17181 BD->
setBody(cast<CompoundStmt>(Body));
17183 if (Body &&
getCurFunction()->HasPotentialAvailabilityViolations)
17208 Expr *CopyExpr =
nullptr;
17217 if (isa<ParmVarDecl>(Var))
17236 if (!
Result.isInvalid() &&
17237 !
Result.get()->getType().isConstQualified()) {
17239 Result.get()->getType().withConst(),
17243 if (!
Result.isInvalid()) {
17253 if (!
Result.isInvalid() &&
17254 !cast<CXXConstructExpr>(
Result.get())->getConstructor()
17257 CopyExpr =
Result.get();
17264 Captures.push_back(NewCap);
17276 if (
Result->getBlockDecl()->hasCaptures()) {
17283 for (
const auto &CI :
Result->getBlockDecl()->captures()) {
17284 const VarDecl *var = CI.getVariable();
17297 {Result},
Result->getType());
17311 Expr *OrigExpr = E;
17360 if (
Init.isInvalid())
17376 diag::err_first_argument_to_va_arg_not_of_type_va_list)
17381 diag::err_second_parameter_to_va_arg_incomplete,
17387 diag::err_second_parameter_to_va_arg_abstract,
17394 ? diag::warn_second_parameter_to_va_arg_ownership_qualified
17395 : diag::warn_second_parameter_to_va_arg_not_pod)
17428 UnderlyingType = ET->getDecl()->getIntegerType();
17451 if (!PromoteType.
isNull())
17453 PDiag(diag::warn_second_parameter_to_va_arg_never_compatible)
17475 llvm_unreachable(
"I don't know size of pointer!");
17492 if ((SLDecl->isCompleteDefinition() || SLDecl->isBeingDefined()) &&
17501 S.
Diag(Loc, diag::err_std_source_location_impl_not_found);
17509 S.
Diag(Loc, diag::err_std_source_location_impl_malformed);
17513 unsigned Count = 0;
17515 StringRef Name = F->getName();
17517 if (Name ==
"_M_file_name") {
17518 if (F->getType() !=
17522 }
else if (Name ==
"_M_function_name") {
17523 if (F->getType() !=
17527 }
else if (Name ==
"_M_line") {
17528 if (!F->getType()->isIntegerType())
17531 }
else if (Name ==
"_M_column") {
17532 if (!F->getType()->isIntegerType())
17541 S.
Diag(Loc, diag::err_std_source_location_impl_malformed);
17604 if (OV->getSourceExpr())
17607 if (
auto *SL = dyn_cast<StringLiteral>(SrcExpr)) {
17609 !(ID && ID->getIdentifier()->isStr(
"NSString")))
17611 if (!SL->isOrdinary())
17615 Diag(SL->getBeginLoc(), diag::err_missing_atsign_prefix)
17622 if ((isa<IntegerLiteral>(SrcExpr) || isa<CharacterLiteral>(SrcExpr) ||
17623 isa<FloatingLiteral>(SrcExpr) || isa<ObjCBoolLiteralExpr>(SrcExpr) ||
17624 isa<CXXBoolLiteralExpr>(SrcExpr)) &&
17627 if (!ID || !ID->getIdentifier()->isStr(
"NSNumber"))
17645 const Expr *SrcExpr) {
17654 auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl());
17667 bool *Complained) {
17669 *Complained =
false;
17672 bool CheckInferredResultType =
false;
17674 unsigned DiagKind = 0;
17676 bool MayHaveConvFixit =
false;
17677 bool MayHaveFunctionDiff =
false;
17688 DiagKind = diag::err_typecheck_convert_pointer_int;
17691 DiagKind = diag::ext_typecheck_convert_pointer_int;
17694 MayHaveConvFixit =
true;
17698 DiagKind = diag::err_typecheck_convert_int_pointer;
17701 DiagKind = diag::ext_typecheck_convert_int_pointer;
17704 MayHaveConvFixit =
true;
17708 diag::warn_typecheck_convert_incompatible_function_pointer_strict;
17710 MayHaveConvFixit =
true;
17714 DiagKind = diag::err_typecheck_convert_incompatible_function_pointer;
17717 DiagKind = diag::ext_typecheck_convert_incompatible_function_pointer;
17720 MayHaveConvFixit =
true;
17724 DiagKind = diag::err_arc_typecheck_convert_incompatible_pointer;
17726 DiagKind = diag::err_typecheck_convert_incompatible_pointer;
17729 DiagKind = diag::ext_typecheck_convert_incompatible_pointer;
17733 if (!CheckInferredResultType) {
17735 }
else if (CheckInferredResultType) {
17739 MayHaveConvFixit =
true;
17743 DiagKind = diag::err_typecheck_convert_incompatible_pointer_sign;
17746 DiagKind = diag::ext_typecheck_convert_incompatible_pointer_sign;
17751 DiagKind = diag::err_typecheck_convert_pointer_void_func;
17754 DiagKind = diag::ext_typecheck_convert_pointer_void_func;
17766 DiagKind = diag::err_typecheck_incompatible_address_space;
17769 DiagKind = diag::err_typecheck_incompatible_ownership;
17773 llvm_unreachable(
"unknown error case for discarding qualifiers!");
17790 DiagKind = diag::err_typecheck_convert_discards_qualifiers;
17793 DiagKind = diag::ext_typecheck_convert_discards_qualifiers;
17800 DiagKind = diag::err_nested_pointer_qualifier_mismatch;
17802 DiagKind = diag::ext_nested_pointer_qualifier_mismatch;
17806 DiagKind = diag::err_typecheck_incompatible_nested_address_space;
17810 DiagKind = diag::err_int_to_block_pointer;
17814 DiagKind = diag::err_typecheck_convert_incompatible_block_pointer;
17821 for (
auto *srcProto : srcOPT->
quals()) {
17827 IFace = IFaceT->getDecl();
17832 for (
auto *dstProto : dstOPT->
quals()) {
17838 IFace = IFaceT->getDecl();
17841 DiagKind = diag::err_incompatible_qualified_id;
17844 DiagKind = diag::warn_incompatible_qualified_id;
17850 DiagKind = diag::err_incompatible_vectors;
17853 DiagKind = diag::warn_incompatible_vectors;
17857 DiagKind = diag::err_arc_weak_unavailable_assign;
17863 *Complained =
true;
17867 DiagKind = diag::err_typecheck_convert_incompatible;
17869 MayHaveConvFixit =
true;
17871 MayHaveFunctionDiff =
true;
17880 FirstType = DstType;
17881 SecondType = SrcType;
17891 FirstType = SrcType;
17892 SecondType = DstType;
17901 FDiag << FirstType << SecondType << ActionForDiag
17904 if (DiagKind == diag::ext_typecheck_convert_incompatible_pointer_sign ||
17905 DiagKind == diag::err_typecheck_convert_incompatible_pointer_sign) {
17915 if (!ConvHints.
isNull()) {
17920 if (MayHaveConvFixit) { FDiag << (
unsigned) (ConvHints.
Kind); }
17922 if (MayHaveFunctionDiff)
17926 if ((DiagKind == diag::warn_incompatible_qualified_id ||
17927 DiagKind == diag::err_incompatible_qualified_id) &&
17929 Diag(IFace->
getLocation(), diag::note_incomplete_class_and_qualified_id)
17936 if (CheckInferredResultType)
17943 *Complained =
true;
17954 return S.
Diag(Loc, diag::err_ice_not_integral)
17958 return S.
Diag(Loc, diag::err_expr_not_ice) << S.
LangOpts.CPlusPlus;
17973 IDDiagnoser(
unsigned DiagID)
17977 return S.
Diag(Loc, DiagID);
17979 } Diagnoser(DiagID);
17992 return S.
Diag(Loc, diag::ext_expr_not_ice) << S.
LangOpts.CPlusPlus;
18014 BaseDiagnoser(BaseDiagnoser) {}
18023 return S.
Diag(Loc, diag::err_ice_incomplete_type) << T;
18028 return S.
Diag(Loc, diag::err_ice_explicit_conversion) << T << ConvTy;
18039 return S.
Diag(Loc, diag::err_ice_ambiguous_conversion) << T;
18050 llvm_unreachable(
"conversion functions are permitted");
18052 } ConvertDiagnoser(Diagnoser);
18058 E = Converted.
get();
18073 E = RValueExpr.
get();
18080 if (!isa<ConstantExpr>(E))
18088 EvalResult.
Diag = &Notes;
18096 if (!isa<ConstantExpr>(E))
18111 if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
18112 diag::note_invalid_subexpr_in_const_expr) {
18113 DiagLoc = Notes[0].first;
18117 if (!Folded || !CanFold) {
18139 class TransformToPE :
public TreeTransform<TransformToPE> {
18143 TransformToPE(
Sema &SemaRef) : BaseTransform(SemaRef) { }
18146 bool AlwaysRebuild() {
return true; }
18147 bool ReplacingOriginal() {
return true; }
18157 if (isa<FieldDecl>(E->
getDecl()) &&
18158 !SemaRef.isUnevaluatedContext())
18160 diag::err_invalid_non_static_member_use)
18163 return BaseTransform::TransformDeclRefExpr(E);
18171 return BaseTransform::TransformUnaryOperator(E);
18179 return SkipLambdaBody(E, Body);
18186 "Should only transform unevaluated expressions");
18191 return TransformToPE(*this).TransformExpr(E);
18196 "Should only transform unevaluated expressions");
18201 return TransformToPE(*this).TransformType(TInfo);
18209 LambdaContextDecl, ExprContext);
18216 .isDiscardedStatementContext();
18224 Prev.isImmediateFunctionContext() || Prev.isConstantEvaluated();
18227 Prev.InImmediateEscalatingFunctionContext;
18246 if (
const auto *E = dyn_cast<UnaryOperator>(PossibleDeref)) {
18247 if (E->getOpcode() == UO_Deref)
18248 return CheckPossibleDeref(S, E->getSubExpr());
18249 }
else if (
const auto *E = dyn_cast<ArraySubscriptExpr>(PossibleDeref)) {
18250 return CheckPossibleDeref(S, E->getBase());
18251 }
else if (
const auto *E = dyn_cast<MemberExpr>(PossibleDeref)) {
18252 return CheckPossibleDeref(S, E->getBase());
18253 }
else if (
const auto E = dyn_cast<DeclRefExpr>(PossibleDeref)) {
18257 Inner = Ptr->getPointeeType();
18259 Inner = Arr->getElementType();
18263 if (Inner->hasAttr(attr::NoDeref))
18273 const DeclRefExpr *DeclRef = CheckPossibleDeref(*
this, E);
18280 Diag(E->
getExprLoc(), diag::warn_dereference_of_noderef_type_no_decl)
18299 if (BO->getOpcode() == BO_Assign) {
18301 llvm::erase(LHSs, BO->getLHS());
18309 "Cannot mark an immediate escalating expression outside of an "
18310 "immediate escalating context");
18313 if (
auto *DeclRef =
18314 dyn_cast<DeclRefExpr>(
Call->getCallee()->IgnoreImplicit()))
18315 DeclRef->setIsImmediateEscalating(
true);
18316 }
else if (
auto *Ctr = dyn_cast<CXXConstructExpr>(E->
IgnoreImplicit())) {
18317 Ctr->setIsImmediateEscalating(
true);
18318 }
else if (
auto *DeclRef = dyn_cast<DeclRefExpr>(E->
IgnoreImplicit())) {
18319 DeclRef->setIsImmediateEscalating(
true);
18321 assert(
false &&
"expected an immediately escalating expression");
18324 FI->FoundImmediateEscalatingExpression =
true;
18339 if (
auto *DeclRef =
18340 dyn_cast<DeclRefExpr>(
Call->getCallee()->IgnoreImplicit()))
18349 auto CheckConstantExpressionAndKeepResult = [&]() {
18352 Eval.
Diag = &Notes;
18354 Eval,
getASTContext(), ConstantExprKind::ImmediateInvocation);
18355 if (Res && Notes.empty()) {
18356 Cached = std::move(Eval.
Val);
18364 !CheckConstantExpressionAndKeepResult()) {
18399 ExprEvalContexts.back().ImmediateInvocationCandidates.emplace_back(Res, 0);
18407 Eval.
Diag = &Notes;
18410 Eval, SemaRef.
getASTContext(), ConstantExprKind::ImmediateInvocation);
18411 if (!
Result || !Notes.empty()) {
18414 if (
auto *
FunctionalCast = dyn_cast<CXXFunctionalCastExpr>(InnerExpr))
18417 if (
auto *
Call = dyn_cast<CallExpr>(InnerExpr))
18418 FD = cast<FunctionDecl>(
Call->getCalleeDecl());
18419 else if (
auto *
Call = dyn_cast<CXXConstructExpr>(InnerExpr))
18420 FD =
Call->getConstructor();
18421 else if (
auto *Cast = dyn_cast<CastExpr>(InnerExpr))
18422 FD = dyn_cast_or_null<FunctionDecl>(Cast->getConversionFunction());
18425 "could not find an immediate function in this expression");
18432 SemaRef.
Diag(
Context->Loc, diag::note_invalid_consteval_initializer)
18434 SemaRef.
Diag(
Context->Decl->getBeginLoc(), diag::note_declared_at);
18438 for (
auto &
Note : Notes)
18450 llvm::SmallPtrSetImpl<DeclRefExpr *> &DRSet;
18454 ComplexRemove(
Sema &SemaRef, llvm::SmallPtrSetImpl<DeclRefExpr *> &DR,
18457 4>::reverse_iterator Current)
18458 :
Base(SemaRef), DRSet(DR), IISet(II), CurrentII(Current) {}
18460 auto It = std::find_if(CurrentII, IISet.rend(),
18462 return Elem.getPointer() == E;
18468 if (It == IISet.rend()) {
18470 CurrentII->setInt(1);
18477 return Base::TransformConstantExpr(E);
18478 RemoveImmediateInvocation(E);
18479 return Base::TransformExpr(E->
getSubExpr());
18485 return Base::TransformCXXOperatorCallExpr(E);
18497 if (
auto *CE = dyn_cast<ConstantExpr>(
Init))
18498 if (CE->isImmediateInvocation())
18499 RemoveImmediateInvocation(CE);
18500 return Base::TransformInitializer(
Init, NotCopyInit);
18511 bool AlwaysRebuild() {
return false; }
18512 bool ReplacingOriginal() {
return true; }
18513 bool AllowSkippingCXXConstructExpr() {
18514 bool Res = AllowSkippingFirstCXXConstructExpr;
18515 AllowSkippingFirstCXXConstructExpr =
true;
18518 bool AllowSkippingFirstCXXConstructExpr =
true;
18528 if (isa<CXXConstructExpr>(It->getPointer()->IgnoreImplicit()))
18529 Transformer.AllowSkippingFirstCXXConstructExpr =
false;
18531 ExprResult Res = Transformer.TransformExpr(It->getPointer()->getSubExpr());
18537 It->getPointer()->setSubExpr(Res.
get());
18572 llvm::SmallPtrSetImpl<DeclRefExpr *> &DRSet;
18573 SimpleRemove(llvm::SmallPtrSetImpl<DeclRefExpr *> &S) : DRSet(S) {}
18576 return DRSet.size();
18579 Visitor.TraverseStmt(
18589 if (DR->isImmediateEscalating())
18591 auto *FD = cast<FunctionDecl>(DR->getDecl());
18593 if (
const auto *MD = dyn_cast<CXXMethodDecl>(ND);
18595 ND = MD->getParent();
18602 bool ImmediateEscalating =
false;
18603 bool IsPotentiallyEvaluated =
18613 SemaRef.
Diag(DR->getBeginLoc(), diag::err_invalid_consteval_take_address)
18614 << ND << isa<CXXRecordDecl>(ND) << FD->isConsteval();
18618 SemaRef.
Diag(
Context->Loc, diag::note_invalid_consteval_initializer)
18620 SemaRef.
Diag(
Context->Decl->getBeginLoc(), diag::note_declared_at);
18622 if (FD->isImmediateEscalating() && !FD->isConsteval())
18638 (Rec.
ExprContext == ExpressionKind::EK_TemplateArgument ||
18646 D = diag::err_lambda_unevaluated_operand;
18652 D = diag::err_lambda_in_constant_expression;
18653 }
else if (Rec.
ExprContext == ExpressionKind::EK_TemplateArgument) {
18656 D = diag::err_lambda_in_invalid_context;
18658 llvm_unreachable(
"Couldn't infer lambda error message.");
18660 for (
const auto *L : Rec.
Lambdas)
18661 Diag(L->getBeginLoc(), D);
18671 PrevRecord.ForRangeLifetimeExtendTemps.append(
18682 Diag(BO->getBeginLoc(), diag::warn_deprecated_simple_assign_volatile)
18755 llvm_unreachable(
"Invalid context");
18764 if (!TT.isOSWindows() || !TT.isX86())
18802 : FD(FD), Param(Param) {}
18809 CCName =
"stdcall";
18812 CCName =
"fastcall";
18815 CCName =
"vectorcall";
18818 llvm_unreachable(
"CC does not need mangling");
18821 S.
Diag(Loc, diag::err_cconv_incomplete_param_type)
18827 ParamIncompleteTypeDiagnoser Diagnoser(FD, Param);
18833enum class OdrUseContext {
18855 return OdrUseContext::None;
18860 Result = OdrUseContext::Used;
18864 Result = OdrUseContext::FormallyOdrUsed;
18870 Result = OdrUseContext::FormallyOdrUsed;
18875 return OdrUseContext::Dependent;
18881 if (!
Func->isConstexpr())
18884 if (
Func->isImplicitlyInstantiable() || !
Func->isUserProvided())
18886 auto *CCD = dyn_cast<CXXConstructorDecl>(
Func);
18887 return CCD && CCD->getInheritedConstructor();
18893 bool MightBeOdrUse) {
18894 assert(
Func &&
"No function?");
18896 Func->setReferenced();
18909 OdrUseContext OdrUse =
18911 if (IsRecursiveCall && OdrUse == OdrUseContext::Used)
18912 OdrUse = OdrUseContext::FormallyOdrUsed;
18916 if (
Func->isTrivial() && !
Func->hasAttr<DLLExportAttr>() &&
18917 OdrUse == OdrUseContext::Used) {
18918 if (
auto *Constructor = dyn_cast<CXXConstructorDecl>(
Func))
18919 if (Constructor->isDefaultConstructor())
18920 OdrUse = OdrUseContext::FormallyOdrUsed;
18921 if (isa<CXXDestructorDecl>(
Func))
18922 OdrUse = OdrUseContext::FormallyOdrUsed;
18929 bool NeededForConstantEvaluation =
18954 bool NeedDefinition = !IsRecursiveCall && (OdrUse == OdrUseContext::Used ||
18955 NeededForConstantEvaluation);
18962 if (NeedDefinition &&
18964 Func->getMemberSpecializationInfo()))
18971 if (NeedDefinition && !
Func->getBody()) {
18974 dyn_cast<CXXConstructorDecl>(
Func)) {
18975 Constructor = cast<CXXConstructorDecl>(Constructor->getFirstDecl());
18976 if (Constructor->isDefaulted() && !Constructor->isDeleted()) {
18977 if (Constructor->isDefaultConstructor()) {
18978 if (Constructor->isTrivial() &&
18979 !Constructor->hasAttr<DLLExportAttr>())
18982 }
else if (Constructor->isCopyConstructor()) {
18984 }
else if (Constructor->isMoveConstructor()) {
18987 }
else if (Constructor->getInheritedConstructor()) {
18991 dyn_cast<CXXDestructorDecl>(
Func)) {
18992 Destructor = cast<CXXDestructorDecl>(Destructor->getFirstDecl());
18993 if (Destructor->isDefaulted() && !Destructor->isDeleted()) {
18994 if (Destructor->isTrivial() && !Destructor->hasAttr<DLLExportAttr>())
18998 if (Destructor->isVirtual() &&
getLangOpts().AppleKext)
19001 if (MethodDecl->isOverloadedOperator() &&
19002 MethodDecl->getOverloadedOperator() == OO_Equal) {
19003 MethodDecl = cast<CXXMethodDecl>(MethodDecl->getFirstDecl());
19004 if (MethodDecl->isDefaulted() && !MethodDecl->isDeleted()) {
19005 if (MethodDecl->isCopyAssignmentOperator())
19007 else if (MethodDecl->isMoveAssignmentOperator())
19010 }
else if (isa<CXXConversionDecl>(MethodDecl) &&
19011 MethodDecl->getParent()->isLambda()) {
19013 cast<CXXConversionDecl>(MethodDecl->getFirstDecl());
19018 }
else if (MethodDecl->isVirtual() &&
getLangOpts().AppleKext)
19022 if (
Func->isDefaulted() && !
Func->isDeleted()) {
19030 if (
Func->isImplicitlyInstantiable()) {
19032 Func->getTemplateSpecializationKindForInstantiation();
19034 bool FirstInstantiation = PointOfInstantiation.
isInvalid();
19035 if (FirstInstantiation) {
19036 PointOfInstantiation = Loc;
19037 if (
auto *MSI =
Func->getMemberSpecializationInfo())
19038 MSI->setPointOfInstantiation(Loc);
19041 Func->setTemplateSpecializationKind(TSK, PointOfInstantiation);
19046 PointOfInstantiation = Loc;
19050 Func->isConstexpr()) {
19051 if (isa<CXXRecordDecl>(
Func->getDeclContext()) &&
19052 cast<CXXRecordDecl>(
Func->getDeclContext())->isLocalClass() &&
19055 std::make_pair(
Func, PointOfInstantiation));
19056 else if (
Func->isConstexpr())
19062 Func->setInstantiationIsPending(
true);
19064 std::make_pair(
Func, PointOfInstantiation));
19071 for (
auto *i :
Func->redecls()) {
19072 if (!i->isUsed(
false) && i->isImplicitlyInstantiable())
19085 Constructor->isImmediateFunction()
19090 if (
Init->isInClassMemberInitializer())
19092 MarkDeclarationsReferencedInExpr(Init->getInit());
19113 if (
LangOpts.OffloadImplicitHostDeviceTemplates &&
LangOpts.CUDAIsDevice &&
19118 if (OdrUse == OdrUseContext::Used && !
Func->isUsed(
false)) {
19120 if (!
Func->isDefined()) {
19121 if (mightHaveNonExternalLinkage(
Func))
19123 else if (
Func->getMostRecentDecl()->isInlined() &&
19125 !
Func->getMostRecentDecl()->hasAttr<GNUInlineAttr>())
19144 if (
auto *Dtor = dyn_cast<CXXDestructorDecl>(
Func)) {
19146 if (
Parent->getNumVBases() > 0 && !Dtor->getBody())
19164 const unsigned *
const FunctionScopeIndexToStopAt =
nullptr) {
19167 VarDecl *Var =
V->getPotentiallyDecomposedVarDecl();
19168 assert(Var &&
"expected a capturable variable");
19178 QualType CaptureType, DeclRefType;
19184 DeclRefType, FunctionScopeIndexToStopAt);
19187 auto *FD = dyn_cast_or_null<FunctionDecl>(SemaRef.
CurContext);
19197 SemaRef.
targetDiag(Loc, diag::err_ref_bad_target)
19198 << 2 << 1 << Var << UserTarget;
19201 ? diag::note_cuda_const_var_unpromoted
19202 : diag::note_cuda_host_var);
19205 !Var->
hasAttr<CUDASharedAttr>() &&
19220 else if (SemaRef.
LangOpts.GPURelocatableDeviceCode &&
19221 (!FD || (!FD->getDescribedFunctionTemplate() &&
19233 unsigned CapturingScopeIndex) {
19244 if (isa<ParmVarDecl>(var) &&
19245 isa<TranslationUnitDecl>(VarDC))
19258 unsigned ValueKind = isa<BindingDecl>(var) ? 1 : 0;
19259 unsigned ContextKind = 3;
19260 if (isa<CXXMethodDecl>(VarDC) &&
19261 cast<CXXRecordDecl>(VarDC->
getParent())->isLambda()) {
19263 }
else if (isa<FunctionDecl>(VarDC)) {
19265 }
else if (isa<BlockDecl>(VarDC)) {
19269 S.
Diag(loc, diag::err_reference_to_local_in_enclosing_context)
19270 << var << ValueKind << ContextKind << VarDC;
19280 bool &SubCapturesAreNested,
19286 SubCapturesAreNested =
true;
19299 !(isa<LambdaScopeInfo>(CSI) &&
19300 !cast<LambdaScopeInfo>(CSI)->lambdaCaptureShouldBeConst()) &&
19301 !(isa<CapturedRegionScopeInfo>(CSI) &&
19302 cast<CapturedRegionScopeInfo>(CSI)->CapRegionKind ==
CR_OpenMP))
19334 assert((isa<VarDecl, BindingDecl>(Var)) &&
19335 "Only variables and structured bindings can be captured");
19337 bool IsBlock = isa<BlockScopeInfo>(CSI);
19338 bool IsLambda = isa<LambdaScopeInfo>(CSI);
19346 S.
Diag(Loc, diag::err_lambda_capture_anonymous_var);
19355 S.
Diag(Loc, diag::err_ref_vm_type);
19363 if (VTTy->getDecl()->hasFlexibleArrayMember()) {
19366 S.
Diag(Loc, diag::err_ref_flexarray_type);
19368 S.
Diag(Loc, diag::err_lambda_capture_flexarray_type) << Var;
19374 const bool HasBlocksAttr = Var->
hasAttr<BlocksAttr>();
19377 if (HasBlocksAttr && (IsLambda || isa<CapturedRegionScopeInfo>(CSI))) {
19379 S.
Diag(Loc, diag::err_capture_block_variable) << Var << !IsLambda;
19388 S.
Diag(Loc, diag::err_opencl_block_ref_block);
19392 if (isa<BindingDecl>(Var)) {
19399 ? diag::warn_cxx17_compat_capture_binding
19400 : diag::ext_capture_binding)
19414 bool ByRef =
false;
19420 if (BuildAndDiagnose) {
19421 S.
Diag(Loc, diag::err_ref_array_type);
19432 if (BuildAndDiagnose) {
19433 S.
Diag(Loc, diag::err_arc_autoreleasing_capture)
19449 if (BuildAndDiagnose) {
19451 S.
Diag(Loc, diag::warn_block_capture_autoreleasing);
19452 S.
Diag(VarLoc, diag::note_declare_parameter_strong);
19457 const bool HasBlocksAttr = Var->
hasAttr<BlocksAttr>();
19466 DeclRefType = CaptureType;
19470 if (BuildAndDiagnose)
19480 const bool BuildAndDiagnose,
QualType &CaptureType,
QualType &DeclRefType,
19507 CaptureType = DeclRefType;
19510 if (BuildAndDiagnose)
19511 RSI->
addCapture(Var,
false, ByRef, RefersToCapturedVariable,
19521 const bool RefersToCapturedVariable,
19526 bool ByRef =
false;
19530 ByRef = (LSI->
ImpCaptureStyle == LambdaScopeInfo::ImpCap_LambdaByref);
19535 S.
Diag(Loc, diag::err_wasm_ca_reference) << 0;
19566 if (!RefType->getPointeeType()->isFunctionType())
19573 if (BuildAndDiagnose) {
19574 S.
Diag(Loc, diag::err_arc_autoreleasing_capture) << 1;
19584 if (!
Invalid && BuildAndDiagnose) {
19588 diag::err_capture_of_incomplete_or_sizeless_type,
19592 diag::err_capture_of_abstract_type))
19613 if (BuildAndDiagnose)
19614 LSI->
addCapture(Var,
false, ByRef, RefersToCapturedVariable,
19615 Loc, EllipsisLoc, CaptureType,
Invalid);
19630 if (!(RD = RD->getDefinition()))
19632 if (RD->hasSimpleCopyConstructor())
19634 if (RD->hasUserDeclaredCopyConstructor())
19636 if (Ctor->isCopyConstructor())
19637 return !Ctor->isDeleted();
19657 if (ShouldOfferCopyFix) {
19661 FixBuffer.assign({Separator, Var->
getName()});
19662 Sema.
Diag(VarInsertLoc, diag::note_lambda_variable_capture_fixit)
19667 FixBuffer.assign({Separator,
"&", Var->
getName()});
19668 Sema.
Diag(VarInsertLoc, diag::note_lambda_variable_capture_fixit)
19680 return !C.isThisCapture() && !C.isInitCapture();
19689 if (ShouldOfferCopyFix) {
19690 bool CanDefaultCopyCapture =
true;
19699 if (CanDefaultCopyCapture && llvm::none_of(LSI->
Captures, [](
Capture &
C) {
19700 return !C.isThisCapture() && !C.isInitCapture() && C.isCopyCapture();
19702 FixBuffer.assign({
"=", Separator});
19703 Sema.
Diag(DefaultInsertLoc, diag::note_lambda_default_capture_fixit)
19712 return !C.isInitCapture() && C.isReferenceCapture() &&
19713 !C.isThisCapture();
19715 FixBuffer.assign({
"&", Separator});
19716 Sema.
Diag(DefaultInsertLoc, diag::note_lambda_default_capture_fixit)
19725 QualType &DeclRefType,
const unsigned *
const FunctionScopeIndexToStopAt) {
19738 const auto *VD = dyn_cast<VarDecl>(Var);
19740 if (VD->isInitCapture())
19745 assert(VD &&
"Cannot capture a null variable");
19747 const unsigned MaxFunctionScopesIndex = FunctionScopeIndexToStopAt
19751 if (FunctionScopeIndexToStopAt) {
19753 while (FSIndex != MaxFunctionScopesIndex) {
19761 bool IsGlobal = !VD->hasLocalStorage();
19764 MaxFunctionScopesIndex)))
19767 if (isa<VarDecl>(Var))
19778 CaptureType = Var->
getType();
19780 bool Nested =
false;
19782 unsigned FunctionScopesIndex = MaxFunctionScopesIndex;
19787 LSI = dyn_cast_or_null<LambdaScopeInfo>(
19790 bool IsInScopeDeclarationContext =
19801 if (IsInScopeDeclarationContext &&
19802 FunctionScopesIndex == MaxFunctionScopesIndex && VarDC == DC)
19808 !IsInScopeDeclarationContext
19811 BuildAndDiagnose, *
this);
19817 FunctionScopesIndex = MaxFunctionScopesIndex - 1;
19836 if (
const auto *Parm = dyn_cast<ParmVarDecl>(Var);
19837 Parm && Parm->getDeclContext() == DC)
19845 if (BuildAndDiagnose) {
19848 Diag(ExprLoc, diag::err_lambda_impcap) << Var;
19863 if (
ParmVarDecl *PVD = dyn_cast_or_null<ParmVarDecl>(Var))
19864 QTy = PVD->getOriginalType();
19869 if (
auto *RSI = dyn_cast<CapturedRegionScopeInfo>(CSI)) {
19875 if (isa<BindingDecl>(Var)) {
19876 if (BuildAndDiagnose) {
19877 Diag(ExprLoc, diag::err_capture_binding_openmp) << Var;
19883 Var, RSI->OpenMPLevel, RSI->OpenMPCaptureLevel);
19888 if (IsOpenMPPrivateDecl != OMPC_unknown &&
19891 if (
ParmVarDecl *PVD = dyn_cast_or_null<ParmVarDecl>(Var))
19892 QTy = PVD->getOriginalType();
19893 for (
int I = 1, E = getNumberOfConstructScopes(RSI->OpenMPLevel);
19895 auto *OuterRSI = cast<CapturedRegionScopeInfo>(
19897 assert(RSI->OpenMPLevel == OuterRSI->OpenMPLevel &&
19898 "Wrong number of captured regions associated with the "
19899 "OpenMP construct.");
19904 IsOpenMPPrivateDecl != OMPC_private &&
19906 RSI->OpenMPCaptureLevel);
19910 RSI->OpenMPCaptureLevel);
19916 adjustOpenMPTargetScopeIndex(FunctionScopesIndex, RSI->OpenMPLevel);
19918 if (IsTargetCap || IsOpenMPPrivateDecl == OMPC_private ||
19919 (IsGlobal && !IsGlobalCap)) {
19920 Nested = !IsTargetCap;
19935 if (BuildAndDiagnose) {
19936 Diag(ExprLoc, diag::err_lambda_impcap) << Var;
19938 auto *LSI = cast<LambdaScopeInfo>(CSI);
19958 FunctionScopesIndex--;
19959 if (IsInScopeDeclarationContext)
19961 }
while (!VarDC->
Equals(DC));
19969 for (
unsigned I = ++FunctionScopesIndex, N = MaxFunctionScopesIndex + 1; I != N;
19982 if (
Invalid && !BuildAndDiagnose)
19987 DeclRefType, Nested, *
this,
Invalid);
19991 RSI, Var, ExprLoc, BuildAndDiagnose, CaptureType, DeclRefType, Nested,
19992 Kind, I == N - 1, *
this,
Invalid);
19998 DeclRefType, Nested, Kind, EllipsisLoc,
20003 if (
Invalid && !BuildAndDiagnose)
20015 DeclRefType,
nullptr);
20022 false, CaptureType,
20023 DeclRefType,
nullptr);
20032 false, CaptureType,
20033 DeclRefType,
nullptr))
20036 return DeclRefType;
20044class CopiedTemplateArgs {
20048 template<
typename RefExpr>
20049 CopiedTemplateArgs(RefExpr *E) : HasArgs(E->hasExplicitTemplateArgs()) {
20051 E->copyTemplateArgumentsInto(TemplateArgStorage);
20054#ifdef __has_cpp_attribute
20055#
if __has_cpp_attribute(clang::lifetimebound)
20056 [[clang::lifetimebound]]
20060 return HasArgs ? &TemplateArgStorage :
nullptr;
20086 auto Rebuild = [&](
Expr *Sub) {
20091 auto IsPotentialResultOdrUsed = [&](
NamedDecl *D) {
20094 auto *VD = dyn_cast<VarDecl>(D);
20117 llvm_unreachable(
"unexpected non-odr-use-reason");
20121 if (VD->getType()->isReferenceType())
20123 if (
auto *RD = VD->getType()->getAsCXXRecordDecl())
20124 if (RD->hasMutableFields())
20126 if (!VD->isUsableInConstantExpressions(S.
Context))
20131 if (VD->getType()->isReferenceType())
20139 auto MarkNotOdrUsed = [&] {
20142 LSI->markVariableExprAsNonODRUsed(E);
20149 case Expr::DeclRefExprClass: {
20150 auto *DRE = cast<DeclRefExpr>(E);
20151 if (DRE->isNonOdrUse() || IsPotentialResultOdrUsed(DRE->getDecl()))
20157 S.
Context, DRE->getQualifierLoc(), DRE->getTemplateKeywordLoc(),
20158 DRE->getDecl(), DRE->refersToEnclosingVariableOrCapture(),
20159 DRE->getNameInfo(), DRE->getType(), DRE->getValueKind(),
20160 DRE->getFoundDecl(), CopiedTemplateArgs(DRE), NOUR);
20163 case Expr::FunctionParmPackExprClass: {
20164 auto *FPPE = cast<FunctionParmPackExpr>(E);
20168 if (IsPotentialResultOdrUsed(D))
20179 case Expr::ArraySubscriptExprClass: {
20180 auto *ASE = cast<ArraySubscriptExpr>(E);
20185 if (!
Base.isUsable())
20187 Expr *LHS = ASE->getBase() == ASE->getLHS() ?
Base.get() : ASE->getLHS();
20188 Expr *RHS = ASE->getBase() == ASE->getRHS() ?
Base.get() : ASE->getRHS();
20191 ASE->getRBracketLoc());
20194 case Expr::MemberExprClass: {
20195 auto *ME = cast<MemberExpr>(E);
20198 if (isa<FieldDecl>(ME->getMemberDecl())) {
20200 if (!
Base.isUsable())
20203 S.
Context,
Base.get(), ME->isArrow(), ME->getOperatorLoc(),
20204 ME->getQualifierLoc(), ME->getTemplateKeywordLoc(),
20205 ME->getMemberDecl(), ME->getFoundDecl(), ME->getMemberNameInfo(),
20206 CopiedTemplateArgs(ME), ME->getType(), ME->getValueKind(),
20207 ME->getObjectKind(), ME->isNonOdrUse());
20210 if (ME->getMemberDecl()->isCXXInstanceMember())
20215 if (ME->isNonOdrUse() || IsPotentialResultOdrUsed(ME->getMemberDecl()))
20221 S.
Context, ME->getBase(), ME->isArrow(), ME->getOperatorLoc(),
20222 ME->getQualifierLoc(), ME->getTemplateKeywordLoc(), ME->getMemberDecl(),
20223 ME->getFoundDecl(), ME->getMemberNameInfo(), CopiedTemplateArgs(ME),
20224 ME->getType(), ME->getValueKind(), ME->getObjectKind(), NOUR);
20227 case Expr::BinaryOperatorClass: {
20228 auto *BO = cast<BinaryOperator>(E);
20229 Expr *LHS = BO->getLHS();
20230 Expr *RHS = BO->getRHS();
20232 if (BO->getOpcode() == BO_PtrMemD) {
20234 if (!Sub.isUsable())
20238 }
else if (BO->getOpcode() == BO_Comma) {
20240 if (!Sub.isUsable())
20246 return S.
BuildBinOp(
nullptr, BO->getOperatorLoc(), BO->getOpcode(),
20251 case Expr::ParenExprClass: {
20252 auto *PE = cast<ParenExpr>(E);
20254 if (!Sub.isUsable())
20256 return S.
ActOnParenExpr(PE->getLParen(), PE->getRParen(), Sub.get());
20261 case Expr::ConditionalOperatorClass: {
20262 auto *CO = cast<ConditionalOperator>(E);
20272 LHS = CO->getLHS();
20274 RHS = CO->getRHS();
20276 CO->getCond(), LHS.
get(), RHS.
get());
20281 case Expr::UnaryOperatorClass: {
20282 auto *UO = cast<UnaryOperator>(E);
20283 if (UO->getOpcode() != UO_Extension)
20286 if (!Sub.isUsable())
20288 return S.
BuildUnaryOp(
nullptr, UO->getOperatorLoc(), UO_Extension,
20295 case Expr::GenericSelectionExprClass: {
20296 auto *GSE = cast<GenericSelectionExpr>(E);
20299 bool AnyChanged =
false;
20300 for (
Expr *OrigAssocExpr : GSE->getAssocExprs()) {
20301 ExprResult AssocExpr = Rebuild(OrigAssocExpr);
20305 AssocExprs.push_back(AssocExpr.
get());
20308 AssocExprs.push_back(OrigAssocExpr);
20312 void *ExOrTy =
nullptr;
20313 bool IsExpr = GSE->isExprPredicate();
20315 ExOrTy = GSE->getControllingExpr();
20317 ExOrTy = GSE->getControllingType();
20319 GSE->getGenericLoc(), GSE->getDefaultLoc(),
20320 GSE->getRParenLoc(), IsExpr, ExOrTy,
20321 GSE->getAssocTypeSourceInfos(), AssocExprs)
20329 case Expr::ChooseExprClass: {
20330 auto *CE = cast<ChooseExpr>(E);
20340 if (!LHS.
get() && !RHS.
get())
20343 LHS = CE->getLHS();
20345 RHS = CE->getRHS();
20348 RHS.
get(), CE->getRParenLoc());
20352 case Expr::ConstantExprClass: {
20353 auto *CE = cast<ConstantExpr>(E);
20355 if (!Sub.isUsable())
20362 case Expr::ImplicitCastExprClass: {
20363 auto *ICE = cast<ImplicitCastExpr>(E);
20367 switch (ICE->getCastKind()) {
20369 case CK_DerivedToBase:
20370 case CK_UncheckedDerivedToBase: {
20371 ExprResult Sub = Rebuild(ICE->getSubExpr());
20372 if (!Sub.isUsable())
20376 ICE->getValueKind(), &Path);
20435 for (
Expr *E : LocalMaybeODRUseExprs) {
20436 if (
auto *DRE = dyn_cast<DeclRefExpr>(E)) {
20438 DRE->getLocation(), *
this);
20439 }
else if (
auto *ME = dyn_cast<MemberExpr>(E)) {
20442 }
else if (
auto *FP = dyn_cast<FunctionParmPackExpr>(E)) {
20446 llvm_unreachable(
"Unexpected expression");
20451 "MarkVarDeclODRUsed failed to cleanup MaybeODRUseExprs?");
20460 const bool RefersToEnclosingScope =
20463 if (RefersToEnclosingScope) {
20478 assert(E &&
"Capture variable should be used in an expression.");
20489 assert((!E || isa<DeclRefExpr>(E) || isa<MemberExpr>(E) ||
20490 isa<FunctionParmPackExpr>(E)) &&
20491 "Invalid Expr argument to DoMarkVarDeclReferenced");
20502 bool UsableInConstantExpr =
20514 bool NeededForConstantEvaluation =
20517 bool NeedDefinition =
20518 OdrUse == OdrUseContext::Used || NeededForConstantEvaluation;
20520 assert(!isa<VarTemplatePartialSpecializationDecl>(Var) &&
20521 "Can't instantiate a partial template specialization.");
20527 !isa<VarTemplateSpecializationDecl>(Var))
20538 bool TryInstantiating =
20542 if (TryInstantiating) {
20545 bool FirstInstantiation = PointOfInstantiation.
isInvalid();
20546 if (FirstInstantiation) {
20547 PointOfInstantiation = Loc;
20549 MSI->setPointOfInstantiation(PointOfInstantiation);
20555 if (UsableInConstantExpr) {
20564 if (
auto *DRE = dyn_cast_or_null<DeclRefExpr>(E))
20565 DRE->setDecl(DRE->getDecl());
20566 else if (
auto *ME = dyn_cast_or_null<MemberExpr>(E))
20567 ME->setMemberDecl(ME->getMemberDecl());
20568 }
else if (FirstInstantiation) {
20570 .push_back(std::make_pair(Var, PointOfInstantiation));
20572 bool Inserted =
false;
20574 auto Iter = llvm::find_if(
20576 return P.first == Var;
20578 if (
Iter != I.end()) {
20591 if (isa<VarTemplateSpecializationDecl>(Var) && !Inserted)
20593 .push_back(std::make_pair(Var, PointOfInstantiation));
20617 if (
DeclRefExpr *DRE = dyn_cast_or_null<DeclRefExpr>(E))
20618 if (DRE->isNonOdrUse())
20620 if (
MemberExpr *ME = dyn_cast_or_null<MemberExpr>(E))
20621 if (ME->isNonOdrUse())
20625 case OdrUseContext::None:
20628 assert((!E || isa<FunctionParmPackExpr>(E) ||
20630 "missing non-odr-use marking for unevaluated decl ref");
20633 case OdrUseContext::FormallyOdrUsed:
20638 case OdrUseContext::Used:
20647 case OdrUseContext::Dependent:
20665 if (OdrUse == OdrUseContext::Used) {
20666 QualType CaptureType, DeclRefType;
20672 }
else if (OdrUse == OdrUseContext::Dependent) {
20691 auto *ID = dyn_cast<DeclRefExpr>(E);
20692 if (!ID || ID->isTypeDependent())
20695 auto IsDependent = [&]() {
20708 ID->setCapturedByCopyInLambdaWithExplicitObjectParameter(
20714 bool MightBeOdrUse,
20719 if (
VarDecl *Var = dyn_cast<VarDecl>(D)) {
20738 const MemberExpr *ME = dyn_cast<MemberExpr>(E);
20745 bool IsVirtualCall = MD->
isVirtual() &&
20747 if (!IsVirtualCall)
20766 bool OdrUse =
true;
20768 if (Method->isVirtual() &&
20772 if (
auto *FD = dyn_cast<FunctionDecl>(E->
getDecl())) {
20777 !FD->isDependentContext())
20792 bool MightBeOdrUse =
true;
20795 if (Method->isPureVirtual())
20796 MightBeOdrUse =
false;
20816 bool MightBeOdrUse) {
20817 if (MightBeOdrUse) {
20818 if (
auto *VD = dyn_cast<VarDecl>(D)) {
20823 if (
auto *FD = dyn_cast<FunctionDecl>(D)) {
20851bool MarkReferencedDecls::TraverseTemplateArgument(
20865 return Inherited::TraverseTemplateArgument(Arg);
20869 MarkReferencedDecls Marker(*
this, Loc);
20870 Marker.TraverseType(T);
20876class EvaluatedExprMarker :
public UsedDeclVisitor<EvaluatedExprMarker> {
20879 bool SkipLocalVariables;
20882 EvaluatedExprMarker(
Sema &S,
bool SkipLocalVariables,
20884 : Inherited(S), SkipLocalVariables(SkipLocalVariables), StopAt(StopAt) {}
20890 void Visit(
Expr *E) {
20891 if (llvm::is_contained(StopAt, E))
20893 Inherited::Visit(E);
20903 if (SkipLocalVariables) {
20905 if (VD->hasLocalStorage())
20929 bool SkipLocalVariables,
20931 EvaluatedExprMarker(*
this, SkipLocalVariables, StopAt).Visit(E);
20953 if (
auto *VD = dyn_cast_or_null<VarDecl>(
20955 if (VD->isConstexpr() ||
20956 (VD->isStaticDataMember() && VD->isFirstDecl() && !VD->isInline()))
21028 class CallReturnIncompleteDiagnoser :
public TypeDiagnoser {
21034 : FD(FD), CE(CE) { }
21038 S.
Diag(Loc, diag::err_call_incomplete_return)
21043 S.
Diag(Loc, diag::err_call_function_incomplete_return)
21048 } Diagnoser(FD, CE);
21061 unsigned diagnostic = diag::warn_condition_is_assignment;
21062 bool IsOrAssign =
false;
21065 if (Op->getOpcode() != BO_Assign && Op->getOpcode() != BO_OrAssign)
21068 IsOrAssign = Op->getOpcode() == BO_OrAssign;
21077 diagnostic = diag::warn_condition_is_idiomatic_assignment;
21081 diagnostic = diag::warn_condition_is_idiomatic_assignment;
21084 Loc = Op->getOperatorLoc();
21086 if (Op->getOperator() != OO_Equal && Op->getOperator() != OO_PipeEqual)
21089 IsOrAssign = Op->getOperator() == OO_PipeEqual;
21090 Loc = Op->getOperatorLoc();
21102 Diag(Loc, diag::note_condition_assign_silence)
21107 Diag(Loc, diag::note_condition_or_assign_to_comparison)
21110 Diag(Loc, diag::note_condition_assign_to_comparison)
21128 if (opE->getOpcode() == BO_EQ &&
21129 opE->getLHS()->IgnoreParenImpCasts()->isModifiableLvalue(
Context)
21135 Diag(Loc, diag::note_equality_comparison_silence)
21138 Diag(Loc, diag::note_equality_comparison_to_assign)
21144 bool IsConstexpr) {
21146 if (
ParenExpr *parenE = dyn_cast<ParenExpr>(E))
21164 Diag(Loc, diag::err_typecheck_statement_requires_scalar)
21168 CheckBoolLikeConversion(E, Loc);
21214 struct RebuildUnknownAnyFunction
21215 :
StmtVisitor<RebuildUnknownAnyFunction, ExprResult> {
21219 RebuildUnknownAnyFunction(
Sema &S) : S(S) {}
21222 llvm_unreachable(
"unexpected statement!");
21233 template <
class T>
ExprResult rebuildSugarExpr(T *E) {
21234 ExprResult SubResult = Visit(E->getSubExpr());
21237 Expr *SubExpr = SubResult.
get();
21238 E->setSubExpr(SubExpr);
21246 return rebuildSugarExpr(E);
21250 return rebuildSugarExpr(E);
21257 Expr *SubExpr = SubResult.
get();
21266 if (!isa<FunctionDecl>(VD))
return VisitExpr(E);
21272 !(isa<CXXMethodDecl>(VD) &&
21273 cast<CXXMethodDecl>(VD)->isInstance()))
21284 return resolveDecl(E, E->
getDecl());
21302 struct RebuildUnknownAnyExpr
21303 :
StmtVisitor<RebuildUnknownAnyExpr, ExprResult> {
21314 llvm_unreachable(
"unexpected statement!");
21328 template <
class T>
ExprResult rebuildSugarExpr(T *E) {
21329 ExprResult SubResult = Visit(E->getSubExpr());
21331 Expr *SubExpr = SubResult.
get();
21332 E->setSubExpr(SubExpr);
21340 return rebuildSugarExpr(E);
21344 return rebuildSugarExpr(E);
21382 return resolveDecl(E, E->
getDecl());
21393 FK_FunctionPointer,
21400 assert(isa<CXXMemberCallExpr>(E) || isa<CXXOperatorCallExpr>(E));
21401 Kind = FK_MemberFunction;
21405 Kind = FK_FunctionPointer;
21408 Kind = FK_BlockPointer;
21414 unsigned diagID = diag::err_func_returning_array_function;
21415 if (Kind == FK_BlockPointer)
21416 diagID = diag::err_block_returning_array_function;
21452 if (ParamTypes.empty() && Proto->
isVariadic()) {
21454 for (
unsigned i = 0, e = E->
getNumArgs(); i != e; ++i) {
21457 ParamTypes = ArgTypes;
21468 case FK_MemberFunction:
21472 case FK_FunctionPointer:
21476 case FK_BlockPointer:
21482 ExprResult CalleeResult = Visit(CalleeExpr);
21493 S.
Diag(E->
getExprLoc(), diag::err_func_returning_array_function)
21501 Method->setReturnType(DestType);
21513 if (E->
getCastKind() == CK_FunctionToPointerDecay) {
21527 }
else if (E->
getCastKind() == CK_LValueToRValue) {
21531 assert(isa<BlockPointerType>(E->
getType()));
21544 llvm_unreachable(
"Unhandled cast type!");
21577 if (DRE && Proto && Proto->getParamTypes().empty() && Proto->isVariadic()) {
21580 S.
Context, FD->getDeclContext(), Loc, Loc,
21581 FD->getNameInfo().getName(), DestType, FD->getTypeSourceInfo(),
21583 false , FD->hasPrototype(),
21586 if (FD->getQualifier())
21590 for (
const auto &AI : FT->param_types()) {
21594 Params.push_back(Param);
21596 NewFD->setParams(Params);
21603 if (MD->isInstance()) {
21613 }
else if (isa<VarDecl>(VD)) {
21617 S.
Diag(E->
getExprLoc(), diag::err_unknown_any_var_function_type)
21645 diag::err_typecheck_cast_to_incomplete))
21660 return RebuildUnknownAnyExpr(*
this, ToType).Visit(E);
21667 ExplicitCastExpr *castArg = dyn_cast<ExplicitCastExpr>(arg->IgnoreParens());
21676 assert(!arg->hasPlaceholderType());
21688 unsigned diagID = diag::err_uncasted_use_of_unknown_any;
21691 if (
CallExpr *call = dyn_cast<CallExpr>(E)) {
21692 E = call->getCallee();
21693 diagID = diag::err_uncasted_call_of_unknown_any;
21701 if (
DeclRefExpr *ref = dyn_cast<DeclRefExpr>(E)) {
21702 loc = ref->getLocation();
21703 d = ref->getDecl();
21704 }
else if (
MemberExpr *mem = dyn_cast<MemberExpr>(E)) {
21705 loc = mem->getMemberLoc();
21706 d = mem->getMemberDecl();
21708 diagID = diag::err_uncasted_call_of_unknown_any;
21709 loc = msg->getSelectorStartLoc();
21710 d = msg->getMethodDecl();
21712 S.
Diag(loc, diag::err_uncasted_send_to_unknown_any_method)
21713 <<
static_cast<unsigned>(msg->isClassMessage()) << msg->getSelector()
21742 if (!placeholderType)
return E;
21744 switch (placeholderType->
getKind()) {
21747 case BuiltinType::Overload: {
21767 case BuiltinType::BoundMember: {
21772 if (isa<CXXPseudoDestructorExpr>(BME)) {
21773 PD =
PDiag(diag::err_dtor_expr_without_call) << 1;
21774 }
else if (
const auto *ME = dyn_cast<MemberExpr>(BME)) {
21775 if (ME->getMemberNameInfo().getName().getNameKind() ==
21777 PD =
PDiag(diag::err_dtor_expr_without_call) << 0;
21785 case BuiltinType::ARCUnbridgedCast: {
21792 case BuiltinType::UnknownAny:
21796 case BuiltinType::PseudoObject:
21799 case BuiltinType::BuiltinFn: {
21803 auto *FD = cast<FunctionDecl>(DRE->
getDecl());
21804 unsigned BuiltinID = FD->getBuiltinID();
21805 if (BuiltinID == Builtin::BI__noop) {
21807 CK_BuiltinFnToFnPtr)
21820 ? diag::err_use_of_unaddressable_function
21821 : diag::warn_cxx20_compat_use_of_unaddressable_function);
21822 if (FD->isImplicitlyInstantiable()) {
21849 case BuiltinType::IncompleteMatrixIdx:
21853 diag::err_matrix_incomplete_index);
21857 case BuiltinType::OMPArraySection:
21862 case BuiltinType::OMPArrayShaping:
21865 case BuiltinType::OMPIterator:
21869#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
21870 case BuiltinType::Id:
21871#include "clang/Basic/OpenCLImageTypes.def"
21872#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
21873 case BuiltinType::Id:
21874#include "clang/Basic/OpenCLExtensionTypes.def"
21875#define SVE_TYPE(Name, Id, SingletonId) \
21876 case BuiltinType::Id:
21877#include "clang/Basic/AArch64SVEACLETypes.def"
21878#define PPC_VECTOR_TYPE(Name, Id, Size) \
21879 case BuiltinType::Id:
21880#include "clang/Basic/PPCTypes.def"
21881#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
21882#include "clang/Basic/RISCVVTypes.def"
21883#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
21884#include "clang/Basic/WebAssemblyReferenceTypes.def"
21885#define BUILTIN_TYPE(Id, SingletonId) case BuiltinType::Id:
21886#define PLACEHOLDER_TYPE(Id, SingletonId)
21887#include "clang/AST/BuiltinTypes.def"
21891 llvm_unreachable(
"invalid placeholder type!");
21905 assert((Kind == tok::kw___objc_yes || Kind == tok::kw___objc_no) &&
21906 "Unknown Objective-C Boolean value!");
21926 auto FindSpecVersion =
21927 [&](StringRef Platform) -> std::optional<VersionTuple> {
21933 if (Spec == AvailSpecs.end() && Platform ==
"maccatalyst") {
21938 if (Spec == AvailSpecs.end())
21939 return std::nullopt;
21943 VersionTuple Version;
21944 if (
auto MaybeVersion =
21946 Version = *MaybeVersion;
21951 Context->HasPotentialAvailabilityViolations =
true;
Defines the clang::ASTContext interface.
This file provides some common utility functions for processing Lambda related AST Constructs.
static bool isObjCPointer(const MemRegion *R)
Defines enum values for all the target-independent builtin functions.
Defines the C++ template declaration subclasses.
Defines the classes clang::DelayedDiagnostic and clang::AccessedEntity.
Defines the clang::Expr interface and subclasses for C++ expressions.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
llvm::MachO::Target Target
llvm::MachO::Record Record
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.
Defines the clang::Preprocessor interface.
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
static Sema::AssignConvertType checkObjCPointerTypesForAssignment(Sema &S, QualType LHSType, QualType RHSType)
checkObjCPointerTypesForAssignment - Compares two objective-c pointer types for assignment compatibil...
static void HandleImmediateInvocations(Sema &SemaRef, Sema::ExpressionEvaluationContextRecord &Rec)
static ExprResult BuildCookedLiteralOperatorCall(Sema &S, Scope *Scope, IdentifierInfo *UDSuffix, SourceLocation UDSuffixLoc, ArrayRef< Expr * > Args, SourceLocation LitEndLoc)
BuildCookedLiteralOperatorCall - A user-defined literal was found.
static ExprResult BuildOverloadedBinOp(Sema &S, Scope *Sc, SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHS, Expr *RHS)
Build an overloaded binary operator expression in the given scope.
static bool canConvertIntTyToFloatTy(Sema &S, ExprResult *Int, QualType FloatTy)
Test if a (constant) integer Int can be casted to floating point type FloatTy without losing precisio...
static bool captureInCapturedRegion(CapturedRegionScopeInfo *RSI, ValueDecl *Var, SourceLocation Loc, const bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType, const bool RefersToCapturedVariable, Sema::TryCaptureKind Kind, bool IsTopScope, Sema &S, bool Invalid)
Capture the given variable in the captured region.
static bool checkArithmeticOpPointerOperand(Sema &S, SourceLocation Loc, Expr *Operand)
Check the validity of an arithmetic pointer operand.
static void DiagnoseBitwisePrecedence(Sema &Self, BinaryOperatorKind Opc, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr)
DiagnoseBitwisePrecedence - Emit a warning when bitwise and comparison operators are mixed in a way t...
static bool isPlaceholderToRemoveAsArg(QualType type)
Is the given type a placeholder that we need to lower out immediately during argument processing?
static void diagnoseArithmeticOnNullPointer(Sema &S, SourceLocation Loc, Expr *Pointer, bool IsGNUIdiom)
Diagnose invalid arithmetic on a null pointer.
static void DiagnoseConditionalPrecedence(Sema &Self, SourceLocation OpLoc, Expr *Condition, const Expr *LHSExpr, const Expr *RHSExpr)
DiagnoseConditionalPrecedence - Emit a warning when a conditional operator and binary operator are mi...
static bool CheckDeclInExpr(Sema &S, SourceLocation Loc, NamedDecl *D, bool AcceptInvalid)
Diagnoses obvious problems with the use of the given declaration as an expression.
static QualType checkConditionalObjectPointersCompatibility(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc)
Return the resulting type when the operands are both pointers.
static QualType OpenCLCheckVectorConditional(Sema &S, ExprResult &Cond, ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
Return the resulting type for the conditional operator in OpenCL (aka "ternary selection operator",...
static void diagnoseLogicalNotOnLHSofCheck(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc)
Warns on !x < y, !x & y where !(x < y), !(x & y) was probably intended.
static void diagnoseArithmeticOnFunctionPointer(Sema &S, SourceLocation Loc, Expr *Pointer)
Diagnose invalid arithmetic on a function pointer.
static void diagnoseObjCLiteralComparison(Sema &S, SourceLocation Loc, ExprResult &LHS, ExprResult &RHS, BinaryOperator::Opcode Opc)
static bool isCapturingReferenceToHostVarInCUDADeviceLambda(const Sema &S, VarDecl *VD)
static UnaryOperatorKind ConvertTokenKindToUnaryOpcode(tok::TokenKind Kind)
static bool isImplicitlyDefinableConstexprFunction(FunctionDecl *Func)
NonConstCaptureKind
Is the given expression (which must be 'const') a reference to a variable which was originally non-co...
static bool tryVectorConvertAndSplat(Sema &S, ExprResult *scalar, QualType scalarTy, QualType vectorEltTy, QualType vectorTy, unsigned &DiagID)
Try to convert a value of non-vector type to a vector type by converting the type to the element type...
static bool isVector(QualType QT, QualType ElementType)
This helper function returns true if QT is a vector type that has element type ElementType.
static void DiagnoseCalleeStaticArrayParam(Sema &S, ParmVarDecl *PVD)
static Expr * recoverFromMSUnqualifiedLookup(Sema &S, ASTContext &Context, DeclarationNameInfo &NameInfo, SourceLocation TemplateKWLoc, const TemplateArgumentListInfo *TemplateArgs)
In Microsoft mode, if we are inside a template class whose parent class has dependent base classes,...
static void FixDependencyOfIdExpressionsInLambdaWithDependentObjectParameter(Sema &SemaRef, ValueDecl *D, Expr *E)
static bool isVariableCapturable(CapturingScopeInfo *CSI, ValueDecl *Var, SourceLocation Loc, const bool Diagnose, Sema &S)
static bool maybeDiagnoseAssignmentToFunction(Sema &S, QualType DstType, const Expr *SrcExpr)
static void SuggestParentheses(Sema &Self, SourceLocation Loc, const PartialDiagnostic &Note, SourceRange ParenRange)
SuggestParentheses - Emit a note with a fixit hint that wraps ParenRange in parentheses.
static Decl * getPredefinedExprDecl(DeclContext *DC)
getPredefinedExprDecl - Returns Decl of a given DeclContext that can be used to determine the value o...
static CXXRecordDecl * LookupStdSourceLocationImpl(Sema &S, SourceLocation Loc)
static bool IgnoreCommaOperand(const Expr *E, const ASTContext &Context)
static QualType CheckRealImagOperand(Sema &S, ExprResult &V, SourceLocation Loc, bool IsReal)
static QualType checkArithmeticOrEnumeralCompare(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc)
static QualType CheckIndirectionOperand(Sema &S, Expr *Op, ExprValueKind &VK, SourceLocation OpLoc, bool IsAfterAmp=false)
CheckIndirectionOperand - Type check unary indirection (prefix '*').
static bool CheckAlignOfExpr(Sema &S, Expr *E, UnaryExprOrTypeTrait ExprKind)
static bool ExprLooksBoolean(const Expr *E)
ExprLooksBoolean - Returns true if E looks boolean, i.e.
static bool isPotentiallyConstantEvaluatedContext(Sema &SemaRef)
Are we in a context that is potentially constant evaluated per C++20 [expr.const]p12?
static void DiagnoseSelfAssignment(Sema &S, Expr *LHSExpr, Expr *RHSExpr, SourceLocation OpLoc, bool IsBuiltin)
DiagnoseSelfAssignment - Emits a warning if a value is assigned to itself.
static void diagnoseStringPlusInt(Sema &Self, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr)
diagnoseStringPlusInt - Emit a warning when adding an integer to a string literal.
static QualType checkConditionalPointerCompatibility(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc)
Checks compatibility between two pointers and return the resulting type.
static void DoMarkVarDeclReferenced(Sema &SemaRef, SourceLocation Loc, VarDecl *Var, Expr *E, llvm::DenseMap< const VarDecl *, int > &RefsMinusAssignments)
static bool ShouldLookupResultBeMultiVersionOverload(const LookupResult &R)
static bool checkCondition(Sema &S, const Expr *Cond, SourceLocation QuestionLoc)
Return false if the condition expression is valid, true otherwise.
static bool checkForArray(const Expr *E)
static void DiagnosedUnqualifiedCallsToStdFunctions(Sema &S, const CallExpr *Call)
static void DiagnoseRecursiveConstFields(Sema &S, const ValueDecl *VD, const RecordType *Ty, SourceLocation Loc, SourceRange Range, OriginalExprKind OEK, bool &DiagnosticEmitted)
static void MarkExprReferenced(Sema &SemaRef, SourceLocation Loc, Decl *D, Expr *E, bool MightBeOdrUse, llvm::DenseMap< const VarDecl *, int > &RefsMinusAssignments)
static ExprResult convertVector(Expr *E, QualType ElementType, Sema &S)
Convert vector E to a vector with the same number of elements but different element type.
static void DoMarkPotentialCapture(Sema &SemaRef, SourceLocation Loc, ValueDecl *Var, Expr *E)
static void RecordModifiableNonNullParam(Sema &S, const Expr *Exp)
static void EvaluateAndDiagnoseImmediateInvocation(Sema &SemaRef, Sema::ImmediateInvocationCandidate Candidate)
static bool checkThreeWayNarrowingConversion(Sema &S, QualType ToType, Expr *E, QualType FromType, SourceLocation Loc)
static bool IsArithmeticBinaryExpr(const Expr *E, BinaryOperatorKind *Opcode, const Expr **RHSExprs)
IsArithmeticBinaryExpr - Returns true if E is an arithmetic binary expression, either using a built-i...
static ExprResult convertHalfVecBinOp(Sema &S, ExprResult LHS, ExprResult RHS, BinaryOperatorKind Opc, QualType ResultTy, ExprValueKind VK, ExprObjectKind OK, bool IsCompAssign, SourceLocation OpLoc, FPOptionsOverride FPFeatures)
static QualType handleIntegerConversion(Sema &S, ExprResult &LHS, ExprResult &RHS, QualType LHSType, QualType RHSType, bool IsCompAssign)
Handle integer arithmetic conversions.
static void checkDirectCallValidity(Sema &S, const Expr *Fn, FunctionDecl *Callee, MultiExprArg ArgExprs)
static void ConstructTransparentUnion(Sema &S, ASTContext &C, ExprResult &EResult, QualType UnionType, FieldDecl *Field)
Constructs a transparent union from an expression that is used to initialize the transparent union.
static QualType OpenCLConvertScalarsToVectors(Sema &S, ExprResult &LHS, ExprResult &RHS, QualType CondTy, SourceLocation QuestionLoc)
Convert scalar operands to a vector that matches the condition in length.
static bool checkConditionalNullPointer(Sema &S, ExprResult &NullExpr, QualType PointerTy)
Return false if the NullExpr can be promoted to PointerTy, true otherwise.
static void diagnoseSubtractionOnNullPointer(Sema &S, SourceLocation Loc, Expr *Pointer, bool BothNull)
Diagnose invalid subraction on a null pointer.
static NamedDecl * getDeclFromExpr(Expr *E)
static bool checkArithmeticOnObjCPointer(Sema &S, SourceLocation opLoc, Expr *op)
Diagnose if arithmetic on the given ObjC pointer is illegal.
static bool IsInvalidCmseNSCallConversion(Sema &S, QualType FromType, QualType ToType)
static void RemoveNestedImmediateInvocation(Sema &SemaRef, Sema::ExpressionEvaluationContextRecord &Rec, SmallVector< Sema::ImmediateInvocationCandidate, 4 >::reverse_iterator It)
static void DiagnoseBitwiseOpInBitwiseOp(Sema &S, BinaryOperatorKind Opc, SourceLocation OpLoc, Expr *SubExpr)
Look for bitwise op in the left or right hand of a bitwise op with lower precedence and emit a diagno...
static void emitEmptyLookupTypoDiagnostic(const TypoCorrection &TC, Sema &SemaRef, const CXXScopeSpec &SS, DeclarationName Typo, SourceLocation TypoLoc, ArrayRef< Expr * > Args, unsigned DiagnosticID, unsigned DiagnosticSuggestID)
static QualType CheckIncrementDecrementOperand(Sema &S, Expr *Op, ExprValueKind &VK, ExprObjectKind &OK, SourceLocation OpLoc, bool IsInc, bool IsPrefix)
CheckIncrementDecrementOperand - unlike most "Check" methods, this routine doesn't need to call Usual...
static QualType OpenCLArithmeticConversions(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
Simple conversion between integer and floating point types.
static bool checkVectorResult(Sema &S, QualType CondTy, QualType VecResTy, SourceLocation QuestionLoc)
Return false if the vector condition type and the vector result type are compatible.
static void DiagnoseDivisionSizeofPointerOrArray(Sema &S, Expr *LHS, Expr *RHS, SourceLocation Loc)
static void diagnoseTautologicalComparison(Sema &S, SourceLocation Loc, Expr *LHS, Expr *RHS, BinaryOperatorKind Opc)
Diagnose some forms of syntactically-obvious tautological comparison.
static void warnOnSizeofOnArrayDecay(Sema &S, SourceLocation Loc, QualType T, const Expr *E)
Check whether E is a pointer from a decayed array type (the decayed pointer type is equal to T) and e...
static void DiagnoseBadDivideOrRemainderValues(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsDiv)
static void ConvertUTF8ToWideString(unsigned CharByteWidth, StringRef Source, SmallString< 32 > &Target)
static TypoCorrection TryTypoCorrectionForCall(Sema &S, Expr *Fn, FunctionDecl *FDecl, ArrayRef< Expr * > Args)
static bool hasAnyExplicitStorageClass(const FunctionDecl *D)
Determine whether a FunctionDecl was ever declared with an explicit storage class.
static void DiagnoseBadShiftValues(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc, QualType LHSType)
static bool CheckVecStepTraitOperandType(Sema &S, QualType T, SourceLocation Loc, SourceRange ArgRange)
static Sema::AssignConvertType checkBlockPointerTypesForAssignment(Sema &S, QualType LHSType, QualType RHSType)
checkBlockPointerTypesForAssignment - This routine determines whether two block pointer types are com...
static bool unsupportedTypeConversion(const Sema &S, QualType LHSType, QualType RHSType)
Diagnose attempts to convert between __float128, __ibm128 and long double if there is no support for ...
static void MarkVarDeclODRUsed(ValueDecl *V, SourceLocation Loc, Sema &SemaRef, const unsigned *const FunctionScopeIndexToStopAt=nullptr)
Directly mark a variable odr-used.
static void diagnoseStringPlusChar(Sema &Self, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr)
Emit a warning when adding a char literal to a string.
static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S)
CheckForModifiableLvalue - Verify that E is a modifiable lvalue.
static ValueDecl * getPrimaryDecl(Expr *E)
getPrimaryDecl - Helper function for CheckAddressOfOperand().
static void diagnoseUseOfInternalDeclInInlineFunction(Sema &S, const NamedDecl *D, SourceLocation Loc)
Check whether we're in an extern inline function and referring to a variable or function with interna...
static bool funcHasParameterSizeMangling(Sema &S, FunctionDecl *FD)
Return true if this function has a calling convention that requires mangling in the size of the param...
static bool convertPointersToCompositeType(Sema &S, SourceLocation Loc, ExprResult &LHS, ExprResult &RHS)
Returns false if the pointers are converted to a composite type, true otherwise.
static void DiagnoseBinOpPrecedence(Sema &Self, BinaryOperatorKind Opc, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr)
DiagnoseBinOpPrecedence - Emit warnings for expressions with tricky precedence.
static void diagnoseAddressOfInvalidType(Sema &S, SourceLocation Loc, Expr *E, unsigned Type)
Diagnose invalid operand for address of operations.
static QualType handleComplexIntConversion(Sema &S, ExprResult &LHS, ExprResult &RHS, QualType LHSType, QualType RHSType, bool IsCompAssign)
Handle conversions with GCC complex int extension.
static bool isMSPropertySubscriptExpr(Sema &S, Expr *Base)
static bool tryGCCVectorConvertAndSplat(Sema &S, ExprResult *Scalar, ExprResult *Vector)
Attempt to convert and splat Scalar into a vector whose types matches Vector following GCC conversion...
static bool captureInLambda(LambdaScopeInfo *LSI, ValueDecl *Var, SourceLocation Loc, const bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType, const bool RefersToCapturedVariable, const Sema::TryCaptureKind Kind, SourceLocation EllipsisLoc, const bool IsTopScope, Sema &S, bool Invalid)
Capture the given variable in the lambda.
static void DiagnoseLogicalAndInLogicalOrLHS(Sema &S, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr)
Look for '&&' in the left hand of a '||' expr.
static void CheckForNullPointerDereference(Sema &S, Expr *E)
static QualType computeConditionalNullability(QualType ResTy, bool IsBin, QualType LHSTy, QualType RHSTy, ASTContext &Ctx)
Compute the nullability of a conditional expression.
static OdrUseContext isOdrUseContext(Sema &SemaRef)
Are we within a context in which references to resolved functions or to variables result in odr-use?
static void DiagnoseConstAssignment(Sema &S, const Expr *E, SourceLocation Loc)
Emit the "read-only variable not assignable" error and print notes to give more information about why...
static Expr * BuildFloatingLiteral(Sema &S, NumericLiteralParser &Literal, QualType Ty, SourceLocation Loc)
static bool IsTypeModifiable(QualType Ty, bool IsDereference)
static bool isVariableAlreadyCapturedInScopeInfo(CapturingScopeInfo *CSI, ValueDecl *Var, bool &SubCapturesAreNested, QualType &CaptureType, QualType &DeclRefType)
static bool checkArithmeticIncompletePointerType(Sema &S, SourceLocation Loc, Expr *Operand)
Emit error if Operand is incomplete pointer type.
static bool CheckExtensionTraitOperandType(Sema &S, QualType T, SourceLocation Loc, SourceRange ArgRange, UnaryExprOrTypeTrait TraitKind)
static QualType checkSizelessVectorShift(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign)
static QualType checkArithmeticOrEnumeralThreeWayCompare(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc)
static ExprResult diagnoseUnknownAnyExpr(Sema &S, Expr *E)
static SourceLocation getUDSuffixLoc(Sema &S, SourceLocation TokLoc, unsigned Offset)
getUDSuffixLoc - Create a SourceLocation for a ud-suffix, given the location of the token and the off...
static bool checkBlockType(Sema &S, const Expr *E)
Return true if the Expr is block type.
static bool captureInBlock(BlockScopeInfo *BSI, ValueDecl *Var, SourceLocation Loc, const bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType, const bool Nested, Sema &S, bool Invalid)
static QualType handleFloatConversion(Sema &S, ExprResult &LHS, ExprResult &RHS, QualType LHSType, QualType RHSType, bool IsCompAssign)
Handle arithmethic conversion with floating point types.
static void diagnoseArithmeticOnVoidPointer(Sema &S, SourceLocation Loc, Expr *Pointer)
Diagnose invalid arithmetic on a void pointer.
static QualType checkVectorShift(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign)
Return the resulting type when a vector is shifted by a scalar or vector shift amount.
static void diagnoseUncapturableValueReferenceOrBinding(Sema &S, SourceLocation loc, ValueDecl *var)
ExprResult PerformCastFn(Sema &S, Expr *operand, QualType toType)
static void checkArithmeticNull(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompare)
static bool IsReadonlyMessage(Expr *E, Sema &S)
static void buildLambdaCaptureFixit(Sema &Sema, LambdaScopeInfo *LSI, ValueDecl *Var)
Create up to 4 fix-its for explicit reference and value capture of Var or default capture.
static void tryImplicitlyCaptureThisIfImplicitMemberFunctionAccessWithDependentArgs(Sema &S, const UnresolvedMemberExpr *const UME, SourceLocation CallLoc)
static Sema::AssignConvertType checkPointerTypesForAssignment(Sema &S, QualType LHSType, QualType RHSType, SourceLocation Loc)
static bool CheckVectorElementsTraitOperandType(Sema &S, QualType T, SourceLocation Loc, SourceRange ArgRange)
static void DiagnoseLogicalAndInLogicalOrRHS(Sema &S, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr)
Look for '&&' in the right hand of a '||' expr.
static QualType getDependentArraySubscriptType(Expr *LHS, Expr *RHS, const ASTContext &Ctx)
static void checkEnumArithmeticConversions(Sema &S, Expr *LHS, Expr *RHS, SourceLocation Loc, Sema::ArithConvKind ACK)
Check that the usual arithmetic conversions can be performed on this pair of expressions that might b...
static void diagnosePointerIncompatibility(Sema &S, SourceLocation Loc, Expr *LHSExpr, Expr *RHSExpr)
Emit error when two pointers are incompatible.
static bool enclosingClassIsRelatedToClassInWhichMembersWereFound(const UnresolvedMemberExpr *const UME, Sema &S)
static unsigned GetFixedPointRank(QualType Ty)
Return the rank of a given fixed point or integer type.
static bool CheckObjCTraitOperandConstraints(Sema &S, QualType T, SourceLocation Loc, SourceRange ArgRange, UnaryExprOrTypeTrait TraitKind)
static void diagnoseArithmeticOnTwoFunctionPointers(Sema &S, SourceLocation Loc, Expr *LHS, Expr *RHS)
Diagnose invalid arithmetic on two function pointers.
static bool checkPointerIntegerMismatch(Sema &S, ExprResult &Int, Expr *PointerExpr, SourceLocation Loc, bool IsIntFirstExpr)
Return false if the first expression is not an integer and the second expression is not a pointer,...
static ImplicitConversionKind castKindToImplicitConversionKind(CastKind CK)
static void diagnoseXorMisusedAsPow(Sema &S, const ExprResult &XorLHS, const ExprResult &XorRHS, const SourceLocation Loc)
static bool checkOpenCLConditionVector(Sema &S, Expr *Cond, SourceLocation QuestionLoc)
Return false if this is a valid OpenCL condition vector.
static bool IsArithmeticOp(BinaryOperatorKind Opc)
static bool handleComplexIntegerToFloatConversion(Sema &S, ExprResult &IntExpr, ExprResult &ComplexExpr, QualType IntTy, QualType ComplexTy, bool SkipCast)
Convert complex integers to complex floats and real integers to real floats as required for complex a...
static std::pair< ExprResult, ExprResult > CorrectDelayedTyposInBinOp(Sema &S, BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr)
static void checkObjCPointerIntrospection(Sema &S, ExprResult &L, ExprResult &R, SourceLocation OpLoc)
Check if a bitwise-& is performed on an Objective-C pointer.
static void DiagnoseDirectIsaAccess(Sema &S, const ObjCIvarRefExpr *OIRE, SourceLocation AssignLoc, const Expr *RHS)
static ExprResult rebuildUnknownAnyFunction(Sema &S, Expr *fn)
Given a function expression of unknown-any type, try to rebuild it to have a function type.
static QualType handleIntToFloatConversion(Sema &S, ExprResult &FloatExpr, ExprResult &IntExpr, QualType FloatTy, QualType IntTy, bool ConvertFloat, bool ConvertInt)
Handle arithmetic conversion from integer to float.
static bool hasIsEqualMethod(Sema &S, const Expr *LHS, const Expr *RHS)
static QualType handleComplexFloatConversion(Sema &S, ExprResult &Shorter, QualType ShorterType, QualType LongerType, bool PromotePrecision)
static FunctionDecl * rewriteBuiltinFunctionDecl(Sema *Sema, ASTContext &Context, FunctionDecl *FDecl, MultiExprArg ArgExprs)
If a builtin function has a pointer argument with no explicit address space, then it should be able t...
static void DoMarkBindingDeclReferenced(Sema &SemaRef, SourceLocation Loc, BindingDecl *BD, Expr *E)
static PredefinedIdentKind getPredefinedExprKind(tok::TokenKind Kind)
static void DiagnoseUnusedOfDecl(Sema &S, NamedDecl *D, SourceLocation Loc)
static QualType handleFixedPointConversion(Sema &S, QualType LHSTy, QualType RHSTy)
handleFixedPointConversion - Fixed point operations between fixed point types and integers or other f...
static QualType handleComplexConversion(Sema &S, ExprResult &LHS, ExprResult &RHS, QualType LHSType, QualType RHSType, bool IsCompAssign)
Handle arithmetic conversion with complex types.
static QualType CheckCommaOperands(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc)
static bool canCaptureVariableByCopy(ValueDecl *Var, const ASTContext &Context)
static void diagnoseArithmeticOnTwoVoidPointers(Sema &S, SourceLocation Loc, Expr *LHSExpr, Expr *RHSExpr)
Diagnose invalid arithmetic on two void pointers.
static void diagnoseDistinctPointerComparison(Sema &S, SourceLocation Loc, ExprResult &LHS, ExprResult &RHS, bool IsError)
Diagnose bad pointer comparisons.
static bool needsConversionOfHalfVec(bool OpRequiresConversion, ASTContext &Ctx, Expr *E0, Expr *E1=nullptr)
Returns true if conversion between vectors of halfs and vectors of floats is needed.
static bool isObjCObjectLiteral(ExprResult &E)
static NonConstCaptureKind isReferenceToNonConstCapture(Sema &S, Expr *E)
static QualType checkConditionalBlockPointerCompatibility(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc)
Return the resulting type when the operands are both block pointers.
static void DiagnoseShiftCompare(Sema &S, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr)
static void DiagnoseAdditionInShift(Sema &S, SourceLocation OpLoc, Expr *SubExpr, StringRef Shift)
static void diagnoseFunctionPointerToVoidComparison(Sema &S, SourceLocation Loc, ExprResult &LHS, ExprResult &RHS, bool IsError)
static void EmitDiagnosticForLogicalAndInLogicalOr(Sema &Self, SourceLocation OpLoc, BinaryOperator *Bop)
It accepts a '&&' expr that is inside a '||' one.
static void captureVariablyModifiedType(ASTContext &Context, QualType T, CapturingScopeInfo *CSI)
static bool canConvertIntToOtherIntTy(Sema &S, ExprResult *Int, QualType OtherIntTy)
Test if a (constant) integer Int can be casted to another integer type IntTy without losing precision...
static DeclContext * getParentOfCapturingContextOrNull(DeclContext *DC, ValueDecl *Var, SourceLocation Loc, const bool Diagnose, Sema &S)
static bool isOverflowingIntegerType(ASTContext &Ctx, QualType T)
static void CheckIdentityFieldAssignment(Expr *LHSExpr, Expr *RHSExpr, SourceLocation Loc, Sema &Sema)
static bool isLegalBoolVectorBinaryOp(BinaryOperatorKind Opc)
static ExprResult rebuildPotentialResultsAsNonOdrUsed(Sema &S, Expr *E, NonOdrUseReason NOUR)
Walk the set of potential results of an expression and mark them all as non-odr-uses if they satisfy ...
static void CheckCompleteParameterTypesForMangler(Sema &S, FunctionDecl *FD, SourceLocation Loc)
Require that all of the parameter types of function be complete.
static bool isScopedEnumerationType(QualType T)
static bool checkArithmeticBinOpPointerOperands(Sema &S, SourceLocation Loc, Expr *LHSExpr, Expr *RHSExpr)
Check the validity of a binary arithmetic operation w.r.t.
static bool breakDownVectorType(QualType type, uint64_t &len, QualType &eltType)
static bool isInvalid(LocType Loc, bool *Invalid)
Defines the SourceManager interface.
Defines various enumerations that describe declaration and type specifiers.
Defines the clang::TypeLoc interface and its subclasses.
Defines enumerations for the type traits support.
C Language Family Type Representation.
@ Open
The standard open() call: int open(const char *path, int oflag, ...);.
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
std::string getAsString(const ASTContext &Ctx, QualType Ty) const
virtual void HandleCXXImplicitFunctionInstantiation(FunctionDecl *D)
Invoked when a function is implicitly instantiated.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
BuiltinVectorTypeInfo getBuiltinVectorTypeInfo(const BuiltinType *VecTy) const
Returns the element type, element count and number of vectors (in case of tuple) for a builtin vector...
TranslationUnitDecl * getTranslationUnitDecl() const
const ConstantArrayType * getAsConstantArrayType(QualType T) const
bool areLaxCompatibleSveTypes(QualType FirstType, QualType SecondType)
Return true if the given vector types are lax-compatible SVE vector types, false otherwise.
CanQualType ARCUnbridgedCastTy
unsigned getIntWidth(QualType T) const
QualType getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType) const
bool areCompatibleRVVTypes(QualType FirstType, QualType SecondType)
Return true if the given types are an RISC-V vector builtin type and a VectorType that is a fixed-len...
const llvm::fltSemantics & getFloatTypeSemantics(QualType T) const
Return the APFloat 'semantics' for the specified scalar floating point type.
QualType areCommonBaseCompatible(const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT)
QualType getBlockPointerType(QualType T) const
Return the uniqued reference to the type for a block of the specified type.
bool ObjCQualifiedIdTypesAreCompatible(const ObjCObjectPointerType *LHS, const ObjCObjectPointerType *RHS, bool ForCompare)
ObjCQualifiedIdTypesAreCompatible - We know that one of lhs/rhs is an ObjCQualifiedIDType.
QualType getMemberPointerType(QualType T, const Type *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
QualType getBuiltinVaListType() const
Retrieve the type of the __builtin_va_list type.
DeclarationNameTable DeclarationNames
int getIntegerTypeOrder(QualType LHS, QualType RHS) const
Return the highest ranked integer type, see C99 6.3.1.8p1.
QualType getRecordType(const RecordDecl *Decl) const
QualType getScalableVectorType(QualType EltTy, unsigned NumElts, unsigned NumFields=1) const
Return the unique reference to a scalable vector type of the specified element type and scalable numb...
QualType getBuiltinMSVaListType() const
Retrieve the type of the __builtin_ms_va_list type.
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like 'int()'.
QualType getCorrespondingSignedFixedPointType(QualType Ty) const
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
QualType getVectorType(QualType VectorType, unsigned NumElts, VectorKind VecKind) const
Return the unique reference to a vector type of the specified element type and size.
CanQualType OMPArrayShapingTy
QualType getObjCSelRedefinitionType() const
Retrieve the type that 'SEL' has been defined to, which may be different from the built-in 'SEL' if '...
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
bool canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT)
canAssignObjCInterfaces - Return true if the two interface types are compatible for assignment from R...
QualType getReferenceQualifiedType(const Expr *e) const
getReferenceQualifiedType - Given an expr, will return the type for that expression,...
bool isObjCSelType(QualType T) const
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.
CanQualType OMPIteratorTy
Builtin::Context & BuiltinInfo
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, const Expr *SizeExpr, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type.
const LangOptions & getLangOpts() const
bool areLaxCompatibleRVVTypes(QualType FirstType, QualType SecondType)
Return true if the given vector types are lax-compatible RISC-V vector types as defined by -flax-vect...
TypedefDecl * getBOOLDecl() const
Retrieve declaration of 'BOOL' typedef.
bool typesAreBlockPointerCompatible(QualType, QualType)
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
QualType getPointerDiffType() const
Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.
void setBOOLDecl(TypedefDecl *TD)
Save declaration of 'BOOL' typedef.
int getFloatingTypeOrder(QualType LHS, QualType RHS) const
Compare the rank of the two specified floating point types, ignoring the domain of the type (i....
QualType getIntTypeForBitwidth(unsigned DestWidth, unsigned Signed) const
getIntTypeForBitwidth - sets integer QualTy according to specified details: bitwidth,...
GVALinkage GetGVALinkageForFunction(const FunctionDecl *FD) const
CanQualType UnsignedLongTy
llvm::DenseSet< const FunctionDecl * > CUDAImplicitHostDeviceFunUsedByDevice
Keep track of CUDA/HIP implicit host device functions used on device side in device compilation.
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
TypeInfo getTypeInfo(const Type *T) const
Get the size and alignment of the specified complete type in bits.
QualType getStringLiteralArrayType(QualType EltTy, unsigned Length) const
Return a type for a constant array for a string literal of the specified element type and length.
QualType getCorrespondingSaturatedType(QualType Ty) const
QualType getBOOLType() const
type of 'BOOL' type.
CanQualType BoundMemberTy
QualType removeAddrSpaceQualType(QualType T) const
Remove any existing address space on the type and returns the type with qualifiers intact (or that's ...
llvm::DenseSet< const VarDecl * > CUDADeviceVarODRUsedByHost
Keep track of CUDA/HIP device-side variables ODR-used by host code.
CanQualType PseudoObjectTy
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
bool areComparableObjCPointerTypes(QualType LHS, QualType RHS)
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
CanQualType ObjCBuiltinBoolTy
llvm::FixedPointSemantics getFixedPointSemantics(QualType Ty) const
QualType mergeTypes(QualType, QualType, bool OfBlockPointer=false, bool Unqualified=false, bool BlockReturnType=false, bool IsConditionalOperator=false)
static bool isObjCNSObjectType(QualType Ty)
Return true if this is an NSObject object with its NSObject attribute set.
QualType getObjCIdType() const
Represents the Objective-CC id type.
llvm::DenseSet< const ValueDecl * > CUDAExternalDeviceDeclODRUsedByHost
Keep track of CUDA/HIP external kernels or device variables ODR-used by host code.
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
CanQualType UnsignedCharTy
CanQualType UnsignedIntTy
TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const
Allocate an uninitialized TypeSourceInfo.
QualType getObjCClassRedefinitionType() const
Retrieve the type that Class has been defined to, which may be different from the built-in Class if C...
CanQualType UnsignedLongLongTy
QualType getCommonSugaredType(QualType X, QualType Y, bool Unqualified=false)
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
QualType getObjCIdRedefinitionType() const
Retrieve the type that id has been defined to, which may be different from the built-in id if id has ...
QualType getPromotedIntegerType(QualType PromotableType) const
Return the type that PromotableType will promote to: C99 6.3.1.1p2, assuming that PromotableType is a...
llvm::APFixedPoint getFixedPointMax(QualType Ty) const
QualType getComplexType(QualType T) const
Return the uniqued reference to the type for a complex number with the specified element type.
bool areCompatibleSveTypes(QualType FirstType, QualType SecondType)
Return true if the given types are an SVE builtin and a VectorType that is a fixed-length representat...
bool hasDirectOwnershipQualifier(QualType Ty) const
Return true if the type has been explicitly qualified with ObjC ownership.
QualType getExtVectorType(QualType VectorType, unsigned NumElts) const
Return the unique reference to an extended vector type of the specified element type and size.
bool areCompatibleVectorTypes(QualType FirstVec, QualType SecondVec)
Return true if the given vector types are of the same unqualified type or if they are equivalent to t...
DeclarationNameInfo getNameForTemplate(TemplateName Name, SourceLocation NameLoc) const
const TargetInfo & getTargetInfo() const
CanQualType IncompleteMatrixIdxTy
std::optional< CharUnits > getTypeSizeInCharsIfKnown(QualType Ty) const
QualType getCorrespondingUnsignedType(QualType T) const
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
QualType getCorrespondingSignedType(QualType T) const
unsigned getTargetAddressSpace(LangAS AS) const
QualType getWideCharType() const
Return the type of wide characters.
bool isPromotableIntegerType(QualType T) const
More type predicates useful for type checking/promotion.
CanQualType getSignedSizeType() const
Return the unique signed counterpart of the integer type corresponding to size_t.
QualType getLogicalOperationType() const
The result type of logical operations, '<', '>', '!=', etc.
unsigned char getFixedPointScale(QualType Ty) const
QualType adjustStringLiteralBaseType(QualType StrLTy) const
bool hasCvrSimilarType(QualType T1, QualType T2)
Determine if two types are similar, ignoring only CVR qualifiers.
bool isDependenceAllowed() const
QualType getConstantMatrixType(QualType ElementType, unsigned NumRows, unsigned NumColumns) const
Return the unique reference to the matrix type of the specified element type and size.
QualType isPromotableBitField(Expr *E) const
Whether this is a promotable bitfield reference according to C99 6.3.1.1p2, bullet 2 (and GCC extensi...
bool isSentinelNullExpr(const Expr *E)
CanQualType OMPArraySectionTy
uint64_t getCharWidth() const
Return the size of the character type, in bits.
QualType getBitIntType(bool Unsigned, unsigned NumBits) const
Return a bit-precise integer type with the specified signedness and bit count.
AddrLabelExpr - The GNU address of label extension, representing &&label.
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
SourceLocation getExprLoc() const LLVM_READONLY
Wrapper for source info for arrays.
Represents an array type, per C99 6.7.5.2 - Array Declarators.
ArraySizeModifier getSizeModifier() const
QualType getElementType() const
AsTypeExpr - Clang builtin function __builtin_astype [OpenCL 6.2.4.2] This AST node provides support ...
Attr - This represents one attribute.
SourceRange getRange() const
static Kind getNullabilityAttrKind(NullabilityKind kind)
Retrieve the attribute kind corresponding to the given nullability kind.
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
One specifier in an @available expression.
StringRef getPlatform() const
VersionTuple getVersion() 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".
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)
Retrieve the overloaded operator kind that corresponds to the given binary opcode.
static bool isComparisonOp(Opcode Opc)
bool isComparisonOp() const
StringRef getOpcodeStr() const
bool isRelationalOp() const
SourceLocation getOperatorLoc() const
bool isCompoundAssignmentOp() const
bool isMultiplicativeOp() const
static StringRef getOpcodeStr(Opcode Op)
getOpcodeStr - Turn an Opcode enum value into the punctuation char it corresponds to,...
bool isEqualityOp() const
static BinaryOperator * Create(const ASTContext &C, Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy, ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc, FPOptionsOverride FPFeatures)
bool isAdditiveOp() const
static bool isNullPointerArithmeticExtension(ASTContext &Ctx, Opcode Opc, const Expr *LHS, const Expr *RHS)
Return true if a binary operator using the specified opcode and operands would match the 'p = (i8*)nu...
bool isAssignmentOp() const
static Opcode getOverloadedOpcode(OverloadedOperatorKind OO)
Retrieve the binary opcode that corresponds to the given overloaded operator.
static bool isBitwiseOp(Opcode Opc)
A binding in a decomposition declaration.
A class which contains all the information about a particular captured value.
Represents a block literal declaration, which is like an unnamed FunctionDecl.
void setParams(ArrayRef< ParmVarDecl * > NewParamInfo)
void setSignatureAsWritten(TypeSourceInfo *Sig)
void setBlockMissingReturnType(bool val=true)
void setIsVariadic(bool value)
SourceLocation getCaretLocation() const
void setBody(CompoundStmt *B)
ArrayRef< ParmVarDecl * > parameters() const
void setCaptures(ASTContext &Context, ArrayRef< Capture > Captures, bool CapturesCXXThis)
static BlockDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L)
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
This class is used for builtin types like 'int'.
bool hasPtrArgsOrResult(unsigned ID) const
Determines whether this builtin has a result or any arguments which are pointer types.
llvm::StringRef getName(unsigned ID) const
Return the identifier name for the specified builtin, e.g.
bool hasCustomTypechecking(unsigned ID) const
Determines whether this builtin has custom typechecking.
bool isInStdNamespace(unsigned ID) const
Determines whether this builtin is a C++ standard library function that lives in (possibly-versioned)...
bool isDirectlyAddressable(unsigned ID) const
Determines whether this builtin can have its address taken with no special action required.
static CUDAKernelCallExpr * Create(const ASTContext &Ctx, Expr *Fn, CallExpr *Config, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation RP, FPOptionsOverride FPFeatures, unsigned MinNumArgs=0)
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 call to a C++ constructor.
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
Represents a C++ constructor within a class.
Represents a C++ conversion function within a class.
bool isLambdaToBlockPointerConversion() const
Determine whether this conversion function is a conversion from a lambda closure type to a block poin...
Represents a C++ base or member initializer.
A default argument (C++ [dcl.fct.default]).
static CXXDefaultArgExpr * Create(const ASTContext &C, SourceLocation Loc, ParmVarDecl *Param, Expr *RewrittenExpr, DeclContext *UsedContext)
A use of a default initializer in a constructor or in aggregate initialization.
static CXXDefaultInitExpr * Create(const ASTContext &Ctx, SourceLocation Loc, FieldDecl *Field, DeclContext *UsedContext, Expr *RewrittenInitExpr)
Field is the non-static data member whose default initializer is used by this expression.
Expr * getExpr()
Get the initialization expression that will be used.
static CXXDependentScopeMemberExpr * Create(const ASTContext &Ctx, Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs)
Represents a C++ destructor within a class.
Represents a static or instance method of a struct/union/class.
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
CXXMethodDecl * getDevirtualizedMethod(const Expr *Base, bool IsAppleKext)
If it's possible to devirtualize a call to this method, return the called function.
A call to an overloaded operator written using operator syntax.
SourceLocation getOperatorLoc() const
Returns the location of the operator symbol in the expression.
SourceRange getSourceRange() const
Represents a C++ struct/union/class.
bool isStandardLayout() const
Determine whether this class is standard-layout per C++ [class]p7.
bool hasAnyDependentBases() const
Determine whether this class has any dependent base classes which are not the current instantiation.
unsigned getNumBases() const
Retrieves the number of base classes of this class.
const CXXRecordDecl * getTemplateInstantiationPattern() const
Retrieve the record declaration from which this record could be instantiated.
bool hasDefinition() const
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
bool isDerivedFrom(const CXXRecordDecl *Base) const
Determine whether this class is derived from the class Base.
Represents a C++ nested-name-specifier or a global scope specifier.
bool isValid() const
A scope specifier is present, and it refers to a real scope.
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
SourceRange getRange() const
SourceLocation getBeginLoc() const
bool isSet() const
Deprecated.
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context.
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
bool isInvalid() const
An error occurred during parsing of the scope specifier.
bool isEmpty() const
No scope specifier.
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
Represents the this expression in C++.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
void setArg(unsigned Arg, Expr *ArgExpr)
setArg - Set the specified argument.
static CallExpr * Create(const ASTContext &Ctx, Expr *Fn, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation RParenLoc, FPOptionsOverride FPFeatures, unsigned MinNumArgs=0, ADLCallKind UsesADL=NotADL)
Create a call expression.
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return null.
void computeDependence()
Compute and set dependence bits.
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
Expr ** getArgs()
Retrieve the call arguments.
void setNumArgsUnsafe(unsigned NewNumArgs)
Bluntly set a new number of arguments without doing any checks whatsoever.
void shrinkNumArgs(unsigned NewNumArgs)
Reduce the number of arguments in this call expression.
QualType withConst() const
Retrieves a version of this type with const applied.
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
CastKind getCastKind() const
const char * getCastKindName() const
CharLiteralParser - Perform interpretation and semantic analysis of a character literal.
Represents a character-granular source range.
static CharSourceRange getCharRange(SourceRange R)
static CharSourceRange getTokenRange(SourceRange R)
CharUnits - This is an opaque type for sizes expressed in character units.
bool isZero() const
isZero - Test whether the quantity equals zero.
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
unsigned getValue() const
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
void mergeFrom(CleanupInfo Rhs)
void setExprNeedsCleanups(bool SideEffects)
bool cleanupsHaveSideEffects() const
bool exprNeedsCleanups() const
Complex values, per C99 6.2.5p11.
QualType getElementType() const
static CompoundAssignOperator * Create(const ASTContext &C, Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy, ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc, FPOptionsOverride FPFeatures, QualType CompLHSType=QualType(), QualType CompResultType=QualType())
CompoundLiteralExpr - [C99 6.5.2.5].
CompoundStmt - This represents a group of statements like { stmt stmt }.
Stmt * getStmtExprResult()
ConditionalOperator - The ?: ternary operator.
Represents the canonical version of C arrays with a specified constant size.
const llvm::APInt & getSize() const
ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluatin...
static ConstantResultStorageKind getStorageKind(const APValue &Value)
void MoveIntoResult(APValue &Value, const ASTContext &Context)
SourceLocation getBeginLoc() const LLVM_READONLY
static ConstantExpr * Create(const ASTContext &Context, Expr *E, const APValue &Result)
bool isImmediateInvocation() const
Represents a concrete matrix type with constant number of rows and columns.
unsigned getNumColumns() const
Returns the number of columns in the matrix.
unsigned getNumRows() const
Returns the number of rows in the matrix.
The result of a constraint satisfaction check, containing the necessary information to diagnose an un...
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
void setTypoName(const IdentifierInfo *II)
void setTypoNNS(NestedNameSpecifier *NNS)
Wrapper for source info for pointers decayed from arrays and functions.
A POD class for pairing a NamedDecl* with an access specifier.
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
The results of name lookup within a DeclContext.
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 Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC.
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
const BlockDecl * getInnermostBlockDecl() const
Return this DeclContext if it is a BlockDecl.
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
void addDecl(Decl *D)
Add the declaration D into this context.
bool containsDecl(Decl *D) const
Checks whether a declaration is in this context.
RecordDecl * getOuterLexicalRecordContext()
Retrieve the outermost lexically enclosing record context.
bool isFunctionOrMethod() const
DeclContext * getLookupParent()
Find the parent context of this context that will be used for unqualified name lookup.
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
A reference to a declared variable, function, enum, etc.
NamedDecl * getFoundDecl()
Get the NamedDecl through which this reference occurred.
bool hasExplicitTemplateArgs() const
Determines whether this declaration reference was followed by an explicit template argument list.
bool refersToEnclosingVariableOrCapture() const
Does this DeclRefExpr refer to an enclosing local or a captured variable?
void setDecl(ValueDecl *NewD)
void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const
Copies the template arguments (if present) into the given structure.
SourceLocation getBeginLoc() const LLVM_READONLY
DeclarationNameInfo getNameInfo() const
SourceLocation getTemplateKeywordLoc() const
Retrieve the location of the template keyword preceding this name, if any.
static DeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, QualType T, ExprValueKind VK, NamedDecl *FoundD=nullptr, const TemplateArgumentListInfo *TemplateArgs=nullptr, NonOdrUseReason NOUR=NOUR_None)
bool hasQualifier() const
Determine whether this declaration reference was preceded by a C++ nested-name-specifier,...
NestedNameSpecifierLoc getQualifierLoc() const
If the name was qualified, retrieves the nested-name-specifier that precedes the name,...
SourceLocation getLocation() const
NestedNameSpecifier * getQualifier() const
If the name was qualified, retrieves the nested-name-specifier that precedes the name.
Decl - This represents one declaration (or definition), e.g.
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
AvailabilityResult getAvailability(std::string *Message=nullptr, VersionTuple EnclosingVersion=VersionTuple(), StringRef *RealizedPlatform=nullptr) const
Determine the availability of the given declaration.
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.
bool isInvalidDecl() const
SourceLocation getLocation() const
void setReferenced(bool R=true)
bool isDefinedOutsideFunctionOrMethod() const
isDefinedOutsideFunctionOrMethod - This predicate returns true if this scoped decl is defined outside...
DeclContext * getDeclContext()
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
The name of a declaration.
IdentifierInfo * getAsIdentifierInfo() const
Retrieve the IdentifierInfo * stored in this declaration name, or null if this declaration name isn't...
bool isDependentName() const
Determines whether the name itself is dependent, e.g., because it involves a C++ type that is itself ...
std::string getAsString() const
Retrieve the human-readable string for this name.
@ CXXConversionFunctionName
bool isIdentifier() const
Predicate functions for querying what type of name this is.
SourceLocation getBeginLoc() const LLVM_READONLY
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier (with source-location information) that qualifies the name of this...
TypeSourceInfo * getTypeSourceInfo() const
Information about one declarator, including the parsed type information and the identifier.
DeclaratorContext getContext() const
SourceLocation getBeginLoc() const LLVM_READONLY
IdentifierInfo * getIdentifier() const
bool isInvalidType() const
static DependentScopeDeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
bool getSuppressSystemWarnings() const
void setElaboratedKeywordLoc(SourceLocation Loc)
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
RAII object that enters a new expression evaluation context.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
EnumDecl * getDecl() const
ExplicitCastExpr - An explicit cast written in the source code.
QualType getTypeAsWritten() const
getTypeAsWritten - Returns the type that this expression is casting to, as written in the source code...
static ExprWithCleanups * Create(const ASTContext &C, EmptyShell empty, unsigned numObjects)
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,...
Expr * IgnoreParenNoopCasts(const ASTContext &Ctx) LLVM_READONLY
Skip past any parentheses and casts which do not change the value (including ptr->int casts of the sa...
isModifiableLvalueResult isModifiableLvalue(ASTContext &Ctx, SourceLocation *Loc=nullptr) const
isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type, does not have an incomplet...
static QualType findBoundMemberType(const Expr *expr)
Given an expression of bound-member type, find the type of the member.
llvm::APSInt EvaluateKnownConstIntCheckOverflow(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
Expr * IgnoreParenCasts() LLVM_READONLY
Skip past any parentheses and casts which might surround this expression until reaching a fixed point...
LValueClassification ClassifyLValue(ASTContext &Ctx) const
Reasons why an expression might not be an l-value.
bool isValueDependent() const
Determines whether the value of this expression depends on.
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
bool containsUnexpandedParameterPack() const
Whether this expression contains an unexpanded parameter pack (for C++11 variadic templates).
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Expr * IgnoreImplicit() LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.
Expr * IgnoreConversionOperatorSingleStep() LLVM_READONLY
Skip conversion operators.
bool containsErrors() const
Whether this expression contains subexpressions which had errors, e.g.
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language.
static bool hasAnyTypeDependentArguments(ArrayRef< Expr * > Exprs)
hasAnyTypeDependentArguments - Determines if any of the expressions in Exprs is type-dependent.
@ NPC_ValueDependentIsNull
Specifies that a value-dependent expression of integral or dependent type should be considered a null...
@ NPC_NeverValueDependent
Specifies that the expression should never be value-dependent.
@ NPC_ValueDependentIsNotNull
Specifies that a value-dependent expression should be considered to never be a null pointer constant.
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...
bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const
HasSideEffects - This routine returns true for all those expressions which have any effect other than...
bool EvaluateAsConstantExpr(EvalResult &Result, const ASTContext &Ctx, ConstantExprKind Kind=ConstantExprKind::Normal) const
Evaluate an expression that is required to be a constant expression.
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.
NullPointerConstantKind
Enumeration used to describe the kind of Null pointer constant returned from isNullPointerConstant().
@ NPCK_ZeroExpression
Expression is a Null pointer constant built from a zero integer expression that is not a simple,...
@ NPCK_ZeroLiteral
Expression is a Null pointer constant built from a literal zero.
@ NPCK_CXX11_nullptr
Expression is a C++11 nullptr.
@ NPCK_NotNull
Expression is not a Null pointer constant.
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant.
QualType getEnumCoercedType(const ASTContext &Ctx) const
If this expression is an enumeration constant, return the enumeration type under which said constant ...
void setValueKind(ExprValueKind Cat)
setValueKind - Set the value kind produced by this expression.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
static bool isSameComparisonOperand(const Expr *E1, const Expr *E2)
Checks that the two Expr's will refer to the same value as a comparison operand.
void setObjectKind(ExprObjectKind Cat)
setObjectKind - Set the object kind produced by this expression.
std::optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.
bool refersToBitField() const
Returns true if this expression is a gl-value that potentially refers to a bit-field.
@ MLV_DuplicateVectorComponents
@ MLV_InvalidMessageExpression
@ MLV_ConstQualifiedField
@ MLV_SubObjCPropertySetting
bool isOrdinaryOrBitFieldObject() const
bool hasPlaceholderType() const
Returns whether this expression has a placeholder type.
static ExprValueKind getValueKindForType(QualType T)
getValueKindForType - Given a formal return or parameter type, give its value kind.
bool isKnownToHaveBooleanValue(bool Semantic=true) const
isKnownToHaveBooleanValue - Return true if this is an integer expression that is known to return 0 or...
ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the ...
ExtVectorType - Extended vector type.
Represents difference between two FPOptions values.
bool isFPConstrained() const
Represents a member of a struct/union/class.
bool isBitField() const
Determines whether this field is a bitfield.
bool hasInClassInitializer() const
Determine whether this member has a C++11 default member initializer.
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined.
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
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.
static FixedPointLiteral * CreateFromRawInt(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l, unsigned Scale)
static FloatingLiteral * Create(const ASTContext &C, const llvm::APFloat &V, bool isexact, QualType Type, SourceLocation L)
FullExpr - Represents a "full-expression" node.
const Expr * getSubExpr() const
bool ValidateCandidate(const TypoCorrection &candidate) override
Simple predicate used by the default RankCandidate to determine whether to return an edit distance of...
Represents a function declaration or definition.
const ParmVarDecl * getParamDecl(unsigned i) const
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to call this function.
bool isImmediateFunction() const
SourceRange getReturnTypeSourceRange() const
Attempt to compute an informative source range covering the function return type.
unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const
Returns a value indicating whether this function corresponds to a builtin function.
bool hasCXXExplicitFunctionObjectParameter() const
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
QualType getReturnType() const
ArrayRef< ParmVarDecl * > parameters() const
bool hasPrototype() const
Whether this function has a prototype, either because one was explicitly written or because it was "i...
bool isExternC() const
Determines whether this function is a function with external, C linkage.
static FunctionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation NLoc, DeclarationName N, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin=false, bool isInlineSpecified=false, bool hasWrittenPrototype=true, ConstexprSpecKind ConstexprKind=ConstexprSpecKind::Unspecified, Expr *TrailingRequiresClause=nullptr)
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.
size_t param_size() const
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body.
SourceRange getParametersSourceRange() const
Attempt to compute an informative source range covering the function parameters, including the ellips...
QualType getCallResultType() const
Determine the type of an expression that calls this function.
Represents a reference to a function parameter pack or init-capture pack that has been substituted bu...
SourceLocation getParameterPackLocation() const
Get the location of the parameter pack.
Represents a prototype with parameter type info, e.g.
ExtParameterInfo getExtParameterInfo(unsigned I) const
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
bool isParamConsumed(unsigned I) const
unsigned getNumParams() const
QualType getParamType(unsigned i) const
bool isVariadic() const
Whether this function prototype is variadic.
ExtProtoInfo getExtProtoInfo() const
ArrayRef< QualType > getParamTypes() const
ArrayRef< QualType > param_types() const
Declaration of a template function.
unsigned getNumParams() const
ParmVarDecl * getParam(unsigned i) const
SourceLocation getLocalRangeEnd() const
TypeLoc getReturnLoc() const
SourceLocation getLocalRangeBegin() const
A class which abstracts out some details necessary for making a call.
bool getCmseNSCall() const
ExtInfo withNoReturn(bool noReturn) const
FunctionType - C99 6.7.5.3 - Function Declarators.
ExtInfo getExtInfo() const
bool getNoReturnAttr() const
Determine whether this function type includes the GNU noreturn attribute.
QualType getReturnType() const
bool getCmseNSCallAttr() const
QualType getCallResultType(const ASTContext &Context) const
Determine the type of an expression that calls a function of this type.
GNUNullExpr - Implements the GNU __null extension, which is a name for a null pointer constant that h...
static GenericSelectionExpr * Create(const ASTContext &Context, SourceLocation GenericLoc, Expr *ControllingExpr, ArrayRef< TypeSourceInfo * > AssocTypes, ArrayRef< Expr * > AssocExprs, SourceLocation DefaultLoc, SourceLocation RParenLoc, bool ContainsUnexpandedParameterPack, unsigned ResultIndex)
Create a non-result-dependent generic selection expression accepting an expression predicate.
One of these records is kept for each identifier that is lexed.
tok::TokenKind getTokenID() const
If this is a source-language token (e.g.
bool isEditorPlaceholder() const
Return true if this identifier is an editor placeholder.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
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)
ImplicitConversionSequence - Represents an implicit conversion sequence, which may be a standard conv...
Represents a field injected from an anonymous union/struct into the parent scope.
Describes an C or C++ initializer list.
Describes the kind of initialization being performed, along with location information for tokens rela...
static InitializationKind CreateCopy(SourceLocation InitLoc, SourceLocation EqualLoc, bool AllowExplicitConvs=false)
Create a copy initialization.
static InitializationKind CreateDirectList(SourceLocation InitLoc)
static InitializationKind CreateCStyleCast(SourceLocation StartLoc, SourceRange TypeRange, bool InitList)
Create a direct initialization for a C-style cast.
Describes the sequence of initializations required to initialize a given object or reference with a s...
ExprResult Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType=nullptr)
Perform the actual initialization of the given entity based on the computed initialization sequence.
Describes an entity that is being initialized.
void setParameterCFAudited()
static InitializedEntity InitializeStmtExprResult(SourceLocation ReturnLoc, QualType Type)
static InitializedEntity InitializeTemporary(QualType Type)
Create the initialization entity for a temporary.
static InitializedEntity InitializeBlock(SourceLocation BlockVarLoc, QualType Type)
static InitializedEntity InitializeParameter(ASTContext &Context, ParmVarDecl *Parm)
Create the initialization entity for a parameter.
static InitializedEntity InitializeCompoundLiteralInit(TypeSourceInfo *TSI)
Create the entity for a compound literal initializer.
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.
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
CXXMethodDecl * getCallOperator() const
Retrieve the function call operator associated with this lambda expression.
FPEvalMethodKind
Possible float expression evaluation method choices.
@ FEM_Extended
Use extended type for fp arithmetic.
@ FEM_Double
Use the type double for fp arithmetic.
@ FEM_UnsetOnCommandLine
Used only for FE option processing; this is only used to indicate that the user did not specify an ex...
@ FEM_Source
Use the declared type for fp arithmetic.
@ None
Permit no implicit vector bitcasts.
@ Integer
Permit vector bitcasts between integer vectors with different numbers of elements but the same total ...
@ All
Permit vector bitcasts between all vectors with the same total bit-width.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
clang::ObjCRuntime ObjCRuntime
bool isSubscriptPointerArithmetic() const
bool isSignedOverflowDefined() const
unsigned getOpenCLCompatibleVersion() const
Return the OpenCL version that kernel language is compatible with.
static StringRef getSourceText(CharSourceRange Range, const SourceManager &SM, const LangOptions &LangOpts, bool *Invalid=nullptr)
Returns a string for the source that the range encompasses.
static SourceLocation AdvanceToTokenCharacter(SourceLocation TokStart, unsigned Characters, const SourceManager &SM, const LangOptions &LangOpts)
AdvanceToTokenCharacter - If the current SourceLocation specifies a location at the start of a token,...
static std::string Stringify(StringRef Str, bool Charify=false)
Stringify - Convert the specified string into a C string by i) escaping '\' and " characters and ii) ...
Represents the results of name lookup.
@ NotFoundInCurrentInstantiation
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
LLVM_ATTRIBUTE_REINITIALIZES void clear()
Clears out any current state.
bool isUnresolvableResult() const
DeclClass * getAsSingle() const
void addDecl(NamedDecl *D)
Add a declaration to these results with its natural access.
void setLookupName(DeclarationName Name)
Sets the name to look up.
bool empty() const
Return true if no decls were found.
void resolveKind()
Resolves the result kind of the lookup, possibly hiding decls.
bool isOverloadedResult() const
Determines if the results are overloaded.
SourceLocation getNameLoc() const
Gets the location of the identifier.
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
CXXRecordDecl * getNamingClass() const
Returns the 'naming class' for this lookup, i.e.
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
void setNamingClass(CXXRecordDecl *Record)
Sets the 'naming class' for this lookup.
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
LookupResultKind getResultKind() const
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
DeclarationName getLookupName() const
Gets the name to look up.
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
MS property subscript expression.
Keeps track of the mangled names of lambda expressions and block literals within a particular context...
virtual unsigned getManglingNumber(const CXXMethodDecl *CallOperator)=0
Retrieve the mangling number of a new lambda expression with the given call operator within this cont...
MatrixSubscriptExpr - Matrix subscript expression for the MatrixType extension.
Represents a matrix type, as defined in the Matrix Types clang extensions.
QualType getElementType() const
Returns type of the elements being stored in the matrix.
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
SourceLocation getMemberLoc() const
getMemberLoc - Return the location of the "member", in X->F, it is the location of 'F'.
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
static MemberExpr * Create(const ASTContext &C, Expr *Base, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *MemberDecl, DeclAccessPair FoundDecl, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs, QualType T, ExprValueKind VK, ExprObjectKind OK, NonOdrUseReason NOUR)
bool performsVirtualDispatch(const LangOptions &LO) const
Returns true if virtual dispatch is performed.
SourceLocation getBeginLoc() const LLVM_READONLY
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
This represents a decl that may have a name.
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
std::string getQualifiedNameAsString() const
Linkage getFormalLinkage() const
Get the linkage from a semantic point of view.
bool isExternallyVisible() const
bool isCXXClassMember() const
Determine whether this declaration is a C++ class member.
Represent a C++ namespace.
A C++ nested-name-specifier augmented with source location information.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
NumericLiteralParser - This performs strict semantic analysis of the content of a ppnumber,...
OpenMP 5.0 [2.1.5, Array Sections].
static QualType getBaseOriginalType(const Expr *Base)
Return original type of the base expression for array section.
static OMPArrayShapingExpr * Create(const ASTContext &Context, QualType T, Expr *Op, SourceLocation L, SourceLocation R, ArrayRef< Expr * > Dims, ArrayRef< SourceRange > BracketRanges)
static OMPIteratorExpr * Create(const ASTContext &Context, QualType T, SourceLocation IteratorKwLoc, SourceLocation L, SourceLocation R, ArrayRef< IteratorDefinition > Data, ArrayRef< OMPIteratorHelperData > Helpers)
A runtime availability query.
ObjCBoolLiteralExpr - Objective-C Boolean Literal.
Represents an ObjC class declaration.
ObjCIvarDecl * lookupInstanceVariable(IdentifierInfo *IVarName, ObjCInterfaceDecl *&ClassDeclared)
bool hasDefinition() const
Determine whether this class has been defined.
ivar_iterator ivar_begin() const
ObjCInterfaceDecl * getSuperClass() const
Interfaces are the core concept in Objective-C for object oriented design.
ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC 'id' type.
ObjCIvarDecl - Represents an ObjC instance variable.
AccessControl getAccessControl() const
QualType getUsageType(QualType objectType) const
Retrieve the type of this instance variable when viewed as a member of a specific object type.
ObjCIvarRefExpr - A reference to an ObjC instance variable.
SourceLocation getBeginLoc() const LLVM_READONLY
SourceLocation getLocation() const
SourceLocation getOpLoc() const
SourceLocation getEndLoc() const LLVM_READONLY
const Expr * getBase() const
An expression that sends a message to the given Objective-C object or class.
const ObjCMethodDecl * getMethodDecl() const
ObjCMethodDecl - Represents an instance or class method declaration.
ImplicitParamDecl * getSelfDecl() const
ArrayRef< ParmVarDecl * > parameters() const
bool isInstanceMethod() const
ObjCMethodFamily getMethodFamily() const
Determines the family of this method.
QualType getReturnType() const
bool isClassMethod() const
ObjCInterfaceDecl * getClassInterface()
Represents a pointer to an Objective C object.
bool isObjCQualifiedIdType() const
True if this is equivalent to 'id.
bool isObjCIdType() const
True if this is equivalent to the 'id' type, i.e.
ObjCInterfaceDecl * getInterfaceDecl() const
If this pointer points to an Objective @interface type, gets the declaration for that interface.
const ObjCInterfaceType * getInterfaceType() const
If this pointer points to an Objective C @interface type, gets the type for that interface.
Represents a class type in Objective C.
Represents one property declaration in an Objective-C interface.
static ObjCPropertyDecl * findPropertyDecl(const DeclContext *DC, const IdentifierInfo *propertyID, ObjCPropertyQueryKind queryKind)
Lookup a property by name in the specified DeclContext.
Represents an Objective-C protocol declaration.
bool allowsSizeofAlignof() const
Does this runtime allow sizeof or alignof on object types?
bool allowsPointerArithmetic() const
Does this runtime allow pointer arithmetic on objects?
static OffsetOfExpr * Create(const ASTContext &C, QualType type, SourceLocation OperatorLoc, TypeSourceInfo *tsi, ArrayRef< OffsetOfNode > comps, ArrayRef< Expr * > exprs, SourceLocation RParenLoc)
Helper class for OffsetOfExpr.
void * getAsOpaquePtr() const
static OpaquePtr getFromOpaquePtr(void *P)
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
bool isAvailableOption(llvm::StringRef Ext, const LangOptions &LO) const
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13....
@ CSK_Normal
Normal lookup.
SmallVectorImpl< OverloadCandidate >::iterator iterator
OverloadingResult BestViableFunction(Sema &S, SourceLocation Loc, OverloadCandidateSet::iterator &Best)
Find the best viable function on this overload set, if it exists.
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr.
static FindResult find(Expr *E)
Finds the overloaded expression in the given expression E of OverloadTy.
ParenExpr - This represents a parethesized expression, e.g.
SourceLocation getBeginLoc() const LLVM_READONLY
const Expr * getSubExpr() const
Expr * getExpr(unsigned Init)
static ParenListExpr * Create(const ASTContext &Ctx, SourceLocation LParenLoc, ArrayRef< Expr * > Exprs, SourceLocation RParenLoc)
Create a paren list.
unsigned getNumExprs() const
Return the number of expressions in this paren list.
SourceLocation getLParenLoc() const
SourceLocation getRParenLoc() const
Represents a parameter to a function.
bool hasUnparsedDefaultArg() const
Determines whether this parameter has a default argument that has not yet been parsed.
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
bool hasUninstantiatedDefaultArg() const
QualType getOriginalType() const
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
bool hasDefaultArg() const
Determines whether this parameter has a default argument, either parsed or not.
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
static std::string ComputeName(PredefinedIdentKind IK, const Decl *CurrentDecl)
static PredefinedExpr * Create(const ASTContext &Ctx, SourceLocation L, QualType FNTy, PredefinedIdentKind IK, bool IsTransparent, StringLiteral *SL)
Create a PredefinedExpr.
SourceLocation getLastFPEvalPragmaLocation() const
void CreateString(StringRef Str, Token &Tok, SourceLocation ExpansionLocStart=SourceLocation(), SourceLocation ExpansionLocEnd=SourceLocation())
Plop the specified string into a scratch buffer and set the specified token's location and length to ...
LangOptions::FPEvalMethodKind getCurrentFPEvalMethod() const
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
SourceManager & getSourceManager() const
bool isMacroDefined(StringRef Id)
const TargetInfo & getTargetInfo() const
char getSpellingOfSingleCharacterNumericConstant(const Token &Tok, bool *Invalid=nullptr) const
Given a Token Tok that is a numeric constant with length 1, return the character.
StringRef getSpelling(SourceLocation loc, SmallVectorImpl< char > &buffer, bool *invalid=nullptr) const
Return the 'spelling' of the token at the given location; does not go up to the spelling location or ...
bool isCodeCompletionEnabled() const
Determine if we are performing code completion.
IdentifierTable & getIdentifierTable()
const LangOptions & getLangOpts() const
DiagnosticsEngine & getDiagnostics() const
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Computes the source location just past the end of the token at this source location.
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const
Forwarding function for diagnostics.
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
bool isTriviallyCopyableType(const ASTContext &Context) const
Return true if this is a trivially copyable type (C++0x [basic.types]p9)
bool hasQualifiers() const
Determine whether this type has any qualifiers.
bool hasNonTrivialToPrimitiveCopyCUnion() const
Check if this is or contains a C union that is non-trivial to copy, which is a union that has a membe...
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type.
bool isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const
QualType withConst() const
void addConst()
Add the const type qualifier to this QualType.
bool isAtLeastAsQualifiedAs(QualType Other) const
Determine whether this type is at least as qualified as the other given type, requiring exact equalit...
bool isNull() const
Return true if this QualType doesn't point to a type yet.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
LangAS getAddressSpace() const
Return the address space of this type.
bool hasNonTrivialToPrimitiveDestructCUnion() const
Check if this is or contains a C union that is non-trivial to destruct, which is a union that has a m...
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
bool isAddressSpaceOverlapping(QualType T) const
Returns true if address space qualifiers overlap with T address space qualifiers.
bool isCXX98PODType(const ASTContext &Context) const
Return true if this is a POD type according to the rules of the C++98 standard, regardless of the cur...
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
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 isWebAssemblyReferenceType() const
Returns true if it is a WebAssembly Reference Type.
QualType withCVRQualifiers(unsigned CVR) const
bool isCForbiddenLValueType() const
Determine whether expressions of the given type are forbidden from being lvalues in C.
bool isConstQualified() const
Determine whether this type is const-qualified.
bool hasAddressSpace() const
Check if this type has any address space qualifier.
QualType getAtomicUnqualifiedType() const
Remove all qualifiers including _Atomic.
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after.
QualType getSingleStepDesugaredType(const ASTContext &Context) const
Return the specified type with one level of "sugar" removed from the type.
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
Qualifiers getLocalQualifiers() const
Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...
bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const
Check if this is or contains a C union that is non-trivial to default-initialize, which is a union th...
The collection of all-type qualifiers we support.
unsigned getCVRQualifiers() const
void removeCVRQualifiers(unsigned mask)
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
@ OCL_Weak
Reading or writing from this object requires a barrier call.
@ OCL_Autoreleasing
Assigning into this object requires a lifetime extension.
void removeObjCLifetime()
void removeAddressSpace()
void setAddressSpace(LangAS space)
static bool isAddressSpaceSupersetOf(LangAS A, LangAS B)
Returns true if address space A is equal to or a superset of B.
ObjCLifetime getObjCLifetime() const
Qualifiers withoutObjCLifetime() const
Qualifiers withoutObjCGCAttr() const
bool compatiblyIncludes(Qualifiers other) const
Determines if these qualifiers compatibly include another set.
LangAS getAddressSpace() const
bool compatiblyIncludesObjCLifetime(Qualifiers other) const
Determines if these qualifiers compatibly include another set of qualifiers from the narrow perspecti...
Represents a struct/union/class.
field_range fields() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
RecordDecl * getDecl() const
static RecoveryExpr * Create(ASTContext &Ctx, QualType T, SourceLocation BeginLoc, SourceLocation EndLoc, ArrayRef< Expr * > SubExprs)
A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Base for LValueReferenceType and RValueReferenceType.
static SYCLUniqueStableNameExpr * Create(const ASTContext &Ctx, SourceLocation OpLoc, SourceLocation LParen, SourceLocation RParen, TypeSourceInfo *TSI)
Scope - A scope is a transient data structure that is used while parsing the program.
unsigned getFlags() const
getFlags - Return the flags for this scope.
@ ContinueScope
This is a while, do, for, which can have continue statements embedded into it.
@ ControlScope
The controlling scope in a if/switch/while/for statement.
@ BreakScope
This is a while, do, switch, for, etc that can have break statements embedded into it.
@ DeclScope
This is a scope that can contain a declaration.
Smart pointer class that efficiently represents Objective-C method names.
StringRef getNameForSlot(unsigned argIndex) const
Retrieve the name at a given position in the selector.
bool isUnarySelector() const
RAII object used to temporarily allow the C++ 'this' expression to be used, with the given qualifiers...
A generic diagnostic builder for errors which may or may not be deferred.
RAII class used to indicate that we are performing provisional semantic analysis to determine the val...
Abstract base class used for diagnosing integer constant expression violations.
virtual SemaDiagnosticBuilder diagnoseNotICE(Sema &S, SourceLocation Loc)=0
virtual SemaDiagnosticBuilder diagnoseNotICEType(Sema &S, SourceLocation Loc, QualType T)
virtual SemaDiagnosticBuilder diagnoseFold(Sema &S, SourceLocation Loc)
Sema - This implements semantic analysis and AST building for C.
const FieldDecl * getSelfAssignmentClassMemberCandidate(const ValueDecl *SelfAssigned)
Returns a field in a CXXRecordDecl that has the same name as the decl SelfAssigned when inside a CXXM...
void DefineImplicitLambdaToFunctionPointerConversion(SourceLocation CurrentLoc, CXXConversionDecl *Conv)
Define the "body" of the conversion from a lambda object to a function pointer.
ObjCMethodDecl * LookupMethodInObjectType(Selector Sel, QualType Ty, bool IsInstance)
LookupMethodInType - Look up a method in an ObjCObjectType.
ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo)
Package the given type and TSI into a ParsedType.
QualType getCurrentThisType()
Try to retrieve the type of the 'this' pointer.
std::optional< ExpressionEvaluationContextRecord::InitializationContext > InnermostDeclarationWithDelayedImmediateInvocations() const
SmallVector< CodeSynthesisContext, 16 > CodeSynthesisContexts
List of active code synthesis contexts.
void CheckFloatComparison(SourceLocation Loc, Expr *LHS, Expr *RHS, BinaryOperatorKind Opcode)
Check for comparisons of floating-point values using == and !=.
Scope * getCurScope() const
Retrieve the parser's current scope.
CUDAFunctionTarget IdentifyCUDATarget(const FunctionDecl *D, bool IgnoreImplicitHDAttr=false)
Determines whether the given function is a CUDA device/host/kernel/etc.
const ValueDecl * getOpenMPDeclareMapperVarName() const
bool DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R, CorrectionCandidateCallback &CCC, TemplateArgumentListInfo *ExplicitTemplateArgs=nullptr, ArrayRef< Expr * > Args=std::nullopt, DeclContext *LookupCtx=nullptr, TypoExpr **Out=nullptr)
Diagnose an empty lookup.
QualType FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
FindCompositeObjCPointerType - Helper method to find composite type of two objective-c pointer types ...
void CheckObjCBridgeRelatedCast(QualType castType, Expr *castExpr)
ExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc, tok::TokenKind Op, Expr *Input, bool IsAfterAmp=false)
bool RequireCompleteSizedExprType(Expr *E, unsigned DiagID, const Ts &...Args)
ExprResult ActOnIntegerConstant(SourceLocation Loc, uint64_t Val)
ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *InputExpr, bool IsAfterAmp=false)
bool isValidRVVBitcast(QualType srcType, QualType destType)
Are the two types RVV-bitcast-compatible types? I.e.
bool isAlwaysConstantEvaluatedContext() const
bool isExternalWithNoLinkageType(const ValueDecl *VD) const
Determine if VD, which must be a variable or function, is an external symbol that nonetheless can't b...
void DiagnoseUnusedParameters(ArrayRef< ParmVarDecl * > Parameters)
Diagnose any unused parameters in the given sequence of ParmVarDecl pointers.
ExprResult IgnoredValueConversions(Expr *E)
IgnoredValueConversions - Given that an expression's result is syntactically ignored,...
bool RequireCompleteSizedType(SourceLocation Loc, QualType T, unsigned DiagID, const Ts &...Args)
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
@ LookupObjCImplicitSelfParam
Look up implicit 'self' parameter of an objective-c method.
@ LookupMemberName
Member name lookup, which finds the names of class/struct/union members.
void DiagnoseSentinelCalls(const NamedDecl *D, SourceLocation Loc, ArrayRef< Expr * > Args)
DiagnoseSentinelCalls - This routine checks whether a call or message-send is to a declaration with t...
ExprResult ActOnConstantExpression(ExprResult Res)
QualType CheckLogicalOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc)
ExprResult ActOnCompoundLiteral(SourceLocation LParenLoc, ParsedType Ty, SourceLocation RParenLoc, Expr *InitExpr)
bool CheckObjCBridgeRelatedConversions(SourceLocation Loc, QualType DestType, QualType SrcType, Expr *&SrcExpr, bool Diagnose=true)
@ NTCUC_LValueToRValueVolatile
ImplicitConversionSequence TryImplicitConversion(Expr *From, QualType ToType, bool SuppressUserConversions, AllowedExplicit AllowExplicit, bool InOverloadResolution, bool CStyle, bool AllowObjCWritebackConversion)
ExprResult BuildLiteralOperatorCall(LookupResult &R, DeclarationNameInfo &SuffixInfo, ArrayRef< Expr * > Args, SourceLocation LitEndLoc, TemplateArgumentListInfo *ExplicitTemplateArgs=nullptr)
BuildLiteralOperatorCall - Build a UserDefinedLiteral by creating a call to a literal operator descri...
bool areVectorTypesSameSize(QualType srcType, QualType destType)
bool isSelfExpr(Expr *RExpr)
Private Helper predicate to check for 'self'.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
ExprResult BuildIvarRefExpr(Scope *S, SourceLocation Loc, ObjCIvarDecl *IV)
void DiagnoseAlwaysNonNullPointer(Expr *E, Expr::NullPointerConstantKind NullType, bool IsEqual, SourceRange Range)
Diagnose pointers that are always non-null.
void DefineImplicitMoveAssignment(SourceLocation CurrentLocation, CXXMethodDecl *MethodDecl)
Defines an implicitly-declared move assignment operator.
void DecomposeUnqualifiedId(const UnqualifiedId &Id, TemplateArgumentListInfo &Buffer, DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *&TemplateArgs)
Decomposes the given name into a DeclarationNameInfo, its location, and possibly a list of template a...
bool InstantiateDefaultArgument(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param)
void ActOnStartStmtExpr()
ExprResult CreateOverloadedArraySubscriptExpr(SourceLocation LLoc, SourceLocation RLoc, Expr *Base, MultiExprArg Args)
void WarnOnPendingNoDerefs(ExpressionEvaluationContextRecord &Rec)
Emit a warning for all pending noderef expressions that we recorded.
void ActOnStmtExprError()
DeclResult LookupIvarInObjCMethod(LookupResult &Lookup, Scope *S, IdentifierInfo *II)
The parser has read a name in, and Sema has detected that we're currently inside an ObjC method.
QualType UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, ArithConvKind ACK)
UsualArithmeticConversions - Performs various conversions that are common to binary operators (C99 6....
void CheckPtrComparisonWithNullChar(ExprResult &E, ExprResult &NullE)
NamedDecl * ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II, Scope *S)
ImplicitlyDefineFunction - An undeclared identifier was used in a function call, forming a call to an...
std::unique_ptr< NSAPI > NSAPIObj
Caches identifiers/selectors for NSFoundation APIs.
unsigned CapturingFunctionScopes
Track the number of currently active capturing scopes.
void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl=nullptr, ExpressionEvaluationContextRecord::ExpressionKind Type=ExpressionEvaluationContextRecord::EK_Other)
ObjCMethodDecl * LookupInstanceMethodInGlobalPool(Selector Sel, SourceRange R, bool receiverIdOrClass=false)
LookupInstanceMethodInGlobalPool - Returns the method and warns if there are multiple signatures.
ExprResult CheckBooleanCondition(SourceLocation Loc, Expr *E, bool IsConstexpr=false)
CheckBooleanCondition - Diagnose problems involving the use of the given expression as a boolean cond...
bool isOpenMPDeclareMapperVarDeclAllowed(const VarDecl *VD) const
@ Boolean
A boolean condition, from 'if', 'while', 'for', or 'do'.
@ Switch
An integral condition for a 'switch' statement.
@ ConstexprIf
A constant boolean condition from 'if constexpr'.
bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC)
Require that the context specified by SS be complete.
ExprResult ActOnIdExpression(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, UnqualifiedId &Id, bool HasTrailingLParen, bool IsAddressOfOperand, CorrectionCandidateCallback *CCC=nullptr, bool IsInlineAsmIdentifier=false, Token *KeywordReplacement=nullptr)
SmallVector< sema::FunctionScopeInfo *, 4 > FunctionScopes
Stack containing information about each of the nested function, block, and method scopes that are cur...
bool CheckObjCARCUnavailableWeakConversion(QualType castType, QualType ExprType)
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.
Preprocessor & getPreprocessor() const
Scope * getScopeForContext(DeclContext *Ctx)
Determines the active Scope associated with the given declaration context.
QualType GetSignedSizelessVectorType(QualType V)
bool CheckCXXThisCapture(SourceLocation Loc, bool Explicit=false, bool BuildAndDiagnose=true, const unsigned *const FunctionScopeIndexToStopAt=nullptr, bool ByCopy=false)
Make sure the value of 'this' is actually available in the current context, if it is a potentially ev...
llvm::SmallPtrSet< ConstantExpr *, 4 > FailedImmediateInvocations
ExprResult ActOnCharacterConstant(const Token &Tok, Scope *UDLScope=nullptr)
DefaultedComparisonKind getDefaultedComparisonKind(const FunctionDecl *FD)
ExprResult MaybeBindToTemporary(Expr *E)
MaybeBindToTemporary - If the passed in expression has a record type with a non-trivial destructor,...
void CheckCompleteDestructorVariant(SourceLocation CurrentLocation, CXXDestructorDecl *Dtor)
Do semantic checks to allow the complete destructor variant to be emitted when the destructor is defi...
void MarkCaptureUsedInEnclosingContext(ValueDecl *Capture, SourceLocation Loc, unsigned CapturingScopeIndex)
bool CheckForConstantInitializer(Expr *e, QualType t)
type checking declaration initializers (C99 6.7.8)
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, AllowFoldKind CanFold=NoFold)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
Expr * BuildBuiltinCallExpr(SourceLocation Loc, Builtin::ID Id, MultiExprArg CallArgs)
BuildBuiltinCallExpr - Create a call to a builtin function specified by Id.
QualType CheckVectorOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign, bool AllowBothBool, bool AllowBoolConversion, bool AllowBoolOperation, bool ReportInvalid)
type checking for vector binary operators.
LiteralOperatorLookupResult LookupLiteralOperator(Scope *S, LookupResult &R, ArrayRef< QualType > ArgTys, bool AllowRaw, bool AllowTemplate, bool AllowStringTemplate, bool DiagnoseMissing, StringLiteral *StringLit=nullptr)
LookupLiteralOperator - Determine which literal operator should be used for a user-defined literal,...
FPOptionsOverride CurFPFeatureOverrides()
bool isValidSveBitcast(QualType srcType, QualType destType)
Are the two types SVE-bitcast-compatible types? I.e.
ExprResult ActOnDependentIdExpression(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, bool isAddressOfOperand, const TemplateArgumentListInfo *TemplateArgs)
ActOnDependentIdExpression - Handle a dependent id-expression that was just parsed.
ObjCLiteralKind CheckLiteralKind(Expr *FromE)
void MarkDeclarationsReferencedInExpr(Expr *E, bool SkipLocalVariables=false, ArrayRef< const Expr * > StopAt=std::nullopt)
Mark any declarations that appear within this expression or any potentially-evaluated subexpressions ...
ObjCMethodDecl * LookupMethodInQualifiedType(Selector Sel, const ObjCObjectPointerType *OPT, bool IsInstance)
LookupMethodInQualifiedType - Lookups up a method in protocol qualifier list of a qualified objective...
ExprResult BuildStmtExpr(SourceLocation LPLoc, Stmt *SubStmt, SourceLocation RPLoc, unsigned TemplateDepth)
ExprResult ActOnOMPArraySectionExpr(Expr *Base, SourceLocation LBLoc, Expr *LowerBound, SourceLocation ColonLocFirst, SourceLocation ColonLocSecond, Expr *Length, Expr *Stride, SourceLocation RBLoc)
ExprResult BuildCallToMemberFunction(Scope *S, Expr *MemExpr, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false, bool AllowRecovery=false)
BuildCallToMemberFunction - Build a call to a member function.
ExprResult BuildVAArgExpr(SourceLocation BuiltinLoc, Expr *E, TypeSourceInfo *TInfo, SourceLocation RPLoc)
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....
ExprResult CheckUnevaluatedOperand(Expr *E)
ExprResult PerformImplicitConversion(Expr *From, QualType ToType, const ImplicitConversionSequence &ICS, AssignmentAction Action, CheckedConversionKind CCK=CCK_ImplicitConversion)
PerformImplicitConversion - Perform an implicit conversion of the expression From to the type ToType ...
ExprResult DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT, FunctionDecl *FDecl)
DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but will create a trap if the resul...
void DiagnoseCommaOperator(const Expr *LHS, SourceLocation Loc)
ExprResult tryConvertExprToType(Expr *E, QualType Ty)
Try to convert an expression E to type Ty.
bool DeduceReturnType(FunctionDecl *FD, SourceLocation Loc, bool Diagnose=true)
std::vector< Token > ExpandFunctionLocalPredefinedMacros(ArrayRef< Token > Toks)
bool CheckMatrixCast(SourceRange R, QualType DestTy, QualType SrcTy, CastKind &Kind)
QualType CheckAddressOfOperand(ExprResult &Operand, SourceLocation OpLoc)
CheckAddressOfOperand - The operand of & must be either a function designator or an lvalue designatin...
ParmVarDecl * BuildParmVarDeclForTypedef(DeclContext *DC, SourceLocation Loc, QualType T)
Synthesizes a variable for a parameter arising from a typedef.
ExprResult CheckSwitchCondition(SourceLocation SwitchLoc, Expr *Cond)
static bool TooManyArguments(size_t NumParams, size_t NumArgs, bool PartialOverloading=false)
To be used for checking whether the arguments being passed to function exceeds the number of paramete...
bool ShouldSplatAltivecScalarInCast(const VectorType *VecTy)
QualType InvalidOperands(SourceLocation Loc, ExprResult &LHS, ExprResult &RHS)
the following "Check" methods will return a valid/converted QualType or a null QualType (indicating a...
bool DiagIfReachable(SourceLocation Loc, ArrayRef< const Stmt * > Stmts, const PartialDiagnostic &PD)
Conditionally issue a diagnostic based on the statements's reachability analysis.
QualType CheckShiftOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc, bool IsCompAssign=false)
ExprResult BuildQualifiedDeclarationNameExpr(CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, bool IsAddressOfOperand, const Scope *S, TypeSourceInfo **RecoveryTSI=nullptr)
BuildQualifiedDeclarationNameExpr - Build a C++ qualified declaration name, generally during template...
DiagnosticsEngine & getDiagnostics() const
ExprResult MaybeConvertParenListExprToParenExpr(Scope *S, Expr *ME)
This is not an AltiVec-style cast or or C++ direct-initialization, so turn the ParenListExpr into a s...
bool checkAddressOfFunctionIsAvailable(const FunctionDecl *Function, bool Complain=false, SourceLocation Loc=SourceLocation())
Returns whether the given function's address can be taken or not, optionally emitting a diagnostic if...
ExprResult checkPseudoObjectAssignment(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opcode, Expr *LHS, Expr *RHS)
bool CheckCaseExpression(Expr *E)
bool LookupBuiltin(LookupResult &R)
Lookup a builtin function, when name lookup would otherwise fail.
QualType CheckMatrixElementwiseOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign)
Type checking for matrix binary operators.
bool tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD, bool ForceComplain=false, bool(*IsPlausibleResult)(QualType)=nullptr)
Try to recover by turning the given expression into a call.
FunctionDecl * ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr, QualType TargetType, bool Complain, DeclAccessPair &Found, bool *pHadMultipleCandidates=nullptr)
ResolveAddressOfOverloadedFunction - Try to resolve the address of an overloaded function (C++ [over....
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
void LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S, UnresolvedSetImpl &Functions)
void checkSpecializationReachability(SourceLocation Loc, NamedDecl *Spec)
void CleanupVarDeclMarking()
ExprResult DefaultFunctionArrayLvalueConversion(Expr *E, bool Diagnose=true)
bool isImmediateFunctionContext() const
ASTContext & getASTContext() const
ExprResult CallExprUnaryConversions(Expr *E)
CallExprUnaryConversions - a special case of an unary conversion performed on a function designator o...
void translateTemplateArguments(const ASTTemplateArgsPtr &In, TemplateArgumentListInfo &Out)
Translates template arguments as provided by the parser into template arguments used by semantic anal...
NamedDecl * LookupSingleName(Scope *S, DeclarationName Name, SourceLocation Loc, LookupNameKind NameKind, RedeclarationKind Redecl=NotForRedeclaration)
Look up a name, looking for a single declaration.
ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *Input, bool IsAfterAmp=false)
bool tryCaptureVariable(ValueDecl *Var, SourceLocation Loc, TryCaptureKind Kind, SourceLocation EllipsisLoc, bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType, const unsigned *const FunctionScopeIndexToStopAt)
Try to capture the given variable.
void MarkVariableReferenced(SourceLocation Loc, VarDecl *Var)
Mark a variable referenced, and check whether it is odr-used (C++ [basic.def.odr]p2,...
void LookupBinOp(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opc, UnresolvedSetImpl &Functions)
ExprResult BuildTemplateIdExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, bool RequiresADL, const TemplateArgumentListInfo *TemplateArgs)
void DiagnoseUnguardedAvailabilityViolations(Decl *FD)
Issue any -Wunguarded-availability warnings in FD.
void PopExpressionEvaluationContext()
AssignConvertType CheckTransparentUnionArgumentConstraints(QualType ArgType, ExprResult &RHS)
ExprResult CreateOverloadedBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *LHS, Expr *RHS, bool RequiresADL=true, bool AllowRewrittenCandidates=true, FunctionDecl *DefaultedFn=nullptr)
Create a binary operation that may resolve to an overloaded operator.
ExprResult DefaultArgumentPromotion(Expr *E)
DefaultArgumentPromotion (C99 6.5.2.2p6).
ExprResult BuildPredefinedExpr(SourceLocation Loc, PredefinedIdentKind IK)
bool CheckArgsForPlaceholders(MultiExprArg args)
Check an argument list for placeholders that we won't try to handle later.
bool UseArgumentDependentLookup(const CXXScopeSpec &SS, const LookupResult &R, bool HasTrailingLParen)
void InstantiateVariableDefinition(SourceLocation PointOfInstantiation, VarDecl *Var, bool Recursive=false, bool DefinitionRequired=false, bool AtEndOfTU=false)
Instantiate the definition of the given variable from its template.
ExprResult BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo, SourceLocation RParenLoc, Expr *LiteralExpr)
ExprResult ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc, LabelDecl *TheDecl)
ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
DefaultedComparisonKind
Kinds of defaulted comparison operator functions.
@ None
This is not a defaultable comparison operator.
ExprResult ActOnParenListExpr(SourceLocation L, SourceLocation R, MultiExprArg Val)
FunctionDecl * ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl, bool Complain=false, DeclAccessPair *Found=nullptr, TemplateSpecCandidateSet *FailedTSC=nullptr)
Given an expression that refers to an overloaded function, try to resolve that overloaded function ex...
QualType CheckMatrixMultiplyOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign)
bool isOpenMPGlobalCapturedDecl(ValueDecl *D, unsigned Level, unsigned CaptureLevel) const
Check if the specified global variable must be captured by outer capture regions.
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)
void DefineImplicitMoveConstructor(SourceLocation CurrentLocation, CXXConstructorDecl *Constructor)
DefineImplicitMoveConstructor - Checks for feasibility of defining this constructor as the move const...
ExprResult ActOnChooseExpr(SourceLocation BuiltinLoc, Expr *CondExpr, Expr *LHSExpr, Expr *RHSExpr, SourceLocation RPLoc)
ExprResult CreateGenericSelectionExpr(SourceLocation KeyLoc, SourceLocation DefaultLoc, SourceLocation RParenLoc, bool PredicateIsExpr, void *ControllingExprOrType, ArrayRef< TypeSourceInfo * > Types, ArrayRef< Expr * > Exprs)
ControllingExprOrType is either a TypeSourceInfo * or an Expr *.
CastKind PrepareCastToObjCObjectPointer(ExprResult &E)
Prepare a conversion of the given expression to an ObjC object pointer type.
ExprResult ActOnUnevaluatedStringLiteral(ArrayRef< Token > StringToks)
void DiagnoseSelfMove(const Expr *LHSExpr, const Expr *RHSExpr, SourceLocation OpLoc)
Warn if a value is moved to itself.
void checkDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D, SourceLocation IdLoc=SourceLocation())
Check declaration inside target region.
ExprResult PerformOpenMPImplicitIntegerConversion(SourceLocation OpLoc, Expr *Op)
SourceRange getExprRange(Expr *E) const
void AddTemplateOverloadCandidate(FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=true, ADLCallKind IsADLCandidate=ADLCallKind::NotADL, OverloadCandidateParamOrder PO={}, bool AggregateCandidateDeduction=false)
Add a C++ function template specialization as a candidate in the candidate set, using template argume...
std::unique_ptr< sema::FunctionScopeInfo, PoppedFunctionScopeDeleter > PoppedFunctionScopePtr
void tryCaptureOpenMPLambdas(ValueDecl *V)
Function tries to capture lambda's captured variables in the OpenMP region before the original lambda...
void DefineImplicitCopyConstructor(SourceLocation CurrentLocation, CXXConstructorDecl *Constructor)
DefineImplicitCopyConstructor - Checks for feasibility of defining this constructor as the copy const...
std::optional< ExpressionEvaluationContextRecord::InitializationContext > OutermostDeclarationWithDelayedImmediateInvocations() const
void DiagnoseUnusedExprResult(const Stmt *S, unsigned DiagID)
DiagnoseUnusedExprResult - If the statement passed in is an expression whose result is unused,...
FPOptions & getCurFPFeatures()
RecordDecl * StdSourceLocationImplDecl
The C++ "std::source_location::__impl" struct, defined in <source_location>.
ConditionResult ActOnCondition(Scope *S, SourceLocation Loc, Expr *SubExpr, ConditionKind CK, bool MissingOK=false)
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
void CheckTollFreeBridgeCast(QualType castType, Expr *castExpr)
@ UPPC_Block
Block expression.
const LangOptions & getLangOpts() const
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, CorrectionCandidateCallback &CCC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr, bool RecordFailure=true)
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
QualType CheckComparisonCategoryType(ComparisonCategoryType Kind, SourceLocation Loc, ComparisonCategoryUsage Usage)
Lookup the specified comparison category types in the standard library, an check the VarDecls possibl...
ExprResult BuildSYCLUniqueStableNameExpr(SourceLocation OpLoc, SourceLocation LParen, SourceLocation RParen, TypeSourceInfo *TSI)
void DiagnoseInvalidJumps(Stmt *Body)
TypoExpr * CorrectTypoDelayed(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, CorrectionCandidateCallback &CCC, TypoDiagnosticGenerator TDG, TypoRecoveryCallback TRC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr)
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
QualType CheckCompareOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc)
CastKind PrepareScalarCast(ExprResult &src, QualType destType)
Prepares for a scalar cast, performing all the necessary stages except the final cast and returning t...
QualType CheckVectorLogicalOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc)
bool tryToFixVariablyModifiedVarType(TypeSourceInfo *&TInfo, QualType &T, SourceLocation Loc, unsigned FailedFoldDiagID)
Attempt to fold a variable-sized type to a constant-sized type, returning true if we were successful.
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
void MarkExpressionAsImmediateEscalating(Expr *E)
void ActOnOpenMPIteratorVarDecl(VarDecl *VD)
NonOdrUseReason getNonOdrUseReasonInCurrentContext(ValueDecl *D)
If D cannot be odr-used in the current expression evaluation context, return a reason explaining why.
void DefineDefaultedComparison(SourceLocation Loc, FunctionDecl *FD, DefaultedComparisonKind DCK)
void diagnoseUnavailableAlignedAllocation(const FunctionDecl &FD, SourceLocation Loc)
Produce diagnostics if FD is an aligned allocation or deallocation function that is unavailable.
bool CheckCUDACall(SourceLocation Loc, FunctionDecl *Callee)
Check whether we're allowed to call Callee from the current context.
void MarkFunctionParmPackReferenced(FunctionParmPackExpr *E)
Perform reference-marking and odr-use handling for a FunctionParmPackExpr.
QualType CheckAdditionOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc, QualType *CompLHSTy=nullptr)
VariadicCallType getVariadicCallType(FunctionDecl *FDecl, const FunctionProtoType *Proto, Expr *Fn)
ExprResult BuildCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false, bool AllowRecovery=false)
BuildCallExpr - Handle a call to Fn with the specified array of arguments.
bool CheckUseOfCXXMethodAsAddressOfOperand(SourceLocation OpLoc, const Expr *Op, const CXXMethodDecl *MD)
ExprResult BuildSourceLocExpr(SourceLocIdentKind Kind, QualType ResultTy, SourceLocation BuiltinLoc, SourceLocation RPLoc, DeclContext *ParentContext)
bool ActOnAlignasTypeArgument(StringRef KWName, ParsedType Ty, SourceLocation OpLoc, SourceRange R)
ActOnAlignasTypeArgument - Handle alignas(type-id) and _Alignas(type-name) .
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
ExprResult checkPseudoObjectIncDec(Scope *S, SourceLocation OpLoc, UnaryOperatorKind Opcode, Expr *Op)
Check an increment or decrement of a pseudo-object expression.
void checkTypeSupport(QualType Ty, SourceLocation Loc, ValueDecl *D=nullptr)
Check if the type is allowed to be used for the current target.
bool areMatrixTypesOfTheSameDimension(QualType srcTy, QualType destTy)
Are the two types matrix types and do they have the same dimensions i.e.
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CCK_ImplicitConversion)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
void CheckExtraCXXDefaultArguments(Declarator &D)
CheckExtraCXXDefaultArguments - Check for any extra default arguments in the declarator,...
bool hasCStrMethod(const Expr *E)
Check to see if a given expression could have '.c_str()' called on it.
const LangOptions & LangOpts
void EmitRelatedResultTypeNoteForReturn(QualType destType)
Given that we had incompatible pointer types in a return statement, check whether we're in a method w...
ExprResult BuildBuiltinOffsetOf(SourceLocation BuiltinLoc, TypeSourceInfo *TInfo, ArrayRef< OffsetOfComponent > Components, SourceLocation RParenLoc)
__builtin_offsetof(type, a.b[123][456].c)
sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)
Retrieve the current lambda scope info, if any.
ExprResult BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, SourceLocation LParenLoc, ArrayRef< Expr * > Arg, SourceLocation RParenLoc, Expr *Config=nullptr, bool IsExecConfig=false, ADLCallKind UsesADL=ADLCallKind::NotADL)
BuildResolvedCallExpr - Build a call to a resolved expression, i.e.
ExprResult CheckForImmediateInvocation(ExprResult E, FunctionDecl *Decl)
Wrap the expression in a ConstantExpr if it is a potential immediate invocation.
ExprResult TemporaryMaterializationConversion(Expr *E)
If E is a prvalue denoting an unmaterialized temporary, materialize it as an xvalue.
NamedDeclSetType UnusedPrivateFields
Set containing all declared private fields that are not used.
Expr * stripARCUnbridgedCast(Expr *e)
stripARCUnbridgedCast - Given an expression of ARCUnbridgedCast type, remove the placeholder cast.
void DefineInheritingConstructor(SourceLocation UseLoc, CXXConstructorDecl *Constructor)
Define the specified inheriting constructor.
void CheckUnusedVolatileAssignment(Expr *E)
Check whether E, which is either a discarded-value expression or an unevaluated operand,...
void MaybeSuggestAddingStaticToDecl(const FunctionDecl *D)
@ OperatorInExpression
The '<=>' operator was used in an expression and a builtin operator was selected.
bool CanUseDecl(NamedDecl *D, bool TreatUnavailableAsInvalid)
Determine whether the use of this declaration is valid, without emitting diagnostics.
void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse)
Perform marking for a reference to an arbitrary declaration.
void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class, bool DefinitionRequired=false)
Note that the vtable for the given class was used at the given location.
QualType InvalidLogicalVectorOperands(SourceLocation Loc, ExprResult &LHS, ExprResult &RHS)
bool diagnoseArgIndependentDiagnoseIfAttrs(const NamedDecl *ND, SourceLocation Loc)
Emit diagnostics for the diagnose_if attributes on Function, ignoring any ArgDependent DiagnoseIfAttr...
CleanupInfo Cleanup
Used to control the generation of ExprWithCleanups.
llvm::DenseMap< ParmVarDecl *, SourceLocation > UnparsedDefaultArgLocs
NamedDecl * getCurFunctionOrMethodDecl() const
getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method or C function we're in,...
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, const CXXScopeSpec &SS, QualType T, TagDecl *OwnedTagDecl=nullptr)
Retrieve a version of the type 'T' that is elaborated by Keyword, qualified by the nested-name-specif...
QualType FindCompositePointerType(SourceLocation Loc, Expr *&E1, Expr *&E2, bool ConvertArgs=true)
Find a merged pointer type and convert the two expressions to it.
SmallVector< std::deque< PendingImplicitInstantiation >, 8 > SavedPendingInstantiations
VarArgKind isValidVarArgType(const QualType &Ty)
Determine the degree of POD-ness for an expression.
bool isQualifiedMemberAccess(Expr *E)
Determine whether the given expression is a qualified member access expression, of a form that could ...
bool isInOpenMPDeclareTargetContext() const
Return true inside OpenMP declare target region.
bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS, bool AllowBuiltinCreation=false, bool EnteringContext=false)
Performs name lookup for a name that was parsed in the source code, and may contain a C++ scope speci...
static CastKind ScalarTypeToBooleanCastKind(QualType ScalarTy)
ScalarTypeToBooleanCastKind - Returns the cast kind corresponding to the conversion from scalar type ...
void DefineImplicitLambdaToBlockPointerConversion(SourceLocation CurrentLoc, CXXConversionDecl *Conv)
Define the "body" of the conversion from a lambda object to a block pointer.
void DefineImplicitDestructor(SourceLocation CurrentLocation, CXXDestructorDecl *Destructor)
DefineImplicitDestructor - Checks for feasibility of defining this destructor as the default destruct...
ExprResult BuildCStyleCastExpr(SourceLocation LParenLoc, TypeSourceInfo *Ty, SourceLocation RParenLoc, Expr *Op)
sema::FunctionScopeInfo * getCurFunction() const
void checkUnsafeExprAssigns(SourceLocation Loc, Expr *LHS, Expr *RHS)
checkUnsafeExprAssigns - Check whether +1 expr is being assigned to weak/__unsafe_unretained expressi...
ExprResult LookupInObjCMethod(LookupResult &LookUp, Scope *S, IdentifierInfo *II, bool AllowBuiltinCreation=false)
The parser has read a name in, and Sema has detected that we're currently inside an ObjC method.
void CUDARecordImplicitHostDeviceFuncUsedByDevice(const FunctionDecl *FD)
Record FD if it is a CUDA/HIP implicit host device function used on device side in device compilation...
QualType CheckSizelessVectorOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign, ArithConvKind OperationKind)
ExprResult ActOnOpenMPCall(ExprResult Call, Scope *Scope, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig)
Given the potential call expression Call, determine if there is a specialization via the OpenMP decla...
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...
llvm::DenseMap< const VarDecl *, int > RefsMinusAssignments
Increment when we find a reference; decrement when we find an ignored assignment.
ExprResult CreateOverloadedUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *input, bool RequiresADL=true)
Create a unary operation that may resolve to an overloaded operator.
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 DefineImplicitDefaultConstructor(SourceLocation CurrentLocation, CXXConstructorDecl *Constructor)
DefineImplicitDefaultConstructor - Checks for feasibility of defining this constructor as the default...
void AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool PartialOverloading=false)
Add the overload candidates named by callee and/or found by argument dependent lookup to the given ov...
ExprResult DefaultLvalueConversion(Expr *E)
ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)
ExprResult BuildObjCStringLiteral(SourceLocation AtLoc, StringLiteral *S)
bool CheckDerivedToBaseConversion(QualType Derived, QualType Base, SourceLocation Loc, SourceRange Range, CXXCastPath *BasePath=nullptr, bool IgnoreAccess=false)
bool isInLifetimeExtendingContext() const
void maybeExtendBlockObject(ExprResult &E)
Do an explicit extend of the given block pointer if we're in ARC.
ExprResult ActOnGenericSelectionExpr(SourceLocation KeyLoc, SourceLocation DefaultLoc, SourceLocation RParenLoc, bool PredicateIsExpr, void *ControllingExprOrType, ArrayRef< ParsedType > ArgTypes, ArrayRef< Expr * > ArgExprs)
ControllingExprOrType is either an opaque pointer coming out of a ParsedType or an Expr *.
void ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope)
ActOnBlockError - If there is an error parsing a block, this callback is invoked to pop the informati...
ExprResult prepareVectorSplat(QualType VectorTy, Expr *SplattedExpr)
Prepare SplattedExpr for a vector splat operation, adding implicit casts if necessary.
sema::BlockScopeInfo * getCurBlock()
Retrieve the current block, if any.
bool IvarBacksCurrentMethodAccessor(ObjCInterfaceDecl *IFace, ObjCMethodDecl *Method, ObjCIvarDecl *IV)
IvarBacksCurrentMethodAccessor - This routine returns 'true' if 'IV' is an ivar synthesized for 'Meth...
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
@ ForVisibleRedeclaration
The lookup results will be used for redeclaration of a name, if an entity by that name already exists...
MaterializeTemporaryExpr * CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary, bool BoundToLvalueReference)
ExprResult checkUnknownAnyCast(SourceRange TypeRange, QualType CastType, Expr *CastExpr, CastKind &CastKind, ExprValueKind &VK, CXXCastPath &Path)
Check a cast of an unknown-any type.
SuppressedDiagnosticsMap SuppressedDiagnostics
DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name)
Retrieves the declaration name from a parsed unqualified-id.
std::deque< PendingImplicitInstantiation > PendingLocalImplicitInstantiations
The queue of implicit template instantiations that are required and must be performed within the curr...
ExprResult ActOnGNUNullExpr(SourceLocation TokenLoc)
ExprResult PerformContextuallyConvertToBool(Expr *From)
PerformContextuallyConvertToBool - Perform a contextual conversion of the expression From to bool (C+...
void DefineImplicitCopyAssignment(SourceLocation CurrentLocation, CXXMethodDecl *MethodDecl)
Defines an implicitly-declared copy assignment operator.
bool DiagnoseConditionalForNull(const Expr *LHSExpr, const Expr *RHSExpr, SourceLocation QuestionLoc)
Emit a specialized diagnostic when one expression is a null pointer constant and the other is not a p...
bool CheckFunctionConstraints(const FunctionDecl *FD, ConstraintSatisfaction &Satisfaction, SourceLocation UsageLoc=SourceLocation(), bool ForOverloadResolution=false)
Check whether the given function decl's trailing requires clause is satisfied, if any.
void MarkDeclarationsReferencedInType(SourceLocation Loc, QualType T)
Mark all of the declarations referenced within a particular AST node as referenced.
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5.
DeclContext * getFunctionLevelDeclContext(bool AllowLambda=false) const
If AllowLambda is true, treat lambda as function.
AssignConvertType
AssignConvertType - All of the 'assignment' semantic checks return this enum to indicate whether the ...
@ IncompatiblePointerDiscardsQualifiers
IncompatiblePointerDiscardsQualifiers - The assignment discards qualifiers that we don't permit to be...
@ IntToPointer
IntToPointer - The assignment converts an int to a pointer, which we accept as an extension.
@ IncompatibleBlockPointer
IncompatibleBlockPointer - The assignment is between two block pointers types that are not compatible...
@ IncompatibleObjCQualifiedId
IncompatibleObjCQualifiedId - The assignment is between a qualified id type and something else (that ...
@ IncompatibleVectors
IncompatibleVectors - The assignment is between two vector types that have the same size,...
@ CompatiblePointerDiscardsQualifiers
CompatiblePointerDiscardsQualifiers - The assignment discards c/v/r qualifiers, which we accept as an...
@ IncompatiblePointer
IncompatiblePointer - The assignment is between two pointers types that are not compatible,...
@ IncompatibleObjCWeakRef
IncompatibleObjCWeakRef - Assigning a weak-unavailable object to an object with __weak qualifier.
@ Compatible
Compatible - the types are compatible according to the standard.
@ IncompatibleFunctionPointerStrict
IncompatibleFunctionPointerStrict - The assignment is between two function pointer types that are not...
@ Incompatible
Incompatible - We reject this conversion outright, it is invalid to represent it in the AST.
@ FunctionVoidPointer
FunctionVoidPointer - The assignment is between a function pointer and void*, which the standard does...
@ IncompatibleFunctionPointer
IncompatibleFunctionPointer - The assignment is between two function pointers types that are not comp...
@ IncompatiblePointerSign
IncompatiblePointerSign - The assignment is between two pointers types which point to integers which ...
@ IncompatibleNestedPointerQualifiers
IncompatibleNestedPointerQualifiers - The assignment is between two nested pointer types,...
@ IncompatibleNestedPointerAddressSpaceMismatch
IncompatibleNestedPointerAddressSpaceMismatch - The assignment changes address spaces in nested point...
@ PointerToInt
PointerToInt - The assignment converts a pointer to an int, which we accept as an extension.
@ IntToBlockPointer
IntToBlockPointer - The assignment converts an int to a block pointer.
void CheckShadowingDeclModification(Expr *E, SourceLocation Loc)
Warn if 'E', which is an expression that is about to be modified, refers to a shadowing declaration.
ArithConvKind
Context in which we're performing a usual arithmetic conversion.
@ ACK_Arithmetic
An arithmetic operation.
@ ACK_CompAssign
A compound assignment expression.
@ ACK_BitwiseOp
A bitwise operation.
@ ACK_Conditional
A conditional (?:) operator.
@ ACK_Comparison
A comparison.
void MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base=nullptr)
Perform reference-marking and odr-use handling for a DeclRefExpr.
ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E)
ExprResult ActOnSourceLocExpr(SourceLocIdentKind Kind, SourceLocation BuiltinLoc, SourceLocation RPLoc)
llvm::PointerIntPair< ConstantExpr *, 1 > ImmediateInvocationCandidate
ExprResult CheckPlaceholderExpr(Expr *E)
Check for operands with placeholder types and complain if found.
ExprResult TransformToPotentiallyEvaluated(Expr *E)
EnableIfAttr * CheckEnableIf(FunctionDecl *Function, SourceLocation CallLoc, ArrayRef< Expr * > Args, bool MissingImplicitThis=false)
Check the enable_if expressions on the given function.
@ CCK_ImplicitConversion
An implicit conversion.
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
SourceManager & getSourceManager() const
@ TryCapture_ExplicitByRef
ExprResult BuildAsTypeExpr(Expr *E, QualType DestTy, SourceLocation BuiltinLoc, SourceLocation RParenLoc)
Create a new AsTypeExpr node (bitcast) from the arguments.
ExprResult checkPseudoObjectRValue(Expr *E)
bool CheckVecStepExpr(Expr *E)
void diagnoseARCUnbridgedCast(Expr *e)
Given that we saw an expression with the ARCUnbridgedCastTy placeholder type, complain bitterly.
ExprResult FixOverloadedFunctionReference(Expr *E, DeclAccessPair FoundDecl, FunctionDecl *Fn)
FixOverloadedFunctionReference - E is an expression that refers to a C++ overloaded function (possibl...
ExprResult ActOnConditionalOp(SourceLocation QuestionLoc, SourceLocation ColonLoc, Expr *CondExpr, Expr *LHSExpr, Expr *RHSExpr)
ActOnConditionalOp - Parse a ?: operation.
QualType CheckVectorCompareOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc)
CheckVectorCompareOperands - vector comparisons are a clang extension that operates on extended vecto...
QualType CheckMultiplyDivideOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign, bool IsDivide)
ExprResult CheckCXXBooleanCondition(Expr *CondExpr, bool IsConstexpr=false)
CheckCXXBooleanCondition - Returns true if conversion to bool is invalid.
ExprResult CheckLValueToRValueConversionOperand(Expr *E)
QualType CheckAssignmentOperands(Expr *LHSExpr, ExprResult &RHS, SourceLocation Loc, QualType CompoundType, BinaryOperatorKind Opc)
ExprResult ActOnSYCLUniqueStableNameExpr(SourceLocation OpLoc, SourceLocation LParen, SourceLocation RParen, ParsedType ParsedTy)
void DiscardMisalignedMemberAddress(const Type *T, Expr *E)
This function checks if the expression is in the sef of potentially misaligned members and it is conv...
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
ExprResult SemaConvertVectorExpr(Expr *E, TypeSourceInfo *TInfo, SourceLocation BuiltinLoc, SourceLocation RParenLoc)
SemaConvertVectorExpr - Handle __builtin_convertvector.
ExprResult ActOnObjCBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind)
ActOnObjCBoolLiteral - Parse {__objc_yes,__objc_no} literals.
bool resolveAndFixAddressOfSingleOverloadCandidate(ExprResult &SrcExpr, bool DoFunctionPointerConversion=false)
Given an overloaded function, tries to turn it into a non-overloaded function reference using resolve...
ARCConversionResult CheckObjCConversion(SourceRange castRange, QualType castType, Expr *&op, CheckedConversionKind CCK, bool Diagnose=true, bool DiagnoseCFAudited=false, BinaryOperatorKind Opc=BO_PtrMemD)
Checks for invalid conversions and casts between retainable pointers and other pointer kinds for ARC ...
QualType CheckPointerToMemberOperands(ExprResult &LHS, ExprResult &RHS, ExprValueKind &VK, SourceLocation OpLoc, bool isIndirect)
bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement, const PartialDiagnostic &PD)
Conditionally issue a diagnostic based on the current evaluation context.
ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param, Expr *Init=nullptr)
BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating the default expr if needed.
void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=true, bool AllowExplicitConversion=false, ADLCallKind IsADLCandidate=ADLCallKind::NotADL, ConversionSequenceList EarlyConversions=std::nullopt, OverloadCandidateParamOrder PO={}, bool AggregateCandidateDeduction=false)
AddOverloadCandidate - Adds the given function to the set of candidate functions, using the given fun...
bool anyAltivecTypes(QualType srcType, QualType destType)
bool isLaxVectorConversion(QualType srcType, QualType destType)
Is this a legal conversion between two types, one of which is known to be a vector type?
void keepInLifetimeExtendingContext()
keepInLifetimeExtendingContext - Pull down InLifetimeExtendingContext flag from previous context.
void PushBlockScope(Scope *BlockScope, BlockDecl *Block)
sema::FunctionScopeInfo * getCurFunctionAvailabilityContext()
Retrieve the current function, if any, that should be analyzed for potential availability violations.
ExprResult BuildOverloadedCallExpr(Scope *S, Expr *Fn, UnresolvedLookupExpr *ULE, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc, Expr *ExecConfig, bool AllowTypoCorrection=true, bool CalleesAddressIsTaken=false)
BuildOverloadedCallExpr - Given the call expression that calls Fn (which eventually refers to the dec...
QualType CXXCheckConditionalOperands(ExprResult &cond, ExprResult &lhs, ExprResult &rhs, ExprValueKind &VK, ExprObjectKind &OK, SourceLocation questionLoc)
Check the operands of ?: under C++ semantics.
ExprResult BuildAnonymousStructUnionMemberReference(const CXXScopeSpec &SS, SourceLocation nameLoc, IndirectFieldDecl *indirectField, DeclAccessPair FoundDecl=DeclAccessPair::make(nullptr, AS_none), Expr *baseObjectExpr=nullptr, SourceLocation opLoc=SourceLocation())
MaybeODRUseExprSet MaybeODRUseExprs
bool InstantiateInClassInitializer(SourceLocation PointOfInstantiation, FieldDecl *Instantiation, FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs)
Instantiate the definition of a field from the given pattern.
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReciever=nullptr, bool SkipTrailingRequiresClause=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics.
bool CheckParmsForFunctionDef(ArrayRef< ParmVarDecl * > Parameters, bool CheckParameterNames)
CheckParmsForFunctionDef - Check that the parameters of the given function are appropriate for the de...
void CheckShadow(NamedDecl *D, NamedDecl *ShadowedDecl, const LookupResult &R)
Diagnose variable or built-in function shadowing.
ExprResult BuildCallToObjectOfClassType(Scope *S, Expr *Object, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc)
BuildCallToObjectOfClassType - Build a call to an object of class type (C++ [over....
ExprResult ActOnStringLiteral(ArrayRef< Token > StringToks, Scope *UDLScope=nullptr)
ActOnStringLiteral - The specified tokens were lexed as pasted string fragments (e....
bool isCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind=CompleteTypeKind::Default)
ExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc, tok::TokenKind Kind, Expr *LHSExpr, Expr *RHSExpr)
VarDecl * isOpenMPCapturedDecl(ValueDecl *D, bool CheckScopeInfo=false, unsigned StopAt=0)
Check if the specified variable is used in one of the private clauses (private, firstprivate,...
void checkUnusedDeclAttributes(Declarator &D)
checkUnusedDeclAttributes - Given a declarator which is not being used to build a declaration,...
ExprResult CheckExtVectorCast(SourceRange R, QualType DestTy, Expr *CastExpr, CastKind &Kind)
void setFunctionHasBranchProtectedScope()
ExprResult ActOnOMPArrayShapingExpr(Expr *Base, SourceLocation LParenLoc, SourceLocation RParenLoc, ArrayRef< Expr * > Dims, ArrayRef< SourceRange > Brackets)
bool CheckLoopHintExpr(Expr *E, SourceLocation Loc)
bool isConstantEvaluatedContext() const
void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation, FunctionDecl *Function, bool Recursive=false, bool DefinitionRequired=false, bool AtEndOfTU=false)
Instantiate the definition of the given function from its template.
void keepInMaterializeTemporaryObjectContext()
keepInMaterializeTemporaryObjectContext - Pull down InMaterializeTemporaryObjectContext flag from pre...
@ CVT_Host
Emitted on device side with a shadow variable on host side.
void mergeDeclAttributes(NamedDecl *New, Decl *Old, AvailabilityMergeKind AMK=AMK_Redeclaration)
mergeDeclAttributes - Copy attributes from the Old decl to the New one.
llvm::SmallPtrSet< const Decl *, 4 > ParsingInitForAutoVars
ParsingInitForAutoVars - a set of declarations with auto types for which we are currently parsing the...
const DeclContext * getCurObjCLexicalContext() const
bool CheckPointerConversion(Expr *From, QualType ToType, CastKind &Kind, CXXCastPath &BasePath, bool IgnoreBaseAccess, bool Diagnose=true)
CheckPointerConversion - Check the pointer conversion from the expression From to the type ToType.
SmallVector< ExprWithCleanups::CleanupObject, 8 > ExprCleanupObjects
ExprCleanupObjects - This is the stack of objects requiring cleanup that are created by the current f...
void NoteDeletedFunction(FunctionDecl *FD)
Emit a note explaining that this function is deleted.
sema::AnalysisBasedWarnings AnalysisWarnings
Worker object for performing CFG-based warnings.
std::deque< PendingImplicitInstantiation > PendingInstantiations
The queue of implicit template instantiations that are required but have not yet been performed.
ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc, Expr *Idx, SourceLocation RLoc)
void NoteAllOverloadCandidates(Expr *E, QualType DestType=QualType(), bool TakingAddress=false)
ExprResult ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind)
QualType GetSignedVectorType(QualType V)
QualType CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS, ExprResult &RHS, ExprValueKind &VK, ExprObjectKind &OK, SourceLocation QuestionLoc)
Note that LHS is not null here, even if this is the gnu "x ?: y" extension.
ExpressionEvaluationContext
Describes how the expressions currently being parsed are evaluated at run-time, if at all.
@ UnevaluatedAbstract
The current expression occurs within an unevaluated operand that unconditionally permits abstract ref...
@ UnevaluatedList
The current expression occurs within a braced-init-list within an unevaluated operand.
@ ConstantEvaluated
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
@ DiscardedStatement
The current expression occurs within a discarded statement.
@ PotentiallyEvaluated
The current expression is potentially evaluated at run time, which means that code may be generated t...
@ Unevaluated
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7),...
@ ImmediateFunctionContext
In addition of being constant evaluated, the current expression occurs in an immediate function conte...
@ PotentiallyEvaluatedIfUsed
The current expression is potentially evaluated, but any declarations referenced inside that expressi...
void CheckCompatibleReinterpretCast(QualType SrcType, QualType DestType, bool IsDereference, SourceRange Range)
ExprResult BuildDependentDeclRefExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)
ExprResult ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy, SourceLocation BuiltinLoc, SourceLocation RParenLoc)
__builtin_astype(...)
ExprResult CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo, SourceLocation OpLoc, UnaryExprOrTypeTrait ExprKind, SourceRange R)
Build a sizeof or alignof expression given a type operand.
TypeSourceInfo * GetTypeForDeclarator(Declarator &D)
GetTypeForDeclarator - Convert the type for the specified declarator to Type instances.
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
bool CheckCallReturnType(QualType ReturnType, SourceLocation Loc, CallExpr *CE, FunctionDecl *FD)
CheckCallReturnType - Checks that a call expression's return type is complete.
bool CheckUnaryExprOrTypeTraitOperand(Expr *E, UnaryExprOrTypeTrait ExprKind)
Check the constraints on expression operands to unary type expression and type traits.
ExprResult ActOnVAArg(SourceLocation BuiltinLoc, Expr *E, ParsedType Ty, SourceLocation RPLoc)
TypeSourceInfo * GetTypeForDeclaratorCast(Declarator &D, QualType FromTy)
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
ExprResult forceUnknownAnyToType(Expr *E, QualType ToType)
Force an expression with unknown-type to an expression of the given type.
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
void NoteDeletedInheritingConstructor(CXXConstructorDecl *CD)
QualType getCapturedDeclRefType(ValueDecl *Var, SourceLocation Loc)
Given a variable, determine the type that a reference to that variable will have in the given scope.
ExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc, Declarator &D, ParsedType &Ty, SourceLocation RParenLoc, Expr *CastExpr)
Expr * MaybeCreateExprWithCleanups(Expr *SubExpr)
MaybeCreateExprWithCleanups - If the current full-expression requires any cleanups,...
ExprResult BuildObjCSubscriptExpression(SourceLocation RB, Expr *BaseExpr, Expr *IndexExpr, ObjCMethodDecl *getterMethod, ObjCMethodDecl *setterMethod)
Build an ObjC subscript pseudo-object expression, given that that's supported by the runtime.
bool RebuildingImmediateInvocation
Whether the AST is currently being rebuilt to correct immediate invocations.
void DiagnoseAvailabilityOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass, bool ObjCPropertyAccess, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReceiver=nullptr)
void DiscardCleanupsInEvaluationContext()
bool NeedToCaptureVariable(ValueDecl *Var, SourceLocation Loc)
Checks if the variable must be captured.
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.
bool CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty, CastKind &Kind)
bool LookupTemplateName(LookupResult &R, Scope *S, CXXScopeSpec &SS, QualType ObjectType, bool EnteringContext, bool &MemberOfUnknownSpecialization, RequiredTemplateKind RequiredTemplate=SourceLocation(), AssumedTemplateKind *ATK=nullptr, bool AllowTypoCorrection=true)
bool isOpenMPCapturedByRef(const ValueDecl *D, unsigned Level, unsigned OpenMPCaptureLevel) const
Return true if the provided declaration VD should be captured by reference.
SourceManager & SourceMgr
bool CheckAlignasTypeArgument(StringRef KWName, TypeSourceInfo *TInfo, SourceLocation OpLoc, SourceRange R)
ExprResult BuildVectorLiteral(SourceLocation LParenLoc, SourceLocation RParenLoc, Expr *E, TypeSourceInfo *TInfo)
Build an altivec or OpenCL literal.
void checkRetainCycles(ObjCMessageExpr *msg)
checkRetainCycles - Check whether an Objective-C message send might create an obvious retain cycle.
bool isUnavailableAlignedAllocationFunction(const FunctionDecl &FD) const
Determine whether FD is an aligned allocation or deallocation function that is unavailable.
bool DiagnoseDependentMemberLookup(const LookupResult &R)
Diagnose a lookup that found results in an enclosing class during error recovery.
DiagnosticsEngine & Diags
OpenCLOptions & getOpenCLOptions()
NamespaceDecl * getStdNamespace() const
ExprResult DefaultFunctionArrayConversion(Expr *E, bool Diagnose=true)
DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).
void deduceClosureReturnType(sema::CapturingScopeInfo &CSI)
Deduce a block or lambda's return type based on the return statements present in the body.
bool areLaxCompatibleVectorTypes(QualType srcType, QualType destType)
Are the two types lax-compatible vector types? That is, given that one of them is a vector,...
ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)
void diagnoseMissingTemplateArguments(TemplateName Name, SourceLocation Loc)
ExprResult BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field)
void DiagnoseAssignmentAsCondition(Expr *E)
DiagnoseAssignmentAsCondition - Given that an expression is being used as a boolean condition,...
void checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec)
We've found a use of a templated declaration that would trigger an implicit instantiation.
void EmitRelatedResultTypeNote(const Expr *E)
If the given expression involves a message send to a method with a related result type,...
QualType CheckBitwiseOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc)
llvm::MapVector< NamedDecl *, SourceLocation > UndefinedButUsed
UndefinedInternals - all the used, undefined objects which require a definition in this translation u...
ExprResult ActOnStmtExpr(Scope *S, SourceLocation LPLoc, Stmt *SubStmt, SourceLocation RPLoc)
bool ResolveAndFixSingleFunctionTemplateSpecialization(ExprResult &SrcExpr, bool DoFunctionPointerConversion=false, bool Complain=false, SourceRange OpRangeForComplaining=SourceRange(), QualType DestTypeForComplaining=QualType(), unsigned DiagIDForComplaining=0)
ExprResult ConvertParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg, SourceLocation EqualLoc)
void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD)
ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in it, apply them to D.
void checkVariadicArgument(const Expr *E, VariadicCallType CT)
Check to see if the given expression is a valid argument to a variadic function, issuing a diagnostic...
void CheckStaticArrayArgument(SourceLocation CallLoc, ParmVarDecl *Param, const Expr *ArgExpr)
CheckStaticArrayArgument - If the given argument corresponds to a static array parameter,...
void FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S, bool ConsiderLinkage, bool AllowInlineNamespace)
Filters out lookup results that don't fall within the given scope as determined by isDeclInScope.
QualType CheckSizelessVectorCompareOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc)
ExprResult ConvertMemberDefaultInitExpression(FieldDecl *FD, Expr *InitExpr, SourceLocation InitLoc)
ExprResult BuildObjCNumericLiteral(SourceLocation AtLoc, Expr *Number)
BuildObjCNumericLiteral - builds an ObjCBoxedExpr AST node for the numeric literal expression.
bool IsInvalidSMECallConversion(QualType FromType, QualType ToType)
void checkNonTrivialCUnionInInitializer(const Expr *Init, SourceLocation Loc)
Emit diagnostics if the initializer or any of its explicit or implicitly-generated subexpressions req...
ExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc, Stmt *Body, Scope *CurScope)
ActOnBlockStmtExpr - This is called when the body of a block statement literal was successfully compl...
void DiagnoseDeletedDefaultedFunction(FunctionDecl *FD)
Produce notes explaining why a defaulted function was defined as deleted.
void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)
Run some code with "sufficient" stack space.
void MarkMemberReferenced(MemberExpr *E)
Perform reference-marking and odr-use handling for a MemberExpr.
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...
void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, bool MightBeOdrUse=true)
Mark a function referenced, and check whether it is odr-used (C++ [basic.def.odr]p2,...
ExprResult ActOnStmtExprResult(ExprResult E)
ExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc, tok::TokenKind Kind, Expr *Input)
bool GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl, const FunctionProtoType *Proto, unsigned FirstParam, ArrayRef< Expr * > Args, SmallVectorImpl< Expr * > &AllArgs, VariadicCallType CallType=VariadicDoesNotApply, bool AllowExplicit=false, bool IsListInitialization=false)
GatherArgumentsForCall - Collector argument expressions for various form of call prototypes.
std::tuple< MangleNumberingContext *, Decl * > getCurrentMangleNumberContext(const DeclContext *DC)
Compute the mangling number context for a lambda expression or block literal.
bool CheckConversionToObjCLiteral(QualType DstType, Expr *&SrcExpr, bool Diagnose=true)
void DiagnoseEqualityWithExtraParens(ParenExpr *ParenE)
Redundant parentheses over an equality comparison can indicate that the user intended an assignment u...
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.
ExprResult BuildBinOp(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr)
ExprResult ActOnNumericConstant(const Token &Tok, Scope *UDLScope=nullptr)
ExprResult PerformObjectMemberConversion(Expr *From, NestedNameSpecifier *Qualifier, NamedDecl *FoundDecl, NamedDecl *Member)
Cast a base object to a member's actual type.
ExprResult BuildInitList(SourceLocation LBraceLoc, MultiExprArg InitArgList, SourceLocation RBraceLoc)
void ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope)
ActOnBlockStart - This callback is invoked when a block literal is started.
ExprResult ActOnArraySubscriptExpr(Scope *S, Expr *Base, SourceLocation LLoc, MultiExprArg ArgExprs, SourceLocation RLoc)
ExprResult CreateBuiltinBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr)
CreateBuiltinBinOp - Creates a new built-in binary operation with operator Opc at location TokLoc.
AssignConvertType CheckAssignmentConstraints(SourceLocation Loc, QualType LHSType, QualType RHSType)
CheckAssignmentConstraints - Perform type checking for assignment, argument passing,...
void DiagnoseUnsatisfiedConstraint(const ConstraintSatisfaction &Satisfaction, bool First=true)
Emit diagnostics explaining why a constraint expression was deemed unsatisfied.
bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base)
Determine whether the type Derived is a C++ class that is derived from the type Base.
ExprResult ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig=nullptr)
ActOnCallExpr - Handle a call to Fn with the specified array of 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...
QualType PreferredConditionType(ConditionKind K) const
void clearDelayedTypo(TypoExpr *TE)
Clears the state of the given TypoExpr.
@ LOLR_ErrorNoDiagnostic
The lookup found no match but no diagnostic was issued.
@ LOLR_Raw
The lookup found a single 'raw' literal operator, which expects a string literal containing the spell...
@ LOLR_Error
The lookup resulted in an error.
@ LOLR_Cooked
The lookup found a single 'cooked' literal operator, which expects a normal literal to be built and p...
@ LOLR_StringTemplatePack
The lookup found an overload set of literal operator templates, which expect the character type and c...
@ LOLR_Template
The lookup found an overload set of literal operator templates, which expect the characters of the sp...
void ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo, Scope *CurScope)
ActOnBlockArguments - This callback allows processing of block arguments.
QualType CheckRemainderOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign=false)
@ Diagnose
Diagnose issues that are non-constant or that are extensions.
std::pair< ValueDecl *, SourceLocation > PendingImplicitInstantiation
An entity for which implicit template instantiation is required.
unsigned getTemplateDepth(Scope *S) const
Determine the number of levels of enclosing template parameters.
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false, bool ForceNoCPlusPlus=false)
Perform unqualified name lookup starting from a given scope.
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
ExprResult ActOnObjCAvailabilityCheckExpr(llvm::ArrayRef< AvailabilitySpec > AvailSpecs, SourceLocation AtLoc, SourceLocation RParen)
bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType)
Helper function to determine whether this is the (deprecated) C++ conversion from a string literal to...
void computeNRVO(Stmt *Body, sema::FunctionScopeInfo *Scope)
Given the set of return statements within a function body, compute the variables that are subject to ...
void checkNonTrivialCUnion(QualType QT, SourceLocation Loc, NonTrivialCUnionContext UseContext, unsigned NonTrivialKind)
Emit diagnostics if a non-trivial C union type or a struct that contains a non-trivial C union is use...
QualType CheckSubtractionOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, QualType *CompLHSTy=nullptr)
static ConditionResult ConditionError()
ExprResult ActOnConvertVectorExpr(Expr *E, ParsedType ParsedDestTy, SourceLocation BuiltinLoc, SourceLocation RParenLoc)
__builtin_convertvector(...)
void HandleFunctionTypeMismatch(PartialDiagnostic &PDiag, QualType FromType, QualType ToType)
HandleFunctionTypeMismatch - Gives diagnostic information for differeing function types.
ExprResult ActOnOMPIteratorExpr(Scope *S, SourceLocation IteratorKwLoc, SourceLocation LLoc, SourceLocation RLoc, ArrayRef< OMPIteratorData > Data)
const TypoExprState & getTypoExprState(TypoExpr *TE) const
ExprResult BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, const TemplateArgumentListInfo *TemplateArgs, const Scope *S, UnresolvedLookupExpr *AsULE=nullptr)
Builds an expression which might be an implicit member expression.
ExprResult checkUnknownAnyArg(SourceLocation callLoc, Expr *result, QualType ¶mType)
Type-check an expression that's being passed to an __unknown_anytype parameter.
bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn, FunctionDecl *FDecl, const FunctionProtoType *Proto, ArrayRef< Expr * > Args, SourceLocation RParenLoc, bool ExecConfig=false)
ConvertArgumentsForCall - Converts the arguments specified in Args/NumArgs to the parameter types of ...
ExprResult ActOnBuiltinOffsetOf(Scope *S, SourceLocation BuiltinLoc, SourceLocation TypeLoc, ParsedType ParsedArgTy, ArrayRef< OffsetOfComponent > Components, SourceLocation RParenLoc)
OpenMPClauseKind isOpenMPPrivateDecl(ValueDecl *D, unsigned Level, unsigned CapLevel) const
Check if the specified variable is used in 'private' clause.
bool hasAnyUnrecoverableErrorsInThisFunction() const
Determine whether any errors occurred within this function/method/ block.
FullExprArg MakeFullExpr(Expr *Arg)
bool IsFunctionConversion(QualType FromType, QualType ToType, QualType &ResultTy)
Determine whether the conversion from FromType to ToType is a valid conversion that strips "noexcept"...
llvm::SmallVector< std::pair< SourceLocation, const BlockDecl * >, 1 > ImplicitlyRetainedSelfLocs
List of SourceLocations where 'self' is implicitly retained inside a block.
MultiLevelTemplateArgumentList getTemplateInstantiationArgs(const NamedDecl *D, const DeclContext *DC=nullptr, bool Final=false, std::optional< ArrayRef< TemplateArgument > > Innermost=std::nullopt, bool RelativeToPrimary=false, const FunctionDecl *Pattern=nullptr, bool ForConstraintInstantiation=false, bool SkipForSpecialization=false)
Retrieve the template argument list(s) that should be used to instantiate the definition of the given...
bool isOpenMPTargetCapturedDecl(const ValueDecl *D, unsigned Level, unsigned CaptureLevel) const
Check if the specified variable is captured by 'target' directive.
bool CheckAltivecInitFromScalar(SourceRange R, QualType VecTy, QualType SrcTy)
ExprResult HandleExprEvaluationContextForTypeof(Expr *E)
ExprResult ActOnInitList(SourceLocation LBraceLoc, MultiExprArg InitArgList, SourceLocation RBraceLoc)
bool isCheckingDefaultArgumentOrInitializer() const
bool CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall, const FunctionProtoType *Proto)
CheckFunctionCall - Check a direct function call for various correctness and safety properties not st...
bool CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param, Expr *Init=nullptr, bool SkipImmediateInvocations=true)
Instantiate or parse a C++ default argument expression as necessary.
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...
void DiagnoseImmediateEscalatingReason(FunctionDecl *FD)
ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)
void FinalizeVarWithDestructor(VarDecl *VD, const RecordType *DeclInitType)
FinalizeVarWithDestructor - Prepare for calling destructor on the constructed variable.
ExprResult CreateBuiltinMatrixSubscriptExpr(Expr *Base, Expr *RowIdx, Expr *ColumnIdx, SourceLocation RBLoc)
Represents a function call to one of __builtin_LINE(), __builtin_COLUMN(), __builtin_FUNCTION(),...
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 isInMainFile(SourceLocation Loc) const
Returns whether the PresumedLoc for a given SourceLocation is in the main file.
bool isInSystemMacro(SourceLocation loc) const
Returns whether Loc is expanded from a macro in a system header.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
StandardConversionSequence - represents a standard conversion sequence (C++ 13.3.3....
ImplicitConversionKind Second
Second - The second conversion can be an integral promotion, floating point promotion,...
void setAsIdentityConversion()
StandardConversionSequence - Set the standard conversion sequence to the identity conversion.
void setToType(unsigned Idx, QualType T)
NarrowingKind getNarrowingKind(ASTContext &Context, const Expr *Converted, APValue &ConstantValue, QualType &ConstantType, bool IgnoreFloatToIntegralConversion=false) const
Check if this standard conversion sequence represents a narrowing conversion, according to C++11 [dcl...
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
StmtVisitor - This class implements a simple visitor for Stmt subclasses.
Stmt - This represents one statement.
SourceLocation getEndLoc() const LLVM_READONLY
StmtClass getStmtClass() const
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
SourceLocation getBeginLoc() const LLVM_READONLY
StringLiteralParser - This decodes string escape characters and performs wide string analysis and Tra...
StringLiteral - This represents a string literal expression, e.g.
unsigned getLength() const
uint32_t getCodeUnit(size_t i) const
static StringLiteral * Create(const ASTContext &Ctx, StringRef Str, StringLiteralKind Kind, bool Pascal, QualType Ty, const SourceLocation *Loc, unsigned NumConcatenated)
This is the "fully general" constructor that allows representation of strings formed from multiple co...
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
bool hasNameForLinkage() const
Is this tag type named, either directly or via being defined in a typedef of this type?
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Exposes information about the current target.
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
StringRef getPlatformName() const
Retrieve the name of the platform as it is used in the availability attribute.
@ CharPtrBuiltinVaList
typedef char* __builtin_va_list;
virtual size_t getMaxBitIntWidth() const
virtual bool useFP16ConversionIntrinsics() const
Check whether llvm intrinsics such as llvm.convert.to.fp16 should be used to convert to and from __fp...
unsigned getTypeWidth(IntType T) const
Return the width (in bits) of the specified integer type enum.
uint64_t getPointerWidth(LangAS AddrSpace) const
Return the width of pointers on this target, for the specified address space.
unsigned getIntWidth() const
getIntWidth/Align - Return the size of 'signed int' and 'unsigned int' for this target,...
IntType getSizeType() const
unsigned getLongLongWidth() const
getLongLongWidth/Align - Return the size of 'signed long long' and 'unsigned long long' for this targ...
bool isTLSSupported() const
Whether the target supports thread-local storage.
virtual bool supportsExtendIntArgs() const
Whether the option -fextend-arguments={32,64} is supported on the target.
virtual BuiltinVaListKind getBuiltinVaListKind() const =0
Returns the kind of __builtin_va_list type that should be used with this target.
bool hasBuiltinMSVaList() const
Returns whether or not type __builtin_ms_va_list type is available on this target.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
unsigned getIntMaxTWidth() const
Return the size of intmax_t and uintmax_t for this target, in bits.
unsigned getLongWidth() const
getLongWidth/Align - Return the size of 'signed long' and 'unsigned long' for this target,...
virtual bool hasFeature(StringRef Feature) const
Determine whether the given target has the given feature.
A convenient class for passing around template argument information.
void setLAngleLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
void addArgument(const TemplateArgumentLoc &Loc)
Location wrapper for a TemplateArgument.
Represents a template argument.
Expr * getAsExpr() const
Retrieve the template argument as an expression.
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
@ Declaration
The template argument is a declaration that was provided for a pointer, reference,...
@ Expression
The template argument is an expression, and we've not resolved it to one of the other forms yet,...
ArgKind getKind() const
Return the kind of stored template argument.
The base class of all kinds of template declarations (e.g., class, function, etc.).
Represents a C++ template name within the type system.
Token - This structure provides full information about a lexed token.
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file.
unsigned getLength() const
void setKind(tok::TokenKind K)
tok::TokenKind getKind() const
void setLocation(SourceLocation L)
void startToken()
Reset all flags to cleared.
void setIdentifierInfo(IdentifierInfo *II)
Represents a declaration of a type.
const Type * getTypeForDecl() const
SourceLocation getBeginLoc() const LLVM_READONLY
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
TypeSpecTypeLoc pushTypeSpec(QualType T)
Pushes space for a typespec TypeLoc.
TypeSourceInfo * getTypeSourceInfo(ASTContext &Context, QualType T)
Creates a TypeSourceInfo for the given type.
Base wrapper for a particular "section" of type source info.
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
void initializeFullCopy(TypeLoc Other)
Initializes this by copying its information from another TypeLoc of the same type.
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
SourceRange getLocalSourceRange() const
Get the local source range.
T getAsAdjusted() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
SourceLocation getBeginLoc() const
Get the begin source location.
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
void setNameLoc(SourceLocation Loc)
The base class of the type hierarchy.
bool isIncompleteOrObjectType() const
Return true if this is an incomplete or object type, in other words, not a function type.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isFixedPointOrIntegerType() const
Return true if this is a fixed point or integer type.
bool isBlockPointerType() const
bool isBooleanType() const
bool isObjCBuiltinType() const
bool hasAttr(attr::Kind AK) const
Determine whether this type had the specified attribute applied to it (looking through top-level type...
const Type * getPointeeOrArrayElementType() const
If this is a pointer type, return the pointee type.
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
bool isPlaceholderType() const
Test for a type which does not represent an actual type-system type but is instead used as a placehol...
bool isComplexType() const
isComplexType() does not include complex integers (a GCC extension).
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
bool isConstantArrayType() const
bool canDecayToPointerType() const
Determines whether this type can decay to a pointer type.
bool hasIntegerRepresentation() const
Determine whether this type has an integer representation of some sort, e.g., it is an integer type o...
bool isVoidPointerType() const
const ComplexType * getAsComplexIntegerType() const
bool isFunctionPointerType() const
bool isArithmeticType() const
bool isConstantMatrixType() const
bool isPointerType() const
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
bool isSVESizelessBuiltinType() const
Returns true for SVE scalable vector types.
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
bool isSignedFixedPointType() const
Return true if this is a fixed point type that is signed according to ISO/IEC JTC1 SC22 WG14 N1169.
bool isEnumeralType() const
bool isScalarType() const
bool isVariableArrayType() const
bool isSizelessBuiltinType() const
bool isSveVLSBuiltinType() const
Determines if this is a sizeless type supported by the 'arm_sve_vector_bits' type attribute,...
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
bool isObjCQualifiedIdType() 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.
bool hasUnsignedIntegerRepresentation() const
Determine whether this type has an unsigned integer representation of some sort, e....
bool isExtVectorType() const
bool isAnyCharacterType() const
Determine whether this type is any of the built-in character types.
bool isExtVectorBoolType() const
QualType getSveEltType(const ASTContext &Ctx) const
Returns the representative type for the element of an SVE builtin type.
bool isNonOverloadPlaceholderType() const
Test for a placeholder type other than Overload; see BuiltinType::isNonOverloadPlaceholderType.
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
bool isBitIntType() const
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
bool isBuiltinType() const
Helper methods to distinguish type categories.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool isAnyComplexType() const
bool isFixedPointType() const
Return true if this is a fixed point type according to ISO/IEC JTC1 SC22 WG14 N1169.
bool isSaturatedFixedPointType() const
Return true if this is a saturated fixed point type according to ISO/IEC JTC1 SC22 WG14 N1169.
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
ScalarTypeKind getScalarTypeKind() const
Given that this is a scalar type, classify it.
const BuiltinType * getAsPlaceholderType() const
bool hasSignedIntegerRepresentation() const
Determine whether this type has an signed integer representation of some sort, e.g....
bool isWebAssemblyTableType() const
Returns true if this is a WebAssembly table type: either an array of reference types,...
bool isMemberPointerType() const
bool isAtomicType() const
bool isOverloadableType() const
Determines whether this is a type for which one can define an overloaded operator.
bool isObjCIdType() const
bool isMatrixType() const
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isComplexIntegerType() const
bool isUnscopedEnumerationType() const
bool isObjCObjectType() const
bool isBlockCompatibleObjCPointerType(ASTContext &ctx) const
const ArrayType * getAsArrayTypeUnsafe() const
A variant of getAs<> for array types which silently discards qualifiers from the outermost type.
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isFunctionType() const
bool isObjCObjectPointerType() const
bool hasFloatingRepresentation() const
Determine whether this type has a floating-point representation of some sort, e.g....
bool isUnsignedFixedPointType() const
Return true if this is a fixed point type that is unsigned according to ISO/IEC JTC1 SC22 WG14 N1169.
bool isVectorType() const
bool isObjCQualifiedClassType() const
bool isObjCClassType() const
bool isRealFloatingType() const
Floating point categories.
bool isRVVSizelessBuiltinType() const
Returns true for RVV scalable vector types.
bool isFloatingType() const
bool isUnsignedIntegerType() const
Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...
bool isAnyPointerType() const
TypeClass getTypeClass() const
const T * getAs() const
Member-template getAs<specific type>'.
bool isNullPtrType() const
bool isRecordType() const
std::optional< NullabilityKind > getNullability() const
Determine the nullability of the given type.
bool isSizelessVectorType() const
Returns true for all scalable vector types.
Represents the declaration of a typedef-name via the 'typedef' type specifier.
Simple class containing the result of Sema::CorrectTypo.
IdentifierInfo * getCorrectionAsIdentifierInfo() const
std::string getAsString(const LangOptions &LO) const
SourceRange getCorrectionRange() const
void WillReplaceSpecifier(bool ForceReplacement)
DeclClass * getCorrectionDeclAs() const
DeclarationName getCorrection() const
Gets the DeclarationName of the typo correction.
NestedNameSpecifier * getCorrectionSpecifier() const
Gets the NestedNameSpecifier needed to use the typo correction.
bool isOverloaded() const
NamedDecl * getFoundDecl() const
Get the correction declaration found by name lookup (before we looked through using shadow declaratio...
TypoExpr - Internal placeholder for expressions where typo correction still needs to be performed and...
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand.
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
SourceLocation getOperatorLoc() const
getOperatorLoc - Return the location of the operator.
Expr * getSubExpr() const
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)
Retrieve the overloaded operator kind that corresponds to the given unary opcode.
static UnaryOperator * Create(const ASTContext &C, Expr *input, Opcode opc, QualType type, ExprValueKind VK, ExprObjectKind OK, SourceLocation l, bool CanOverflow, FPOptionsOverride FPFeatures)
bool isIncrementDecrementOp() const
An artificial decl, representing a global anonymous constant value which is uniquified by value withi...
Represents a C++ unqualified-id that has been parsed.
void setImplicitSelfParam(const IdentifierInfo *Id)
Specify that this unqualified-id is an implicit 'self' parameter.
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
static UnresolvedLookupExpr * Create(const ASTContext &Context, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool RequiresADL, bool Overloaded, UnresolvedSetIterator Begin, UnresolvedSetIterator End)
Represents a C++ member access expression for which lookup produced a set of overloaded functions.
CXXRecordDecl * getNamingClass()
Retrieve the naming class of this lookup.
bool isImplicitAccess() const
True if this is an implicit access, i.e., one in which the member being accessed was not written in t...
A set of unresolved declarations.
A set of unresolved declarations.
A call to a literal operator (C++11 [over.literal]) written as a user-defined literal (C++11 [lit....
Represents a call to the builtin function __builtin_va_arg.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
void setType(QualType newType)
bool isWeak() const
Determine whether this symbol is weakly-imported, or declared with the weak or weak-ref attr.
VarDecl * getPotentiallyDecomposedVarDecl()
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)
VarDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
bool isStaticDataMember() const
Determines whether this is a static data member.
bool hasGlobalStorage() const
Returns true for all variables that do not have local storage.
bool mightBeUsableInConstantExpressions(const ASTContext &C) const
Determine whether this variable's value might be usable in a constant expression, according to the re...
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
For a static data member that was instantiated from a static data member of a class template,...
bool isInline() const
Whether this variable is (C++1z) inline.
const Expr * getInit() const
bool hasExternalStorage() const
Returns true if a variable has extern or private_extern storage.
bool isARCPseudoStrong() const
Determine whether this variable is an ARC pseudo-__strong variable.
bool hasLocalStorage() const
Returns true if a variable with function scope is a non-static local variable.
@ TLS_None
Not a TLS variable.
@ DeclarationOnly
This declaration is only a declaration.
DefinitionKind hasDefinition(ASTContext &) const
Check whether this variable is defined in this translation unit.
bool isUsableInConstantExpressions(const ASTContext &C) const
Determine whether this variable's value can be used in a constant expression, according to the releva...
SourceLocation getPointOfInstantiation() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
bool isLocalVarDeclOrParm() const
Similar to isLocalVarDecl but also includes parameters.
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this variable is an instantiation of a static data member of a class template specialization,...
Declaration of a variable template.
Represents a C array with a specified size that is not an integer-constant-expression.
Expr * getSizeExpr() const
Represents a GCC generic vector type.
unsigned getNumElements() const
VectorKind getVectorKind() const
QualType getElementType() const
Policy getDefaultPolicy()
Retains information about a block that is currently being parsed.
Scope * TheScope
TheScope - This is the scope for the block itself, which contains arguments etc.
QualType FunctionType
BlockType - The function type of the block, if one was given.
ValueDecl * getVariable() const
bool isBlockCapture() const
SourceLocation getLocation() const
Retrieve the location at which this variable was captured.
void markUsed(bool IsODRUse)
bool isThisCapture() const
QualType getCaptureType() const
Retrieve the capture type for this capture, which is effectively the type of the non-static data memb...
bool isCopyCapture() const
Retains information about a captured region.
unsigned short OpenMPLevel
unsigned short CapRegionKind
The kind of captured region.
unsigned short OpenMPCaptureLevel
void addVLATypeCapture(SourceLocation Loc, const VariableArrayType *VLAType, QualType CaptureType)
QualType ReturnType
ReturnType - The target type of return statements in this context, or null if unknown.
SmallVector< Capture, 4 > Captures
Captures - The captures.
ImplicitCaptureStyle ImpCaptureStyle
unsigned CXXThisCaptureIndex
CXXThisCaptureIndex - The (index+1) of the capture of 'this'; zero if 'this' is not captured.
bool HasImplicitReturnType
Capture & getCXXThisCapture()
Retrieve the capture of C++ 'this', if it has been captured.
llvm::DenseMap< ValueDecl *, unsigned > CaptureMap
CaptureMap - A map of captured variables to (index+1) into Captures.
bool isCXXThisCaptured() const
Determine whether the C++ 'this' is captured.
bool isVLATypeCaptured(const VariableArrayType *VAT) const
Determine whether the given variable-array type has been captured.
void addCapture(ValueDecl *Var, bool isBlock, bool isByref, bool isNested, SourceLocation Loc, SourceLocation EllipsisLoc, QualType CaptureType, bool Invalid)
Capture & getCapture(ValueDecl *Var)
Retrieve the capture of the given variable, if it has been captured already.
Retains information about a function, method, or block that is currently being parsed.
void recordUseOfWeak(const ExprT *E, bool IsRead=true)
Record that a weak object was accessed.
void markSafeWeakUse(const Expr *E)
Record that a given expression is a "safe" access of a weak object (e.g.
void addBlock(const BlockDecl *BD)
void setHasBranchProtectedScope()
llvm::SmallVector< AddrLabelExpr *, 4 > AddrLabels
The set of GNU address of label extension "&&label".
bool HasOMPDeclareReductionCombiner
True if current scope is for OpenMP declare reduction combiner.
SourceRange IntroducerRange
Source range covering the lambda introducer [...].
bool lambdaCaptureShouldBeConst() const
void addPotentialCapture(Expr *VarExpr)
Add a variable that might potentially be captured by the lambda and therefore the enclosing lambdas.
void addPotentialThisCapture(SourceLocation Loc)
ParmVarDecl * ExplicitObjectParameter
CXXRecordDecl * Lambda
The class that describes the lambda.
unsigned NumExplicitCaptures
The number of captures in the Captures list that are explicit captures.
bool AfterParameterList
Indicate that we parsed the parameter list at which point the mutability of the lambda is known.
CXXMethodDecl * CallOperator
The lambda's compiler-generated operator().
Defines the clang::TargetInfo interface.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
bool isStringLiteral(TokenKind K)
Return true if this is a C or C++ string-literal (or C++11 user-defined-string-literal) token.
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
The JSON file list parser is used to communicate input to InstallAPI.
@ Vector
'vector' clause, allowed on 'loop', Combined, and 'routine' directives.
@ Self
'self' clause, allowed on Compute and Combined Constructs, plus 'update'.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
@ OO_None
Not an overloaded operator.
bool isa(CodeGen::Address addr)
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
@ OR_Success
Overload resolution succeeded.
bool isTargetAddressSpace(LangAS AS)
DeclContext * getLambdaAwareParentOfDeclContext(DeclContext *DC)
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
NullabilityKind
Describes the nullability of a particular type.
@ Nullable
Values of this type can be null.
@ Unspecified
Whether values of this type can be null is (explicitly) unspecified.
@ NonNull
Values of this type can never be null.
ExprObjectKind
A further classification of the kind of object referenced by an l-value or x-value.
@ OK_VectorComponent
A vector component is an element or range of elements on a vector.
@ OK_ObjCProperty
An Objective-C property is a logical field of an Objective-C object which is read and written via Obj...
@ OK_Ordinary
An ordinary object is located at an address in memory.
@ OK_BitField
A bitfield object is a bitfield on a C or C++ record.
@ OK_MatrixComponent
A matrix component is a single element of a matrix.
@ IK_ImplicitSelfParam
An implicit 'self' parameter.
@ IK_TemplateId
A template-id, e.g., f<int>.
llvm::omp::Clause OpenMPClauseKind
OpenMP clauses.
std::optional< ComparisonCategoryType > getComparisonCategoryForBuiltinCmp(QualType T)
Get the comparison category that should be used when comparing values of type T.
UnaryExprOrTypeTrait
Names for the "expression or type" traits.
ObjCMethodFamily
A family of Objective-C methods.
unsigned toTargetAddressSpace(LangAS AS)
@ Internal
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
TemplateDecl * getAsTypeTemplateDecl(Decl *D)
bool isLambdaCallOperator(const CXXMethodDecl *MD)
@ Result
The result type of a method or function.
ImplicitConversionKind
ImplicitConversionKind - The kind of implicit conversion used to convert an argument to a parameter's...
@ ICK_Complex_Conversion
Complex conversions (C99 6.3.1.6)
@ ICK_Integral_Conversion
Integral conversions (C++ [conv.integral])
@ ICK_Floating_Integral
Floating-integral conversions (C++ [conv.fpint])
@ ICK_Array_To_Pointer
Array-to-pointer conversion (C++ [conv.array])
@ ICK_Identity
Identity conversion (no conversion)
@ ICK_Lvalue_To_Rvalue
Lvalue-to-rvalue conversion (C++ [conv.lval])
@ ICK_Floating_Conversion
Floating point conversions (C++ [conv.double].
@ ICK_Complex_Real
Complex-real conversions (C99 6.3.1.7)
@ ICK_Function_To_Pointer
Function-to-pointer (C++ [conv.array])
bool isFunctionLocalStringLiteralMacro(tok::TokenKind K, const LangOptions &LO)
Return true if the token corresponds to a function local predefined macro, which expands to a string ...
ActionResult< Expr * > ExprResult
LangAS
Defines the address space values used by the address space qualifier of QualType.
CastKind
CastKind - The kind of operation required for a conversion.
OverloadedOperatorKind getRewrittenOverloadedOperator(OverloadedOperatorKind Kind)
Get the other overloaded operator that the given operator can be rewritten into, if any such operator...
@ TNK_Var_template
The name refers to a variable template whose specialization produces a variable.
bool isPtrSizeAddressSpace(LangAS AS)
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
@ VK_XValue
An x-value expression is a reference to an object with independent storage but which can be "moved",...
@ VK_LValue
An l-value expression is a reference to an object with independent storage.
const char * getTraitSpelling(ExpressionTrait T) LLVM_READONLY
Return the spelling of the type trait TT. Never null.
@ NK_Not_Narrowing
Not a narrowing conversion.
@ NK_Constant_Narrowing
A narrowing conversion, because a constant expression got narrowed.
@ NK_Dependent_Narrowing
Cannot tell whether this is a narrowing conversion because the expression is value-dependent.
@ NK_Type_Narrowing
A narrowing conversion by virtue of the source and destination types.
@ NK_Variable_Narrowing
A narrowing conversion, because a non-constant-expression variable might have got narrowed.
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
ActionResult< Decl * > DeclResult
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
@ TSK_ExplicitInstantiationDeclaration
This template specialization was instantiated from a template due to an explicit instantiation declar...
@ TSK_ImplicitInstantiation
This template specialization was implicitly instantiated from a template.
@ TSK_Undeclared
This template specialization was formed from a template-id but has not yet been declared,...
CallingConv
CallingConv - Specifies the calling convention that a function uses.
@ AltiVecBool
is AltiVec 'vector bool ...'
@ SveFixedLengthData
is AArch64 SVE fixed-length data vector
@ AltiVecVector
is AltiVec vector
@ AltiVecPixel
is AltiVec 'vector Pixel'
@ Generic
not a target-specific vector type
@ RVVFixedLengthData
is RISC-V RVV fixed-length data vector
@ RVVFixedLengthMask
is RISC-V RVV fixed-length mask vector
@ SveFixedLengthPredicate
is AArch64 SVE fixed-length predicate vector
@ None
No keyword precedes the qualified type name.
@ Other
Other implicit parameter.
bool isGenericLambdaCallOperatorSpecialization(const CXXMethodDecl *MD)
NonOdrUseReason
The reason why a DeclRefExpr does not constitute an odr-use.
@ NOUR_Discarded
This name appears as a potential result of a discarded value expression.
@ NOUR_Unevaluated
This name appears in an unevaluated operand.
@ NOUR_None
This is an odr-use.
@ NOUR_Constant
This name appears as a potential result of an lvalue-to-rvalue conversion that is a constant expressi...
Represents an element in a path from a derived class to a base class.
The class facilities generation and storage of conversion FixIts.
OverloadFixItKind Kind
The type of fix applied.
bool tryToFixConversion(const Expr *FromExpr, const QualType FromQTy, const QualType ToQTy, Sema &S)
If possible, generates and stores a fix for the given conversion.
std::vector< FixItHint > Hints
The list of Hints generated so far.
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
DeclarationName getName() const
getName - Returns the embedded declaration name.
void setCXXLiteralOperatorNameLoc(SourceLocation Loc)
setCXXLiteralOperatorNameLoc - Sets the location of the literal operator name (not the operator keywo...
SourceLocation getBeginLoc() const
getBeginLoc - Retrieve the location of the first token.
SourceLocation getEndLoc() const LLVM_READONLY
EvalResult is a struct with detailed info about an evaluated expression.
APValue Val
Val - This is the value the expression can be folded to.
SmallVectorImpl< PartialDiagnosticAt > * Diag
Diag - If this is non-null, it will be filled in with a stack of notes indicating why evaluation fail...
bool HasSideEffects
Whether the evaluated expression has side effects.
Extra information about a function prototype.
unsigned HasTrailingReturn
FunctionType::ExtInfo ExtInfo
Iterator definition representation.
SourceLocation AssignmentLoc
SourceLocation SecondColonLoc
Helper expressions and declaration for OMPIteratorExpr class for each iteration space.
Expr * CounterUpdate
Updater for the internal counter: ++CounterVD;.
Expr * Upper
Normalized upper bound.
Expr * Update
Update expression for the originally specified iteration variable, calculated as VD = Begin + Counter...
VarDecl * CounterVD
Internal normalized counter.
bool HasFormOfMemberPointer
OverloadExpr * Expression
@ DefaultFunctionArgumentInstantiation
We are instantiating a default argument for a function.
Data structure used to record current or nested expression evaluation contexts.
llvm::SmallPtrSet< const Expr *, 8 > PossibleDerefs
SmallVector< Expr *, 2 > VolatileAssignmentLHSs
Expressions appearing as the LHS of a volatile assignment in this context.
bool isUnevaluated() const
llvm::SmallPtrSet< DeclRefExpr *, 4 > ReferenceToConsteval
Set of DeclRefExprs referencing a consteval function when used in a context not already known to be i...
llvm::SmallVector< ImmediateInvocationCandidate, 4 > ImmediateInvocationCandidates
Set of candidates for starting an immediate invocation.
SmallVector< MaterializeTemporaryExpr *, 8 > ForRangeLifetimeExtendTemps
P2718R0 - Lifetime extension in range-based for loops.
enum clang::Sema::ExpressionEvaluationContextRecord::ExpressionKind ExprContext
SmallVector< LambdaExpr *, 2 > Lambdas
The lambdas that are present within this context, if it is indeed an unevaluated context.
ExpressionKind
Describes whether we are in an expression constext which we have to handle differently.
MaybeODRUseExprSet SavedMaybeODRUseExprs
CleanupInfo ParentCleanup
Whether the enclosing context needed a cleanup.
unsigned NumTypos
The number of typos encountered during this expression evaluation context (i.e.
bool isConstantEvaluated() const
ExpressionEvaluationContext Context
The expression evaluation context.
bool InImmediateEscalatingFunctionContext
unsigned NumCleanupObjects
The number of active cleanup objects when we entered this expression evaluation context.
Data structure for iterator expression.
Abstract class used to diagnose incomplete types.
Location information for a TemplateArgument.