58#include "llvm/ADT/STLExtras.h"
59#include "llvm/ADT/STLForwardCompat.h"
60#include "llvm/ADT/StringExtras.h"
61#include "llvm/Support/Casting.h"
62#include "llvm/Support/ConvertUTF.h"
63#include "llvm/Support/SaveAndRestore.h"
64#include "llvm/Support/TypeSize.h"
90 if (TreatUnavailableAsInvalid &&
100 if (isa<UnresolvedUsingIfExistsDecl>(D))
108 if (
const auto *A = D->
getAttr<UnusedAttr>()) {
111 if (A->getSemanticSpelling() != UnusedAttr::CXX11_maybe_unused &&
112 A->getSemanticSpelling() != UnusedAttr::C23_maybe_unused) {
114 if (DC && !DC->
hasAttr<UnusedAttr>())
115 S.
Diag(
Loc, diag::warn_used_but_marked_unused) << D;
124 if (
Decl->isDefaulted()) {
135 auto *Ctor = dyn_cast<CXXConstructorDecl>(
Decl);
136 if (Ctor && Ctor->isInheritingConstructor())
147 if (I->getStorageClass() !=
SC_None)
174 if (!Current->isInlined())
176 if (!Current->isExternallyVisible())
192 if (!DowngradeWarning && UsedFn)
195 S.
Diag(
Loc, DowngradeWarning ? diag::ext_internal_in_extern_inline_quiet
196 : diag::ext_internal_in_extern_inline)
211 Diag(DeclBegin, diag::note_convert_inline_to_static)
230 bool ObjCPropertyAccess,
231 bool AvoidPartialAvailabilityChecks,
233 bool SkipTrailingRequiresClause) {
241 Diag(Suppressed.first, Suppressed.second);
252 if (cast<FunctionDecl>(D)->isMain())
253 Diag(
Loc, diag::ext_main_used);
260 if (isa<BindingDecl>(D)) {
261 Diag(
Loc, diag::err_binding_cannot_appear_in_own_initializer)
264 Diag(
Loc, diag::err_auto_variable_cannot_appear_in_own_initializer)
265 << D->
getDeclName() << cast<VarDecl>(D)->getType();
272 if (FD->isDeleted()) {
273 auto *Ctor = dyn_cast<CXXConstructorDecl>(FD);
274 if (Ctor && Ctor->isInheritingConstructor())
275 Diag(
Loc, diag::err_deleted_inherited_ctor_use)
277 << Ctor->getInheritedConstructor().getConstructor()->getParent();
280 Diag(
Loc, diag::err_deleted_function_use)
281 << (Msg !=
nullptr) << (Msg ? Msg->
getString() : StringRef());
295 if (!SkipTrailingRequiresClause && FD->getTrailingRequiresClause()) {
304 diag::err_reference_to_function_with_unsatisfied_constraints)
322 if (
auto *MD = dyn_cast<CXXMethodDecl>(D)) {
324 if (MD->getParent()->isLambda() &&
325 ((isa<CXXConstructorDecl>(MD) &&
326 cast<CXXConstructorDecl>(MD)->isDefaultConstructor()) ||
327 MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator())) {
328 Diag(
Loc, diag::warn_cxx17_compat_lambda_def_ctor_assign)
329 << !isa<CXXConstructorDecl>(MD);
333 auto getReferencedObjCProp = [](
const NamedDecl *D) ->
335 if (
const auto *MD = dyn_cast<ObjCMethodDecl>(D))
350 auto *DRD = dyn_cast<OMPDeclareReductionDecl>(
CurContext);
353 Diag(
Loc, diag::err_omp_wrong_var_in_declare_reduction)
364 if (
LangOpts.OpenMP && isa<VarDecl>(D) &&
365 !
OpenMP().isOpenMPDeclareMapperVarDeclAllowed(cast<VarDecl>(D))) {
366 Diag(
Loc, diag::err_omp_declare_mapper_wrong_var)
372 if (
const auto *EmptyD = dyn_cast<UnresolvedUsingIfExistsDecl>(D)) {
373 Diag(
Loc, diag::err_use_of_empty_using_if_exists);
374 Diag(EmptyD->getLocation(), diag::note_empty_using_if_exists_here);
379 AvoidPartialAvailabilityChecks, ClassReceiver);
385 if (D->
hasAttr<AvailableOnlyInDefaultEvalMethodAttr>()) {
391 diag::err_type_available_only_in_default_eval_method)
395 if (
auto *VD = dyn_cast<ValueDecl>(D))
401 if (
const auto *VD = dyn_cast<VarDecl>(D))
403 targetDiag(*Locs.begin(), diag::err_thread_unsupported);
406 if (isa<ParmVarDecl>(D) && isa<RequiresExprBodyDecl>(D->
getDeclContext()) &&
411 Diag(
Loc, diag::err_requires_expr_parameter_referenced_in_evaluated_context)
426 const SentinelAttr *
Attr = D->
getAttr<SentinelAttr>();
431 unsigned NumFormalParams;
435 enum { CK_Function, CK_Method, CK_Block } CalleeKind;
437 if (
const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
438 NumFormalParams = MD->param_size();
439 CalleeKind = CK_Method;
440 }
else if (
const auto *FD = dyn_cast<FunctionDecl>(D)) {
441 NumFormalParams = FD->param_size();
442 CalleeKind = CK_Function;
443 }
else if (
const auto *VD = dyn_cast<VarDecl>(D)) {
450 CalleeKind = CK_Function;
453 CalleeKind = CK_Block;
458 if (
const auto *proto = dyn_cast<FunctionProtoType>(Fn))
459 NumFormalParams = proto->getNumParams();
470 unsigned NullPos =
Attr->getNullPos();
471 assert((NullPos == 0 || NullPos == 1) &&
"invalid null position on sentinel");
472 NumFormalParams = (NullPos > NumFormalParams ? 0 : NumFormalParams - NullPos);
475 unsigned NumArgsAfterSentinel =
Attr->getSentinel();
479 if (Args.size() < NumFormalParams + NumArgsAfterSentinel + 1) {
486 const Expr *SentinelExpr = Args[Args.size() - NumArgsAfterSentinel - 1];
499 std::string NullValue;
503 NullValue =
"nullptr";
507 NullValue =
"(void*) 0";
510 Diag(
Loc, diag::warn_missing_sentinel) <<
int(CalleeKind);
512 Diag(MissingNilLoc, diag::warn_missing_sentinel)
537 assert(!Ty.
isNull() &&
"DefaultFunctionArrayConversion - missing type");
541 if (
auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl()))
546 CK_FunctionToPointerDecay).
get();
561 CK_ArrayToPointerDecay);
577 if (UO && UO->getOpcode() == UO_Deref &&
578 UO->getSubExpr()->getType()->isPointerType()) {
580 UO->getSubExpr()->getType()->getPointeeType().getAddressSpace();
583 UO->getSubExpr()->IgnoreParenCasts()->isNullPointerConstant(
585 !UO->getType().isVolatileQualified()) {
587 S.
PDiag(diag::warn_indirection_through_null)
588 << UO->getSubExpr()->getSourceRange());
590 S.
PDiag(diag::note_indirection_through_null));
622 if (ObjectSetClass) {
666 assert(!
T.isNull() &&
"r-value conversion on typeless expression?");
708 SourceRange(OISA->getOpLoc(), OISA->getIsaMemberLoc()),
")");
725 if (
T.hasQualifiers())
726 T =
T.getUnqualifiedType();
756 T =
Atomic->getValueType().getUnqualifiedType();
783 CK_FunctionToPointerDecay);
806 assert(!Ty.
isNull() &&
"UsualUnaryConversions - missing type");
813 switch (EvalMethod) {
815 llvm_unreachable(
"Unrecognized float evaluation method");
818 llvm_unreachable(
"Float evaluation method should be set by now");
826 CK_FloatingComplexCast)
835 CK_FloatingComplexCast)
883 assert(!Ty.
isNull() &&
"DefaultArgumentPromotion - missing type");
895 if (BTy && (BTy->
getKind() == BuiltinType::Half ||
896 BTy->
getKind() == BuiltinType::Float)) {
899 if (BTy->
getKind() == BuiltinType::Half) {
917 "Unexpected typesize for LongLongTy");
982 if (!
Record->hasNonTrivialCopyConstructor() &&
983 !
Record->hasNonTrivialMoveConstructor() &&
984 !
Record->hasNonTrivialDestructor())
1011 PDiag(diag::warn_cxx98_compat_pass_non_pod_arg_to_vararg) << Ty << CT);
1018 PDiag(diag::warn_pass_class_arg_to_vararg)
1026 PDiag(diag::warn_cannot_pass_non_pod_arg_to_vararg)
1033 diag::err_cannot_pass_non_trivial_c_struct_to_vararg)
1037 PDiag(diag::err_cannot_pass_objc_interface_to_vararg)
1041 << isa<InitListExpr>(E) << Ty << CT;
1052 if (PlaceholderTy->getKind() == BuiltinType::ARCUnbridgedCast &&
1054 (FDecl && FDecl->
hasAttr<CFAuditedTransferAttr>()))) {
1093 if (
Call.isInvalid())
1098 if (Comma.isInvalid())
1105 diag::err_call_incomplete_argument))
1123 if (SkipCast)
return false;
1130 CK_IntegralComplexToFloatingComplex);
1148 bool PromotePrecision) {
1153 if (PromotePrecision) {
1158 if (LongerIsComplex)
1170 QualType RHSType,
bool IsCompAssign) {
1195 bool ConvertFloat,
bool ConvertInt) {
1200 CK_IntegralToFloating);
1211 CK_IntegralComplexToFloatingComplex);
1216 CK_FloatingRealToComplex);
1225 QualType RHSType,
bool IsCompAssign) {
1235 else if (!IsCompAssign)
1237 return LHSFloat ? LHSType : RHSType;
1242 if (LHSFloat && RHSFloat) {
1249 assert(order < 0 &&
"illegal float comparison");
1283 QualType LHSElem = LHSComplex ? LHSComplex->getElementType() : LHSType;
1289 if ((&LHSSem != &llvm::APFloat::PPCDoubleDouble() ||
1290 &RHSSem != &llvm::APFloat::IEEEquad()) &&
1291 (&LHSSem != &llvm::APFloat::IEEEquad() ||
1292 &RHSSem != &llvm::APFloat::PPCDoubleDouble()))
1309 CK_IntegralComplexCast);
1315template <PerformCastFn doLHSCast, PerformCastFn doRHSCast>
1318 QualType RHSType,
bool IsCompAssign) {
1323 if (LHSSigned == RHSSigned) {
1326 RHS = (*doRHSCast)(S, RHS.
get(), LHSType);
1328 }
else if (!IsCompAssign)
1329 LHS = (*doLHSCast)(S, LHS.
get(), RHSType);
1331 }
else if (order != (LHSSigned ? 1 : -1)) {
1335 RHS = (*doRHSCast)(S, RHS.
get(), LHSType);
1337 }
else if (!IsCompAssign)
1338 LHS = (*doLHSCast)(S, LHS.
get(), RHSType);
1345 RHS = (*doRHSCast)(S, RHS.
get(), LHSType);
1347 }
else if (!IsCompAssign)
1348 LHS = (*doLHSCast)(S, LHS.
get(), RHSType);
1357 RHS = (*doRHSCast)(S, RHS.
get(), result);
1359 LHS = (*doLHSCast)(S, LHS.
get(), result);
1369 bool IsCompAssign) {
1373 if (LHSComplexInt && RHSComplexInt) {
1377 handleIntegerConversion<doComplexIntegralCast, doComplexIntegralCast>
1378 (S, LHS, RHS, LHSEltType, RHSEltType, IsCompAssign);
1383 if (LHSComplexInt) {
1386 handleIntegerConversion<doComplexIntegralCast, doIntegralCast>
1387 (S, LHS, RHS, LHSEltType, RHSType, IsCompAssign);
1390 CK_IntegralRealToComplex);
1395 assert(RHSComplexInt);
1399 handleIntegerConversion<doIntegralCast, doComplexIntegralCast>
1400 (S, LHS, RHS, LHSType, RHSEltType, IsCompAssign);
1405 CK_IntegralRealToComplex);
1414 assert(BTy &&
"Expected a builtin type.");
1416 switch (BTy->getKind()) {
1417 case BuiltinType::ShortFract:
1418 case BuiltinType::UShortFract:
1419 case BuiltinType::SatShortFract:
1420 case BuiltinType::SatUShortFract:
1422 case BuiltinType::Fract:
1423 case BuiltinType::UFract:
1424 case BuiltinType::SatFract:
1425 case BuiltinType::SatUFract:
1427 case BuiltinType::LongFract:
1428 case BuiltinType::ULongFract:
1429 case BuiltinType::SatLongFract:
1430 case BuiltinType::SatULongFract:
1432 case BuiltinType::ShortAccum:
1433 case BuiltinType::UShortAccum:
1434 case BuiltinType::SatShortAccum:
1435 case BuiltinType::SatUShortAccum:
1437 case BuiltinType::Accum:
1438 case BuiltinType::UAccum:
1439 case BuiltinType::SatAccum:
1440 case BuiltinType::SatUAccum:
1442 case BuiltinType::LongAccum:
1443 case BuiltinType::ULongAccum:
1444 case BuiltinType::SatLongAccum:
1445 case BuiltinType::SatULongAccum:
1448 if (BTy->isInteger())
1450 llvm_unreachable(
"Unexpected fixed point or integer type");
1462 "Expected at least one of the operands to be a fixed point type");
1465 "Special fixed point arithmetic operation conversions are only "
1466 "applied to ints or other fixed point types");
1488 QualType ResultTy = LHSTyRank > RHSTyRank ? LHSTy : RHSTy;
1511 REnum = R->isUnscopedEnumerationType();
1513 if ((!IsCompAssign && LEnum && R->isFloatingType()) ||
1516 ? diag::err_arith_conv_enum_float_cxx26
1518 ? diag::warn_arith_conv_enum_float_cxx20
1519 : diag::warn_arith_conv_enum_float)
1522 }
else if (!IsCompAssign && LEnum && REnum &&
1528 DiagID = diag::err_conv_mixed_enum_types_cxx26;
1530 !R->castAs<
EnumType>()->getDecl()->hasNameForLinkage()) {
1535 ? diag::warn_arith_conv_mixed_anon_enum_types_cxx20
1536 : diag::warn_arith_conv_mixed_anon_enum_types;
1541 ? diag::warn_conditional_mixed_enum_types_cxx20
1542 : diag::warn_conditional_mixed_enum_types;
1547 ? diag::warn_comparison_mixed_enum_types_cxx20
1548 : diag::warn_comparison_mixed_enum_types;
1551 ? diag::warn_arith_conv_mixed_enum_types_cxx20
1552 : diag::warn_arith_conv_mixed_enum_types;
1555 << (
int)ACK << L << R;
1585 LHSType = AtomicLHS->getValueType();
1597 QualType LHSUnpromotedType = LHSType;
1601 if (!LHSBitfieldPromoteTy.
isNull())
1602 LHSType = LHSBitfieldPromoteTy;
1636 return handleIntegerConversion<doIntegralCast, doIntegralCast>
1647 bool PredicateIsExpr,
void *ControllingExprOrType,
1649 unsigned NumAssocs = ArgTypes.size();
1650 assert(NumAssocs == ArgExprs.size());
1653 for (
unsigned i = 0; i < NumAssocs; ++i) {
1662 if (!PredicateIsExpr) {
1666 assert(ControllingType &&
"couldn't get the type out of the parser");
1667 ControllingExprOrType = ControllingType;
1671 KeyLoc, DefaultLoc, RParenLoc, PredicateIsExpr, ControllingExprOrType,
1679 bool PredicateIsExpr,
void *ControllingExprOrType,
1681 unsigned NumAssocs = Types.size();
1682 assert(NumAssocs == Exprs.size());
1683 assert(ControllingExprOrType &&
1684 "Must have either a controlling expression or a controlling type");
1686 Expr *ControllingExpr =
nullptr;
1688 if (PredicateIsExpr) {
1695 reinterpret_cast<Expr *
>(ControllingExprOrType));
1698 ControllingExpr = R.
get();
1701 ControllingType =
reinterpret_cast<TypeSourceInfo *
>(ControllingExprOrType);
1702 if (!ControllingType)
1706 bool TypeErrorFound =
false,
1707 IsResultDependent = ControllingExpr
1710 ContainsUnexpandedParameterPack =
1720 diag::warn_side_effects_unevaluated_context);
1722 for (
unsigned i = 0; i < NumAssocs; ++i) {
1723 if (Exprs[i]->containsUnexpandedParameterPack())
1724 ContainsUnexpandedParameterPack =
true;
1727 if (Types[i]->getType()->containsUnexpandedParameterPack())
1728 ContainsUnexpandedParameterPack =
true;
1730 if (Types[i]->getType()->isDependentType()) {
1731 IsResultDependent =
true;
1744 if (ControllingExpr && Types[i]->getType()->isIncompleteType())
1745 D = diag::err_assoc_type_incomplete;
1746 else if (ControllingExpr && !Types[i]->getType()->isObjectType())
1747 D = diag::err_assoc_type_nonobject;
1748 else if (Types[i]->getType()->isVariablyModifiedType())
1749 D = diag::err_assoc_type_variably_modified;
1750 else if (ControllingExpr) {
1769 unsigned Reason = 0;
1778 Diag(Types[i]->getTypeLoc().getBeginLoc(),
1779 diag::warn_unreachable_association)
1780 << QT << (Reason - 1);
1784 Diag(Types[i]->getTypeLoc().getBeginLoc(), D)
1785 << Types[i]->getTypeLoc().getSourceRange()
1786 << Types[i]->getType();
1787 TypeErrorFound =
true;
1792 for (
unsigned j = i+1; j < NumAssocs; ++j)
1793 if (Types[j] && !Types[j]->getType()->isDependentType() &&
1795 Types[j]->getType())) {
1796 Diag(Types[j]->getTypeLoc().getBeginLoc(),
1797 diag::err_assoc_compatible_types)
1798 << Types[j]->getTypeLoc().getSourceRange()
1799 << Types[j]->getType()
1800 << Types[i]->getType();
1801 Diag(Types[i]->getTypeLoc().getBeginLoc(),
1802 diag::note_compat_assoc)
1803 << Types[i]->getTypeLoc().getSourceRange()
1804 << Types[i]->getType();
1805 TypeErrorFound =
true;
1815 if (IsResultDependent) {
1816 if (ControllingExpr)
1818 Types, Exprs, DefaultLoc, RParenLoc,
1819 ContainsUnexpandedParameterPack);
1821 Exprs, DefaultLoc, RParenLoc,
1822 ContainsUnexpandedParameterPack);
1826 unsigned DefaultIndex = -1U;
1830 for (
unsigned i = 0; i < NumAssocs; ++i) {
1833 else if (ControllingExpr &&
1836 Types[i]->getType()))
1837 CompatIndices.push_back(i);
1838 else if (ControllingType &&
1841 Types[i]->getType()))
1842 CompatIndices.push_back(i);
1845 auto GetControllingRangeAndType = [](
Expr *ControllingExpr,
1849 if (ControllingExpr)
1858 return std::make_pair(SR, QT);
1864 if (CompatIndices.size() > 1) {
1865 auto P = GetControllingRangeAndType(ControllingExpr, ControllingType);
1868 << SR <<
P.second << (
unsigned)CompatIndices.size();
1869 for (
unsigned I : CompatIndices) {
1870 Diag(Types[I]->getTypeLoc().getBeginLoc(),
1871 diag::note_compat_assoc)
1872 << Types[I]->getTypeLoc().getSourceRange()
1873 << Types[I]->getType();
1881 if (DefaultIndex == -1U && CompatIndices.size() == 0) {
1882 auto P = GetControllingRangeAndType(ControllingExpr, ControllingType);
1884 Diag(SR.
getBegin(), diag::err_generic_sel_no_match) << SR <<
P.second;
1893 unsigned ResultIndex =
1894 CompatIndices.size() ? CompatIndices[0] : DefaultIndex;
1896 if (ControllingExpr) {
1898 Context, KeyLoc, ControllingExpr, Types, Exprs, DefaultLoc, RParenLoc,
1899 ContainsUnexpandedParameterPack, ResultIndex);
1902 Context, KeyLoc, ControllingType, Types, Exprs, DefaultLoc, RParenLoc,
1903 ContainsUnexpandedParameterPack, ResultIndex);
1909 llvm_unreachable(
"unexpected TokenKind");
1910 case tok::kw___func__:
1912 case tok::kw___FUNCTION__:
1914 case tok::kw___FUNCDNAME__:
1916 case tok::kw___FUNCSIG__:
1918 case tok::kw_L__FUNCTION__:
1920 case tok::kw_L__FUNCSIG__:
1922 case tok::kw___PRETTY_FUNCTION__:
1931 while (DC && !isa<BlockDecl, CapturedDecl, FunctionDecl, ObjCMethodDecl>(DC))
1933 return cast_or_null<Decl>(DC);
1951 assert(Args.size() <= 2 &&
"too many arguments for literal operator");
1954 for (
unsigned ArgIdx = 0; ArgIdx != Args.size(); ++ArgIdx) {
1955 ArgTy[ArgIdx] = Args[ArgIdx]->getType();
1956 if (ArgTy[ArgIdx]->isArrayType())
1977 std::vector<Token> ExpandedToks;
1983 if (Literal.hadError)
1987 for (
const Token &Tok : StringToks)
1988 StringTokLocs.push_back(Tok.getLocation());
1992 &StringTokLocs[0], StringTokLocs.size());
1994 if (!Literal.getUDSuffix().empty()) {
1997 Literal.getUDSuffixOffset());
1998 return ExprError(
Diag(UDSuffixLoc, diag::err_invalid_string_udl));
2020 std::vector<Token> ExpandedToks;
2021 ExpandedToks.reserve(Toks.size());
2022 for (
const Token &Tok : Toks) {
2025 ExpandedToks.emplace_back(Tok);
2028 if (isa<TranslationUnitDecl>(CurrentDecl))
2029 Diag(Tok.getLocation(), diag::ext_predef_outside_function);
2031 Diag(Tok.getLocation(), diag::ext_string_literal_from_predefined)
2034 llvm::raw_svector_ostream
OS(Str);
2035 Token &Exp = ExpandedToks.emplace_back();
2037 if (Tok.getKind() == tok::kw_L__FUNCTION__ ||
2038 Tok.getKind() == tok::kw_L__FUNCSIG__) {
2040 Exp.
setKind(tok::wide_string_literal);
2042 Exp.
setKind(tok::string_literal);
2050 return ExpandedToks;
2061 assert(!StringToks.empty() &&
"Must have at least one string!");
2064 std::vector<Token> ExpandedToks;
2069 if (Literal.hadError)
2073 for (
const Token &Tok : StringToks)
2074 StringTokLocs.push_back(Tok.getLocation());
2078 if (Literal.isWide()) {
2081 }
else if (Literal.isUTF8()) {
2085 }
else if (Literal.isUTF16()) {
2088 }
else if (Literal.isUTF32()) {
2091 }
else if (Literal.isPascal()) {
2099 Diag(StringTokLocs.front(), diag::warn_cxx20_compat_utf8_string);
2105 auto RemovalDiag =
PDiag(diag::note_cxx20_compat_utf8_string_remove_u8);
2107 for (
const Token &Tok : StringToks) {
2108 if (Tok.getKind() == tok::utf8_string_literal) {
2110 RemovalDiagLoc = Tok.getLocation();
2117 Diag(RemovalDiagLoc, RemovalDiag);
2125 Kind, Literal.Pascal, StrTy,
2127 StringTokLocs.size());
2128 if (Literal.getUDSuffix().empty())
2135 Literal.getUDSuffixOffset());
2139 return ExprError(
Diag(UDSuffixLoc, diag::err_invalid_string_udl));
2164 Expr *Args[] = { Lit, LenArg };
2175 StringTokLocs.back(), &ExplicitArgs);
2183 llvm::APSInt
Value(CharBits, CharIsUnsigned);
2189 for (
unsigned I = 0, N = Lit->
getLength(); I != N; ++I) {
2196 StringTokLocs.back(), &ExplicitArgs);
2200 llvm_unreachable(
"unexpected literal operator lookup result");
2204 llvm_unreachable(
"unexpected literal operator lookup result");
2236 auto *DRE = dyn_cast<DeclRefExpr>(VD->
getInit());
2239 auto *Referee = dyn_cast<VarDecl>(DRE->getDecl());
2240 if (!Referee || !Referee->hasGlobalStorage() ||
2241 Referee->hasAttr<CUDADeviceAttr>())
2247 auto *MD = dyn_cast_or_null<CXXMethodDecl>(S.
CurContext);
2248 if (MD && MD->getParent()->isLambda() &&
2249 MD->getOverloadedOperator() == OO_Call && MD->hasAttr<CUDADeviceAttr>() &&
2271 if (
VarDecl *VD = dyn_cast<VarDecl>(D)) {
2272 if (VD->getType()->isReferenceType() &&
2275 VD->isUsableInConstantExpressions(
Context))
2292 bool RefersToCapturedVariable = isa<VarDecl, BindingDecl>(D) &&
2296 Context, NNS, TemplateKWLoc, D, RefersToCapturedVariable, NameInfo, Ty,
2324 const auto *FD = dyn_cast<FieldDecl>(D);
2325 if (
const auto *IFD = dyn_cast<IndirectFieldDecl>(D))
2326 FD = IFD->getAnonField();
2330 if (FD->isBitField())
2336 if (
const auto *BD = dyn_cast<BindingDecl>(D))
2337 if (
const auto *BE = BD->getBinding())
2362 Id.TemplateId->NumArgs);
2368 TemplateArgs = &Buffer;
2371 TemplateArgs =
nullptr;
2378 unsigned DiagnosticID,
unsigned DiagnosticSuggestID) {
2385 SemaRef.
Diag(TypoLoc, diag::err_no_member) << Typo << Ctx
2388 SemaRef.
Diag(TypoLoc, DiagnosticID) << Typo;
2393 bool DroppedSpecifier =
2396 ? diag::note_implicit_param_decl
2397 : diag::note_previous_decl;
2400 SemaRef.
PDiag(NoteID));
2403 << Typo << Ctx << DroppedSpecifier
2405 SemaRef.
PDiag(NoteID));
2420 bool isDefaultArgument =
2424 const auto *CurMethod = dyn_cast<CXXMethodDecl>(
CurContext);
2425 bool isInstance = CurMethod && CurMethod->isInstance() &&
2434 unsigned DiagID = diag::err_found_in_dependent_base;
2435 unsigned NoteID = diag::note_member_declared_at;
2437 DiagID =
getLangOpts().MSVCCompat ? diag::ext_found_later_in_class
2438 : diag::err_found_later_in_class;
2440 DiagID = diag::ext_found_in_dependent_base;
2441 NoteID = diag::note_dependent_member_use;
2457 Diag(D->getLocation(), NoteID);
2466 if (isDefaultArgument && ((*R.
begin())->isCXXInstanceMember())) {
2485 unsigned diagnostic = diag::err_undeclared_var_use;
2486 unsigned diagnostic_suggest = diag::err_undeclared_var_use_suggest;
2490 diagnostic = diag::err_undeclared_use;
2491 diagnostic_suggest = diag::err_undeclared_use_suggest;
2501 if (isa<CXXRecordDecl>(DC)) {
2517 R.
addDecl(Best->FoundDecl.getDecl(), Best->FoundDecl.getAccess());
2534 assert(!ExplicitTemplateArgs &&
2535 "Diagnosing an empty lookup with explicit template args!");
2539 emitEmptyLookupTypoDiagnostic(TC, *this, SS, Name, TypoLoc, Args,
2540 diagnostic, diagnostic_suggest);
2545 }
else if (S && (Corrected =
2549 bool DroppedSpecifier =
2553 bool AcceptableWithRecovery =
false;
2554 bool AcceptableWithoutRecovery =
false;
2563 dyn_cast<FunctionTemplateDecl>(CD))
2567 else if (
FunctionDecl *FD = dyn_cast<FunctionDecl>(CD))
2568 if (!ExplicitTemplateArgs || ExplicitTemplateArgs->
size() == 0)
2574 ND = Best->FoundDecl;
2575 Corrected.setCorrectionDecl(ND);
2579 Corrected.setCorrectionDecl(ND);
2591 Record = cast<CXXRecordDecl>(
2597 AcceptableWithRecovery = isa<ValueDecl>(UnderlyingND) ||
2598 isa<FunctionTemplateDecl>(UnderlyingND);
2604 AcceptableWithoutRecovery = isa<TypeDecl>(UnderlyingND) ||
2606 isa<ObjCInterfaceDecl>(UnderlyingND);
2610 AcceptableWithoutRecovery =
true;
2613 if (AcceptableWithRecovery || AcceptableWithoutRecovery) {
2615 ? diag::note_implicit_param_decl
2616 : diag::note_previous_decl;
2619 PDiag(NoteID), AcceptableWithRecovery);
2623 << DroppedSpecifier << SS.
getRange(),
2624 PDiag(NoteID), AcceptableWithRecovery);
2627 return !AcceptableWithRecovery;
2663 else if (
auto *MD = dyn_cast<CXXMethodDecl>(S.
CurContext))
2671 auto DB = S.
Diag(
Loc, diag::ext_undeclared_unqual_id_with_dependent_base);
2672 DB << NameInfo.
getName() << RD;
2674 if (!ThisType.
isNull()) {
2677 Context,
nullptr, ThisType,
true,
2679 nullptr, NameInfo, TemplateArgs);
2696 bool HasTrailingLParen,
bool IsAddressOfOperand,
2698 bool IsInlineAsmIdentifier,
Token *KeywordReplacement) {
2699 assert(!(IsAddressOfOperand && HasTrailingLParen) &&
2700 "cannot be direct & operand and have a trailing lparen");
2732 bool DependentID =
false;
2734 Name.getCXXNameType()->isDependentType()) {
2736 }
else if (SS.
isSet()) {
2747 IsAddressOfOperand, TemplateArgs);
2758 if (
auto *VD = dyn_cast<ValueDecl>(R.
getFoundDecl())) {
2772 if (TemplateKWLoc.
isValid() || TemplateArgs) {
2780 false, TemplateKWLoc,
2786 IsAddressOfOperand, TemplateArgs);
2790 !IvarLookupFollowUp);
2796 IsAddressOfOperand, TemplateArgs);
2800 if (IvarLookupFollowUp) {
2815 if (R.
empty() && HasTrailingLParen && II &&
2825 if (R.
empty() && !ADL) {
2828 TemplateKWLoc, TemplateArgs))
2833 if (IsInlineAsmIdentifier)
2843 "Typo correction callback misconfigured");
2854 std::nullopt,
nullptr, &TE)) {
2855 if (TE && KeywordReplacement) {
2857 auto BestTC = State.Consumer->getNextCorrection();
2858 if (BestTC.isKeyword()) {
2859 auto *II = BestTC.getCorrectionAsIdentifierInfo();
2860 if (State.DiagHandler)
2861 State.DiagHandler(BestTC);
2865 KeywordReplacement->
setLocation(BestTC.getCorrectionRange().getBegin());
2871 return (
Expr*)
nullptr;
2873 State.Consumer->resetCorrectionStream();
2878 assert(!R.
empty() &&
2879 "DiagnoseEmptyLookup returned false but added no results");
2886 ExprResult E(
ObjC().LookupInObjCMethod(R, S, Ivar->getIdentifier()));
2896 assert(!R.
empty() || ADL);
2926 if (TemplateArgs || TemplateKWLoc.
isValid()) {
2934 "There should only be one declaration found.");
2977 if (
const auto *CD = dyn_cast<CXXRecordDecl>(DC))
2978 if (CD->isInvalidDecl())
2989 unsigned DiagID = diag::err_typename_missing;
2991 DiagID = diag::ext_typename_missing;
3024 if (!R.
empty() && (*R.
begin())->isCXXClassMember() && !IsAddressOfOperand)
3057 const auto *RD = dyn_cast<CXXRecordDecl>(
Member->getDeclContext());
3065 bool PointerConversions =
false;
3066 if (isa<FieldDecl>(
Member)) {
3070 DestRecordType, FromPtrType
3077 PointerConversions =
true;
3079 DestType = DestRecordType;
3080 FromRecordType = FromType;
3082 }
else if (
const auto *Method = dyn_cast<CXXMethodDecl>(
Member)) {
3083 if (!Method->isImplicitObjectMemberFunction())
3086 DestType = Method->getThisType().getNonReferenceType();
3087 DestRecordType = Method->getFunctionObjectParameterType();
3091 PointerConversions =
true;
3093 FromRecordType = FromType;
3094 DestType = DestRecordType;
3099 if (FromAS != DestAS) {
3104 if (PointerConversions)
3145 if (Qualifier && Qualifier->getAsType()) {
3147 assert(QType->
isRecordType() &&
"lookup done with non-record type");
3157 FromLoc, FromRange, &BasePath))
3160 if (PointerConversions)
3163 VK, &BasePath).
get();
3166 FromRecordType = QRecordType;
3177 FromLoc, FromRange, &BasePath,
3187 bool HasTrailingLParen) {
3189 if (!HasTrailingLParen)
3207 if (D->isCXXClassMember())
3216 if (isa<UsingShadowDecl>(D))
3217 D = cast<UsingShadowDecl>(D)->getTargetDecl();
3218 else if (D->getLexicalDeclContext()->isFunctionOrMethod())
3225 if (
const auto *FDecl = dyn_cast<FunctionDecl>(D)) {
3227 if (FDecl->getBuiltinID() && FDecl->isImplicit())
3229 }
else if (!isa<FunctionTemplateDecl>(D))
3242 bool AcceptInvalid) {
3246 if (isa<TypedefNameDecl>(D)) {
3251 if (isa<ObjCInterfaceDecl>(D)) {
3256 if (isa<NamespaceDecl>(D)) {
3268 const auto *FD = dyn_cast<FunctionDecl>(R.
getFoundDecl());
3270 (FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion());
3275 bool AcceptInvalidDecl) {
3314 bool AcceptInvalidDecl) {
3315 assert(D &&
"Cannot refer to a NULL declaration");
3316 assert(!isa<FunctionTemplateDecl>(D) &&
3317 "Cannot refer unambiguously to a function template");
3327 if (
TemplateDecl *Template = dyn_cast<TemplateDecl>(D)) {
3335 if (!isa<ValueDecl, UnresolvedUsingIfExistsDecl>(D)) {
3348 auto *VD = cast<ValueDecl>(D);
3351 if (VD->isInvalidDecl() && !AcceptInvalidDecl)
3357 if (
auto *IndirectField = dyn_cast<IndirectFieldDecl>(VD);
3358 IndirectField && !IndirectField->isCXXClassMember())
3370 type =
type.getNonPackExpansionType();
3374#define ABSTRACT_DECL(kind)
3375#define VALUE(type, base)
3376#define DECL(type, base) case Decl::type:
3377#include "clang/AST/DeclNodes.inc"
3378 llvm_unreachable(
"invalid value decl kind");
3381 case Decl::ObjCAtDefsField:
3382 llvm_unreachable(
"forming non-member reference to ivar?");
3386 case Decl::EnumConstant:
3387 case Decl::UnresolvedUsingValue:
3388 case Decl::OMPDeclareReduction:
3389 case Decl::OMPDeclareMapper:
3398 case Decl::IndirectField:
3399 case Decl::ObjCIvar:
3401 "building reference to field in C?");
3411 case Decl::NonTypeTemplateParm: {
3413 type = reftype->getPointeeType();
3423 if (
type->isRecordType()) {
3424 type =
type.getUnqualifiedType().withConst();
3437 case Decl::VarTemplateSpecialization:
3438 case Decl::VarTemplatePartialSpecialization:
3439 case Decl::Decomposition:
3440 case Decl::OMPCapturedExpr:
3443 type->isVoidType()) {
3449 case Decl::ImplicitParam:
3450 case Decl::ParmVar: {
3460 if (!CapturedType.
isNull())
3461 type = CapturedType;
3473 case Decl::Function: {
3474 if (
unsigned BID = cast<FunctionDecl>(VD)->getBuiltinID()) {
3503 if (!cast<FunctionDecl>(VD)->hasPrototype() && isa<FunctionProtoType>(fty))
3512 case Decl::CXXDeductionGuide:
3513 llvm_unreachable(
"building reference to deduction guide");
3515 case Decl::MSProperty:
3517 case Decl::TemplateParamObject:
3523 case Decl::UnnamedGlobalConstant:
3527 case Decl::CXXMethod:
3532 dyn_cast<FunctionProtoType>(VD->getType()))
3540 if (cast<CXXMethodDecl>(VD)->isStatic()) {
3546 case Decl::CXXConversion:
3547 case Decl::CXXDestructor:
3548 case Decl::CXXConstructor:
3560 if (VD->isInvalidDecl() && E)
3567 Target.resize(CharByteWidth * (Source.size() + 1));
3568 char *ResultPtr = &
Target[0];
3569 const llvm::UTF8 *ErrorPtr;
3571 llvm::ConvertUTF8toWide(CharByteWidth, Source, ResultPtr, ErrorPtr);
3581 Diag(
Loc, diag::ext_predef_outside_function);
3587 if (cast<DeclContext>(currentDecl)->isDependentContext())
3592 bool ForceElaboratedPrinting =
3596 unsigned Length = Str.length();
3598 llvm::APInt LengthI(32, Length + 1);
3638 if (Literal.hadError())
3642 if (Literal.isWide())
3648 else if (Literal.isUTF16())
3650 else if (Literal.isUTF32())
3659 if (Literal.isWide())
3661 else if (Literal.isUTF16())
3663 else if (Literal.isUTF32())
3665 else if (Literal.isUTF8())
3671 if (Literal.getUDSuffix().empty())
3681 return ExprError(
Diag(UDSuffixLoc, diag::err_invalid_character_udl));
3699 using llvm::APFloat;
3700 APFloat Val(Format);
3703 if (RM == llvm::RoundingMode::Dynamic)
3704 RM = llvm::RoundingMode::NearestTiesToEven;
3705 APFloat::opStatus result = Literal.GetFloatValue(Val, RM);
3709 if ((result & APFloat::opOverflow) ||
3710 ((result & APFloat::opUnderflow) && Val.isZero())) {
3711 unsigned diagnostic;
3713 if (result & APFloat::opOverflow) {
3714 diagnostic = diag::warn_float_overflow;
3715 APFloat::getLargest(Format).toString(buffer);
3717 diagnostic = diag::warn_float_underflow;
3718 APFloat::getSmallest(Format).toString(buffer);
3723 << StringRef(buffer.data(), buffer.size());
3726 bool isExact = (result == APFloat::opOK);
3731 assert(E &&
"Invalid expression");
3738 Diag(E->
getExprLoc(), diag::err_pragma_loop_invalid_argument_type) << QT;
3742 llvm::APSInt ValueAPS;
3753 bool ValueIsPositive =
3754 AllowZero ? ValueAPS.isNonNegative() : ValueAPS.isStrictlyPositive();
3755 if (!ValueIsPositive || ValueAPS.getActiveBits() > 31) {
3756 Diag(E->
getExprLoc(), diag::err_pragma_loop_invalid_argument_value)
3757 <<
toString(ValueAPS, 10) << ValueIsPositive;
3777 SpellingBuffer.resize(Tok.
getLength() + 1);
3788 if (Literal.hadError)
3791 if (Literal.hasUDSuffix()) {
3799 return ExprError(
Diag(UDSuffixLoc, diag::err_invalid_numeric_udl));
3802 if (Literal.isFloatingLiteral()) {
3827 !Literal.isImaginary)) {
3836 if (Literal.isFloatingLiteral()) {
3840 if (Literal.GetIntegerValue(ResultVal))
3853 unsigned Length = Literal.getUDSuffixOffset();
3860 false, StrTy, &TokLoc, 1);
3871 bool CharIsUnsigned =
Context.
CharTy->isUnsignedIntegerType();
3872 llvm::APSInt
Value(CharBits, CharIsUnsigned);
3873 for (
unsigned I = 0, N = Literal.getUDSuffixOffset(); I != N; ++I) {
3874 Value = TokSpelling[I];
3883 llvm_unreachable(
"unexpected literal operator lookup result");
3889 if (Literal.isFixedPointLiteral()) {
3892 if (Literal.isAccum) {
3893 if (Literal.isHalf) {
3895 }
else if (Literal.isLong) {
3900 }
else if (Literal.isFract) {
3901 if (Literal.isHalf) {
3903 }
else if (Literal.isLong) {
3912 bool isSigned = !Literal.isUnsigned;
3916 llvm::APInt Val(bit_width, 0, isSigned);
3917 bool Overflowed = Literal.GetFixedPointValue(Val, scale);
3918 bool ValIsZero = Val.isZero() && !Overflowed;
3921 if (Literal.isFract && Val == MaxVal + 1 && !ValIsZero)
3927 else if (Val.ugt(MaxVal) || Overflowed)
3932 }
else if (Literal.isFloatingLiteral()) {
3934 if (Literal.isHalf){
3942 }
else if (Literal.isFloat)
3944 else if (Literal.isLong)
3946 else if (Literal.isFloat16)
3948 else if (Literal.isFloat128)
3970 }
else if (!Literal.isIntegerLiteral()) {
3976 if (Literal.isSizeT)
3979 ? diag::warn_cxx20_compat_size_t_suffix
3980 : diag::ext_cxx23_size_t_suffix
3981 : diag::err_cxx23_size_t_suffix);
3988 if (Literal.isBitInt)
3992 : diag::ext_c23_bitint_suffix);
4001 unsigned BitsNeeded =
4002 Literal.isBitInt ? llvm::APInt::getSufficientBitsNeeded(
4003 Literal.getLiteralDigits(), Literal.getRadix())
4005 llvm::APInt ResultVal(BitsNeeded, 0);
4007 if (Literal.GetIntegerValue(ResultVal)) {
4013 "long long is not intmax_t?");
4020 bool AllowUnsigned = Literal.isUnsigned || Literal.getRadix() != 10;
4027 Literal.isLong =
true;
4028 Literal.isLongLong =
false;
4035 if (Literal.MicrosoftInteger) {
4036 if (Literal.MicrosoftInteger == 8 && !Literal.isUnsigned) {
4040 Width = Literal.MicrosoftInteger;
4042 !Literal.isUnsigned);
4048 if (Literal.isBitInt) {
4051 Width = std::max(ResultVal.getActiveBits(), 1u) +
4052 (Literal.isUnsigned ? 0u : 1u);
4056 unsigned int MaxBitIntWidth =
4058 if (Width > MaxBitIntWidth) {
4060 << Literal.isUnsigned;
4061 Width = MaxBitIntWidth;
4068 ResultVal = ResultVal.zextOrTrunc(Width);
4073 if (Literal.isSizeT) {
4074 assert(!Literal.MicrosoftInteger &&
4075 "size_t literals can't be Microsoft literals");
4080 if (ResultVal.isIntN(SizeTSize)) {
4082 if (!Literal.isUnsigned && ResultVal[SizeTSize - 1] == 0)
4084 else if (AllowUnsigned)
4090 if (Ty.
isNull() && !Literal.isLong && !Literal.isLongLong &&
4096 if (ResultVal.isIntN(IntSize)) {
4098 if (!Literal.isUnsigned && ResultVal[IntSize-1] == 0)
4100 else if (AllowUnsigned)
4107 if (Ty.
isNull() && !Literal.isLongLong && !Literal.isSizeT) {
4111 if (ResultVal.isIntN(LongSize)) {
4113 if (!Literal.isUnsigned && ResultVal[LongSize-1] == 0)
4115 else if (AllowUnsigned)
4120 const unsigned LongLongSize =
4125 ? diag::warn_old_implicitly_unsigned_long_cxx
4127 ext_old_implicitly_unsigned_long_cxx
4128 : diag::warn_old_implicitly_unsigned_long)
4129 << (LongLongSize > LongSize ? 0
4138 if (Ty.
isNull() && !Literal.isSizeT) {
4142 if (ResultVal.isIntN(LongLongSize)) {
4146 if (!Literal.isUnsigned && (ResultVal[LongLongSize-1] == 0 ||
4147 (
getLangOpts().MSVCCompat && Literal.isLongLong)))
4149 else if (AllowUnsigned)
4151 Width = LongLongSize;
4157 ? diag::warn_cxx98_compat_longlong
4158 : diag::ext_cxx11_longlong);
4168 if (Literal.isSizeT)
4170 << Literal.isUnsigned;
4173 diag::ext_integer_literal_too_large_for_signed);
4178 if (ResultVal.getBitWidth() != Width)
4179 ResultVal = ResultVal.trunc(Width);
4185 if (Literal.isImaginary) {
4195 assert(E &&
"ActOnParenExpr() missing expr");
4211 S.
Diag(
Loc, diag::err_vecstep_non_scalar_vector_type)
4217 "Scalar types should always be complete");
4226 return S.
Diag(
Loc, diag::err_builtin_non_vector_type)
4228 <<
"__builtin_vectorelements" <<
T << ArgRange;
4243 (TraitKind == UETT_SizeOf || TraitKind == UETT_AlignOf ||
4244 TraitKind == UETT_PreferredAlignOf)) {
4246 S.
Diag(
Loc, diag::ext_sizeof_alignof_function_type)
4254 unsigned DiagID = S.
LangOpts.OpenCL ? diag::err_opencl_sizeof_alignof_type
4255 : diag::ext_sizeof_alignof_void_type;
4270 S.
Diag(
Loc, diag::err_sizeof_nonfragile_interface)
4271 <<
T << (TraitKind == UETT_SizeOf)
4288 const auto *ICE = dyn_cast<ImplicitCastExpr>(E);
4289 if (!ICE || ICE->getCastKind() != CK_ArrayToPointerDecay)
4292 S.
Diag(
Loc, diag::warn_sizeof_array_decay) << ICE->getSourceRange()
4294 << ICE->getSubExpr()->getType();
4309 bool IsUnevaluatedOperand =
4310 (ExprKind == UETT_SizeOf || ExprKind == UETT_DataSizeOf ||
4311 ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf ||
4312 ExprKind == UETT_VecStep);
4313 if (IsUnevaluatedOperand) {
4329 Diag(E->
getExprLoc(), diag::warn_side_effects_unevaluated_context);
4331 if (ExprKind == UETT_VecStep)
4335 if (ExprKind == UETT_VectorElements)
4357 if (ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf) {
4360 diag::err_sizeof_alignof_incomplete_or_sizeless_type,
4365 E, diag::err_sizeof_alignof_incomplete_or_sizeless_type,
4384 if (ExprKind == UETT_SizeOf) {
4385 if (
const auto *DeclRef = dyn_cast<DeclRefExpr>(E->
IgnoreParens())) {
4386 if (
const auto *PVD = dyn_cast<ParmVarDecl>(DeclRef->getFoundDecl())) {
4387 QualType OType = PVD->getOriginalType();
4392 Diag(PVD->getLocation(), diag::note_declared_at);
4400 if (
const auto *BO = dyn_cast<BinaryOperator>(E->
IgnoreParens())) {
4417 S.
Diag(E->
getExprLoc(), diag::err_sizeof_alignof_typeof_bitfield)
4424 if (
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Inner)) {
4426 }
else if (
MemberExpr *ME = dyn_cast<MemberExpr>(Inner)) {
4427 D = ME->getMemberDecl();
4447 if (
FieldDecl *FD = dyn_cast_or_null<FieldDecl>(D)) {
4450 if (!FD->getParent()->isCompleteDefinition()) {
4451 S.
Diag(E->
getExprLoc(), diag::err_alignof_member_of_incomplete_type)
4460 if (!FD->getType()->isReferenceType())
4480 assert(CSI !=
nullptr);
4484 const Type *Ty =
T.getTypePtr();
4486#define TYPE(Class, Base)
4487#define ABSTRACT_TYPE(Class, Base)
4488#define NON_CANONICAL_TYPE(Class, Base)
4489#define DEPENDENT_TYPE(Class, Base) case Type::Class:
4490#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base)
4491#include "clang/AST/TypeNodes.inc"
4498 case Type::ExtVector:
4499 case Type::ConstantMatrix:
4502 case Type::TemplateSpecialization:
4503 case Type::ObjCObject:
4504 case Type::ObjCInterface:
4505 case Type::ObjCObjectPointer:
4506 case Type::ObjCTypeParam:
4509 llvm_unreachable(
"type class is never variably-modified!");
4510 case Type::Elaborated:
4511 T = cast<ElaboratedType>(Ty)->getNamedType();
4513 case Type::Adjusted:
4514 T = cast<AdjustedType>(Ty)->getOriginalType();
4519 case Type::ArrayParameter:
4520 T = cast<ArrayParameterType>(Ty)->getElementType();
4525 case Type::BlockPointer:
4528 case Type::LValueReference:
4529 case Type::RValueReference:
4532 case Type::MemberPointer:
4535 case Type::ConstantArray:
4536 case Type::IncompleteArray:
4538 T = cast<ArrayType>(Ty)->getElementType();
4540 case Type::VariableArray: {
4548 (isa<CapturedRegionScopeInfo>(CSI) || isa<LambdaScopeInfo>(CSI)))
4554 case Type::FunctionProto:
4555 case Type::FunctionNoProto:
4560 case Type::UnaryTransform:
4561 case Type::Attributed:
4562 case Type::BTFTagAttributed:
4563 case Type::SubstTemplateTypeParm:
4564 case Type::MacroQualified:
4565 case Type::CountAttributed:
4567 T =
T.getSingleStepDesugaredType(Context);
4570 T = cast<TypedefType>(Ty)->
desugar();
4572 case Type::Decltype:
4573 T = cast<DecltypeType>(Ty)->
desugar();
4575 case Type::PackIndexing:
4576 T = cast<PackIndexingType>(Ty)->
desugar();
4579 T = cast<UsingType>(Ty)->
desugar();
4582 case Type::DeducedTemplateSpecialization:
4583 T = cast<DeducedType>(Ty)->getDeducedType();
4585 case Type::TypeOfExpr:
4586 T = cast<TypeOfExprType>(Ty)->getUnderlyingExpr()->getType();
4589 T = cast<AtomicType>(Ty)->getValueType();
4630 if (ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf ||
4631 ExprKind == UETT_OpenMPRequiredSimdAlign)
4634 if (ExprKind == UETT_VecStep)
4637 if (ExprKind == UETT_VectorElements)
4647 OpLoc, ExprType, diag::err_sizeof_alignof_incomplete_or_sizeless_type,
4652 Diag(OpLoc, diag::err_sizeof_alignof_function_type) << KWName << ExprRange;
4660 Diag(OpLoc, diag::err_wasm_table_invalid_uett_operand)
4674 auto *CSI = dyn_cast<CapturingScopeInfo>(*I);
4678 if (
auto *LSI = dyn_cast<LambdaScopeInfo>(CSI))
4679 DC = LSI->CallOperator;
4680 else if (
auto *CRSI = dyn_cast<CapturedRegionScopeInfo>(CSI))
4681 DC = CRSI->TheCapturedDecl;
4682 else if (
auto *BSI = dyn_cast<BlockScopeInfo>(CSI))
4737 }
else if (ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf) {
4739 }
else if (ExprKind == UETT_VecStep) {
4741 }
else if (ExprKind == UETT_OpenMPRequiredSimdAlign) {
4745 Diag(E->
getExprLoc(), diag::err_sizeof_alignof_typeof_bitfield) << 0;
4747 }
else if (ExprKind == UETT_VectorElements) {
4793 UETT_AlignOf, KWName);
4813 if (
V.get()->isTypeDependent())
4825 return CT->getElementType();
4828 if (
V.get()->getType()->isArithmeticType())
4829 return V.get()->getType();
4834 if (PR.
get() !=
V.get()) {
4840 S.
Diag(
Loc, diag::err_realimag_invalid_type) <<
V.get()->getType()
4841 << (IsReal ?
"__real" :
"__imag");
4852 default: llvm_unreachable(
"Unknown unary op!");
4853 case tok::plusplus: Opc = UO_PostInc;
break;
4854 case tok::minusminus: Opc = UO_PostDec;
break;
4873 !S.
LangOpts.ObjCSubscriptingLegacyRuntime)
4876 S.
Diag(opLoc, diag::err_arithmetic_nonfragile_interface)
4883 auto *BaseNoParens =
Base->IgnoreParens();
4884 if (
auto *MSProp = dyn_cast<MSPropertyRefExpr>(BaseNoParens))
4885 return MSProp->getPropertyDecl()->getType()->isArrayType();
4886 return isa<MSPropertySubscriptExpr>(BaseNoParens);
4906 if (RTy->isIntegralOrUnscopedEnumerationType()) {
4908 Result = PT->getPointeeType();
4910 Result = AT->getElementType();
4913 Result = PT->getPointeeType();
4915 Result = AT->getElementType();
4928 auto *AS = cast<ArraySectionExpr>(base);
4929 if (AS->isOMPArraySection())
4941 if (isa<ParenListExpr>(base)) {
4945 base = result.
get();
4952 auto CheckAndReportCommaError = [
this, base, rbLoc](
Expr *E) {
4953 if (isa<BinaryOperator>(E) && cast<BinaryOperator>(E)->isCommaOp()) {
4954 Diag(E->getExprLoc(), diag::err_matrix_subscript_comma)
4964 !isa<MatrixSubscriptExpr>(base)) {
4965 Diag(base->
getExprLoc(), diag::err_matrix_separate_incomplete_index)
4971 auto *matSubscriptE = dyn_cast<MatrixSubscriptExpr>(base);
4972 if (matSubscriptE) {
4973 assert(ArgExprs.size() == 1);
4974 if (CheckAndReportCommaError(ArgExprs.front()))
4977 assert(matSubscriptE->isIncomplete() &&
4978 "base has to be an incomplete matrix subscript");
4980 matSubscriptE->getRowIdx(),
4981 ArgExprs.front(), rbLoc);
4994 bool IsMSPropertySubscript =
false;
4997 if (!IsMSPropertySubscript) {
5001 base = result.
get();
5007 assert(ArgExprs.size() == 1);
5008 if (CheckAndReportCommaError(ArgExprs.front()))
5016 Expr *idx = ArgExprs[0];
5017 if ((isa<BinaryOperator>(idx) && cast<BinaryOperator>(idx)->isCommaOp()) ||
5018 (isa<CXXOperatorCallExpr>(idx) &&
5019 cast<CXXOperatorCallExpr>(idx)->getOperator() == OO_Comma)) {
5025 if (ArgExprs.size() == 1 &&
5026 ArgExprs[0]->getType()->isNonOverloadPlaceholderType()) {
5030 ArgExprs[0] = result.
get();
5040 !isa<PackExpansionExpr>(ArgExprs[0])) {
5042 base, ArgExprs.front(),
5055 if (IsMSPropertySubscript) {
5056 assert(ArgExprs.size() == 1);
5074 (ArgExprs.size() != 1 || isa<PackExpansionExpr>(ArgExprs[0]) ||
5075 ArgExprs[0]->getType()->isRecordType())))) {
5082 if (!Res.
isInvalid() && isa<ArraySubscriptExpr>(Res.
get()))
5083 CheckSubscriptAccessOfNoDeref(cast<ArraySubscriptExpr>(Res.
get()));
5093 return InitSeq.
Perform(*
this, Entity, Kind, E);
5107 RowIdx = RowR.
get();
5122 ColumnIdx = ColumnR.
get();
5127 auto IsIndexValid = [&](
Expr *IndexExpr,
unsigned Dim,
5128 bool IsColumnIdx) ->
Expr * {
5136 if (std::optional<llvm::APSInt> Idx =
5138 if ((*Idx < 0 || *Idx >= Dim)) {
5140 << IsColumnIdx << Dim;
5148 "should be able to convert any integer type to size type");
5149 return ConvExpr.
get();
5153 RowIdx = IsIndexValid(RowIdx, MTy->getNumRows(),
false);
5154 ColumnIdx = IsIndexValid(ColumnIdx, MTy->getNumColumns(),
true);
5155 if (!RowIdx || !ColumnIdx)
5159 MTy->getElementType(), RBLoc);
5162void Sema::CheckAddressOfNoDeref(
const Expr *E) {
5169 while ((
Member = dyn_cast<MemberExpr>(StrippedExpr)) && !
Member->isArrow())
5170 StrippedExpr =
Member->getBase()->IgnoreParenImpCasts();
5172 LastRecord.PossibleDerefs.erase(StrippedExpr);
5183 if (isa<ArrayType>(ResultTy))
5186 if (ResultTy->
hasAttr(attr::NoDeref)) {
5187 LastRecord.PossibleDerefs.insert(E);
5195 if (!(isa<ArrayType>(BaseTy) || isa<PointerType>(BaseTy)))
5200 while ((
Member = dyn_cast<MemberExpr>(
Base->IgnoreParenCasts())) &&
5204 if (
const auto *Ptr = dyn_cast<PointerType>(
Base->getType())) {
5205 if (Ptr->getPointeeType()->hasAttr(attr::NoDeref))
5206 LastRecord.PossibleDerefs.insert(E);
5222 for (
auto *Op : {LHSExp, RHSExp}) {
5223 Op = Op->IgnoreImplicit();
5224 if (Op->getType()->isArrayType() && !Op->isLValue())
5247 Expr *BaseExpr, *IndexExpr;
5282 Diag(LLoc, diag::err_subscript_nonfragile_interface)
5294 LHSExp = Materialized.
get();
5300 ResultType = VTy->getElementType();
5304 Qualifiers Combined = BaseQuals + MemberQuals;
5305 if (Combined != MemberQuals)
5320 LHSExp = Materialized.
get();
5331 Qualifiers Combined = BaseQuals + MemberQuals;
5332 if (Combined != MemberQuals)
5343 CK_ArrayToPointerDecay).
get();
5349 }
else if (RHSTy->isArrayType()) {
5354 CK_ArrayToPointerDecay).
get();
5361 return ExprError(
Diag(LLoc, diag::err_typecheck_subscript_value)
5366 return ExprError(
Diag(LLoc, diag::err_typecheck_subscript_not_integer)
5372 std::optional<llvm::APSInt> IntegerContantExpr =
5374 if (!IntegerContantExpr.has_value() ||
5375 IntegerContantExpr.value().isNegative())
5391 Diag(LLoc, diag::ext_gnu_subscript_void_type)
5402 diag::err_subscript_incomplete_or_sizeless_type, BaseExpr))
5415 auto *CSI = dyn_cast<CapturingScopeInfo>(*I);
5419 if (
auto *LSI = dyn_cast<LambdaScopeInfo>(CSI))
5420 DC = LSI->CallOperator;
5421 else if (
auto *CRSI = dyn_cast<CapturedRegionScopeInfo>(CSI))
5422 DC = CRSI->TheCapturedDecl;
5423 else if (
auto *BSI = dyn_cast<BlockScopeInfo>(CSI))
5441 bool SkipImmediateInvocations) {
5443 assert(!RewrittenInit &&
"Should not have a rewritten init expression yet");
5447 Diag(Param->
getBeginLoc(), diag::err_recursive_default_argument) << FD;
5448 Diag(CallLoc, diag::note_recursive_default_argument_used_here);
5453 Diag(CallLoc, diag::err_use_of_default_argument_to_function_declared_later)
5456 diag::note_default_argument_declared_here);
5461 assert(!RewrittenInit &&
"Should not have a rewitten init expression yet");
5467 assert(
Init &&
"default argument but no initializer?");
5476 if (
auto *InitWithCleanup = dyn_cast<ExprWithCleanups>(
Init)) {
5483 assert(!InitWithCleanup->getNumObjects() &&
5484 "default argument expression has capturing blocks?");
5497 SkipImmediateInvocations;
5508 bool HasImmediateCalls =
false;
5513 HasImmediateCalls |= FD->isImmediateFunction();
5519 HasImmediateCalls |= FD->isImmediateFunction();
5528 HasImmediateCalls =
true;
5543 return TraverseStmt(E->
getExpr());
5547 return TraverseStmt(E->
getExpr());
5572 assert(Param->
hasDefaultArg() &&
"can't build nonexistent default arg");
5576 std::optional<ExpressionEvaluationContextRecord::InitializationContext>
5577 InitializationContext =
5579 if (!InitializationContext.has_value())
5580 InitializationContext.emplace(CallLoc, Param,
CurContext);
5606 if (!NestedDefaultChecking)
5607 V.TraverseDecl(Param);
5611 if (
V.HasImmediateCalls || InLifetimeExtendingContext) {
5612 if (
V.HasImmediateCalls)
5621 Res = Immediate.TransformInitializer(Param->
getInit(),
5635 CallLoc, FD, Param,
Init,
5636 NestedDefaultChecking))
5640 Init, InitializationContext->Context);
5644 assert(Field->hasInClassInitializer());
5647 if (Field->isInvalidDecl())
5652 auto *ParentRD = cast<CXXRecordDecl>(Field->getParent());
5654 std::optional<ExpressionEvaluationContextRecord::InitializationContext>
5655 InitializationContext =
5657 if (!InitializationContext.has_value())
5667 if (!Field->getInClassInitializer()) {
5673 ClassPattern->
lookup(Field->getDeclName());
5676 for (
auto *L : Lookup) {
5677 if ((Pattern = dyn_cast<FieldDecl>(L)))
5680 assert(Pattern &&
"We must have set the Pattern!");
5684 Field->setInvalidDecl();
5696 if (!NestedDefaultChecking)
5697 V.TraverseDecl(Field);
5698 if (
V.HasImmediateCalls) {
5702 NestedDefaultChecking;
5707 Res = Immediate.TransformInitializer(Field->getInClassInitializer(),
5713 Field->setInvalidDecl();
5719 if (Field->getInClassInitializer()) {
5720 Expr *E =
Init ?
Init : Field->getInClassInitializer();
5721 if (!NestedDefaultChecking)
5729 if (Res.isInvalid()) {
5730 Field->setInvalidDecl();
5736 Field, InitializationContext->Context,
5755 Diag(
Loc, diag::err_default_member_initializer_not_yet_parsed)
5756 << OutermostClass << Field;
5757 Diag(Field->getEndLoc(),
5758 diag::note_default_member_initializer_not_yet_parsed);
5761 Field->setInvalidDecl();
5769 if (isa_and_nonnull<CXXConstructorDecl>(FDecl))
5774 if (
CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl))
5775 if (Method->isInstance())
5790 FunctionName(FuncName) {}
5792 bool ValidateCandidate(
const TypoCorrection &candidate)
override {
5801 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
5802 return std::make_unique<FunctionCallCCC>(*
this);
5822 if (
NamedDecl *ND = Corrected.getFoundDecl()) {
5823 if (Corrected.isOverloaded()) {
5833 ND = Best->FoundDecl;
5834 Corrected.setCorrectionDecl(ND);
5840 ND = ND->getUnderlyingDecl();
5841 if (isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND))
5860 bool IsExecConfig) {
5869 bool HasExplicitObjectParameter =
5871 unsigned ExplicitObjectParameterOffset = HasExplicitObjectParameter ? 1 : 0;
5882 if (Args.size() < NumParams) {
5883 if (Args.size() < MinArgs) {
5888 ? diag::err_typecheck_call_too_few_args_suggest
5889 : diag::err_typecheck_call_too_few_args_at_least_suggest;
5892 << FnKind << MinArgs - ExplicitObjectParameterOffset
5893 <<
static_cast<unsigned>(Args.size()) -
5894 ExplicitObjectParameterOffset
5896 }
else if (MinArgs - ExplicitObjectParameterOffset == 1 && FDecl &&
5901 ? diag::err_typecheck_call_too_few_args_one
5902 : diag::err_typecheck_call_too_few_args_at_least_one)
5903 << FnKind << FDecl->
getParamDecl(ExplicitObjectParameterOffset)
5907 ? diag::err_typecheck_call_too_few_args
5908 : diag::err_typecheck_call_too_few_args_at_least)
5909 << FnKind << MinArgs - ExplicitObjectParameterOffset
5910 <<
static_cast<unsigned>(Args.size()) -
5911 ExplicitObjectParameterOffset
5915 if (!TC && FDecl && !FDecl->
getBuiltinID() && !IsExecConfig)
5923 assert((
Call->getNumArgs() == NumParams) &&
5924 "We should have reserved space for the default arguments before!");
5929 if (Args.size() > NumParams) {
5935 ? diag::err_typecheck_call_too_many_args_suggest
5936 : diag::err_typecheck_call_too_many_args_at_most_suggest;
5939 << FnKind << NumParams - ExplicitObjectParameterOffset
5940 <<
static_cast<unsigned>(Args.size()) -
5941 ExplicitObjectParameterOffset
5943 }
else if (NumParams - ExplicitObjectParameterOffset == 1 && FDecl &&
5946 Diag(Args[NumParams]->getBeginLoc(),
5947 MinArgs == NumParams
5948 ? diag::err_typecheck_call_too_many_args_one
5949 : diag::err_typecheck_call_too_many_args_at_most_one)
5950 << FnKind << FDecl->
getParamDecl(ExplicitObjectParameterOffset)
5951 <<
static_cast<unsigned>(Args.size()) -
5952 ExplicitObjectParameterOffset
5955 Args.back()->getEndLoc());
5957 Diag(Args[NumParams]->getBeginLoc(),
5958 MinArgs == NumParams
5959 ? diag::err_typecheck_call_too_many_args
5960 : diag::err_typecheck_call_too_many_args_at_most)
5961 << FnKind << NumParams - ExplicitObjectParameterOffset
5962 <<
static_cast<unsigned>(Args.size()) -
5963 ExplicitObjectParameterOffset
5966 Args.back()->getEndLoc());
5969 if (!TC && FDecl && !FDecl->
getBuiltinID() && !IsExecConfig)
5974 Call->shrinkNumArgs(NumParams);
5985 unsigned TotalNumArgs = AllArgs.size();
5986 for (
unsigned i = 0; i < TotalNumArgs; ++i)
5987 Call->setArg(i, AllArgs[i]);
5989 Call->computeDependence();
5998 bool IsListInitialization) {
6003 for (
unsigned i = FirstParam; i < NumParams; i++) {
6008 if (ArgIx < Args.size()) {
6009 Arg = Args[ArgIx++];
6012 diag::err_call_incomplete_argument, Arg))
6016 bool CFAudited =
false;
6018 FDecl && FDecl->
hasAttr<CFAuditedTransferAttr>() &&
6019 (!Param || !Param->
hasAttr<CFConsumedAttr>()))
6022 FDecl && FDecl->
hasAttr<CFAuditedTransferAttr>() &&
6023 (!Param || !Param->
hasAttr<CFConsumedAttr>()))
6029 BE->getBlockDecl()->setDoesNotEscape();
6042 Entity,
SourceLocation(), Arg, IsListInitialization, AllowExplicit);
6048 assert(Param &&
"can't use default arguments without a known callee");
6060 CheckArrayAccess(Arg);
6065 AllArgs.push_back(Arg);
6074 for (
Expr *A : Args.slice(ArgIx)) {
6078 AllArgs.push_back(arg.get());
6083 for (
Expr *A : Args.slice(ArgIx)) {
6086 AllArgs.push_back(Arg.
get());
6091 for (
Expr *A : Args.slice(ArgIx))
6092 CheckArrayAccess(A);
6100 TL = DTL.getOriginalLoc();
6103 << ATL.getLocalSourceRange();
6117 const Expr *ArgExpr) {
6147 Diag(CallLoc, diag::warn_static_array_too_small)
6155 std::optional<CharUnits> ArgSize =
6157 std::optional<CharUnits> ParmSize =
6159 if (ArgSize && ParmSize && *ArgSize < *ParmSize) {
6160 Diag(CallLoc, diag::warn_static_array_too_small)
6162 << (
unsigned)ParmSize->getQuantity() << 1;
6176 if (!placeholder)
return false;
6178 switch (placeholder->
getKind()) {
6180#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
6181 case BuiltinType::Id:
6182#include "clang/Basic/OpenCLImageTypes.def"
6183#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
6184 case BuiltinType::Id:
6185#include "clang/Basic/OpenCLExtensionTypes.def"
6188#define SVE_TYPE(Name, Id, SingletonId) \
6189 case BuiltinType::Id:
6190#include "clang/Basic/AArch64SVEACLETypes.def"
6191#define PPC_VECTOR_TYPE(Name, Id, Size) \
6192 case BuiltinType::Id:
6193#include "clang/Basic/PPCTypes.def"
6194#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
6195#include "clang/Basic/RISCVVTypes.def"
6196#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
6197#include "clang/Basic/WebAssemblyReferenceTypes.def"
6198#define PLACEHOLDER_TYPE(ID, SINGLETON_ID)
6199#define BUILTIN_TYPE(ID, SINGLETON_ID) case BuiltinType::ID:
6200#include "clang/AST/BuiltinTypes.def"
6203 case BuiltinType::UnresolvedTemplate:
6206 case BuiltinType::Overload:
6211 case BuiltinType::ARCUnbridgedCast:
6215 case BuiltinType::PseudoObject:
6220 case BuiltinType::UnknownAny:
6224 case BuiltinType::BoundMember:
6225 case BuiltinType::BuiltinFn:
6226 case BuiltinType::IncompleteMatrixIdx:
6227 case BuiltinType::ArraySection:
6228 case BuiltinType::OMPArrayShaping:
6229 case BuiltinType::OMPIterator:
6233 llvm_unreachable(
"bad builtin type kind");
6239 bool hasInvalid =
false;
6240 for (
size_t i = 0, e = args.size(); i != e; i++) {
6243 if (result.
isInvalid()) hasInvalid =
true;
6244 else args[i] = result.
get();
6272 bool NeedsNewDecl =
false;
6285 if (!ParamType->isPointerType() || ParamType.hasAddressSpace() ||
6289 OverloadParams.push_back(ParamType);
6297 NeedsNewDecl =
true;
6310 OverloadParams, EPI);
6319 FT = cast<FunctionProtoType>(OverloadTy);
6320 for (
unsigned i = 0, e = FT->
getNumParams(); i != e; ++i) {
6327 Params.push_back(Parm);
6329 OverloadDecl->setParams(Params);
6331 return OverloadDecl;
6342 !Callee->isVariadic())
6344 if (Callee->getMinRequiredArguments() > ArgExprs.size())
6347 if (
const EnableIfAttr *
Attr =
6350 isa<CXXMethodDecl>(Callee)
6351 ? diag::err_ovl_no_viable_member_function_in_call
6352 : diag::err_ovl_no_viable_function_in_call)
6353 << Callee << Callee->getSourceRange();
6354 S.
Diag(Callee->getLocation(),
6355 diag::note_ovl_candidate_disabled_by_function_cond_attr)
6356 <<
Attr->getCond()->getSourceRange() <<
Attr->getMessage();
6364 const auto GetFunctionLevelDCIfCXXClass =
6372 if (
const auto *MD = dyn_cast<CXXMethodDecl>(DC))
6373 return MD->
getParent()->getCanonicalDecl();
6376 if (
const auto *RD = dyn_cast<CXXRecordDecl>(DC))
6377 return RD->getCanonicalDecl();
6384 const CXXRecordDecl *
const CurParentClass = GetFunctionLevelDCIfCXXClass(S);
6385 if (!CurParentClass)
6392 assert(NamingClass &&
"Must have naming class even for implicit access");
6398 return CurParentClass == NamingClass ||
6447 if (
Call->getNumArgs() != 1)
6450 const Expr *E =
Call->getCallee()->IgnoreParenImpCasts();
6451 if (!E || isa<UnresolvedLookupExpr>(E))
6453 const DeclRefExpr *DRE = dyn_cast_if_present<DeclRefExpr>(E);
6466 if (BuiltinID != Builtin::BImove && BuiltinID != Builtin::BIforward)
6469 S.
Diag(DRE->
getLocation(), diag::warn_unqualified_call_to_std_cast_function)
6480 if (
Call.isInvalid())
6485 if (
const auto *ULE = dyn_cast<UnresolvedLookupExpr>(Fn);
6486 ULE && ULE->hasExplicitTemplateArgs() &&
6487 ULE->decls_begin() == ULE->decls_end()) {
6489 ? diag::warn_cxx17_compat_adl_only_template_id
6490 : diag::ext_adl_only_template_id)
6498 if (
const auto *CE = dyn_cast<CallExpr>(
Call.get()))
6509 Expr *ExecConfig,
bool IsExecConfig,
6510 bool AllowRecovery) {
6521 if (isa<CXXPseudoDestructorExpr>(Fn)) {
6522 if (!ArgExprs.empty()) {
6527 ArgExprs.back()->getEndLoc()));
6544 cast<CallExpr>(ExecConfig), ArgExprs,
6550 *
this, dyn_cast<UnresolvedMemberExpr>(Fn->
IgnoreParens()),
6571 RParenLoc, ExecConfig, IsExecConfig,
6588 Scope, Fn, ULE, LParenLoc, ArgExprs, RParenLoc, ExecConfig,
6591 RParenLoc, ExecConfig, IsExecConfig,
6605 bool CallingNDeclIndirectly =
false;
6607 if (
UnaryOperator *UnOp = dyn_cast<UnaryOperator>(NakedFn)) {
6608 if (UnOp->getOpcode() == UO_AddrOf) {
6609 CallingNDeclIndirectly =
true;
6614 if (
auto *DRE = dyn_cast<DeclRefExpr>(NakedFn)) {
6615 NDecl = DRE->getDecl();
6628 nullptr, DRE->isNonOdrUse());
6631 }
else if (
auto *ME = dyn_cast<MemberExpr>(NakedFn))
6632 NDecl = ME->getMemberDecl();
6634 if (
FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(NDecl)) {
6648 FD->getBuiltinID()) {
6649 for (
unsigned Idx = 0; Idx < FD->param_size(); ++Idx) {
6652 !ArgExprs[Idx]->getType()->isPointerType())
6656 auto ArgTy = ArgExprs[Idx]->getType();
6657 auto ArgPtTy = ArgTy->getPointeeType();
6658 auto ArgAS = ArgPtTy.getAddressSpace();
6661 bool NeedImplicitASC =
6666 if (!NeedImplicitASC)
6670 if (ArgExprs[Idx]->isGLValue()) {
6672 Context, ArgExprs[Idx]->getType(), CK_NoOp, ArgExprs[Idx],
6677 Qualifiers ArgPtQuals = ArgPtTy.getQualifiers();
6687 CK_AddressSpaceConversion)
6697 llvm::any_of(ArgExprs,
6698 [](
clang::Expr *E) { return E->containsErrors(); })) &&
6699 "should only occur in error-recovery path.");
6704 ExecConfig, IsExecConfig);
6717 assert(BuiltInDecl &&
"failed to find builtin declaration");
6721 assert(DeclRef.
isUsable() &&
"Builtin reference cannot fail");
6726 assert(!
Call.isInvalid() &&
"Call to builtin cannot fail!");
6751 Diag(BuiltinLoc, diag::err_invalid_astype_of_different_size)
6780 FunctionDecl *FDecl = dyn_cast_or_null<FunctionDecl>(NDecl);
6781 unsigned BuiltinID = (FDecl ? FDecl->
getBuiltinID() : 0);
6784 if (FDecl && FDecl->
hasAttr<AnyX86InterruptAttr>()) {
6797 if (Caller->hasAttr<ARMInterruptAttr>()) {
6799 if (VFP && (!FDecl || !FDecl->
hasAttr<ARMInterruptAttr>())) {
6800 Diag(Fn->
getExprLoc(), diag::warn_arm_interrupt_calling_convention);
6805 if (Caller->hasAttr<AnyX86InterruptAttr>() ||
6806 Caller->hasAttr<AnyX86NoCallerSavedRegistersAttr>()) {
6808 bool HasNonGPRRegisters =
6810 if (HasNonGPRRegisters &&
6811 (!FDecl || !FDecl->
hasAttr<AnyX86NoCallerSavedRegistersAttr>())) {
6813 << (Caller->hasAttr<AnyX86InterruptAttr>() ? 0 : 1);
6853 return ExprError(
Diag(LParenLoc, diag::err_typecheck_call_not_function)
6868 return ExprError(
Diag(LParenLoc, diag::err_typecheck_call_not_function)
6876 const auto *Proto = dyn_cast_or_null<FunctionProtoType>(FuncT);
6877 unsigned NumParams = Proto ? Proto->getNumParams() : 0;
6881 assert(UsesADL == ADLCallKind::NotADL &&
6882 "CUDAKernelCallExpr should not use ADL");
6903 TheCall = dyn_cast<CallExpr>(
Result.get());
6904 bool CorrectedTypos = TheCall != TheOldCall;
6905 if (!TheCall)
return Result;
6912 if (CorrectedTypos && Args.size() < NumParams) {
6928 return CheckBuiltinFunctionCall(FDecl, BuiltinID, TheCall);
6933 if (FDecl && !FDecl->
hasAttr<CUDAGlobalAttr>())
6934 return ExprError(
Diag(LParenLoc,diag::err_kern_call_not_global_function)
6941 return ExprError(
Diag(LParenLoc, diag::err_kern_type_not_void_return)
6945 if (FDecl && FDecl->
hasAttr<CUDAGlobalAttr>())
6946 return ExprError(
Diag(LParenLoc, diag::err_global_call_not_config)
6962 for (
const Expr *Arg : Args) {
6963 if (Arg && Arg->getType()->isWebAssemblyTableType()) {
6965 diag::err_wasm_table_as_function_parameter));
6975 assert(isa<FunctionNoProtoType>(FuncT) &&
"Unknown FunctionType!");
6983 if (!Proto || !(Proto->isVariadic() && Args.size() >= Def->
param_size()))
6984 Diag(RParenLoc, diag::warn_call_wrong_number_of_arguments)
7004 if (!Proto && !Args.empty() &&
7008 Diag(LParenLoc, diag::warn_strict_uses_without_prototype)
7009 << (FDecl !=
nullptr) << FDecl;
7012 for (
unsigned i = 0, e = Args.size(); i != e; i++) {
7013 Expr *Arg = Args[i];
7015 if (Proto && i < Proto->getNumParams()) {
7017 Context, Proto->getParamType(i), Proto->isParamConsumed(i));
7035 diag::err_call_incomplete_argument, Arg))
7043 if (
CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl))
7044 if (!isa<RequiresExprBodyDecl>(
CurContext) &&
7045 Method->isImplicitObjectMemberFunction())
7046 return ExprError(
Diag(LParenLoc, diag::err_member_call_without_object)
7055 for (
unsigned i = 0, e = Args.size(); i != e; i++) {
7056 if (
const auto *RT =
7057 dyn_cast<RecordType>(Args[i]->getType().getCanonicalType())) {
7058 if (RT->getDecl()->isOrContainsUnion())
7059 Diag(Args[i]->getBeginLoc(), diag::warn_cmse_nonsecure_union)
7070 checkFortifiedBuiltinMemoryFunction(FDecl, TheCall);
7073 return CheckBuiltinFunctionCall(FDecl, BuiltinID, TheCall);
7075 if (CheckPointerCall(NDecl, TheCall, Proto))
7078 if (CheckOtherCall(TheCall, Proto))
7088 assert(Ty &&
"ActOnCompoundLiteral(): missing type");
7089 assert(InitExpr &&
"ActOnCompoundLiteral(): missing expression");
7107 diag::err_array_incomplete_or_sizeless_type,
7130 ? diag::err_variable_object_no_init
7131 : diag::err_compound_literal_with_vla_type;
7138 diag::err_typecheck_decl_incomplete_type,
7153 LiteralExpr =
Result.get();
7181 if (
auto ILE = dyn_cast<InitListExpr>(LiteralExpr))
7182 for (
unsigned i = 0, j = ILE->getNumInits(); i != j; i++) {
7188 VK, LiteralExpr, isFileScope);
7200 Diag(LParenLoc, diag::err_compound_literal_with_address_space)
7236 bool DiagnosedArrayDesignator =
false;
7237 bool DiagnosedNestedDesignator =
false;
7238 bool DiagnosedMixedDesignator =
false;
7242 for (
unsigned I = 0, E = InitArgList.size(); I != E; ++I) {
7243 if (
auto *DIE = dyn_cast<DesignatedInitExpr>(InitArgList[I])) {
7245 FirstDesignator = DIE->getBeginLoc();
7250 if (!DiagnosedNestedDesignator && DIE->size() > 1) {
7251 DiagnosedNestedDesignator =
true;
7252 Diag(DIE->getBeginLoc(), diag::ext_designated_init_nested)
7253 << DIE->getDesignatorsSourceRange();
7256 for (
auto &Desig : DIE->designators()) {
7257 if (!Desig.isFieldDesignator() && !DiagnosedArrayDesignator) {
7258 DiagnosedArrayDesignator =
true;
7259 Diag(Desig.getBeginLoc(), diag::ext_designated_init_array)
7260 << Desig.getSourceRange();
7264 if (!DiagnosedMixedDesignator &&
7265 !isa<DesignatedInitExpr>(InitArgList[0])) {
7266 DiagnosedMixedDesignator =
true;
7267 Diag(DIE->getBeginLoc(), diag::ext_designated_init_mixed)
7268 << DIE->getSourceRange();
7269 Diag(InitArgList[0]->getBeginLoc(), diag::note_designated_init_mixed)
7270 << InitArgList[0]->getSourceRange();
7273 isa<DesignatedInitExpr>(InitArgList[0])) {
7274 DiagnosedMixedDesignator =
true;
7275 auto *DIE = cast<DesignatedInitExpr>(InitArgList[0]);
7276 Diag(DIE->getBeginLoc(), diag::ext_designated_init_mixed)
7277 << DIE->getSourceRange();
7278 Diag(InitArgList[I]->getBeginLoc(), diag::note_designated_init_mixed)
7279 << InitArgList[I]->getSourceRange();
7283 if (FirstDesignator.
isValid()) {
7287 !DiagnosedNestedDesignator && !DiagnosedMixedDesignator) {
7289 ? diag::warn_cxx17_compat_designated_init
7290 : diag::ext_cxx_designated_init);
7292 Diag(FirstDesignator, diag::ext_designated_init);
7307 for (
unsigned I = 0, E = InitArgList.size(); I != E; ++I) {
7308 if (InitArgList[I]->getType()->isNonOverloadPlaceholderType()) {
7315 InitArgList[I] = result.
get();
7352 llvm_unreachable(
"member pointer type in C");
7361 if (SrcAS != DestAS)
7362 return CK_AddressSpaceConversion;
7369 ? CK_BitCast : CK_AnyPointerToBlockPointerCast);
7374 return CK_CPointerToObjCPointerCast;
7376 return CK_BlockPointerToObjCPointerCast;
7378 return CK_PointerToBoolean;
7380 return CK_PointerToIntegral;
7386 llvm_unreachable(
"illegal cast from pointer");
7388 llvm_unreachable(
"Should have returned before this");
7393 return CK_FixedPointCast;
7395 return CK_FixedPointToBoolean;
7397 return CK_FixedPointToIntegral;
7399 return CK_FixedPointToFloating;
7403 diag::err_unimplemented_conversion_with_fixed_point_type)
7405 return CK_IntegralCast;
7410 llvm_unreachable(
"illegal cast to pointer type");
7412 llvm_unreachable(
"Should have returned before this");
7422 return CK_NullToPointer;
7423 return CK_IntegralToPointer;
7425 return CK_IntegralToBoolean;
7427 return CK_IntegralCast;
7429 return CK_IntegralToFloating;
7434 return CK_IntegralRealToComplex;
7438 CK_IntegralToFloating);
7439 return CK_FloatingRealToComplex;
7441 llvm_unreachable(
"member pointer type in C");
7443 return CK_IntegralToFixedPoint;
7445 llvm_unreachable(
"Should have returned before this");
7450 return CK_FloatingCast;
7452 return CK_FloatingToBoolean;
7454 return CK_FloatingToIntegral;
7459 return CK_FloatingRealToComplex;
7463 CK_FloatingToIntegral);
7464 return CK_IntegralRealToComplex;
7468 llvm_unreachable(
"valid float->pointer cast?");
7470 llvm_unreachable(
"member pointer type in C");
7472 return CK_FloatingToFixedPoint;
7474 llvm_unreachable(
"Should have returned before this");
7479 return CK_FloatingComplexCast;
7481 return CK_FloatingComplexToIntegralComplex;
7485 return CK_FloatingComplexToReal;
7487 return CK_FloatingCast;
7490 return CK_FloatingComplexToBoolean;
7494 CK_FloatingComplexToReal);
7495 return CK_FloatingToIntegral;
7499 llvm_unreachable(
"valid complex float->pointer cast?");
7501 llvm_unreachable(
"member pointer type in C");
7504 diag::err_unimplemented_conversion_with_fixed_point_type)
7506 return CK_IntegralCast;
7508 llvm_unreachable(
"Should have returned before this");
7513 return CK_IntegralComplexToFloatingComplex;
7515 return CK_IntegralComplexCast;
7519 return CK_IntegralComplexToReal;
7521 return CK_IntegralCast;
7524 return CK_IntegralComplexToBoolean;
7528 CK_IntegralComplexToReal);
7529 return CK_IntegralToFloating;
7533 llvm_unreachable(
"valid complex int->pointer cast?");
7535 llvm_unreachable(
"member pointer type in C");
7538 diag::err_unimplemented_conversion_with_fixed_point_type)
7540 return CK_IntegralCast;
7542 llvm_unreachable(
"Should have returned before this");
7545 llvm_unreachable(
"Unhandled scalar cast");
7552 len = vecType->getNumElements();
7553 eltType = vecType->getElementType();
7560 if (!
type->isRealType())
return false;
7576 auto ValidScalableConversion = [](
QualType FirstType,
QualType SecondType) {
7580 const auto *VecTy = SecondType->getAs<
VectorType>();
7584 return ValidScalableConversion(srcTy, destTy) ||
7585 ValidScalableConversion(destTy, srcTy);
7597 auto ValidScalableConversion = [](
QualType FirstType,
QualType SecondType) {
7601 const auto *VecTy = SecondType->getAs<
VectorType>();
7605 return ValidScalableConversion(srcTy, destTy) ||
7606 ValidScalableConversion(destTy, srcTy);
7618 return matSrcType->
getNumRows() == matDestType->getNumRows() &&
7619 matSrcType->
getNumColumns() == matDestType->getNumColumns();
7625 uint64_t SrcLen, DestLen;
7638 return (SrcLen * SrcEltSize == DestLen * DestEltSize);
7644 "expected at least one type to be a vector here");
7646 bool IsSrcTyAltivec =
7662 return (IsSrcTyAltivec || IsDestTyAltivec);
7698 if (!Vec || !Vec->getElementType()->isIntegralOrEnumerationType())
7703 if (!Vec || !Vec->getElementType()->isIntegralOrEnumerationType())
7720 return Diag(R.
getBegin(), diag::err_invalid_conversion_between_matrixes)
7721 << DestTy << SrcTy << R;
7725 diag::err_invalid_conversion_between_matrix_and_type)
7726 << SrcTy << DestTy << R;
7729 diag::err_invalid_conversion_between_matrix_and_type)
7730 << DestTy << SrcTy << R;
7733 Kind = CK_MatrixCast;
7739 assert(VectorTy->
isVectorType() &&
"Not a vector type!");
7745 diag::err_invalid_conversion_between_vectors :
7746 diag::err_invalid_conversion_between_vector_and_integer)
7747 << VectorTy << Ty << R;
7750 diag::err_invalid_conversion_between_vector_and_scalar)
7751 << VectorTy << Ty << R;
7760 if (DestElemTy == SplattedExpr->
getType())
7761 return SplattedExpr;
7774 CK_BooleanToSignedIntegral);
7775 SplattedExpr = CastExprRes.
get();
7776 CK = CK_IntegralToFloating;
7778 CK = CK_BooleanToSignedIntegral;
7785 SplattedExpr = CastExprRes.
get();
7804 Diag(R.
getBegin(),diag::err_invalid_conversion_between_ext_vectors)
7805 << DestTy << SrcTy << R;
7817 diag::err_invalid_conversion_between_vector_and_scalar)
7818 << DestTy << SrcTy << R;
7820 Kind = CK_VectorSplat;
7829 "ActOnCastExpr(): missing type or expr");
7851 bool isVectorLiteral =
false;
7866 isVectorLiteral =
true;
7869 isVectorLiteral =
true;
7874 if (isVectorLiteral)
7880 if (isa<ParenListExpr>(
CastExpr)) {
7901 assert((isa<ParenListExpr>(E) || isa<ParenExpr>(E)) &&
7902 "Expected paren or paren list expression");
7909 LiteralLParenLoc = PE->getLParenLoc();
7910 LiteralRParenLoc = PE->getRParenLoc();
7911 exprs = PE->getExprs();
7912 numExprs = PE->getNumExprs();
7914 LiteralLParenLoc = cast<ParenExpr>(E)->getLParen();
7915 LiteralRParenLoc = cast<ParenExpr>(E)->getRParen();
7916 subExpr = cast<ParenExpr>(E)->getSubExpr();
7939 if (numExprs == 1) {
7942 if (Literal.isInvalid())
7948 else if (numExprs < numElems) {
7950 diag::err_incorrect_number_of_vector_initializers);
7954 initExprs.append(exprs, exprs + numExprs);
7963 if (Literal.isInvalid())
7970 initExprs.append(exprs, exprs + numExprs);
7975 initExprs, LiteralRParenLoc);
8010 const Expr *NullExpr = LHSExpr;
8011 const Expr *NonPointerExpr = RHSExpr;
8018 NonPointerExpr = LHSExpr;
8040 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands_null)
8041 << NonPointerExpr->
getType() << DiagType
8053 S.
Diag(QuestionLoc, diag::err_typecheck_cond_expect_nonfloat)
8061 S.
Diag(QuestionLoc, diag::err_typecheck_cond_expect_scalar)
8095 bool IsBlockPointer =
false;
8099 IsBlockPointer =
true;
8124 ResultAddrSpace = LAddrSpace;
8126 ResultAddrSpace = RAddrSpace;
8128 S.
Diag(
Loc, diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
8135 auto LHSCastKind = CK_BitCast, RHSCastKind = CK_BitCast;
8150 LAddrSpace == ResultAddrSpace ? CK_BitCast : CK_AddressSpaceConversion;
8152 RAddrSpace == ResultAddrSpace ? CK_BitCast : CK_AddressSpaceConversion;
8160 lhptee, rhptee,
false,
false,
8163 if (CompositeTy.
isNull()) {
8180 S.
Diag(
Loc, diag::ext_typecheck_cond_incompatible_pointers)
8191 QualType ResultTy = [&, ResultAddrSpace]() {
8197 .withCVRQualifiers(MergedCVRQual);
8226 S.
Diag(
Loc, diag::err_typecheck_cond_incompatible_operands)
8279 bool IsIntFirstExpr) {
8281 !Int.get()->getType()->isIntegerType())
8284 Expr *Expr1 = IsIntFirstExpr ? Int.get() : PointerExpr;
8285 Expr *Expr2 = IsIntFirstExpr ? PointerExpr : Int.get();
8287 S.
Diag(
Loc, diag::ext_typecheck_cond_pointer_integer_mismatch)
8291 CK_IntegralToPointer);
8325 S.
Diag(QuestionLoc, diag::err_typecheck_cond_expect_int_float)
8331 S.
Diag(QuestionLoc, diag::err_typecheck_cond_expect_int_float)
8337 if (LHSType == RHSType)
8346 return handleIntegerConversion<doIntegralCast, doIntegralCast>
8347 (S, LHS, RHS, LHSType, RHSType,
false);
8381 llvm::raw_svector_ostream OS(Str);
8382 OS <<
"(vector of " << NumElements <<
" '" << EleTyName <<
"' values)";
8383 S.
Diag(QuestionLoc, diag::err_conditional_vector_element_size)
8384 << CondTy << OS.str();
8405 S.
Diag(QuestionLoc, diag::err_typecheck_cond_expect_nonfloat)
8423 S.
Diag(QuestionLoc, diag::err_conditional_vector_size)
8424 << CondTy << VecResTy;
8429 QualType RVE = RV->getElementType();
8432 S.
Diag(QuestionLoc, diag::err_conditional_vector_element_size)
8433 << CondTy << VecResTy;
8459 bool IsBoolVecLang =
8483 if (
const CallExpr *CE = dyn_cast<CallExpr>(E)) {
8484 QualType Ty = CE->getCallee()->getType();
8522 "should only occur in error-recovery path.");
8557 Diag(QuestionLoc, diag::err_wasm_table_conditional_expression)
8566 diag::err_typecheck_cond_incompatible_operands) << LHSTy << RHSTy
8585 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
8601 if (LHSRT->getDecl() == RHSRT->getDecl())
8645 if (!compositeType.
isNull())
8646 return compositeType;
8680 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
8719 const Expr **RHSExprs) {
8724 if (
const auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E)) {
8725 E = MTE->getSubExpr();
8730 if (
const auto *OP = dyn_cast<BinaryOperator>(E);
8732 *Opcode = OP->getOpcode();
8733 *RHSExprs = OP->getRHS();
8738 if (
const auto *
Call = dyn_cast<CXXOperatorCallExpr>(E)) {
8739 if (
Call->getNumArgs() != 2)
8745 if (OO < OO_Plus || OO > OO_Arrow ||
8746 OO == OO_PlusPlus || OO == OO_MinusMinus)
8752 *RHSExprs =
Call->getArg(1);
8768 if (
const auto *OP = dyn_cast<BinaryOperator>(E))
8769 return OP->isComparisonOp() || OP->isLogicalOp();
8770 if (
const auto *OP = dyn_cast<UnaryOperator>(E))
8771 return OP->getOpcode() == UO_LNot;
8786 const Expr *RHSExpr) {
8788 const Expr *CondRHS;
8799 ? diag::warn_precedence_bitwise_conditional
8800 : diag::warn_precedence_conditional;
8802 Self.Diag(OpLoc, DiagID)
8808 Self.PDiag(diag::note_precedence_silence)
8813 Self.PDiag(diag::note_precedence_conditional_first),
8824 auto GetNullability = [](
QualType Ty) {
8825 std::optional<NullabilityKind> Kind = Ty->getNullability();
8835 auto LHSKind = GetNullability(LHSTy), RHSKind = GetNullability(RHSTy);
8843 MergedKind = RHSKind;
8850 MergedKind = RHSKind;
8852 MergedKind = LHSKind;
8858 if (GetNullability(ResTy) == MergedKind)
8895 CondExpr = CondResult.
get();
8896 LHSExpr = LHSResult.
get();
8897 RHSExpr = RHSResult.
get();
8903 Expr *commonExpr =
nullptr;
8905 commonExpr = CondExpr;
8912 commonExpr = result.
get();
8926 commonExpr = commonRes.
get();
8936 commonExpr = MatExpr.
get();
8944 LHSExpr = CondExpr = opaqueValue;
8950 ExprResult Cond = CondExpr, LHS = LHSExpr, RHS = RHSExpr;
8952 VK, OK, QuestionLoc);
8960 CheckBoolLikeConversion(Cond.
get(), QuestionLoc);
8968 RHS.get(), result, VK, OK);
8971 commonExpr, opaqueValue, Cond.
get(), LHS.get(), RHS.get(), QuestionLoc,
8972 ColonLoc, result, VK, OK);
8977 unsigned FromAttributes = 0, ToAttributes = 0;
8978 if (
const auto *FromFn =
8982 if (
const auto *ToFn =
8987 return FromAttributes != ToAttributes;
8995 if (
const auto *ToFn =
8997 if (
const auto *FromFn =
9016 assert(LHSType.
isCanonical() &&
"LHS not canonicalized!");
9017 assert(RHSType.
isCanonical() &&
"RHS not canonicalized!");
9020 const Type *lhptee, *rhptee;
9022 std::tie(lhptee, lhq) =
9023 cast<PointerType>(LHSType)->getPointeeType().split().asPair();
9024 std::tie(rhptee, rhq) =
9025 cast<PointerType>(RHSType)->getPointeeType().split().asPair();
9085 diag::warn_typecheck_convert_incompatible_function_pointer_strict,
9108 if (ltrans == rtrans) {
9122 if (isa<PointerType>(lhptee) && isa<PointerType>(rhptee)) {
9124 std::tie(lhptee, lhq) =
9125 cast<PointerType>(lhptee)->getPointeeType().split().asPair();
9126 std::tie(rhptee, rhq) =
9127 cast<PointerType>(rhptee)->getPointeeType().split().asPair();
9140 }
while (isa<PointerType>(lhptee) && isa<PointerType>(rhptee));
9142 if (lhptee == rhptee)
9168 assert(LHSType.
isCanonical() &&
"LHS not canonicalized!");
9169 assert(RHSType.
isCanonical() &&
"RHS not canonicalized!");
9190 if (LQuals != RQuals)
9219 assert(LHSType.
isCanonical() &&
"LHS was not canonicalized!");
9220 assert(RHSType.
isCanonical() &&
"RHS was not canonicalized!");
9268 return VT->getElementType().getCanonicalType() == ElementType;
9301 if (LHSType == RHSType) {
9308 if (
const auto *AT = dyn_cast<AutoType>(LHSType)) {
9309 if (AT->isGNUAutoType()) {
9317 if (
const AtomicType *AtomicTy = dyn_cast<AtomicType>(LHSType)) {
9322 if (Kind != CK_NoOp && ConvertRHS)
9324 Kind = CK_NonAtomicToAtomic;
9337 Kind = CK_LValueBitCast;
9352 Kind = CK_VectorSplat;
9378 << RHSType << LHSType;
9397 << RHSType << LHSType;
9447 if (
const PointerType *LHSPointer = dyn_cast<PointerType>(LHSType)) {
9449 if (isa<PointerType>(RHSType)) {
9450 LangAS AddrSpaceL = LHSPointer->getPointeeType().getAddressSpace();
9452 if (AddrSpaceL != AddrSpaceR)
9453 Kind = CK_AddressSpaceConversion;
9464 Kind = CK_IntegralToPointer;
9470 if (isa<ObjCObjectPointerType>(RHSType)) {
9472 if (LHSPointer->getPointeeType()->isVoidType()) {
9491 if (LHSPointer->getPointeeType()->isVoidType()) {
9492 LangAS AddrSpaceL = LHSPointer->getPointeeType().getAddressSpace();
9497 AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion : CK_BitCast;
9506 if (isa<BlockPointerType>(LHSType)) {
9515 Kind = AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion : CK_BitCast;
9521 Kind = CK_IntegralToPointer;
9527 Kind = CK_AnyPointerToBlockPointerCast;
9533 if (RHSPT->getPointeeType()->isVoidType()) {
9534 Kind = CK_AnyPointerToBlockPointerCast;
9542 if (isa<ObjCObjectPointerType>(LHSType)) {
9548 if (
getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
9550 !
ObjC().CheckObjCARCUnavailableWeakConversion(OrigLHSType, RHSType))
9557 Kind = CK_IntegralToPointer;
9563 if (isa<PointerType>(RHSType)) {
9564 Kind = CK_CPointerToObjCPointerCast;
9586 Kind = CK_BlockPointerToObjCPointerCast;
9598 Kind = CK_NullToPointer;
9603 if (isa<PointerType>(RHSType)) {
9606 Kind = CK_PointerToBoolean;
9612 Kind = CK_PointerToIntegral;
9620 if (isa<ObjCObjectPointerType>(RHSType)) {
9623 Kind = CK_PointerToBoolean;
9629 Kind = CK_PointerToIntegral;
9637 if (isa<TagType>(LHSType) && isa<TagType>(RHSType)) {
9645 Kind = CK_IntToOCLSampler;
9687 for (
auto *it : UD->
fields()) {
9688 if (it->getType()->isPointerType()) {
9727 bool DiagnoseCFAudited,
9731 assert((ConvertRHS || !
Diagnose) &&
"can't indicate whether we diagnosed");
9737 ExprResult &RHS = ConvertRHS ? CallerRHS : LocalRHS;
9741 if (RHSPtrType->getPointeeType()->hasAttr(attr::NoDeref) &&
9742 !LHSPtrType->getPointeeType()->hasAttr(attr::NoDeref)) {
9744 diag::warn_noderef_to_dereferenceable_pointer)
9763 AllowedExplicit::None,
9775 if (
getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
9776 !
ObjC().CheckObjCARCUnavailableWeakConversion(LHSType, RHSType))
9790 RHS.
get(), LHSType,
false, DAP))
9881 if (
getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
9891 ObjC().CheckConversionToObjCLiteral(LHSType, E,
Diagnose))) {
9911struct OriginalOperand {
9912 explicit OriginalOperand(
Expr *Op) : Orig(Op), Conversion(nullptr) {
9913 if (
auto *MTE = dyn_cast<MaterializeTemporaryExpr>(Op))
9914 Op = MTE->getSubExpr();
9915 if (
auto *BTE = dyn_cast<CXXBindTemporaryExpr>(Op))
9916 Op = BTE->getSubExpr();
9917 if (
auto *ICE = dyn_cast<ImplicitCastExpr>(Op)) {
9918 Orig = ICE->getSubExprAsWritten();
9919 Conversion = ICE->getConversionFunction();
9923 QualType getType()
const {
return Orig->getType(); }
9932 OriginalOperand OrigLHS(LHS.
get()), OrigRHS(RHS.
get());
9934 Diag(
Loc, diag::err_typecheck_invalid_operands)
9935 << OrigLHS.getType() << OrigRHS.getType()
9940 if (OrigLHS.Conversion) {
9941 Diag(OrigLHS.Conversion->getLocation(),
9942 diag::note_typecheck_invalid_operands_converted)
9945 if (OrigRHS.Conversion) {
9946 Diag(OrigRHS.Conversion->getLocation(),
9947 diag::note_typecheck_invalid_operands_converted)
9965 if (!(LHSNatVec && RHSNatVec)) {
9967 Expr *NonVector = !LHSNatVec ? LHS.
get() : RHS.
get();
9968 Diag(
Loc, diag::err_typecheck_logical_vector_expr_gnu_cpp_restrict)
9970 <<
Vector->getSourceRange();
9974 Diag(
Loc, diag::err_typecheck_logical_vector_expr_gnu_cpp_restrict)
10006 DiagID = diag::err_opencl_scalar_type_rank_greater_than_vector_type;
10011 scalarCast = CK_IntegralCast;
10016 DiagID = diag::err_opencl_scalar_type_rank_greater_than_vector_type;
10019 scalarCast = CK_FloatingCast;
10022 scalarCast = CK_IntegralToFloating;
10031 if (scalarCast != CK_NoOp)
10042 assert(VecTy &&
"Expression E must be a vector");
10047 VecTy->getVectorKind());
10051 if (
auto *ICE = dyn_cast<ImplicitCastExpr>(E))
10052 if (ICE->getSubExpr()->getType() == NewVecTy)
10053 return ICE->getSubExpr();
10055 auto Cast = ElementType->
isIntegerType() ? CK_IntegralCast : CK_FloatingCast;
10063 QualType IntTy = Int->get()->getType().getUnqualifiedType();
10069 bool CstInt = Int->get()->EvaluateAsInt(EVResult, S.
Context);
10078 unsigned NumBits = IntSigned
10080 :
Result.getActiveBits())
10081 :
Result.getActiveBits();
10088 return (IntSigned != OtherIntSigned &&
10094 return (Order < 0);
10101 QualType IntTy = Int->get()->getType().getUnqualifiedType();
10106 bool CstInt = Int->get()->EvaluateAsInt(EVResult, S.
Context);
10118 llvm::APFloat::rmTowardZero);
10121 bool Ignored =
false;
10122 Float.convertToInteger(ConvertBack, llvm::APFloat::rmNearestTiesToEven,
10124 if (
Result != ConvertBack)
10130 unsigned FloatPrec = llvm::APFloat::semanticsPrecision(
10132 if (Bits > FloatPrec)
10145 QualType ScalarTy = Scalar->get()->getType().getUnqualifiedType();
10146 QualType VectorTy =
Vector->get()->getType().getUnqualifiedType();
10150 assert(!isa<ExtVectorType>(VT) &&
10151 "ExtVectorTypes should not be handled here!");
10152 VectorEltTy = VT->getElementType();
10157 llvm_unreachable(
"Only Fixed-Length and SVE Vector types are handled here");
10183 ScalarCast = CK_IntegralCast;
10187 ScalarCast = CK_FloatingToIntegral;
10195 llvm::APFloat
Result(0.0);
10201 bool CstScalar = Scalar->get()->isValueDependent() ||
10204 if (!CstScalar && Order < 0)
10210 bool Truncated =
false;
10212 llvm::APFloat::rmNearestTiesToEven, &Truncated);
10217 ScalarCast = CK_FloatingCast;
10222 ScalarCast = CK_IntegralToFloating;
10229 if (ScalarCast != CK_NoOp)
10237 bool AllowBothBool,
10238 bool AllowBoolConversions,
10239 bool AllowBoolOperation,
10240 bool ReportInvalid) {
10241 if (!IsCompAssign) {
10257 assert(LHSVecType || RHSVecType);
10261 if (!AllowBothBool && LHSVecType &&
10267 if (!AllowBoolOperation &&
10276 if (LHSVecType && RHSVecType &&
10278 if (isa<ExtVectorType>(LHSVecType)) {
10291 if (AllowBoolConversions && LHSVecType && RHSVecType &&
10301 if (!IsCompAssign &&
10304 RHSVecType->getElementType()->isIntegerType()) {
10313 unsigned &SVEorRVV) {
10331 if (IsSveRVVConversion(LHSType, RHSType, SVEorRVV) ||
10332 IsSveRVVConversion(RHSType, LHSType, SVEorRVV)) {
10333 Diag(
Loc, diag::err_typecheck_sve_rvv_ambiguous)
10334 << SVEorRVV << LHSType << RHSType;
10341 unsigned &SVEorRVV) {
10346 if (FirstVecType && SecondVecType) {
10349 SecondVecType->getVectorKind() ==
10361 if (SecondVecType &&
10374 if (IsSveRVVGnuConversion(LHSType, RHSType, SVEorRVV) ||
10375 IsSveRVVGnuConversion(RHSType, LHSType, SVEorRVV)) {
10376 Diag(
Loc, diag::err_typecheck_sve_rvv_gnu_ambiguous)
10377 << SVEorRVV << LHSType << RHSType;
10383 unsigned DiagID = diag::err_typecheck_vector_not_convertable;
10385 if (isa<ExtVectorType>(LHSVecType)) {
10396 if (isa<ExtVectorType>(RHSVecType)) {
10398 LHSType, RHSVecType->getElementType(),
10411 QualType VecType = LHSVecType ? LHSType : RHSType;
10412 const VectorType *VT = LHSVecType ? LHSVecType : RHSVecType;
10413 QualType OtherType = LHSVecType ? RHSType : LHSType;
10414 ExprResult *OtherExpr = LHSVecType ? &RHS : &LHS;
10419 Diag(
Loc, diag::warn_deprecated_lax_vec_conv_all) << RHSType << LHSType;
10423 if (!IsCompAssign) {
10442 if ((!RHSVecType && !RHSType->
isRealType()) ||
10444 Diag(
Loc, diag::err_typecheck_vector_not_convertable_non_scalar)
10445 << LHSType << RHSType
10455 RHSVecType && isa<ExtVectorType>(RHSVecType) &&
10456 LHSVecType && isa<ExtVectorType>(LHSVecType)) {
10457 Diag(
Loc, diag::err_opencl_implicit_vector_conversion) << LHSType
10466 if ((RHSVecType && !isa<ExtVectorType>(RHSVecType)) ||
10467 (LHSVecType && !isa<ExtVectorType>(LHSVecType))) {
10468 QualType Scalar = LHSVecType ? RHSType : LHSType;
10470 unsigned ScalarOrVector = LHSVecType && RHSVecType ? 1 : 0;
10472 diag::err_typecheck_vector_not_convertable_implict_truncation)
10473 << ScalarOrVector << Scalar <<
Vector;
10480 << LHSType << RHSType
10489 if (!IsCompAssign) {
10504 unsigned DiagID = diag::err_typecheck_invalid_operands;
10506 ((LHSBuiltinTy && LHSBuiltinTy->
isSVEBool()) ||
10507 (RHSBuiltinTy && RHSBuiltinTy->isSVEBool()))) {
10528 Diag(
Loc, diag::err_typecheck_vector_not_convertable_non_scalar)
10537 Diag(
Loc, diag::err_typecheck_vector_lengths_not_equal)
10546 bool ScalarOrVector =
10549 Diag(
Loc, diag::err_typecheck_vector_not_convertable_implict_truncation)
10550 << ScalarOrVector << Scalar <<
Vector;
10582 S.
Diag(
Loc, diag::warn_null_in_arithmetic_operation)
10594 S.
Diag(
Loc, diag::warn_null_in_comparison_operation)
10595 << LHSNull << NonNullType
10601 const auto *LUE = dyn_cast<UnaryExprOrTypeTraitExpr>(LHS);
10602 const auto *RUE = dyn_cast<UnaryExprOrTypeTraitExpr>(RHS);
10605 if (LUE->getKind() != UETT_SizeOf || LUE->isArgumentType() ||
10606 RUE->getKind() != UETT_SizeOf)
10613 if (RUE->isArgumentType())
10614 RHSTy = RUE->getArgumentType().getNonReferenceType();
10616 RHSTy = RUE->getArgumentExpr()->IgnoreParens()->getType();
10623 if (
const auto *DRE = dyn_cast<DeclRefExpr>(LHSArg)) {
10624 if (
const ValueDecl *LHSArgDecl = DRE->getDecl())
10625 S.
Diag(LHSArgDecl->getLocation(), diag::note_pointer_declared_here)
10629 QualType ArrayElemTy = ArrayTy->getElementType();
10635 S.
Diag(
Loc, diag::warn_division_sizeof_array)
10637 if (
const auto *DRE = dyn_cast<DeclRefExpr>(LHSArg)) {
10638 if (
const ValueDecl *LHSArgDecl = DRE->getDecl())
10639 S.
Diag(LHSArgDecl->getLocation(), diag::note_array_declared_here)
10643 S.
Diag(
Loc, diag::note_precedence_silence) << RHS;
10656 S.
PDiag(diag::warn_remainder_division_by_zero)
10662 bool IsCompAssign,
bool IsDiv) {
10740 ? diag::err_typecheck_pointer_arith_void_type
10741 : diag::ext_gnu_void_ptr)
10750 ? diag::err_typecheck_pointer_arith_void_type
10751 : diag::ext_gnu_void_ptr)
10752 << 0 <<
Pointer->getSourceRange();
10763 S.
Diag(
Loc, diag::warn_gnu_null_ptr_arith)
10764 <<
Pointer->getSourceRange();
10766 S.
Diag(
Loc, diag::warn_pointer_arith_null_ptr)
10783 S.
PDiag(diag::warn_pointer_sub_null_ptr)
10785 <<
Pointer->getSourceRange());
10794 ? diag::err_typecheck_pointer_arith_function_type
10795 : diag::ext_gnu_ptr_func_arith)
10807 assert(
Pointer->getType()->isAnyPointerType());
10809 ? diag::err_typecheck_pointer_arith_function_type
10810 : diag::ext_gnu_ptr_func_arith)
10811 << 0 <<
Pointer->getType()->getPointeeType()
10813 <<
Pointer->getSourceRange();
10821 QualType ResType = Operand->getType();
10823 ResType = ResAtomicType->getValueType();
10829 diag::err_typecheck_arithmetic_incomplete_or_sizeless_type,
10830 Operand->getSourceRange());
10843 QualType ResType = Operand->getType();
10845 ResType = ResAtomicType->getValueType();
10877 if (!isLHSPointer && !isRHSPointer)
return true;
10879 QualType LHSPointeeTy, RHSPointeeTy;
10884 if (isLHSPointer && isRHSPointer) {
10887 diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
10895 bool isLHSVoidPtr = isLHSPointer && LHSPointeeTy->
isVoidType();
10896 bool isRHSVoidPtr = isRHSPointer && RHSPointeeTy->
isVoidType();
10897 if (isLHSVoidPtr || isRHSVoidPtr) {
10905 bool isLHSFuncPtr = isLHSPointer && LHSPointeeTy->
isFunctionType();
10906 bool isRHSFuncPtr = isRHSPointer && RHSPointeeTy->
isFunctionType();
10907 if (isLHSFuncPtr || isRHSFuncPtr) {
10929 Expr* IndexExpr = RHSExpr;
10932 IndexExpr = LHSExpr;
10935 bool IsStringPlusInt = StrExpr &&
10941 Self.Diag(OpLoc, diag::warn_string_plus_int)
10945 if (IndexExpr == RHSExpr) {
10947 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence)
10952 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence);
10958 const Expr *StringRefExpr = LHSExpr;
10963 CharExpr = dyn_cast<CharacterLiteral>(LHSExpr->
IgnoreImpCasts());
10964 StringRefExpr = RHSExpr;
10967 if (!CharExpr || !StringRefExpr)
10987 Self.Diag(OpLoc, diag::warn_string_plus_char)
10988 << DiagRange << Ctx.
CharTy;
10990 Self.Diag(OpLoc, diag::warn_string_plus_char)
10991 << DiagRange << CharExpr->
getType();
10997 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence)
11002 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence);
11011 S.
Diag(
Loc, diag::err_typecheck_sub_ptr_compatible)
11030 if (CompLHSTy) *CompLHSTy = compType;
11039 *CompLHSTy = compType;
11048 *CompLHSTy = compType;
11058 if (Opc == BO_Add) {
11065 if (CompLHSTy) *CompLHSTy = compType;
11079 std::swap(PExp, IExp);
11090 if (!IExp->getType()->isIntegerType())
11099 (!IExp->isValueDependent() &&
11100 (!IExp->EvaluateAsInt(KnownVal,
Context) ||
11104 Context, BO_Add, PExp, IExp);
11116 CheckArrayAccess(PExp, IExp);
11125 *CompLHSTy = LHSTy;
11145 if (CompLHSTy) *CompLHSTy = compType;
11154 *CompLHSTy = compType;
11163 *CompLHSTy = compType;
11176 if (CompLHSTy) *CompLHSTy = compType;
11210 CheckArrayAccess(LHS.
get(), RHS.
get(),
nullptr,
11213 if (CompLHSTy) *CompLHSTy = LHS.
get()->
getType();
11257 if (ElementSize.
isZero()) {
11258 Diag(
Loc,diag::warn_sub_ptr_zero_size_types)
11264 if (CompLHSTy) *CompLHSTy = LHS.
get()->
getType();
11274 return ET->getDecl()->isScoped();
11291 llvm::APSInt Right = RHSResult.
Val.
getInt();
11293 if (Right.isNegative()) {
11295 S.
PDiag(diag::warn_shift_negative)
11306 LeftSize = FXSema.getWidth() - (
unsigned)FXSema.hasUnsignedPadding();
11308 if (Right.uge(LeftSize)) {
11310 S.
PDiag(diag::warn_shift_gt_typewidth)
11330 llvm::APSInt Left = LHSResult.
Val.
getInt();
11341 if (Left.isNegative()) {
11343 S.
PDiag(diag::warn_shift_lhs_negative)
11348 llvm::APInt ResultBits =
11349 static_cast<llvm::APInt &
>(Right) + Left.getSignificantBits();
11350 if (ResultBits.ule(LeftSize))
11352 llvm::APSInt
Result = Left.extend(ResultBits.getLimitedValue());
11358 Result.toString(HexResult, 16,
false,
true);
11364 if (ResultBits - 1 == LeftSize) {
11365 S.
Diag(
Loc, diag::warn_shift_result_sets_sign_bit)
11366 << HexResult << LHSType
11371 S.
Diag(
Loc, diag::warn_shift_result_gt_typewidth)
11372 << HexResult.str() <<
Result.getSignificantBits() << LHSType
11384 S.
Diag(
Loc, diag::err_shift_rhs_only_vector)
11390 if (!IsCompAssign) {
11412 S.
Diag(
Loc, diag::err_typecheck_invalid_operands)
11419 if (!LHSEleType->isIntegerType()) {
11420 S.
Diag(
Loc, diag::err_typecheck_expect_int)
11425 if (!RHSEleType->isIntegerType()) {
11426 S.
Diag(
Loc, diag::err_typecheck_expect_int)
11435 if (LHSEleType != RHSEleType) {
11437 LHSEleType = RHSEleType;
11443 }
else if (RHSVecTy) {
11448 S.
Diag(
Loc, diag::err_typecheck_vector_lengths_not_equal)
11456 if (LHSBT != RHSBT &&
11458 S.
Diag(
Loc, diag::warn_typecheck_vector_element_sizes_not_equal)
11475 bool IsCompAssign) {
11476 if (!IsCompAssign) {
11499 if ((LHSBuiltinTy && LHSBuiltinTy->
isSVEBool()) ||
11500 (RHSBuiltinTy && RHSBuiltinTy->
isSVEBool())) {
11501 S.
Diag(
Loc, diag::err_typecheck_invalid_operands)
11506 if (!LHSEleType->isIntegerType()) {
11507 S.
Diag(
Loc, diag::err_typecheck_expect_int)
11512 if (!RHSEleType->isIntegerType()) {
11513 S.
Diag(
Loc, diag::err_typecheck_expect_int)
11521 S.
Diag(
Loc, diag::err_typecheck_invalid_operands)
11531 if (LHSEleType != RHSEleType) {
11533 LHSEleType = RHSEleType;
11535 const llvm::ElementCount VecSize =
11544 S.
Diag(
Loc, diag::err_typecheck_vector_lengths_not_equal)
11550 const llvm::ElementCount VecSize =
11552 if (LHSEleType != RHSEleType) {
11554 RHSEleType = LHSEleType;
11567 bool IsCompAssign) {
11601 if (IsCompAssign) LHS = OldLHS;
11632 S.
Diag(
Loc, IsError ? diag::err_typecheck_comparison_of_distinct_pointers
11633 : diag::ext_typecheck_comparison_of_distinct_pointers)
11673 S.
Diag(
Loc, IsError ? diag::err_typecheck_comparison_of_fptr_to_void
11674 : diag::ext_typecheck_comparison_of_fptr_to_void)
11681 case Stmt::ObjCArrayLiteralClass:
11682 case Stmt::ObjCDictionaryLiteralClass:
11683 case Stmt::ObjCStringLiteralClass:
11684 case Stmt::ObjCBoxedExprClass:
11745 Literal = LHS.
get();
11748 Literal = RHS.
get();
11764 llvm_unreachable(
"Unknown Objective-C object literal kind");
11768 S.
Diag(
Loc, diag::warn_objc_string_literal_comparison)
11769 << Literal->getSourceRange();
11771 S.
Diag(
Loc, diag::warn_objc_literal_comparison)
11772 << LiteralKind << Literal->getSourceRange();
11781 S.
Diag(
Loc, diag::note_objc_literal_comparison_isequal)
11794 if (!UO || UO->
getOpcode() != UO_LNot)
return;
11804 bool IsBitwiseOp = Opc == BO_And || Opc == BO_Or || Opc == BO_Xor;
11806 <<
Loc << IsBitwiseOp;
11833 if (
const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(E)) {
11835 }
else if (
const MemberExpr *Mem = dyn_cast<MemberExpr>(E)) {
11836 if (Mem->isImplicitAccess())
11837 D = Mem->getMemberDecl();
11892 S.
Diag(
Loc, diag::warn_depr_array_comparison)
11918 Result = AlwaysConstant;
11922 S.
PDiag(diag::warn_comparison_always)
11937 Result = AlwaysConstant;
11941 S.
PDiag(diag::warn_comparison_always)
11947 if (isa<CastExpr>(LHSStripped))
11949 if (isa<CastExpr>(RHSStripped))
11954 Expr *LiteralString =
nullptr;
11955 Expr *LiteralStringStripped =
nullptr;
11956 if ((isa<StringLiteral>(LHSStripped) || isa<ObjCEncodeExpr>(LHSStripped)) &&
11959 LiteralString = LHS;
11960 LiteralStringStripped = LHSStripped;
11961 }
else if ((isa<StringLiteral>(RHSStripped) ||
11962 isa<ObjCEncodeExpr>(RHSStripped)) &&
11965 LiteralString = RHS;
11966 LiteralStringStripped = RHSStripped;
11969 if (LiteralString) {
11971 S.
PDiag(diag::warn_stringcompare)
11972 << isa<ObjCEncodeExpr>(LiteralStringStripped)
11984 llvm_unreachable(
"unhandled cast kind");
11986 case CK_UserDefinedConversion:
11988 case CK_LValueToRValue:
11990 case CK_ArrayToPointerDecay:
11992 case CK_FunctionToPointerDecay:
11994 case CK_IntegralCast:
11996 case CK_FloatingCast:
11998 case CK_IntegralToFloating:
11999 case CK_FloatingToIntegral:
12001 case CK_IntegralComplexCast:
12002 case CK_FloatingComplexCast:
12003 case CK_FloatingComplexToIntegralComplex:
12004 case CK_IntegralComplexToFloatingComplex:
12006 case CK_FloatingComplexToReal:
12007 case CK_FloatingRealToComplex:
12008 case CK_IntegralComplexToReal:
12009 case CK_IntegralRealToComplex:
12011 case CK_HLSLArrayRValue:
12024 if (
const auto *ICE = dyn_cast<ImplicitCastExpr>(E))
12051 << 0 << FromType << ToType;
12056 llvm_unreachable(
"unhandled case in switch");
12083 if (NumEnumArgs == 1) {
12085 QualType OtherTy = LHSIsEnum ? RHSStrippedType : LHSStrippedType;
12091 if (NumEnumArgs == 2) {
12100 LHSStrippedType->
castAs<
EnumType>()->getDecl()->getIntegerType();
12111 LHSType = RHSType = IntType;
12123 std::optional<ComparisonCategoryType> CCT =
12135 assert(!
Type.isNull() &&
"composite type for <=> has not been set");
12176 if (
const auto *CL = dyn_cast<CharacterLiteral>(E.
get())) {
12177 if (CL->getValue() == 0)
12181 NullValue ?
"NULL" :
"(void *)0");
12182 }
else if (
const auto *CE = dyn_cast<CStyleCastExpr>(E.
get())) {
12189 NullValue ?
"NULL" :
"(void *)0");
12199 bool IsThreeWay = Opc == BO_Cmp;
12200 bool IsOrdered = IsRelational || IsThreeWay;
12211 if (!IsThreeWay || IsAnyPointerType(LHS) || IsAnyPointerType(RHS)) {
12264 auto computeResultTy = [&]() {
12273 std::optional<ComparisonCategoryType> CCT =
12278 if (CompositeTy->
isPointerType() && LHSIsNull != RHSIsNull) {
12282 Diag(
Loc, diag::err_typecheck_three_way_comparison_of_pointer_and_zero)
12292 if (!IsOrdered && LHSIsNull != RHSIsNull) {
12293 bool IsEquality = Opc == BO_EQ;
12305 bool IsError = Opc == BO_Cmp;
12307 IsError ? diag::err_typecheck_ordered_comparison_of_function_pointers
12309 ? diag::warn_typecheck_ordered_comparison_of_function_pointers
12310 : diag::ext_typecheck_ordered_comparison_of_function_pointers;
12339 return computeResultTy();
12355 (IsOrdered ? 2 : 1) &&
12360 return computeResultTy();
12374 if (IsRelational) {
12379 Diag(
Loc, diag::ext_typecheck_compare_complete_incomplete_pointers)
12385 }
else if (!IsRelational &&
12389 && !LHSIsNull && !RHSIsNull)
12396 if (LCanPointeeTy != RCanPointeeTy) {
12401 diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
12402 << LHSType << RHSType << 0
12408 CastKind Kind = AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion
12410 if (LHSIsNull && !RHSIsNull)
12415 return computeResultTy();
12427 if (!IsOrdered && LHSIsNull && RHSIsNull) {
12430 return computeResultTy();
12434 return computeResultTy();
12445 return computeResultTy();
12449 return computeResultTy();
12458 return computeResultTy();
12463 return computeResultTy();
12467 if (IsRelational &&
12476 if (isa<FunctionDecl>(DC))
12478 if (
auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
12479 if (CTSD->isInStdNamespace() &&
12480 llvm::StringSwitch<bool>(CTSD->getName())
12481 .Cases(
"less",
"less_equal",
"greater",
"greater_equal",
true)
12487 return computeResultTy();
12500 return computeResultTy();
12510 if (!LHSIsNull && !RHSIsNull &&
12512 Diag(
Loc, diag::err_typecheck_comparison_of_distinct_blocks)
12517 return computeResultTy();
12524 if (!LHSIsNull && !RHSIsNull) {
12529 Diag(
Loc, diag::err_typecheck_comparison_of_distinct_blocks)
12533 if (LHSIsNull && !RHSIsNull)
12536 : CK_AnyPointerToBlockPointerCast);
12540 : CK_AnyPointerToBlockPointerCast);
12541 return computeResultTy();
12550 bool RPtrToVoid = RPT ? RPT->getPointeeType()->isVoidType() :
false;
12552 if (!LPtrToVoid && !RPtrToVoid &&
12560 if (LHSIsNull && !RHSIsNull) {
12566 RPT ? CK_BitCast :CK_CPointerToObjCPointerCast);
12576 LPT ? CK_BitCast :CK_CPointerToObjCPointerCast);
12578 return computeResultTy();
12588 if (LHSIsNull && !RHSIsNull)
12592 return computeResultTy();
12598 CK_BlockPointerToObjCPointerCast);
12599 return computeResultTy();
12600 }
else if (!IsOrdered &&
12604 CK_BlockPointerToObjCPointerCast);
12605 return computeResultTy();
12610 unsigned DiagID = 0;
12611 bool isError =
false;
12620 isError ? diag::err_typecheck_ordered_comparison_of_pointer_and_zero
12621 : diag::ext_typecheck_ordered_comparison_of_pointer_and_zero;
12624 DiagID = diag::err_typecheck_comparison_of_pointer_integer;
12626 }
else if (IsOrdered)
12627 DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_integer;
12629 DiagID = diag::ext_typecheck_comparison_of_pointer_integer;
12641 LHSIsNull ? CK_NullToPointer : CK_IntegralToPointer);
12644 RHSIsNull ? CK_NullToPointer : CK_IntegralToPointer);
12645 return computeResultTy();
12649 if (!IsOrdered && RHSIsNull
12652 return computeResultTy();
12654 if (!IsOrdered && LHSIsNull
12657 return computeResultTy();
12660 if (
getLangOpts().getOpenCLCompatibleVersion() >= 200) {
12662 return computeResultTy();
12666 return computeResultTy();
12669 if (LHSIsNull && RHSType->
isQueueT()) {
12671 return computeResultTy();
12674 if (LHSType->
isQueueT() && RHSIsNull) {
12676 return computeResultTy();
12692 if (isa<ExtVectorType>(VTy)) {
12706 "Unhandled vector element size in vector compare");
12726 "Unhandled vector element size in vector compare");
12750 if (Opc == BO_Cmp) {
12751 Diag(
Loc, diag::err_three_way_vector_comparison);
12782 Diag(
Loc, diag::warn_deprecated_altivec_src_compat);
12812 if (Opc == BO_Cmp) {
12813 Diag(
Loc, diag::err_three_way_vector_comparison);
12841 if (LHSBuiltinTy && RHSBuiltinTy && LHSBuiltinTy->
isSVEBool() &&
12842 RHSBuiltinTy->isSVEBool())
12861 bool Negative =
false;
12862 bool ExplicitPlus =
false;
12863 const auto *LHSInt = dyn_cast<IntegerLiteral>(XorLHS.
get());
12864 const auto *RHSInt = dyn_cast<IntegerLiteral>(XorRHS.
get());
12870 if (
const auto *UO = dyn_cast<UnaryOperator>(XorRHS.
get())) {
12872 if (Opc != UO_Minus && Opc != UO_Plus)
12874 RHSInt = dyn_cast<IntegerLiteral>(UO->getSubExpr());
12877 Negative = (Opc == UO_Minus);
12878 ExplicitPlus = !Negative;
12884 const llvm::APInt &LeftSideValue = LHSInt->getValue();
12885 llvm::APInt RightSideValue = RHSInt->getValue();
12886 if (LeftSideValue != 2 && LeftSideValue != 10)
12889 if (LeftSideValue.getBitWidth() != RightSideValue.getBitWidth())
12894 llvm::StringRef ExprStr =
12899 llvm::StringRef XorStr =
12902 if (XorStr ==
"xor")
12913 RightSideValue = -RightSideValue;
12914 RHSStr =
"-" + RHSStr;
12915 }
else if (ExplicitPlus) {
12916 RHSStr =
"+" + RHSStr;
12919 StringRef LHSStrRef = LHSStr;
12920 StringRef RHSStrRef = RHSStr;
12923 if (LHSStrRef.starts_with(
"0b") || LHSStrRef.starts_with(
"0B") ||
12924 RHSStrRef.starts_with(
"0b") || RHSStrRef.starts_with(
"0B") ||
12925 LHSStrRef.starts_with(
"0x") || LHSStrRef.starts_with(
"0X") ||
12926 RHSStrRef.starts_with(
"0x") || RHSStrRef.starts_with(
"0X") ||
12927 (LHSStrRef.size() > 1 && LHSStrRef.starts_with(
"0")) ||
12928 (RHSStrRef.size() > 1 && RHSStrRef.starts_with(
"0")) ||
12929 LHSStrRef.contains(
'\'') || RHSStrRef.contains(
'\''))
12934 const llvm::APInt XorValue = LeftSideValue ^ RightSideValue;
12935 int64_t RightSideIntValue = RightSideValue.getSExtValue();
12936 if (LeftSideValue == 2 && RightSideIntValue >= 0) {
12937 std::string SuggestedExpr =
"1 << " + RHSStr;
12938 bool Overflow =
false;
12939 llvm::APInt One = (LeftSideValue - 1);
12940 llvm::APInt PowValue = One.sshl_ov(RightSideValue, Overflow);
12942 if (RightSideIntValue < 64)
12943 S.
Diag(
Loc, diag::warn_xor_used_as_pow_base)
12944 << ExprStr <<
toString(XorValue, 10,
true) << (
"1LL << " + RHSStr)
12946 else if (RightSideIntValue == 64)
12947 S.
Diag(
Loc, diag::warn_xor_used_as_pow)
12948 << ExprStr <<
toString(XorValue, 10,
true);
12952 S.
Diag(
Loc, diag::warn_xor_used_as_pow_base_extra)
12953 << ExprStr <<
toString(XorValue, 10,
true) << SuggestedExpr
12956 ExprRange, (RightSideIntValue == 0) ?
"1" : SuggestedExpr);
12959 S.
Diag(
Loc, diag::note_xor_used_as_pow_silence)
12960 << (
"0x2 ^ " + RHSStr) << SuggestXor;
12961 }
else if (LeftSideValue == 10) {
12962 std::string SuggestedValue =
"1e" + std::to_string(RightSideIntValue);
12963 S.
Diag(
Loc, diag::warn_xor_used_as_pow_base)
12964 << ExprStr <<
toString(XorValue, 10,
true) << SuggestedValue
12966 S.
Diag(
Loc, diag::note_xor_used_as_pow_silence)
12967 << (
"0xA ^ " + RHSStr) << SuggestXor;
12983 getLangOpts().getOpenCLCompatibleVersion() < 120 &&
12998 bool IsCompAssign) {
12999 if (!IsCompAssign) {
13015 assert((LHSMatType || RHSMatType) &&
"At least one operand must be a matrix");
13024 if (LHSMatType && !RHSMatType) {
13032 if (!LHSMatType && RHSMatType) {
13044 bool IsCompAssign) {
13045 if (!IsCompAssign) {
13056 assert((LHSMatType || RHSMatType) &&
"At least one operand must be a matrix");
13058 if (LHSMatType && RHSMatType) {
13059 if (LHSMatType->getNumColumns() != RHSMatType->
getNumRows())
13067 QualType LHSELTy = LHSMatType->getElementType(),
13098 bool IsCompAssign =
13099 Opc == BO_AndAssign || Opc == BO_OrAssign || Opc == BO_XorAssign;
13110 LegalBoolVecOperator,
13140 ExprResult LHSResult = LHS, RHSResult = RHS;
13143 if (LHSResult.
isInvalid() || RHSResult.isInvalid())
13145 LHS = LHSResult.
get();
13146 RHS = RHSResult.
get();
13165 bool EnumConstantInBoolContext =
false;
13167 if (
const auto *DREHS = dyn_cast<DeclRefExpr>(HS.get())) {
13168 const auto *ECDHS = dyn_cast<EnumConstantDecl>(DREHS->getDecl());
13169 if (ECDHS && ECDHS->getInitVal() != 0 && ECDHS->getInitVal() != 1)
13170 EnumConstantInBoolContext =
true;
13174 if (EnumConstantInBoolContext)
13175 Diag(
Loc, diag::warn_enum_constant_in_bool_context);
13180 const auto *LHSATy = dyn_cast<ArrayType>(LHSTy);
13181 const auto *RHSATy = dyn_cast<ArrayType>(RHSTy);
13182 if ((LHSATy && LHSATy->getElementType().isWebAssemblyReferenceType()) ||
13183 (RHSATy && RHSATy->getElementType().isWebAssemblyReferenceType())) {
13205 Diag(
Loc, diag::warn_logical_instead_of_bitwise)
13208 Diag(
Loc, diag::note_logical_instead_of_bitwise_change_operator)
13209 << (Opc == BO_LAnd ?
"&" :
"|")
13212 Opc == BO_LAnd ?
"&" :
"|");
13213 if (Opc == BO_LAnd)
13215 Diag(
Loc, diag::note_logical_instead_of_bitwise_remove_constant)
13271 const MemberExpr *ME = dyn_cast<MemberExpr>(E);
13272 if (!ME)
return false;
13276 if (!
Base)
return false;
13277 return Base->getMethodDecl() !=
nullptr;
13297 assert(var->
hasLocalStorage() &&
"capture added 'const' to non-local?");
13305 if (
auto *FD = dyn_cast<FunctionDecl>(DC))
13348 bool DiagnosticEmitted =
false;
13352 bool IsDereference =
false;
13353 bool NextIsDereference =
false;
13357 IsDereference = NextIsDereference;
13360 if (
const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
13361 NextIsDereference = ME->isArrow();
13362 const ValueDecl *VD = ME->getMemberDecl();
13363 if (
const FieldDecl *Field = dyn_cast<FieldDecl>(VD)) {
13365 if (Field->isMutable()) {
13366 assert(DiagnosticEmitted &&
"Expected diagnostic not emitted.");
13371 if (!DiagnosticEmitted) {
13372 S.
Diag(
Loc, diag::err_typecheck_assign_const)
13374 << Field->getType();
13375 DiagnosticEmitted =
true;
13378 <<
ConstMember <<
false << Field << Field->getType()
13379 << Field->getSourceRange();
13383 }
else if (
const VarDecl *VDecl = dyn_cast<VarDecl>(VD)) {
13384 if (VDecl->getType().isConstQualified()) {
13385 if (!DiagnosticEmitted) {
13386 S.
Diag(
Loc, diag::err_typecheck_assign_const)
13388 << VDecl->getType();
13389 DiagnosticEmitted =
true;
13392 <<
ConstMember <<
true << VDecl << VDecl->getType()
13393 << VDecl->getSourceRange();
13400 dyn_cast<ArraySubscriptExpr>(E)) {
13404 dyn_cast<ExtVectorElementExpr>(E)) {
13411 if (
const CallExpr *CE = dyn_cast<CallExpr>(E)) {
13415 if (!DiagnosticEmitted) {
13416 S.
Diag(
Loc, diag::err_typecheck_assign_const) << ExprRange
13418 DiagnosticEmitted =
true;
13421 diag::note_typecheck_assign_const)
13425 }
else if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
13427 if (
const ValueDecl *VD = DRE->getDecl()) {
13429 if (!DiagnosticEmitted) {
13430 S.
Diag(
Loc, diag::err_typecheck_assign_const)
13432 DiagnosticEmitted =
true;
13434 S.
Diag(VD->getLocation(), diag::note_typecheck_assign_const)
13435 <<
ConstVariable << VD << VD->getType() << VD->getSourceRange();
13438 }
else if (isa<CXXThisExpr>(E)) {
13440 if (
const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(DC)) {
13441 if (MD->isConst()) {
13442 if (!DiagnosticEmitted) {
13443 S.
Diag(
Loc, diag::err_typecheck_assign_const) << ExprRange
13445 DiagnosticEmitted =
true;
13447 S.
Diag(MD->getLocation(), diag::note_typecheck_assign_const)
13454 if (DiagnosticEmitted)
13471 bool &DiagnosticEmitted) {
13472 std::vector<const RecordType *> RecordTypeList;
13473 RecordTypeList.push_back(Ty);
13474 unsigned NextToCheckIndex = 0;
13477 while (RecordTypeList.size() > NextToCheckIndex) {
13478 bool IsNested = NextToCheckIndex > 0;
13480 RecordTypeList[NextToCheckIndex]->getDecl()->fields()) {
13482 QualType FieldTy = Field->getType();
13484 if (!DiagnosticEmitted) {
13485 S.
Diag(
Loc, diag::err_typecheck_assign_const)
13487 << IsNested << Field;
13488 DiagnosticEmitted =
true;
13490 S.
Diag(Field->getLocation(), diag::note_typecheck_assign_const)
13492 << FieldTy << Field->getSourceRange();
13498 if (!llvm::is_contained(RecordTypeList, FieldRecTy))
13499 RecordTypeList.push_back(FieldRecTy);
13502 ++NextToCheckIndex;
13511 assert(Ty->
isRecordType() &&
"lvalue was not record?");
13514 bool DiagEmitted =
false;
13516 if (
const MemberExpr *ME = dyn_cast<MemberExpr>(E))
13519 else if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
13544 unsigned DiagID = 0;
13545 bool NeedType =
false;
13552 DiagID = diag::err_block_decl_ref_not_modifiable_lvalue;
13554 DiagID = diag::err_lambda_decl_ref_not_modifiable_lvalue;
13562 if (declRef && isa<VarDecl>(declRef->
getDecl())) {
13575 ? diag::err_typecheck_arc_assign_self_class_method
13576 : diag::err_typecheck_arc_assign_self;
13579 }
else if (var->
hasAttr<ObjCExternallyRetainedAttr>() ||
13580 isa<ParmVarDecl>(var)) {
13581 DiagID = diag::err_typecheck_arc_assign_externally_retained;
13585 DiagID = diag::err_typecheck_arr_assign_enumeration;
13589 if (
Loc != OrigLoc)
13615 DiagID = diag::err_typecheck_array_not_modifiable_lvalue;
13619 DiagID = diag::err_typecheck_non_object_not_modifiable_lvalue;
13623 DiagID = diag::err_typecheck_lvalue_casts_not_supported;
13626 llvm_unreachable(
"did not take early return for MLV_Valid");
13630 DiagID = diag::err_typecheck_expression_not_modifiable_lvalue;
13635 diag::err_typecheck_incomplete_type_not_modifiable_lvalue, E);
13637 DiagID = diag::err_typecheck_duplicate_vector_components_not_mlvalue;
13640 llvm_unreachable(
"readonly properties should be processed differently");
13642 DiagID = diag::err_readonly_message_assignment;
13645 DiagID = diag::err_no_subobject_property_setting;
13650 if (
Loc != OrigLoc)
13672 MemberExpr *ML = dyn_cast<MemberExpr>(LHSExpr);
13673 MemberExpr *MR = dyn_cast<MemberExpr>(RHSExpr);
13675 if (!(isa<CXXThisExpr>(ML->
getBase()) && isa<CXXThisExpr>(MR->
getBase())))
13681 if (LHSDecl != RHSDecl)
13686 if (RefTy->getPointeeType().isVolatileQualified())
13689 Sema.
Diag(
Loc, diag::warn_identity_field_assign) << 0;
13699 Sema.
Diag(
Loc, diag::warn_identity_field_assign) << 1;
13723 Diag(
Loc, diag::err_opencl_half_load_store) << 1
13730 Diag(
Loc, diag::err_wasm_table_art) << 0;
13735 if (CompoundType.
isNull()) {
13754 Diag(
Loc, diag::err_objc_object_assignment)
13761 RHSCheck = ICE->getSubExpr();
13762 if (
UnaryOperator *UO = dyn_cast<UnaryOperator>(RHSCheck)) {
13763 if ((UO->getOpcode() == UO_Plus || UO->getOpcode() == UO_Minus) &&
13764 Loc.
isFileID() && UO->getOperatorLoc().isFileID() &&
13770 UO->getSubExpr()->getBeginLoc().
isFileID()) {
13771 Diag(
Loc, diag::warn_not_compound_assign)
13772 << (UO->getOpcode() == UO_Plus ?
"+" :
"-")
13773 <<
SourceRange(UO->getOperatorLoc(), UO->getOperatorLoc());
13783 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InnerLHS);
13819 if (CompoundType.
isNull()) {
13845 if (
const CastExpr *CE = dyn_cast<CastExpr>(E)) {
13846 if (CE->getCastKind() == CK_ToVoid) {
13852 CE->getSubExpr()->getType()->isDependentType()) {
13857 if (
const auto *CE = dyn_cast<CallExpr>(E))
13858 return CE->getCallReturnType(Context)->isVoidType();
13881 const unsigned ForIncrementFlags =
13887 if ((ScopeFlags & ForIncrementFlags) == ForIncrementFlags ||
13888 (ScopeFlags & ForInitFlags) == ForInitFlags)
13893 while (
const BinaryOperator *BO = dyn_cast<BinaryOperator>(LHS)) {
13894 if (BO->getOpcode() != BO_Comma)
13896 LHS = BO->getRHS();
13903 Diag(
Loc, diag::warn_comma_operator);
13907 LangOpts.CPlusPlus ?
"static_cast<void>("
13939 diag::err_incomplete_type);
13960 ResType = ResAtomicType->getValueType();
13962 assert(!ResType.
isNull() &&
"no type for increment/decrement expression");
13972 : diag::warn_increment_bool)
13976 S.
Diag(OpLoc, diag::err_increment_decrement_enum) << IsInc << ResType;
13992 S.
Diag(OpLoc, diag::ext_increment_complex)
14009 S.
Diag(OpLoc, diag::err_typecheck_illegal_increment_decrement)
14020 S.
Diag(OpLoc, diag::warn_deprecated_increment_decrement_volatile)
14021 << IsInc << ResType;
14053 case Stmt::DeclRefExprClass:
14054 return cast<DeclRefExpr>(E)->getDecl();
14055 case Stmt::MemberExprClass:
14059 if (cast<MemberExpr>(E)->isArrow())
14063 case Stmt::ArraySubscriptExprClass: {
14066 Expr*
Base = cast<ArraySubscriptExpr>(E)->getBase();
14068 if (ICE->getSubExpr()->getType()->isArrayType())
14073 case Stmt::UnaryOperatorClass: {
14085 case Stmt::ParenExprClass:
14087 case Stmt::ImplicitCastExprClass:
14091 case Stmt::CXXUuidofExprClass:
14092 return cast<CXXUuidofExpr>(E)->getGuidDecl();
14101 AO_Vector_Element = 1,
14102 AO_Property_Expansion = 2,
14103 AO_Register_Variable = 3,
14104 AO_Matrix_Element = 4,
14119 const auto *DRE = cast<DeclRefExpr>(Op->
IgnoreParens());
14122 return Diag(OpLoc, diag::err_parens_pointer_member_function)
14126 if (isa<CXXDestructorDecl>(MD))
14127 return Diag(OpLoc, diag::err_typecheck_addrof_dtor)
14128 << DRE->getSourceRange();
14130 if (DRE->getQualifier())
14134 return Diag(OpLoc, diag::err_unqualified_pointer_member_function)
14135 << DRE->getSourceRange();
14139 return Diag(OpLoc, diag::err_unqualified_pointer_member_function)
14140 << DRE->getSourceRange()
14153 if (PTy->getKind() == BuiltinType::Overload) {
14155 if (!isa<OverloadExpr>(E)) {
14156 assert(cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf);
14157 Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof_addrof_function)
14163 if (isa<UnresolvedMemberExpr>(Ovl))
14165 Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
14173 if (PTy->getKind() == BuiltinType::UnknownAny)
14176 if (PTy->getKind() == BuiltinType::BoundMember) {
14177 Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
14200 auto* VarRef = dyn_cast<DeclRefExpr>(op);
14201 if (VarRef && VarRef->refersToEnclosingVariableOrCapture()) {
14202 Diag(op->
getExprLoc(), diag::err_opencl_taking_address_capture);
14210 if (uOp->getOpcode() == UO_Deref)
14213 return uOp->getSubExpr()->getType();
14220 if (
auto *FD = dyn_cast_or_null<FunctionDecl>(dcl))
14226 unsigned AddressOfError = AO_No_Error;
14231 : diag::ext_typecheck_addrof_temporary)
14238 }
else if (isa<ObjCSelectorExpr>(op)) {
14245 if (!isa<DeclRefExpr>(op)) {
14246 Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
14266 if (isa<PseudoObjectExpr>(op)) {
14267 AddressOfError = AO_Property_Expansion;
14269 Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof)
14273 }
else if (
const auto *DRE = dyn_cast<DeclRefExpr>(op)) {
14274 if (
const auto *MD = dyn_cast_or_null<CXXMethodDecl>(DRE->getDecl()))
14280 AddressOfError = AO_Bit_Field;
14283 AddressOfError = AO_Vector_Element;
14286 AddressOfError = AO_Matrix_Element;
14290 if (
const VarDecl *vd = dyn_cast<VarDecl>(dcl)) {
14295 AddressOfError = AO_Register_Variable;
14297 }
else if (isa<MSPropertyDecl>(dcl)) {
14298 AddressOfError = AO_Property_Expansion;
14299 }
else if (isa<FunctionTemplateDecl>(dcl)) {
14301 }
else if (isa<FieldDecl>(dcl) || isa<IndirectFieldDecl>(dcl)) {
14305 if (isa<DeclRefExpr>(op) && cast<DeclRefExpr>(op)->getQualifier()) {
14310 diag::err_cannot_form_pointer_to_member_of_reference_type)
14318 if (isa<ParenExpr>(OrigOp.
get())) {
14323 diag::err_form_ptr_to_member_from_parenthesized_expr)
14331 while (cast<RecordDecl>(Ctx)->isAnonymousStructOrUnion())
14345 llvm_unreachable(
"Unknown/unexpected decl type");
14348 if (AddressOfError != AO_No_Error) {
14368 Diag(OpLoc, diag::err_wasm_ca_reference)
14373 Diag(OpLoc, diag::err_wasm_table_pr)
14379 CheckAddressOfPackedMember(op);
14385 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Exp);
14391 const ParmVarDecl *Param = dyn_cast<ParmVarDecl>(D);
14395 if (!FD->hasAttr<NonNullAttr>() && !Param->
hasAttr<NonNullAttr>())
14398 FD->ModifiedNonNullParams.insert(Param);
14404 bool IsAfterAmp =
false) {
14408 Op = ConvResult.
get();
14412 if (isa<CXXReinterpretCastExpr>(Op)) {
14420 Result = PT->getPointeeType();
14424 Result = OPT->getPointeeType();
14428 if (PR.
get() != Op)
14433 S.
Diag(OpLoc, diag::err_typecheck_indirection_requires_pointer)
14438 if (
Result->isVoidType()) {
14444 S.
Diag(OpLoc, diag::err_typecheck_indirection_through_void_pointer_cpp)
14447 S.
Diag(OpLoc, diag::ext_typecheck_indirection_through_void_pointer)
14464 default: llvm_unreachable(
"Unknown binop!");
14465 case tok::periodstar: Opc = BO_PtrMemD;
break;
14466 case tok::arrowstar: Opc = BO_PtrMemI;
break;
14467 case tok::star: Opc = BO_Mul;
break;
14468 case tok::slash: Opc = BO_Div;
break;
14469 case tok::percent: Opc = BO_Rem;
break;
14470 case tok::plus: Opc = BO_Add;
break;
14471 case tok::minus: Opc = BO_Sub;
break;
14472 case tok::lessless: Opc = BO_Shl;
break;
14473 case tok::greatergreater: Opc = BO_Shr;
break;
14474 case tok::lessequal: Opc = BO_LE;
break;
14475 case tok::less: Opc = BO_LT;
break;
14476 case tok::greaterequal: Opc = BO_GE;
break;
14477 case tok::greater: Opc = BO_GT;
break;
14478 case tok::exclaimequal: Opc = BO_NE;
break;
14479 case tok::equalequal: Opc = BO_EQ;
break;
14480 case tok::spaceship: Opc = BO_Cmp;
break;
14481 case tok::amp: Opc = BO_And;
break;
14482 case tok::caret: Opc = BO_Xor;
break;
14483 case tok::pipe: Opc = BO_Or;
break;
14484 case tok::ampamp: Opc = BO_LAnd;
break;
14485 case tok::pipepipe: Opc = BO_LOr;
break;
14486 case tok::equal: Opc = BO_Assign;
break;
14487 case tok::starequal: Opc = BO_MulAssign;
break;
14488 case tok::slashequal: Opc = BO_DivAssign;
break;
14489 case tok::percentequal: Opc = BO_RemAssign;
break;
14490 case tok::plusequal: Opc = BO_AddAssign;
break;
14491 case tok::minusequal: Opc = BO_SubAssign;
break;
14492 case tok::lesslessequal: Opc = BO_ShlAssign;
break;
14493 case tok::greatergreaterequal: Opc = BO_ShrAssign;
break;
14494 case tok::ampequal: Opc = BO_AndAssign;
break;
14495 case tok::caretequal: Opc = BO_XorAssign;
break;
14496 case tok::pipeequal: Opc = BO_OrAssign;
break;
14497 case tok::comma: Opc = BO_Comma;
break;
14506 default: llvm_unreachable(
"Unknown unary op!");
14507 case tok::plusplus: Opc = UO_PreInc;
break;
14508 case tok::minusminus: Opc = UO_PreDec;
break;
14509 case tok::amp: Opc = UO_AddrOf;
break;
14510 case tok::star: Opc = UO_Deref;
break;
14511 case tok::plus: Opc = UO_Plus;
break;
14512 case tok::minus: Opc = UO_Minus;
break;
14513 case tok::tilde: Opc = UO_Not;
break;
14514 case tok::exclaim: Opc = UO_LNot;
break;
14515 case tok::kw___real: Opc = UO_Real;
break;
14516 case tok::kw___imag: Opc = UO_Imag;
break;
14517 case tok::kw___extension__: Opc = UO_Extension;
break;
14533 if (!isa<ParmVarDecl>(SelfAssigned))
14535 const auto *Method =
14549 llvm::find_if(
Parent->fields(),
14551 return F->getDeclName() == Name;
14553 return (Field !=
Parent->field_end()) ? *Field :
nullptr;
14568 const DeclRefExpr *LHSDeclRef = dyn_cast<DeclRefExpr>(LHSExpr);
14569 const DeclRefExpr *RHSDeclRef = dyn_cast<DeclRefExpr>(RHSExpr);
14570 if (!LHSDeclRef || !RHSDeclRef ||
14578 if (LHSDecl != RHSDecl)
14583 if (RefTy->getPointeeType().isVolatileQualified())
14586 auto Diag = S.
Diag(OpLoc, IsBuiltin ? diag::warn_self_assignment_builtin
14587 : diag::warn_self_assignment_overloaded)
14592 Diag << 1 << SelfAssignField
14605 const Expr *ObjCPointerExpr =
nullptr, *OtherExpr =
nullptr;
14610 ObjCPointerExpr = LHS;
14614 ObjCPointerExpr = RHS;
14622 if (ObjCPointerExpr && isa<IntegerLiteral>(OtherExpr->IgnoreParenCasts())) {
14623 unsigned Diag = diag::warn_objc_pointer_masking;
14631 StringRef SelArg0 = S.getNameForSlot(0);
14632 if (SelArg0.starts_with(
"performSelector"))
14633 Diag = diag::warn_objc_pointer_masking_performSelector;
14644 if (
auto *DRE = dyn_cast<DeclRefExpr>(E))
14645 return DRE->getDecl();
14646 if (
auto *ME = dyn_cast<MemberExpr>(E))
14647 return ME->getMemberDecl();
14648 if (
auto *IRE = dyn_cast<ObjCIvarRefExpr>(E))
14649 return IRE->getDecl();
14664 "Result must be a vector of half or short");
14667 "both operands expected to be a half vector");
14679 ResultTy, VK, OK, OpLoc, FPFeatures,
14680 BinOpResTy, BinOpResTy);
14684 BinOpResTy, VK, OK, OpLoc, FPFeatures);
14688static std::pair<ExprResult, ExprResult>
14698 RHS,
nullptr,
false,
14699 [Opc, LHS](
Expr *E) {
14700 if (Opc != BO_Assign)
14707 return std::make_pair(LHS, RHS);
14714 if (!OpRequiresConversion || Ctx.
getLangOpts().NativeHalfType ||
14718 auto HasVectorOfHalfType = [&Ctx](
Expr *E) {
14728 return VT->getElementType().getCanonicalType() == Ctx.
HalfTy;
14733 return HasVectorOfHalfType(E0) && (!E1 || HasVectorOfHalfType(E1));
14755 if (
Init.isInvalid())
14757 RHSExpr =
Init.get();
14767 bool ConvertHalfVec =
false;
14770 if (!LHS.
isUsable() || !RHS.isUsable())
14780 if (BO_Assign == Opc)
14781 Diag(OpLoc, diag::err_opencl_atomic_init) << 0 << SR;
14809 if (!ResultTy.
isNull()) {
14826 if (
auto *BE = dyn_cast<BlockExpr>(RHS.get()->IgnoreParens()))
14828 if (
auto *VD = dyn_cast<VarDecl>(DRE->getDecl()))
14829 if (VD->hasLocalStorage() &&
getCurScope()->isDeclScope(VD))
14830 BE->getBlockDecl()->setCanAvoidCopyToHeap();
14841 Opc == BO_PtrMemI);
14845 ConvertHalfVec =
true;
14853 ConvertHalfVec =
true;
14857 ConvertHalfVec =
true;
14868 ConvertHalfVec =
true;
14871 if (
const auto *BI = dyn_cast<BinaryOperator>(LHSExpr);
14872 BI && BI->isComparisonOp())
14873 Diag(OpLoc, diag::warn_consecutive_comparison);
14878 ConvertHalfVec =
true;
14882 ConvertHalfVec =
true;
14895 ConvertHalfVec =
true;
14900 ConvertHalfVec =
true;
14902 Opc == BO_DivAssign);
14903 CompLHSTy = CompResultTy;
14910 CompLHSTy = CompResultTy;
14916 ConvertHalfVec =
true;
14923 ConvertHalfVec =
true;
14932 CompLHSTy = CompResultTy;
14943 CompLHSTy = CompResultTy;
14951 VK = RHS.get()->getValueKind();
14952 OK = RHS.get()->getObjectKind();
14966 "both sides are half vectors or neither sides are");
14971 CheckArrayAccess(LHS.
get());
14972 CheckArrayAccess(RHS.get());
14978 if (ObjectSetClass && isa<ObjCIsaExpr>(LHS.
get())) {
14982 "object_setClass(")
14995 if (CompResultTy.
isNull()) {
14996 if (ConvertHalfVec)
15016 if (ConvertHalfVec)
15021 Context, LHS.
get(), RHS.get(), Opc, ResultTy, VK, OK, OpLoc,
15038 if (isLeftComp == isRightComp)
15043 bool isLeftBitwise = LHSBO && LHSBO->
isBitwiseOp();
15044 bool isRightBitwise = RHSBO && RHSBO->
isBitwiseOp();
15045 if (isLeftBitwise || isRightBitwise)
15057 Self.Diag(OpLoc, diag::warn_precedence_bitwise_rel)
15060 Self.PDiag(diag::note_precedence_silence) << OpStr,
15061 (isLeftComp ? LHSExpr : RHSExpr)->getSourceRange());
15063 Self.PDiag(diag::note_precedence_bitwise_first)
15078 Self.PDiag(diag::note_precedence_silence)
15087 if (Bop->getOpcode() == BO_LAnd) {
15090 if (!isa<StringLiteral>(Bop->getLHS()->IgnoreParenImpCasts()))
15092 }
else if (Bop->getOpcode() == BO_LOr) {
15093 if (
BinaryOperator *RBop = dyn_cast<BinaryOperator>(Bop->getRHS())) {
15096 if (RBop->getOpcode() == BO_LAnd &&
15097 isa<StringLiteral>(RBop->getRHS()->IgnoreParenImpCasts()))
15108 if (Bop->getOpcode() == BO_LAnd) {
15111 if (!isa<StringLiteral>(Bop->getRHS()->IgnoreParenImpCasts()))
15123 if (Bop->isBitwiseOp() && Bop->getOpcode() < Opc) {
15124 S.
Diag(Bop->getOperatorLoc(), diag::warn_bitwise_op_in_bitwise_op)
15126 << Bop->getSourceRange() << OpLoc;
15128 S.
PDiag(diag::note_precedence_silence)
15129 << Bop->getOpcodeStr(),
15130 Bop->getSourceRange());
15136 Expr *SubExpr, StringRef Shift) {
15138 if (Bop->getOpcode() == BO_Add || Bop->getOpcode() == BO_Sub) {
15139 StringRef Op = Bop->getOpcodeStr();
15140 S.
Diag(Bop->getOperatorLoc(), diag::warn_addition_in_bitshift)
15141 << Bop->getSourceRange() << OpLoc << Shift << Op;
15143 S.
PDiag(diag::note_precedence_silence) << Op,
15144 Bop->getSourceRange());
15160 if (Kind != OO_LessLess && Kind != OO_GreaterGreater)
15163 S.
Diag(OpLoc, diag::warn_overloaded_shift_in_comparison)
15165 << (Kind == OO_LessLess);
15167 S.
PDiag(diag::note_precedence_silence)
15168 << (Kind == OO_LessLess ?
"<<" :
">>"),
15171 S, OpLoc, S.
PDiag(diag::note_evaluate_comparison_first),
15185 if ((Opc == BO_Or || Opc == BO_Xor) &&
15193 if (Opc == BO_LOr && !OpLoc.
isMacroID()) {
15199 || Opc == BO_Shr) {
15216 assert(LHSExpr &&
"ActOnBinOp(): missing left expression");
15217 assert(RHSExpr &&
"ActOnBinOp(): missing right expression");
15222 return BuildBinOp(S, TokLoc, Opc, LHSExpr, RHSExpr);
15228 if (OverOp !=
OO_None && OverOp != OO_Equal)
15282 LHSExpr = LHS.
get();
15283 RHSExpr = RHS.
get();
15294 if (pty->getKind() == BuiltinType::PseudoObject &&
15307 RHSExpr = resolvedRHS.
get();
15321 (pty->getKind() == BuiltinType::BoundMember ||
15322 pty->getKind() == BuiltinType::Overload)) {
15323 auto *OE = dyn_cast<OverloadExpr>(LHSExpr);
15324 if (OE && !OE->hasTemplateKeyword() && !OE->hasExplicitTemplateArgs() &&
15325 llvm::any_of(OE->decls(), [](
NamedDecl *ND) {
15326 return isa<FunctionTemplateDecl>(ND);
15328 Diag(OE->getQualifier() ? OE->getQualifierLoc().getBeginLoc()
15329 : OE->getNameLoc(),
15330 diag::err_template_kw_missing)
15331 << OE->getName().getAsString() <<
"";
15338 LHSExpr = LHS.
get();
15345 if (Opc == BO_Assign && pty->getKind() == BuiltinType::Overload) {
15361 RHSExpr = resolvedRHS.
get();
15377 "Should only occur in error-recovery path.");
15383 Context, LHSExpr, RHSExpr, Opc,
15403 ResultType = RHSExpr->
getType();
15435 bool CanOverflow =
false;
15437 bool ConvertHalfVec =
false;
15446 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15453 if (Opc == UO_AddrOf)
15454 return ExprError(
Diag(OpLoc, diag::err_hlsl_operator_unsupported) << 0);
15455 if (Opc == UO_Deref)
15456 return ExprError(
Diag(OpLoc, diag::err_hlsl_operator_unsupported) << 1);
15470 Opc == UO_PreInc || Opc == UO_PostInc,
15471 Opc == UO_PreInc || Opc == UO_PreDec);
15476 CheckAddressOfNoDeref(InputExpr);
15489 CanOverflow = Opc == UO_Minus &&
15501 if (ConvertHalfVec)
15518 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15529 Diag(OpLoc, diag::ext_integer_complement_complex)
15538 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15541 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15563 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15579 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15589 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15599 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15606 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15640 "the co_await expression must be non-dependant before "
15641 "building operator co_await");
15652 if (Opc != UO_AddrOf && Opc != UO_Deref)
15653 CheckArrayAccess(Input.
get());
15659 if (Opc == UO_Deref && UO->getType()->hasAttr(attr::NoDeref) &&
15660 !isa<ArrayType>(UO->getType().getDesugaredType(
Context)) &&
15665 if (ConvertHalfVec)
15674 if (
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
15675 if (!DRE->getQualifier())
15682 if (isa<FieldDecl>(VD) || isa<IndirectFieldDecl>(VD))
15685 return Method->isImplicitObjectMemberFunction();
15691 if (!ULE->getQualifier())
15696 if (Method->isImplicitObjectMemberFunction())
15717 if (pty->getKind() == BuiltinType::PseudoObject &&
15722 if (Opc == UO_Extension)
15727 if (Opc == UO_AddrOf &&
15728 (pty->getKind() == BuiltinType::Overload ||
15729 pty->getKind() == BuiltinType::UnknownAny ||
15730 pty->getKind() == BuiltinType::BoundMember))
15756 Expr *Input,
bool IsAfterAmp) {
15796 assert(SubStmt && isa<CompoundStmt>(SubStmt) &&
"Invalid action invocation!");
15802 "cleanups within StmtExpr not correctly bound!");
15812 bool StmtExprMayBindToTemp =
false;
15815 if (
const auto *LastStmt =
15817 if (
const Expr *
Value = LastStmt->getExprStmt()) {
15818 StmtExprMayBindToTemp =
true;
15826 Expr *ResStmtExpr =
15828 if (StmtExprMayBindToTemp)
15830 return ResStmtExpr;
15853 auto *Cast = dyn_cast<ImplicitCastExpr>(E);
15854 if (Cast && Cast->getCastKind() == CK_ARCConsumeObject)
15855 return Cast->getSubExpr();
15876 return ExprError(
Diag(BuiltinLoc, diag::err_offsetof_record_type)
15877 << ArgTy << TypeRange);
15883 diag::err_offsetof_incomplete_type, TypeRange))
15886 bool DidWarnAboutNonPOD =
false;
15891 if (OC.isBrackets) {
15896 return ExprError(
Diag(OC.LocEnd, diag::err_offsetof_array_type)
15916 Comps.push_back(
OffsetOfNode(OC.LocStart, Exprs.size(), OC.LocEnd));
15917 Exprs.push_back(Idx);
15925 Comps.push_back(
OffsetOfNode(OC.LocStart, OC.U.IdentInfo, OC.LocEnd));
15932 diag::err_offsetof_incomplete_type))
15938 return ExprError(
Diag(OC.LocEnd, diag::err_offsetof_record_type)
15950 bool IsSafe =
LangOpts.CPlusPlus11? CRD->isStandardLayout() : CRD->isPOD();
15952 LangOpts.CPlusPlus11? diag::ext_offsetof_non_standardlayout_type
15953 : diag::ext_offsetof_non_pod_type;
15956 Diag(BuiltinLoc, DiagID)
15957 <<
SourceRange(Components[0].LocStart, OC.LocEnd) << CurrentType;
15958 DidWarnAboutNonPOD =
true;
15969 MemberDecl = IndirectMemberDecl->getAnonField();
15977 Diag(BuiltinLoc, diag::err_no_member)
15978 << OC.U.IdentInfo << RD <<
SourceRange(OC.LocStart, OC.LocEnd);
15987 Diag(OC.LocEnd, diag::err_offsetof_bitfield)
15995 if (IndirectMemberDecl)
15996 Parent = cast<RecordDecl>(IndirectMemberDecl->getDeclContext());
16003 if (Paths.getDetectedVirtual()) {
16004 Diag(OC.LocEnd, diag::err_offsetof_field_of_virtual_base)
16015 if (IndirectMemberDecl) {
16016 for (
auto *FI : IndirectMemberDecl->chain()) {
16017 assert(isa<FieldDecl>(FI));
16019 cast<FieldDecl>(FI), OC.LocEnd));
16022 Comps.push_back(
OffsetOfNode(OC.LocStart, MemberDecl, OC.LocEnd));
16028 Comps, Exprs, RParenLoc);
16054 assert((CondExpr && LHSExpr && RHSExpr) &&
"Missing type argument(s)");
16059 bool CondIsTrue =
false;
16064 llvm::APSInt condEval(32);
16066 CondExpr, &condEval, diag::err_typecheck_choose_expr_requires_constant);
16069 CondExpr = CondICE.
get();
16070 CondIsTrue = condEval.getZExtValue();
16073 Expr *ActiveExpr = CondIsTrue ? LHSExpr : RHSExpr;
16075 resType = ActiveExpr->
getType();
16081 resType, VK, OK, RPLoc, CondIsTrue);
16094 Decl *ManglingContextDecl;
16095 std::tie(MCtx, ManglingContextDecl) =
16099 Block->setBlockMangling(ManglingNumber, ManglingContextDecl);
16121 "block-id should have no identifier!");
16143 "GetTypeForDeclarator made a non-function block signature");
16159 unsigned Size =
Result.getFullDataSize();
16171 QualType RetTy = Fn->getReturnType();
16173 (isa<FunctionProtoType>(Fn) && cast<FunctionProtoType>(Fn)->isVariadic());
16189 if (ExplicitSignature) {
16190 for (
unsigned I = 0, E = ExplicitSignature.
getNumParams(); I != E; ++I) {
16198 Params.push_back(Param);
16204 for (
const auto &I : Fn->param_types()) {
16207 Params.push_back(Param);
16212 if (!Params.empty()) {
16223 AI->setOwningFunction(CurBlock->
TheDecl);
16226 if (AI->getIdentifier()) {
16232 if (AI->isInvalidDecl())
16255 Diag(CaretLoc, diag::err_blocks_disable) <<
LangOpts.OpenCL;
16261 "cleanups within block not correctly bound!");
16274 bool NoReturn = BD->
hasAttr<NoReturnAttr>();
16282 if (NoReturn && !Ext.getNoReturn()) Ext = Ext.
withNoReturn(
true);
16285 if (isa<FunctionNoProtoType>(FTy)) {
16320 BD->
setBody(cast<CompoundStmt>(Body));
16322 if (Body &&
getCurFunction()->HasPotentialAvailabilityViolations)
16347 Expr *CopyExpr =
nullptr;
16356 if (isa<ParmVarDecl>(Var))
16375 if (!
Result.isInvalid() &&
16376 !
Result.get()->getType().isConstQualified()) {
16378 Result.get()->getType().withConst(),
16382 if (!
Result.isInvalid()) {
16392 if (!
Result.isInvalid() &&
16393 !cast<CXXConstructExpr>(
Result.get())->getConstructor()
16396 CopyExpr =
Result.get();
16403 Captures.push_back(NewCap);
16415 if (
Result->getBlockDecl()->hasCaptures()) {
16422 for (
const auto &CI :
Result->getBlockDecl()->captures()) {
16423 const VarDecl *var = CI.getVariable();
16436 {Result},
Result->getType());
16450 Expr *OrigExpr = E;
16500 if (
Init.isInvalid())
16516 diag::err_first_argument_to_va_arg_not_of_type_va_list)
16521 diag::err_second_parameter_to_va_arg_incomplete,
16527 diag::err_second_parameter_to_va_arg_abstract,
16534 ? diag::warn_second_parameter_to_va_arg_ownership_qualified
16535 : diag::warn_second_parameter_to_va_arg_not_pod)
16568 UnderlyingType = ET->getDecl()->getIntegerType();
16591 if (!PromoteType.
isNull())
16593 PDiag(diag::warn_second_parameter_to_va_arg_never_compatible)
16615 llvm_unreachable(
"I don't know size of pointer!");
16632 if ((SLDecl->isCompleteDefinition() || SLDecl->isBeingDefined()) &&
16641 S.
Diag(
Loc, diag::err_std_source_location_impl_not_found);
16649 S.
Diag(
Loc, diag::err_std_source_location_impl_malformed);
16653 unsigned Count = 0;
16655 StringRef Name = F->getName();
16657 if (Name ==
"_M_file_name") {
16658 if (F->getType() !=
16662 }
else if (Name ==
"_M_function_name") {
16663 if (F->getType() !=
16667 }
else if (Name ==
"_M_line") {
16668 if (!F->getType()->isIntegerType())
16671 }
else if (Name ==
"_M_column") {
16672 if (!F->getType()->isIntegerType())
16681 S.
Diag(
Loc, diag::err_std_source_location_impl_malformed);
16730 const Expr *SrcExpr) {
16739 auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl());
16752 bool *Complained) {
16754 *Complained =
false;
16757 bool CheckInferredResultType =
false;
16759 unsigned DiagKind = 0;
16761 bool MayHaveConvFixit =
false;
16762 bool MayHaveFunctionDiff =
false;
16773 DiagKind = diag::err_typecheck_convert_pointer_int;
16776 DiagKind = diag::ext_typecheck_convert_pointer_int;
16779 MayHaveConvFixit =
true;
16783 DiagKind = diag::err_typecheck_convert_int_pointer;
16786 DiagKind = diag::ext_typecheck_convert_int_pointer;
16789 MayHaveConvFixit =
true;
16793 diag::warn_typecheck_convert_incompatible_function_pointer_strict;
16795 MayHaveConvFixit =
true;
16799 DiagKind = diag::err_typecheck_convert_incompatible_function_pointer;
16802 DiagKind = diag::ext_typecheck_convert_incompatible_function_pointer;
16805 MayHaveConvFixit =
true;
16809 DiagKind = diag::err_arc_typecheck_convert_incompatible_pointer;
16811 DiagKind = diag::err_typecheck_convert_incompatible_pointer;
16814 DiagKind = diag::ext_typecheck_convert_incompatible_pointer;
16818 if (CheckInferredResultType) {
16824 MayHaveConvFixit =
true;
16828 DiagKind = diag::err_typecheck_convert_incompatible_pointer_sign;
16831 DiagKind = diag::ext_typecheck_convert_incompatible_pointer_sign;
16836 DiagKind = diag::err_typecheck_convert_pointer_void_func;
16839 DiagKind = diag::ext_typecheck_convert_pointer_void_func;
16851 DiagKind = diag::err_typecheck_incompatible_address_space;
16854 DiagKind = diag::err_typecheck_incompatible_ownership;
16858 llvm_unreachable(
"unknown error case for discarding qualifiers!");
16875 DiagKind = diag::err_typecheck_convert_discards_qualifiers;
16878 DiagKind = diag::ext_typecheck_convert_discards_qualifiers;
16885 DiagKind = diag::err_nested_pointer_qualifier_mismatch;
16887 DiagKind = diag::ext_nested_pointer_qualifier_mismatch;
16891 DiagKind = diag::err_typecheck_incompatible_nested_address_space;
16895 DiagKind = diag::err_int_to_block_pointer;
16899 DiagKind = diag::err_typecheck_convert_incompatible_block_pointer;
16906 for (
auto *srcProto : srcOPT->
quals()) {
16912 IFace = IFaceT->getDecl();
16917 for (
auto *dstProto : dstOPT->
quals()) {
16923 IFace = IFaceT->getDecl();
16926 DiagKind = diag::err_incompatible_qualified_id;
16929 DiagKind = diag::warn_incompatible_qualified_id;
16935 DiagKind = diag::err_incompatible_vectors;
16938 DiagKind = diag::warn_incompatible_vectors;
16942 DiagKind = diag::err_arc_weak_unavailable_assign;
16948 *Complained =
true;
16952 DiagKind = diag::err_typecheck_convert_incompatible;
16954 MayHaveConvFixit =
true;
16956 MayHaveFunctionDiff =
true;
16965 FirstType = DstType;
16966 SecondType = SrcType;
16976 FirstType = SrcType;
16977 SecondType = DstType;
16986 FDiag << FirstType << SecondType << ActionForDiag
16989 if (DiagKind == diag::ext_typecheck_convert_incompatible_pointer_sign ||
16990 DiagKind == diag::err_typecheck_convert_incompatible_pointer_sign) {
17000 if (!ConvHints.
isNull()) {
17005 if (MayHaveConvFixit) { FDiag << (
unsigned) (ConvHints.
Kind); }
17007 if (MayHaveFunctionDiff)
17011 if ((DiagKind == diag::warn_incompatible_qualified_id ||
17012 DiagKind == diag::err_incompatible_qualified_id) &&
17014 Diag(IFace->
getLocation(), diag::note_incomplete_class_and_qualified_id)
17021 if (CheckInferredResultType)
17028 *Complained =
true;
17039 return S.
Diag(
Loc, diag::err_ice_not_integral)
17058 IDDiagnoser(
unsigned DiagID)
17064 } Diagnoser(DiagID);
17099 BaseDiagnoser(BaseDiagnoser) {}
17108 return S.
Diag(
Loc, diag::err_ice_incomplete_type) <<
T;
17113 return S.
Diag(
Loc, diag::err_ice_explicit_conversion) <<
T << ConvTy;
17124 return S.
Diag(
Loc, diag::err_ice_ambiguous_conversion) <<
T;
17135 llvm_unreachable(
"conversion functions are permitted");
17137 } ConvertDiagnoser(Diagnoser);
17143 E = Converted.
get();
17148 if (isa<RecoveryExpr>(E))
17164 E = RValueExpr.
get();
17171 if (!isa<ConstantExpr>(E))
17179 EvalResult.
Diag = &Notes;
17187 if (!isa<ConstantExpr>(E))
17202 if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
17203 diag::note_invalid_subexpr_in_const_expr) {
17204 DiagLoc = Notes[0].first;
17208 if (!Folded || !CanFold) {
17230 class TransformToPE :
public TreeTransform<TransformToPE> {
17234 TransformToPE(
Sema &SemaRef) : BaseTransform(SemaRef) { }
17237 bool AlwaysRebuild() {
return true; }
17238 bool ReplacingOriginal() {
return true; }
17248 if (isa<FieldDecl>(E->
getDecl()) &&
17249 !SemaRef.isUnevaluatedContext())
17251 diag::err_invalid_non_static_member_use)
17254 return BaseTransform::TransformDeclRefExpr(E);
17262 return BaseTransform::TransformUnaryOperator(E);
17270 return SkipLambdaBody(E, Body);
17277 "Should only transform unevaluated expressions");
17282 return TransformToPE(*this).TransformExpr(E);
17287 "Should only transform unevaluated expressions");
17292 return TransformToPE(*this).TransformType(TInfo);
17300 LambdaContextDecl, ExprContext);
17307 .isDiscardedStatementContext();
17315 Prev.isImmediateFunctionContext() || Prev.isConstantEvaluated();
17318 Prev.InImmediateEscalatingFunctionContext;
17337 if (
const auto *E = dyn_cast<UnaryOperator>(PossibleDeref)) {
17338 if (E->getOpcode() == UO_Deref)
17339 return CheckPossibleDeref(S, E->getSubExpr());
17340 }
else if (
const auto *E = dyn_cast<ArraySubscriptExpr>(PossibleDeref)) {
17341 return CheckPossibleDeref(S, E->getBase());
17342 }
else if (
const auto *E = dyn_cast<MemberExpr>(PossibleDeref)) {
17343 return CheckPossibleDeref(S, E->getBase());
17344 }
else if (
const auto E = dyn_cast<DeclRefExpr>(PossibleDeref)) {
17348 Inner = Ptr->getPointeeType();
17350 Inner = Arr->getElementType();
17354 if (Inner->hasAttr(attr::NoDeref))
17364 const DeclRefExpr *DeclRef = CheckPossibleDeref(*
this, E);
17371 Diag(E->
getExprLoc(), diag::warn_dereference_of_noderef_type_no_decl)
17390 if (BO->getOpcode() == BO_Assign) {
17392 llvm::erase(LHSs, BO->getLHS());
17400 "Cannot mark an immediate escalating expression outside of an "
17401 "immediate escalating context");
17404 if (
auto *DeclRef =
17405 dyn_cast<DeclRefExpr>(
Call->getCallee()->IgnoreImplicit()))
17406 DeclRef->setIsImmediateEscalating(
true);
17407 }
else if (
auto *Ctr = dyn_cast<CXXConstructExpr>(E->
IgnoreImplicit())) {
17408 Ctr->setIsImmediateEscalating(
true);
17409 }
else if (
auto *DeclRef = dyn_cast<DeclRefExpr>(E->
IgnoreImplicit())) {
17410 DeclRef->setIsImmediateEscalating(
true);
17412 assert(
false &&
"expected an immediately escalating expression");
17415 FI->FoundImmediateEscalatingExpression =
true;
17430 if (
auto *DeclRef =
17431 dyn_cast<DeclRefExpr>(
Call->getCallee()->IgnoreImplicit()))
17440 auto CheckConstantExpressionAndKeepResult = [&]() {
17443 Eval.
Diag = &Notes;
17445 Eval,
getASTContext(), ConstantExprKind::ImmediateInvocation);
17446 if (Res && Notes.empty()) {
17447 Cached = std::move(Eval.
Val);
17455 !CheckConstantExpressionAndKeepResult()) {
17490 ExprEvalContexts.back().ImmediateInvocationCandidates.emplace_back(Res, 0);
17498 Eval.
Diag = &Notes;
17502 if (!
Result || !Notes.empty()) {
17505 if (
auto *
FunctionalCast = dyn_cast<CXXFunctionalCastExpr>(InnerExpr))
17508 if (
auto *
Call = dyn_cast<CallExpr>(InnerExpr))
17509 FD = cast<FunctionDecl>(
Call->getCalleeDecl());
17510 else if (
auto *
Call = dyn_cast<CXXConstructExpr>(InnerExpr))
17511 FD =
Call->getConstructor();
17512 else if (
auto *Cast = dyn_cast<CastExpr>(InnerExpr))
17513 FD = dyn_cast_or_null<FunctionDecl>(Cast->getConversionFunction());
17516 "could not find an immediate function in this expression");
17529 for (
auto &
Note : Notes)
17541 llvm::SmallPtrSetImpl<DeclRefExpr *> &DRSet;
17545 ComplexRemove(
Sema &SemaRef, llvm::SmallPtrSetImpl<DeclRefExpr *> &DR,
17548 4>::reverse_iterator Current)
17549 :
Base(SemaRef), DRSet(DR), IISet(II), CurrentII(Current) {}
17551 auto It = std::find_if(CurrentII, IISet.rend(),
17553 return Elem.getPointer() == E;
17559 if (It == IISet.rend()) {
17561 CurrentII->setInt(1);
17568 return Base::TransformConstantExpr(E);
17569 RemoveImmediateInvocation(E);
17570 return Base::TransformExpr(E->
getSubExpr());
17576 return Base::TransformCXXOperatorCallExpr(E);
17588 if (
auto *CE = dyn_cast<ConstantExpr>(
Init))
17589 if (CE->isImmediateInvocation())
17590 RemoveImmediateInvocation(CE);
17591 return Base::TransformInitializer(
Init, NotCopyInit);
17602 bool AlwaysRebuild() {
return false; }
17603 bool ReplacingOriginal() {
return true; }
17604 bool AllowSkippingCXXConstructExpr() {
17605 bool Res = AllowSkippingFirstCXXConstructExpr;
17606 AllowSkippingFirstCXXConstructExpr =
true;
17609 bool AllowSkippingFirstCXXConstructExpr =
true;
17619 if (isa<CXXConstructExpr>(It->getPointer()->IgnoreImplicit()))
17620 Transformer.AllowSkippingFirstCXXConstructExpr =
false;
17622 ExprResult Res = Transformer.TransformExpr(It->getPointer()->getSubExpr());
17628 It->getPointer()->setSubExpr(Res.
get());
17663 llvm::SmallPtrSetImpl<DeclRefExpr *> &DRSet;
17664 SimpleRemove(llvm::SmallPtrSetImpl<DeclRefExpr *> &S) : DRSet(S) {}
17667 return DRSet.size();
17670 Visitor.TraverseStmt(
17680 if (DR->isImmediateEscalating())
17682 auto *FD = cast<FunctionDecl>(DR->getDecl());
17684 if (
const auto *MD = dyn_cast<CXXMethodDecl>(ND);
17686 ND = MD->getParent();
17693 bool ImmediateEscalating =
false;
17694 bool IsPotentiallyEvaluated =
17704 SemaRef.
Diag(DR->getBeginLoc(), diag::err_invalid_consteval_take_address)
17705 << ND << isa<CXXRecordDecl>(ND) << FD->isConsteval();
17713 if (FD->isImmediateEscalating() && !FD->isConsteval())
17729 (Rec.
ExprContext == ExpressionKind::EK_TemplateArgument ||
17737 D = diag::err_lambda_unevaluated_operand;
17743 D = diag::err_lambda_in_constant_expression;
17744 }
else if (Rec.
ExprContext == ExpressionKind::EK_TemplateArgument) {
17747 D = diag::err_lambda_in_invalid_context;
17749 llvm_unreachable(
"Couldn't infer lambda error message.");
17751 for (
const auto *L : Rec.
Lambdas)
17752 Diag(L->getBeginLoc(), D);
17760 PrevRecord.InLifetimeExtendingContext &&
17762 PrevRecord.ForRangeLifetimeExtendTemps.append(
17773 Diag(BO->getBeginLoc(), diag::warn_deprecated_simple_assign_volatile)
17846 llvm_unreachable(
"Invalid context");
17855 if (!TT.isOSWindows() || !TT.isX86())
17893 : FD(FD), Param(Param) {}
17900 CCName =
"stdcall";
17903 CCName =
"fastcall";
17906 CCName =
"vectorcall";
17909 llvm_unreachable(
"CC does not need mangling");
17912 S.
Diag(
Loc, diag::err_cconv_incomplete_param_type)
17918 ParamIncompleteTypeDiagnoser Diagnoser(FD, Param);
17924enum class OdrUseContext {
17946 return OdrUseContext::None;
17951 Result = OdrUseContext::Used;
17955 Result = OdrUseContext::FormallyOdrUsed;
17961 Result = OdrUseContext::FormallyOdrUsed;
17966 return OdrUseContext::Dependent;
17972 if (!
Func->isConstexpr())
17975 if (
Func->isImplicitlyInstantiable() || !
Func->isUserProvided())
17977 auto *CCD = dyn_cast<CXXConstructorDecl>(
Func);
17978 return CCD && CCD->getInheritedConstructor();
17984 bool MightBeOdrUse) {
17985 assert(
Func &&
"No function?");
17987 Func->setReferenced();
18000 OdrUseContext OdrUse =
18002 if (IsRecursiveCall && OdrUse == OdrUseContext::Used)
18003 OdrUse = OdrUseContext::FormallyOdrUsed;
18007 if (
Func->isTrivial() && !
Func->hasAttr<DLLExportAttr>() &&
18008 OdrUse == OdrUseContext::Used) {
18009 if (
auto *Constructor = dyn_cast<CXXConstructorDecl>(
Func))
18010 if (Constructor->isDefaultConstructor())
18011 OdrUse = OdrUseContext::FormallyOdrUsed;
18012 if (isa<CXXDestructorDecl>(
Func))
18013 OdrUse = OdrUseContext::FormallyOdrUsed;
18020 bool NeededForConstantEvaluation =
18045 bool NeedDefinition =
18046 !IsRecursiveCall &&
18047 (OdrUse == OdrUseContext::Used ||
18048 (NeededForConstantEvaluation && !
Func->isPureVirtual()));
18055 if (NeedDefinition &&
18057 Func->getMemberSpecializationInfo()))
18064 if (NeedDefinition && !
Func->getBody()) {
18067 dyn_cast<CXXConstructorDecl>(
Func)) {
18068 Constructor = cast<CXXConstructorDecl>(Constructor->getFirstDecl());
18069 if (Constructor->isDefaulted() && !Constructor->isDeleted()) {
18070 if (Constructor->isDefaultConstructor()) {
18071 if (Constructor->isTrivial() &&
18072 !Constructor->hasAttr<DLLExportAttr>())
18075 }
else if (Constructor->isCopyConstructor()) {
18077 }
else if (Constructor->isMoveConstructor()) {
18080 }
else if (Constructor->getInheritedConstructor()) {
18084 dyn_cast<CXXDestructorDecl>(
Func)) {
18094 if (MethodDecl->isOverloadedOperator() &&
18095 MethodDecl->getOverloadedOperator() == OO_Equal) {
18096 MethodDecl = cast<CXXMethodDecl>(MethodDecl->getFirstDecl());
18097 if (MethodDecl->isDefaulted() && !MethodDecl->isDeleted()) {
18098 if (MethodDecl->isCopyAssignmentOperator())
18100 else if (MethodDecl->isMoveAssignmentOperator())
18103 }
else if (isa<CXXConversionDecl>(MethodDecl) &&
18104 MethodDecl->getParent()->isLambda()) {
18106 cast<CXXConversionDecl>(MethodDecl->getFirstDecl());
18111 }
else if (MethodDecl->isVirtual() &&
getLangOpts().AppleKext)
18115 if (
Func->isDefaulted() && !
Func->isDeleted()) {
18123 if (
Func->isImplicitlyInstantiable()) {
18125 Func->getTemplateSpecializationKindForInstantiation();
18127 bool FirstInstantiation = PointOfInstantiation.
isInvalid();
18128 if (FirstInstantiation) {
18129 PointOfInstantiation =
Loc;
18130 if (
auto *MSI =
Func->getMemberSpecializationInfo())
18131 MSI->setPointOfInstantiation(
Loc);
18134 Func->setTemplateSpecializationKind(TSK, PointOfInstantiation);
18139 PointOfInstantiation =
Loc;
18143 Func->isConstexpr()) {
18144 if (isa<CXXRecordDecl>(
Func->getDeclContext()) &&
18145 cast<CXXRecordDecl>(
Func->getDeclContext())->isLocalClass() &&
18148 std::make_pair(
Func, PointOfInstantiation));
18149 else if (
Func->isConstexpr())
18155 Func->setInstantiationIsPending(
true);
18157 std::make_pair(
Func, PointOfInstantiation));
18164 for (
auto *i :
Func->redecls()) {
18165 if (!i->isUsed(
false) && i->isImplicitlyInstantiable())
18178 Constructor->isImmediateFunction()
18183 if (
Init->isInClassMemberInitializer())
18185 MarkDeclarationsReferencedInExpr(Init->getInit());
18206 if (
LangOpts.OffloadImplicitHostDeviceTemplates &&
LangOpts.CUDAIsDevice &&
18211 if (OdrUse == OdrUseContext::Used && !
Func->isUsed(
false)) {
18213 if (!
Func->isDefined()) {
18214 if (mightHaveNonExternalLinkage(
Func))
18216 else if (
Func->getMostRecentDecl()->isInlined() &&
18218 !
Func->getMostRecentDecl()->hasAttr<GNUInlineAttr>())
18237 if (
auto *Dtor = dyn_cast<CXXDestructorDecl>(
Func)) {
18239 if (
Parent->getNumVBases() > 0 && !Dtor->getBody())
18257 const unsigned *
const FunctionScopeIndexToStopAt =
nullptr) {
18260 VarDecl *Var =
V->getPotentiallyDecomposedVarDecl();
18261 assert(Var &&
"expected a capturable variable");
18271 QualType CaptureType, DeclRefType;
18277 DeclRefType, FunctionScopeIndexToStopAt);
18293 << llvm::to_underlying(UserTarget);
18296 ? diag::note_cuda_const_var_unpromoted
18297 : diag::note_cuda_host_var);
18300 !Var->
hasAttr<CUDASharedAttr>() &&
18316 (!FD || (!FD->getDescribedFunctionTemplate() &&
18328 unsigned CapturingScopeIndex) {
18339 if (isa<ParmVarDecl>(var) &&
18340 isa<TranslationUnitDecl>(VarDC))
18353 unsigned ValueKind = isa<BindingDecl>(var) ? 1 : 0;
18354 unsigned ContextKind = 3;
18355 if (isa<CXXMethodDecl>(VarDC) &&
18356 cast<CXXRecordDecl>(VarDC->
getParent())->isLambda()) {
18358 }
else if (isa<FunctionDecl>(VarDC)) {
18360 }
else if (isa<BlockDecl>(VarDC)) {
18364 S.
Diag(loc, diag::err_reference_to_local_in_enclosing_context)
18365 << var << ValueKind << ContextKind << VarDC;
18375 bool &SubCapturesAreNested,
18381 SubCapturesAreNested =
true;
18394 !(isa<LambdaScopeInfo>(CSI) &&
18395 !cast<LambdaScopeInfo>(CSI)->lambdaCaptureShouldBeConst()) &&
18396 !(isa<CapturedRegionScopeInfo>(CSI) &&
18397 cast<CapturedRegionScopeInfo>(CSI)->CapRegionKind ==
CR_OpenMP))
18429 assert((isa<VarDecl, BindingDecl>(Var)) &&
18430 "Only variables and structured bindings can be captured");
18432 bool IsBlock = isa<BlockScopeInfo>(CSI);
18433 bool IsLambda = isa<LambdaScopeInfo>(CSI);
18441 S.
Diag(
Loc, diag::err_lambda_capture_anonymous_var);
18450 S.
Diag(
Loc, diag::err_ref_vm_type);
18458 if (VTTy->getDecl()->hasFlexibleArrayMember()) {
18461 S.
Diag(
Loc, diag::err_ref_flexarray_type);
18463 S.
Diag(
Loc, diag::err_lambda_capture_flexarray_type) << Var;
18469 const bool HasBlocksAttr = Var->
hasAttr<BlocksAttr>();
18472 if (HasBlocksAttr && (IsLambda || isa<CapturedRegionScopeInfo>(CSI))) {
18474 S.
Diag(
Loc, diag::err_capture_block_variable) << Var << !IsLambda;
18483 S.
Diag(
Loc, diag::err_opencl_block_ref_block);
18487 if (isa<BindingDecl>(Var)) {
18494 ? diag::warn_cxx17_compat_capture_binding
18495 : diag::ext_capture_binding)
18509 bool ByRef =
false;
18515 if (BuildAndDiagnose) {
18516 S.
Diag(
Loc, diag::err_ref_array_type);
18527 if (BuildAndDiagnose) {
18528 S.
Diag(
Loc, diag::err_arc_autoreleasing_capture)
18544 if (BuildAndDiagnose) {
18546 S.
Diag(
Loc, diag::warn_block_capture_autoreleasing);
18547 S.
Diag(VarLoc, diag::note_declare_parameter_strong);
18552 const bool HasBlocksAttr = Var->
hasAttr<BlocksAttr>();
18561 DeclRefType = CaptureType;
18565 if (BuildAndDiagnose)
18575 const bool BuildAndDiagnose,
QualType &CaptureType,
QualType &DeclRefType,
18602 CaptureType = DeclRefType;
18605 if (BuildAndDiagnose)
18606 RSI->
addCapture(Var,
false, ByRef, RefersToCapturedVariable,
18616 const bool RefersToCapturedVariable,
18621 bool ByRef =
false;
18625 ByRef = (LSI->
ImpCaptureStyle == LambdaScopeInfo::ImpCap_LambdaByref);
18630 S.
Diag(
Loc, diag::err_wasm_ca_reference) << 0;
18661 if (!RefType->getPointeeType()->isFunctionType())
18668 if (BuildAndDiagnose) {
18669 S.
Diag(
Loc, diag::err_arc_autoreleasing_capture) << 1;
18679 if (!
Invalid && BuildAndDiagnose) {
18683 diag::err_capture_of_incomplete_or_sizeless_type,
18687 diag::err_capture_of_abstract_type))
18708 if (BuildAndDiagnose)
18709 LSI->
addCapture(Var,
false, ByRef, RefersToCapturedVariable,
18721 if (
T.isTriviallyCopyableType(
Context))
18725 if (!(RD = RD->getDefinition()))
18727 if (RD->hasSimpleCopyConstructor())
18729 if (RD->hasUserDeclaredCopyConstructor())
18731 if (Ctor->isCopyConstructor())
18732 return !Ctor->isDeleted();
18752 if (ShouldOfferCopyFix) {
18756 FixBuffer.assign({Separator, Var->
getName()});
18757 Sema.
Diag(VarInsertLoc, diag::note_lambda_variable_capture_fixit)
18762 FixBuffer.assign({Separator,
"&", Var->
getName()});
18763 Sema.
Diag(VarInsertLoc, diag::note_lambda_variable_capture_fixit)
18775 return !C.isThisCapture() && !C.isInitCapture();
18784 if (ShouldOfferCopyFix) {
18785 bool CanDefaultCopyCapture =
true;
18794 if (CanDefaultCopyCapture && llvm::none_of(LSI->
Captures, [](
Capture &
C) {
18795 return !C.isThisCapture() && !C.isInitCapture() && C.isCopyCapture();
18797 FixBuffer.assign({
"=", Separator});
18798 Sema.
Diag(DefaultInsertLoc, diag::note_lambda_default_capture_fixit)
18807 return !C.isInitCapture() && C.isReferenceCapture() &&
18808 !C.isThisCapture();
18810 FixBuffer.assign({
"&", Separator});
18811 Sema.
Diag(DefaultInsertLoc, diag::note_lambda_default_capture_fixit)
18820 QualType &DeclRefType,
const unsigned *
const FunctionScopeIndexToStopAt) {
18833 const auto *VD = dyn_cast<VarDecl>(Var);
18835 if (VD->isInitCapture())
18840 assert(VD &&
"Cannot capture a null variable");
18842 const unsigned MaxFunctionScopesIndex = FunctionScopeIndexToStopAt
18846 if (FunctionScopeIndexToStopAt) {
18848 while (FSIndex != MaxFunctionScopesIndex) {
18856 bool IsGlobal = !VD->hasLocalStorage();
18857 if (IsGlobal && !(
LangOpts.OpenMP &&
18858 OpenMP().isOpenMPCapturedDecl(Var,
true,
18859 MaxFunctionScopesIndex)))
18862 if (isa<VarDecl>(Var))
18873 CaptureType = Var->
getType();
18875 bool Nested =
false;
18877 unsigned FunctionScopesIndex = MaxFunctionScopesIndex;
18882 LSI = dyn_cast_or_null<LambdaScopeInfo>(
18885 bool IsInScopeDeclarationContext =
18896 if (IsInScopeDeclarationContext &&
18897 FunctionScopesIndex == MaxFunctionScopesIndex && VarDC == DC)
18903 !IsInScopeDeclarationContext
18906 BuildAndDiagnose, *
this);
18912 FunctionScopesIndex = MaxFunctionScopesIndex - 1;
18931 if (
const auto *Parm = dyn_cast<ParmVarDecl>(Var);
18932 Parm && Parm->getDeclContext() == DC)
18940 if (BuildAndDiagnose) {
18943 Diag(ExprLoc, diag::err_lambda_impcap) << Var;
18958 if (
ParmVarDecl *PVD = dyn_cast_or_null<ParmVarDecl>(Var))
18959 QTy = PVD->getOriginalType();
18964 if (
auto *RSI = dyn_cast<CapturedRegionScopeInfo>(CSI)) {
18970 if (isa<BindingDecl>(Var)) {
18971 if (BuildAndDiagnose) {
18972 Diag(ExprLoc, diag::err_capture_binding_openmp) << Var;
18978 Var, RSI->OpenMPLevel, RSI->OpenMPCaptureLevel);
18983 if (IsOpenMPPrivateDecl != OMPC_unknown &&
18986 if (
ParmVarDecl *PVD = dyn_cast_or_null<ParmVarDecl>(Var))
18987 QTy = PVD->getOriginalType();
18989 E =
OpenMP().getNumberOfConstructScopes(RSI->OpenMPLevel);
18991 auto *OuterRSI = cast<CapturedRegionScopeInfo>(
18993 assert(RSI->OpenMPLevel == OuterRSI->OpenMPLevel &&
18994 "Wrong number of captured regions associated with the "
18995 "OpenMP construct.");
19000 IsOpenMPPrivateDecl != OMPC_private &&
19002 RSI->OpenMPCaptureLevel);
19006 Var, RSI->OpenMPLevel, RSI->OpenMPCaptureLevel);
19012 OpenMP().adjustOpenMPTargetScopeIndex(FunctionScopesIndex,
19015 if (IsTargetCap || IsOpenMPPrivateDecl == OMPC_private ||
19016 (IsGlobal && !IsGlobalCap)) {
19017 Nested = !IsTargetCap;
19032 if (BuildAndDiagnose) {
19033 Diag(ExprLoc, diag::err_lambda_impcap) << Var;
19035 auto *LSI = cast<LambdaScopeInfo>(CSI);
19055 FunctionScopesIndex--;
19056 if (IsInScopeDeclarationContext)
19058 }
while (!VarDC->
Equals(DC));
19066 for (
unsigned I = ++FunctionScopesIndex, N = MaxFunctionScopesIndex + 1; I != N;
19079 if (
Invalid && !BuildAndDiagnose)
19084 DeclRefType, Nested, *
this,
Invalid);
19088 RSI, Var, ExprLoc, BuildAndDiagnose, CaptureType, DeclRefType, Nested,
19089 Kind, I == N - 1, *
this,
Invalid);
19095 DeclRefType, Nested, Kind, EllipsisLoc,
19100 if (
Invalid && !BuildAndDiagnose)
19112 DeclRefType,
nullptr);
19119 false, CaptureType,
19120 DeclRefType,
nullptr);
19129 false, CaptureType,
19130 DeclRefType,
nullptr))
19133 return DeclRefType;
19141class CopiedTemplateArgs {
19145 template<
typename RefExpr>
19146 CopiedTemplateArgs(RefExpr *E) : HasArgs(E->hasExplicitTemplateArgs()) {
19148 E->copyTemplateArgumentsInto(TemplateArgStorage);
19151#ifdef __has_cpp_attribute
19152#
if __has_cpp_attribute(clang::lifetimebound)
19153 [[clang::lifetimebound]]
19157 return HasArgs ? &TemplateArgStorage :
nullptr;
19183 auto Rebuild = [&](
Expr *Sub) {
19188 auto IsPotentialResultOdrUsed = [&](
NamedDecl *D) {
19191 auto *VD = dyn_cast<VarDecl>(D);
19214 llvm_unreachable(
"unexpected non-odr-use-reason");
19218 if (VD->getType()->isReferenceType())
19220 if (
auto *RD = VD->getType()->getAsCXXRecordDecl())
19221 if (RD->hasMutableFields())
19223 if (!VD->isUsableInConstantExpressions(S.
Context))
19228 if (VD->getType()->isReferenceType())
19236 auto MarkNotOdrUsed = [&] {
19239 LSI->markVariableExprAsNonODRUsed(E);
19246 case Expr::DeclRefExprClass: {
19247 auto *DRE = cast<DeclRefExpr>(E);
19248 if (DRE->isNonOdrUse() || IsPotentialResultOdrUsed(DRE->getDecl()))
19254 S.
Context, DRE->getQualifierLoc(), DRE->getTemplateKeywordLoc(),
19255 DRE->getDecl(), DRE->refersToEnclosingVariableOrCapture(),
19256 DRE->getNameInfo(), DRE->getType(), DRE->getValueKind(),
19257 DRE->getFoundDecl(), CopiedTemplateArgs(DRE), NOUR);
19260 case Expr::FunctionParmPackExprClass: {
19261 auto *FPPE = cast<FunctionParmPackExpr>(E);
19265 if (IsPotentialResultOdrUsed(D))
19276 case Expr::ArraySubscriptExprClass: {
19277 auto *ASE = cast<ArraySubscriptExpr>(E);
19282 if (!
Base.isUsable())
19284 Expr *LHS = ASE->getBase() == ASE->getLHS() ?
Base.get() : ASE->getLHS();
19285 Expr *RHS = ASE->getBase() == ASE->getRHS() ?
Base.get() : ASE->getRHS();
19288 ASE->getRBracketLoc());
19291 case Expr::MemberExprClass: {
19292 auto *ME = cast<MemberExpr>(E);
19295 if (isa<FieldDecl>(ME->getMemberDecl())) {
19297 if (!
Base.isUsable())
19300 S.
Context,
Base.get(), ME->isArrow(), ME->getOperatorLoc(),
19301 ME->getQualifierLoc(), ME->getTemplateKeywordLoc(),
19302 ME->getMemberDecl(), ME->getFoundDecl(), ME->getMemberNameInfo(),
19303 CopiedTemplateArgs(ME), ME->getType(), ME->getValueKind(),
19304 ME->getObjectKind(), ME->isNonOdrUse());
19307 if (ME->getMemberDecl()->isCXXInstanceMember())
19312 if (ME->isNonOdrUse() || IsPotentialResultOdrUsed(ME->getMemberDecl()))
19318 S.
Context, ME->getBase(), ME->isArrow(), ME->getOperatorLoc(),
19319 ME->getQualifierLoc(), ME->getTemplateKeywordLoc(), ME->getMemberDecl(),
19320 ME->getFoundDecl(), ME->getMemberNameInfo(), CopiedTemplateArgs(ME),
19321 ME->getType(), ME->getValueKind(), ME->getObjectKind(), NOUR);
19324 case Expr::BinaryOperatorClass: {
19325 auto *BO = cast<BinaryOperator>(E);
19326 Expr *LHS = BO->getLHS();
19327 Expr *RHS = BO->getRHS();
19329 if (BO->getOpcode() == BO_PtrMemD) {
19331 if (!Sub.isUsable())
19333 BO->setLHS(Sub.get());
19335 }
else if (BO->getOpcode() == BO_Comma) {
19337 if (!Sub.isUsable())
19339 BO->setRHS(Sub.get());
19347 case Expr::ParenExprClass: {
19348 auto *PE = cast<ParenExpr>(E);
19350 if (!Sub.isUsable())
19352 return S.
ActOnParenExpr(PE->getLParen(), PE->getRParen(), Sub.get());
19357 case Expr::ConditionalOperatorClass: {
19358 auto *CO = cast<ConditionalOperator>(E);
19368 LHS = CO->getLHS();
19370 RHS = CO->getRHS();
19372 CO->getCond(), LHS.
get(), RHS.
get());
19377 case Expr::UnaryOperatorClass: {
19378 auto *UO = cast<UnaryOperator>(E);
19379 if (UO->getOpcode() != UO_Extension)
19382 if (!Sub.isUsable())
19384 return S.
BuildUnaryOp(
nullptr, UO->getOperatorLoc(), UO_Extension,
19391 case Expr::GenericSelectionExprClass: {
19392 auto *GSE = cast<GenericSelectionExpr>(E);
19395 bool AnyChanged =
false;
19396 for (
Expr *OrigAssocExpr : GSE->getAssocExprs()) {
19397 ExprResult AssocExpr = Rebuild(OrigAssocExpr);
19401 AssocExprs.push_back(AssocExpr.
get());
19404 AssocExprs.push_back(OrigAssocExpr);
19408 void *ExOrTy =
nullptr;
19409 bool IsExpr = GSE->isExprPredicate();
19411 ExOrTy = GSE->getControllingExpr();
19413 ExOrTy = GSE->getControllingType();
19415 GSE->getGenericLoc(), GSE->getDefaultLoc(),
19416 GSE->getRParenLoc(), IsExpr, ExOrTy,
19417 GSE->getAssocTypeSourceInfos(), AssocExprs)
19425 case Expr::ChooseExprClass: {
19426 auto *CE = cast<ChooseExpr>(E);
19436 if (!LHS.
get() && !RHS.
get())
19439 LHS = CE->getLHS();
19441 RHS = CE->getRHS();
19444 RHS.
get(), CE->getRParenLoc());
19448 case Expr::ConstantExprClass: {
19449 auto *CE = cast<ConstantExpr>(E);
19451 if (!Sub.isUsable())
19458 case Expr::ImplicitCastExprClass: {
19459 auto *ICE = cast<ImplicitCastExpr>(E);
19463 switch (ICE->getCastKind()) {
19465 case CK_DerivedToBase:
19466 case CK_UncheckedDerivedToBase: {
19467 ExprResult Sub = Rebuild(ICE->getSubExpr());
19468 if (!Sub.isUsable())
19472 ICE->getValueKind(), &Path);
19531 for (
Expr *E : LocalMaybeODRUseExprs) {
19532 if (
auto *DRE = dyn_cast<DeclRefExpr>(E)) {
19534 DRE->getLocation(), *
this);
19535 }
else if (
auto *ME = dyn_cast<MemberExpr>(E)) {
19538 }
else if (
auto *FP = dyn_cast<FunctionParmPackExpr>(E)) {
19542 llvm_unreachable(
"Unexpected expression");
19547 "MarkVarDeclODRUsed failed to cleanup MaybeODRUseExprs?");
19556 const bool RefersToEnclosingScope =
19559 if (RefersToEnclosingScope) {
19574 assert(E &&
"Capture variable should be used in an expression.");
19585 assert((!E || isa<DeclRefExpr>(E) || isa<MemberExpr>(E) ||
19586 isa<FunctionParmPackExpr>(E)) &&
19587 "Invalid Expr argument to DoMarkVarDeclReferenced");
19598 bool UsableInConstantExpr =
19610 bool NeededForConstantEvaluation =
19613 bool NeedDefinition =
19614 OdrUse == OdrUseContext::Used || NeededForConstantEvaluation;
19616 assert(!isa<VarTemplatePartialSpecializationDecl>(Var) &&
19617 "Can't instantiate a partial template specialization.");
19623 !isa<VarTemplateSpecializationDecl>(Var))
19634 bool TryInstantiating =
19638 if (TryInstantiating) {
19641 bool FirstInstantiation = PointOfInstantiation.
isInvalid();
19642 if (FirstInstantiation) {
19643 PointOfInstantiation =
Loc;
19645 MSI->setPointOfInstantiation(PointOfInstantiation);
19651 if (UsableInConstantExpr) {
19660 if (
auto *DRE = dyn_cast_or_null<DeclRefExpr>(E))
19661 DRE->setDecl(DRE->getDecl());
19662 else if (
auto *ME = dyn_cast_or_null<MemberExpr>(E))
19663 ME->setMemberDecl(ME->getMemberDecl());
19664 }
else if (FirstInstantiation) {
19666 .push_back(std::make_pair(Var, PointOfInstantiation));
19668 bool Inserted =
false;
19670 auto Iter = llvm::find_if(
19672 return P.first == Var;
19674 if (
Iter != I.end()) {
19687 if (isa<VarTemplateSpecializationDecl>(Var) && !Inserted)
19689 .push_back(std::make_pair(Var, PointOfInstantiation));
19713 if (
DeclRefExpr *DRE = dyn_cast_or_null<DeclRefExpr>(E))
19714 if (DRE->isNonOdrUse())
19716 if (
MemberExpr *ME = dyn_cast_or_null<MemberExpr>(E))
19717 if (ME->isNonOdrUse())
19721 case OdrUseContext::None:
19724 assert((!E || isa<FunctionParmPackExpr>(E) ||
19726 "missing non-odr-use marking for unevaluated decl ref");
19729 case OdrUseContext::FormallyOdrUsed:
19734 case OdrUseContext::Used:
19743 case OdrUseContext::Dependent:
19761 if (OdrUse == OdrUseContext::Used) {
19762 QualType CaptureType, DeclRefType;
19768 }
else if (OdrUse == OdrUseContext::Dependent) {
19787 auto *ID = dyn_cast<DeclRefExpr>(E);
19788 if (!ID || ID->isTypeDependent() || !ID->refersToEnclosingVariableOrCapture())
19795 auto IsDependent = [&]() {
19797 auto *LSI = dyn_cast<sema::LambdaScopeInfo>(
Scope);
19802 LSI->AfterParameterList)
19805 const auto *MD = LSI->CallOperator;
19806 if (MD->getType().isNull())
19810 if (!Ty || !MD->isExplicitObjectMemberFunction() ||
19814 if (
auto *
C = LSI->CaptureMap.count(D) ? &LSI->getCapture(D) :
nullptr) {
19815 if (
C->isCopyCapture())
19820 if (LSI->ImpCaptureStyle == LambdaScopeInfo::ImpCap_LambdaByval)
19826 ID->setCapturedByCopyInLambdaWithExplicitObjectParameter(
19832 bool MightBeOdrUse,
19837 if (
VarDecl *Var = dyn_cast<VarDecl>(D)) {
19856 const MemberExpr *ME = dyn_cast<MemberExpr>(E);
19863 bool IsVirtualCall = MD->
isVirtual() &&
19865 if (!IsVirtualCall)
19884 bool OdrUse =
true;
19886 if (Method->isVirtual() &&
19890 if (
auto *FD = dyn_cast<FunctionDecl>(E->
getDecl())) {
19895 !FD->isDependentContext())
19910 bool MightBeOdrUse =
true;
19913 if (Method->isPureVirtual())
19914 MightBeOdrUse =
false;
19934 bool MightBeOdrUse) {
19935 if (MightBeOdrUse) {
19936 if (
auto *VD = dyn_cast<VarDecl>(D)) {
19941 if (
auto *FD = dyn_cast<FunctionDecl>(D)) {
19969bool MarkReferencedDecls::TraverseTemplateArgument(
19983 return Inherited::TraverseTemplateArgument(Arg);
19987 MarkReferencedDecls Marker(*
this,
Loc);
19988 Marker.TraverseType(
T);
19994class EvaluatedExprMarker :
public UsedDeclVisitor<EvaluatedExprMarker> {
19997 bool SkipLocalVariables;
20000 EvaluatedExprMarker(
Sema &S,
bool SkipLocalVariables,
20002 : Inherited(S), SkipLocalVariables(SkipLocalVariables), StopAt(StopAt) {}
20008 void Visit(
Expr *E) {
20009 if (llvm::is_contained(StopAt, E))
20011 Inherited::Visit(E);
20021 if (SkipLocalVariables) {
20023 if (VD->hasLocalStorage())
20047 bool SkipLocalVariables,
20049 EvaluatedExprMarker(*
this, SkipLocalVariables, StopAt).Visit(E);
20071 if (
auto *VD = dyn_cast_or_null<VarDecl>(
20073 if (VD->isConstexpr() ||
20074 (VD->isStaticDataMember() && VD->isFirstDecl() && !VD->isInline()))
20146 class CallReturnIncompleteDiagnoser :
public TypeDiagnoser {
20152 : FD(FD), CE(CE) { }
20156 S.
Diag(
Loc, diag::err_call_incomplete_return)
20161 S.
Diag(
Loc, diag::err_call_function_incomplete_return)
20166 } Diagnoser(FD, CE);
20179 unsigned diagnostic = diag::warn_condition_is_assignment;
20180 bool IsOrAssign =
false;
20183 if (Op->getOpcode() != BO_Assign && Op->getOpcode() != BO_OrAssign)
20186 IsOrAssign = Op->getOpcode() == BO_OrAssign;
20194 if (
ObjC().isSelfExpr(Op->getLHS()) && ME->getMethodFamily() ==
OMF_init)
20195 diagnostic = diag::warn_condition_is_idiomatic_assignment;
20199 diagnostic = diag::warn_condition_is_idiomatic_assignment;
20202 Loc = Op->getOperatorLoc();
20204 if (Op->getOperator() != OO_Equal && Op->getOperator() != OO_PipeEqual)
20207 IsOrAssign = Op->getOperator() == OO_PipeEqual;
20208 Loc = Op->getOperatorLoc();
20220 Diag(
Loc, diag::note_condition_assign_silence)
20225 Diag(
Loc, diag::note_condition_or_assign_to_comparison)
20228 Diag(
Loc, diag::note_condition_assign_to_comparison)
20246 if (opE->getOpcode() == BO_EQ &&
20247 opE->getLHS()->IgnoreParenImpCasts()->isModifiableLvalue(
Context)
20253 Diag(
Loc, diag::note_equality_comparison_silence)
20256 Diag(
Loc, diag::note_equality_comparison_to_assign)
20262 bool IsConstexpr) {
20264 if (
ParenExpr *parenE = dyn_cast<ParenExpr>(E))
20282 Diag(
Loc, diag::err_typecheck_statement_requires_scalar)
20286 CheckBoolLikeConversion(E,
Loc);
20332 struct RebuildUnknownAnyFunction
20333 :
StmtVisitor<RebuildUnknownAnyFunction, ExprResult> {
20337 RebuildUnknownAnyFunction(
Sema &S) : S(S) {}
20340 llvm_unreachable(
"unexpected statement!");
20351 template <
class T>
ExprResult rebuildSugarExpr(
T *E) {
20352 ExprResult SubResult = Visit(E->getSubExpr());
20355 Expr *SubExpr = SubResult.
get();
20356 E->setSubExpr(SubExpr);
20364 return rebuildSugarExpr(E);
20368 return rebuildSugarExpr(E);
20375 Expr *SubExpr = SubResult.
get();
20384 if (!isa<FunctionDecl>(VD))
return VisitExpr(E);
20390 !(isa<CXXMethodDecl>(VD) &&
20391 cast<CXXMethodDecl>(VD)->isInstance()))
20402 return resolveDecl(E, E->
getDecl());
20420 struct RebuildUnknownAnyExpr
20421 :
StmtVisitor<RebuildUnknownAnyExpr, ExprResult> {
20432 llvm_unreachable(
"unexpected statement!");
20446 template <
class T>
ExprResult rebuildSugarExpr(
T *E) {
20447 ExprResult SubResult = Visit(E->getSubExpr());
20449 Expr *SubExpr = SubResult.
get();
20450 E->setSubExpr(SubExpr);
20458 return rebuildSugarExpr(E);
20462 return rebuildSugarExpr(E);
20500 return resolveDecl(E, E->
getDecl());
20511 FK_FunctionPointer,
20518 assert(isa<CXXMemberCallExpr>(E) || isa<CXXOperatorCallExpr>(E));
20519 Kind = FK_MemberFunction;
20523 Kind = FK_FunctionPointer;
20526 Kind = FK_BlockPointer;
20532 unsigned diagID = diag::err_func_returning_array_function;
20533 if (Kind == FK_BlockPointer)
20534 diagID = diag::err_block_returning_array_function;
20570 if (ParamTypes.empty() && Proto->
isVariadic()) {
20572 for (
unsigned i = 0, e = E->
getNumArgs(); i != e; ++i) {
20575 ParamTypes = ArgTypes;
20586 case FK_MemberFunction:
20590 case FK_FunctionPointer:
20594 case FK_BlockPointer:
20600 ExprResult CalleeResult = Visit(CalleeExpr);
20611 S.
Diag(E->
getExprLoc(), diag::err_func_returning_array_function)
20619 Method->setReturnType(DestType);
20631 if (E->
getCastKind() == CK_FunctionToPointerDecay) {
20645 }
else if (E->
getCastKind() == CK_LValueToRValue) {
20649 assert(isa<BlockPointerType>(E->
getType()));
20662 llvm_unreachable(
"Unhandled cast type!");
20695 if (DRE && Proto && Proto->getParamTypes().empty() && Proto->isVariadic()) {
20699 FD->getNameInfo().getName(), DestType, FD->getTypeSourceInfo(),
20701 false , FD->hasPrototype(),
20704 if (FD->getQualifier())
20708 for (
const auto &AI : FT->param_types()) {
20712 Params.push_back(Param);
20714 NewFD->setParams(Params);
20721 if (MD->isInstance()) {
20731 }
else if (isa<VarDecl>(VD)) {
20735 S.
Diag(E->
getExprLoc(), diag::err_unknown_any_var_function_type)
20763 diag::err_typecheck_cast_to_incomplete))
20778 return RebuildUnknownAnyExpr(*
this, ToType).Visit(E);
20785 ExplicitCastExpr *castArg = dyn_cast<ExplicitCastExpr>(arg->IgnoreParens());
20794 assert(!arg->hasPlaceholderType());
20806 unsigned diagID = diag::err_uncasted_use_of_unknown_any;
20809 if (
CallExpr *call = dyn_cast<CallExpr>(E)) {
20810 E = call->getCallee();
20811 diagID = diag::err_uncasted_call_of_unknown_any;
20819 if (
DeclRefExpr *ref = dyn_cast<DeclRefExpr>(E)) {
20820 loc = ref->getLocation();
20821 d = ref->getDecl();
20822 }
else if (
MemberExpr *mem = dyn_cast<MemberExpr>(E)) {
20823 loc = mem->getMemberLoc();
20824 d = mem->getMemberDecl();
20826 diagID = diag::err_uncasted_call_of_unknown_any;
20827 loc = msg->getSelectorStartLoc();
20828 d = msg->getMethodDecl();
20830 S.
Diag(loc, diag::err_uncasted_send_to_unknown_any_method)
20831 <<
static_cast<unsigned>(msg->isClassMessage()) << msg->getSelector()
20860 if (!placeholderType)
return E;
20862 switch (placeholderType->
getKind()) {
20863 case BuiltinType::UnresolvedTemplate: {
20864 auto *ULE = cast<UnresolvedLookupExpr>(E);
20869 const bool IsTypeAliasTemplateDecl = isa<TypeAliasTemplateDecl>(Temp);
20872 Diag(NameInfo.
getLoc(), diag::err_template_kw_refers_to_type_template)
20874 <<
Loc.getSourceRange() << IsTypeAliasTemplateDecl;
20876 Diag(NameInfo.
getLoc(), diag::err_template_kw_refers_to_type_template)
20878 << IsTypeAliasTemplateDecl;
20880 << IsTypeAliasTemplateDecl;
20886 case BuiltinType::Overload: {
20906 case BuiltinType::BoundMember: {
20911 if (isa<CXXPseudoDestructorExpr>(BME)) {
20912 PD =
PDiag(diag::err_dtor_expr_without_call) << 1;
20913 }
else if (
const auto *ME = dyn_cast<MemberExpr>(BME)) {
20914 if (ME->getMemberNameInfo().getName().getNameKind() ==
20916 PD =
PDiag(diag::err_dtor_expr_without_call) << 0;
20924 case BuiltinType::ARCUnbridgedCast: {
20931 case BuiltinType::UnknownAny:
20935 case BuiltinType::PseudoObject:
20938 case BuiltinType::BuiltinFn: {
20942 auto *FD = cast<FunctionDecl>(DRE->
getDecl());
20943 unsigned BuiltinID = FD->getBuiltinID();
20944 if (BuiltinID == Builtin::BI__noop) {
20946 CK_BuiltinFnToFnPtr)
20959 ? diag::err_use_of_unaddressable_function
20960 : diag::warn_cxx20_compat_use_of_unaddressable_function);
20961 if (FD->isImplicitlyInstantiable()) {
20988 case BuiltinType::IncompleteMatrixIdx:
20992 diag::err_matrix_incomplete_index);
20996 case BuiltinType::ArraySection:
20998 << cast<ArraySectionExpr>(E)->isOMPArraySection();
21002 case BuiltinType::OMPArrayShaping:
21005 case BuiltinType::OMPIterator:
21009#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
21010 case BuiltinType::Id:
21011#include "clang/Basic/OpenCLImageTypes.def"
21012#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
21013 case BuiltinType::Id:
21014#include "clang/Basic/OpenCLExtensionTypes.def"
21015#define SVE_TYPE(Name, Id, SingletonId) \
21016 case BuiltinType::Id:
21017#include "clang/Basic/AArch64SVEACLETypes.def"
21018#define PPC_VECTOR_TYPE(Name, Id, Size) \
21019 case BuiltinType::Id:
21020#include "clang/Basic/PPCTypes.def"
21021#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
21022#include "clang/Basic/RISCVVTypes.def"
21023#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
21024#include "clang/Basic/WebAssemblyReferenceTypes.def"
21025#define BUILTIN_TYPE(Id, SingletonId) case BuiltinType::Id:
21026#define PLACEHOLDER_TYPE(Id, SingletonId)
21027#include "clang/AST/BuiltinTypes.def"
21031 llvm_unreachable(
"invalid placeholder type!");
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.
This file declares semantic analysis for CUDA constructs.
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)
This file declares semantic analysis for Objective-C.
This file declares semantic analysis for OpenMP constructs and clauses.
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 getBlockPointerType(QualType T) const
Return the uniqued reference to the type for a block of the specified type.
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.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
QualType getReferenceQualifiedType(const Expr *e) const
getReferenceQualifiedType - Given an expr, will return the type for that expression,...
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.
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...
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>.
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
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.
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.
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 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)
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.
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.
llvm::APInt getSize() const
Return the constant array size as an APInt.
uint64_t getZExtSize() const
Return the size zero-extended as a uint64_t.
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...
ConvertVectorExpr - Clang builtin function __builtin_convertvector This AST node provides support for...
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.
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)
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
bool isInvalidType() const
const IdentifierInfo * getIdentifier() 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
RoundingMode getRoundingMode() 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...
bool wasNotFoundInCurrentInstantiation() const
Determine whether no result was found because we could not search into dependent base classes of the ...
LLVM_ATTRIBUTE_REINITIALIZES void clear()
Clears out any current state.
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.
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>::".
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, const IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
NumericLiteralParser - This performs strict semantic analysis of the content of a ppnumber,...
Represents an ObjC class declaration.
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.
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
QualType getReturnType() const
bool isClassMethod() const
Represents a pointer to an Objective C object.
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, const 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 PredefinedExpr * Create(const ASTContext &Ctx, SourceLocation L, QualType FNTy, PredefinedIdentKind IK, bool IsTransparent, StringLiteral *SL)
Create a PredefinedExpr.
static std::string ComputeName(PredefinedIdentKind IK, const Decl *CurrentDecl, bool ForceElaboratedPrinting=false)
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 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.
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
A generic diagnostic builder for errors which may or may not be deferred.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
void RecordImplicitHostDeviceFuncUsedByDevice(const FunctionDecl *FD)
Record FD if it is a CUDA/HIP implicit host device function used on device side in device compilation...
CUDAFunctionTarget IdentifyTarget(const FunctionDecl *D, bool IgnoreImplicitHDAttr=false)
Determines whether the given function is a CUDA device/host/kernel/etc.
bool CheckCall(SourceLocation Loc, FunctionDecl *Callee)
Check whether we're allowed to call Callee from the current context.
@ CVT_Host
Emitted on device side with a shadow variable on host side.
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 ...
ObjCMethodDecl * LookupInstanceMethodInGlobalPool(Selector Sel, SourceRange R, bool receiverIdOrClass=false)
LookupInstanceMethodInGlobalPool - Returns the method and warns if there are multiple signatures.
ObjCLiteralKind CheckLiteralKind(Expr *FromE)
ObjCMethodDecl * LookupMethodInObjectType(Selector Sel, QualType Ty, bool IsInstance)
LookupMethodInType - Look up a method in an ObjCObjectType.
void CheckObjCBridgeRelatedCast(QualType castType, Expr *castExpr)
QualType FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
FindCompositeObjCPointerType - Helper method to find composite type of two objective-c pointer types ...
void CheckTollFreeBridgeCast(QualType castType, Expr *castExpr)
const DeclContext * getCurObjCLexicalContext() const
void checkRetainCycles(ObjCMessageExpr *msg)
checkRetainCycles - Check whether an Objective-C message send might create an obvious retain cycle.
void EmitRelatedResultTypeNote(const Expr *E)
If the given expression involves a message send to a method with a related result type,...
void EmitRelatedResultTypeNoteForReturn(QualType destType)
Given that we had incompatible pointer types in a return statement, check whether we're in a method w...
void diagnoseARCUnbridgedCast(Expr *e)
Given that we saw an expression with the ARCUnbridgedCastTy placeholder type, complain bitterly.
ObjCMethodDecl * LookupMethodInQualifiedType(Selector Sel, const ObjCObjectPointerType *OPT, bool IsInstance)
LookupMethodInQualifiedType - Lookups up a method in protocol qualifier list of a qualified objective...
Expr * stripARCUnbridgedCast(Expr *e)
stripARCUnbridgedCast - Given an expression of ARCUnbridgedCast type, remove the placeholder cast.
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.
std::unique_ptr< NSAPI > NSAPIObj
Caches identifiers/selectors for NSFoundation APIs.
ExprResult ActOnArraySectionExpr(Expr *Base, SourceLocation LBLoc, Expr *LowerBound, SourceLocation ColonLocFirst, Expr *Length, SourceLocation RBLoc)
Checks and creates an Array Section used in an OpenACC construct/clause.
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...
void tryCaptureOpenMPLambdas(ValueDecl *V)
Function tries to capture lambda's captured variables in the OpenMP region before the original lambda...
OpenMPClauseKind isOpenMPPrivateDecl(ValueDecl *D, unsigned Level, unsigned CapLevel) const
Check if the specified variable is used in 'private' clause.
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,...
ExprResult ActOnOMPArraySectionExpr(Expr *Base, SourceLocation LBLoc, Expr *LowerBound, SourceLocation ColonLocFirst, SourceLocation ColonLocSecond, Expr *Length, Expr *Stride, SourceLocation RBLoc)
bool isOpenMPCapturedByRef(const ValueDecl *D, unsigned Level, unsigned OpenMPCaptureLevel) const
Return true if the provided declaration VD should be captured by reference.
bool isOpenMPTargetCapturedDecl(const ValueDecl *D, unsigned Level, unsigned CaptureLevel) const
Check if the specified variable is captured by 'target' directive.
bool isOpenMPGlobalCapturedDecl(ValueDecl *D, unsigned Level, unsigned CaptureLevel) const
Check if the specified global variable must be captured by outer capture regions.
bool isInOpenMPDeclareTargetContext() const
Return true inside OpenMP declare target region.
void checkDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D, SourceLocation IdLoc=SourceLocation())
Check declaration inside target region.
const ValueDecl * getOpenMPDeclareMapperVarName() const
RAII object used to temporarily allow the C++ 'this' expression to be used, with the given qualifiers...
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.
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.
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.
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 LookupTemplateName(LookupResult &R, Scope *S, CXXScopeSpec &SS, QualType ObjectType, bool EnteringContext, RequiredTemplateKind RequiredTemplate=SourceLocation(), AssumedTemplateKind *ATK=nullptr, bool AllowTypoCorrection=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)
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()
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...
unsigned CapturingFunctionScopes
Track the number of currently active capturing scopes.
void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl=nullptr, ExpressionEvaluationContextRecord::ExpressionKind Type=ExpressionEvaluationContextRecord::EK_Other)
ExprResult CheckBooleanCondition(SourceLocation Loc, Expr *E, bool IsConstexpr=false)
CheckBooleanCondition - Diagnose problems involving the use of the given expression as a boolean cond...
@ 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...
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)
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.
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 ...
ExprResult BuildStmtExpr(SourceLocation LPLoc, Stmt *SubStmt, SourceLocation RPLoc, unsigned TemplateDepth)
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.
NamedDecl * LookupSingleName(Scope *S, DeclarationName Name, SourceLocation Loc, LookupNameKind NameKind, RedeclarationKind Redecl=RedeclarationKind::NotForRedeclaration)
Look up a name, looking for a single declaration.
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 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)
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...
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 ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
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)
bool isBoundsAttrContext() const
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)
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 *.
ExprResult ActOnUnevaluatedStringLiteral(ArrayRef< Token > StringToks)
void DiagnoseSelfMove(const Expr *LHSExpr, const Expr *RHSExpr, SourceLocation OpLoc)
Warn if a value is moved to itself.
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 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()
@ 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...
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)
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 LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS, QualType ObjectType, 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...
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)
bool isPotentialImplicitMemberAccess(const CXXScopeSpec &SS, LookupResult &R, bool IsAddressOfOperand)
Check whether an expression might be an implicit class member access.
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.
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
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.
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 ...
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...
bool CheckLoopHintExpr(Expr *E, SourceLocation Loc, bool AllowZero)
QualType CheckSizelessVectorOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign, ArithConvKind OperationKind)
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)
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.
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
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.
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)
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)
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...
ExprResult BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, const TemplateArgumentListInfo *TemplateArgs, const Scope *S)
Builds an expression which might be an implicit member expression.
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
bool resolveAndFixAddressOfSingleOverloadCandidate(ExprResult &SrcExpr, bool DoFunctionPointerConversion=false)
Given an overloaded function, tries to turn it into a non-overloaded function reference using resolve...
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)
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
ExprResult PerformImplicitConversion(Expr *From, QualType ToType, const ImplicitConversionSequence &ICS, AssignmentAction Action, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
PerformImplicitConversion - Perform an implicit conversion of the expression From to the type ToType ...
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)
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()
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 mergeDeclAttributes(NamedDecl *New, Decl *Old, AvailabilityMergeKind AMK=AMK_Redeclaration)
mergeDeclAttributes - Copy attributes from the Old decl to the New one.
bool CheckForConstantInitializer(Expr *Init, unsigned DiagID=diag::err_init_element_not_constant)
type checking declaration initializers (C99 6.7.8)
llvm::SmallPtrSet< const Decl *, 4 > ParsingInitForAutoVars
ParsingInitForAutoVars - a set of declarations with auto types for which we are currently parsing the...
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,...
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)
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.
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.
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,...
QualType CheckSizelessVectorCompareOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc)
ExprResult ConvertMemberDefaultInitExpression(FieldDecl *FD, Expr *InitExpr, SourceLocation InitLoc)
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.
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)
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.
const TypoExprState & getTypoExprState(TypoExpr *TE) const
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)
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"...
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 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...
StringRef getString() const
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.
@ 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 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.
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.
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, UnresolvedSetIterator Begin, UnresolvedSetIterator End, bool KnownDependent)
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.
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)
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...
if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))
@ 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.
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_HLSL_Array_RValue
HLSL non-decaying array rvalue cast.
@ 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.
const FunctionProtoType * T
@ 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.
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
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.
@ Implicit
An implicit conversion.
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
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
bool InLifetimeExtendingContext
Whether we are currently in a context in which all temporaries must be lifetime-extended,...
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.
bool isImmediateFunctionContext() const
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.
Abstract class used to diagnose incomplete types.
Location information for a TemplateArgument.