61#include "llvm/ADT/STLExtras.h"
62#include "llvm/ADT/STLForwardCompat.h"
63#include "llvm/ADT/StringExtras.h"
64#include "llvm/Support/ConvertUTF.h"
65#include "llvm/Support/SaveAndRestore.h"
66#include "llvm/Support/TimeProfiler.h"
67#include "llvm/Support/TypeSize.h"
91 if (TreatUnavailableAsInvalid &&
101 if (isa<UnresolvedUsingIfExistsDecl>(
D))
109 if (
const auto *A =
D->
getAttr<UnusedAttr>()) {
112 if (A->getSemanticSpelling() != UnusedAttr::CXX11_maybe_unused &&
113 A->getSemanticSpelling() != UnusedAttr::C23_maybe_unused) {
115 if (DC && !DC->
hasAttr<UnusedAttr>())
116 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)
218 bool ObjCPropertyAccess,
219 bool AvoidPartialAvailabilityChecks,
221 bool SkipTrailingRequiresClause) {
229 Diag(Suppressed.first, Suppressed.second);
240 if (cast<FunctionDecl>(
D)->isMain())
241 Diag(
Loc, diag::ext_main_used);
248 if (isa<BindingDecl>(
D)) {
249 Diag(
Loc, diag::err_binding_cannot_appear_in_own_initializer)
252 Diag(
Loc, diag::err_auto_variable_cannot_appear_in_own_initializer)
253 <<
D->getDeclName() << cast<VarDecl>(
D)->getType();
260 if (FD->isDeleted()) {
261 auto *Ctor = dyn_cast<CXXConstructorDecl>(FD);
262 if (Ctor && Ctor->isInheritingConstructor())
263 Diag(
Loc, diag::err_deleted_inherited_ctor_use)
265 << Ctor->getInheritedConstructor().getConstructor()->getParent();
268 Diag(
Loc, diag::err_deleted_function_use)
269 << (Msg !=
nullptr) << (Msg ? Msg->
getString() : StringRef());
283 if (!SkipTrailingRequiresClause && FD->getTrailingRequiresClause()) {
292 diag::err_reference_to_function_with_unsatisfied_constraints)
310 if (
auto *
Concept = dyn_cast<ConceptDecl>(
D);
314 if (
auto *MD = dyn_cast<CXXMethodDecl>(
D)) {
316 if (MD->getParent()->isLambda() &&
317 ((isa<CXXConstructorDecl>(MD) &&
318 cast<CXXConstructorDecl>(MD)->isDefaultConstructor()) ||
319 MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator())) {
320 Diag(
Loc, diag::warn_cxx17_compat_lambda_def_ctor_assign)
321 << !isa<CXXConstructorDecl>(MD);
325 auto getReferencedObjCProp = [](
const NamedDecl *
D) ->
327 if (
const auto *MD = dyn_cast<ObjCMethodDecl>(
D))
342 auto *DRD = dyn_cast<OMPDeclareReductionDecl>(
CurContext);
345 Diag(
Loc, diag::err_omp_wrong_var_in_declare_reduction)
356 if (
LangOpts.OpenMP && isa<VarDecl>(
D) &&
357 !
OpenMP().isOpenMPDeclareMapperVarDeclAllowed(cast<VarDecl>(
D))) {
358 Diag(
Loc, diag::err_omp_declare_mapper_wrong_var)
364 if (
const auto *EmptyD = dyn_cast<UnresolvedUsingIfExistsDecl>(
D)) {
365 Diag(
Loc, diag::err_use_of_empty_using_if_exists);
366 Diag(EmptyD->getLocation(), diag::note_empty_using_if_exists_here);
371 AvoidPartialAvailabilityChecks, ClassReceiver);
377 if (
D->
hasAttr<AvailableOnlyInDefaultEvalMethodAttr>()) {
383 diag::err_type_available_only_in_default_eval_method)
387 if (
auto *VD = dyn_cast<ValueDecl>(
D))
393 if (
const auto *VD = dyn_cast<VarDecl>(
D))
395 targetDiag(*Locs.begin(), diag::err_thread_unsupported);
398 if (isa<ParmVarDecl>(
D) && isa<RequiresExprBodyDecl>(
D->
getDeclContext()) &&
403 Diag(
Loc, diag::err_requires_expr_parameter_referenced_in_evaluated_context)
419 unsigned NumFormalParams;
423 enum { CK_Function, CK_Method, CK_Block } CalleeKind;
425 if (
const auto *MD = dyn_cast<ObjCMethodDecl>(
D)) {
426 NumFormalParams = MD->param_size();
427 CalleeKind = CK_Method;
428 }
else if (
const auto *FD = dyn_cast<FunctionDecl>(
D)) {
429 NumFormalParams = FD->param_size();
430 CalleeKind = CK_Function;
431 }
else if (
const auto *VD = dyn_cast<VarDecl>(
D)) {
438 CalleeKind = CK_Function;
441 CalleeKind = CK_Block;
446 if (
const auto *proto = dyn_cast<FunctionProtoType>(Fn))
447 NumFormalParams = proto->getNumParams();
458 unsigned NullPos =
Attr->getNullPos();
459 assert((NullPos == 0 || NullPos == 1) &&
"invalid null position on sentinel");
460 NumFormalParams = (NullPos > NumFormalParams ? 0 : NumFormalParams - NullPos);
463 unsigned NumArgsAfterSentinel =
Attr->getSentinel();
467 if (Args.size() < NumFormalParams + NumArgsAfterSentinel + 1) {
468 Diag(
Loc, diag::warn_not_enough_argument) <<
D->getDeclName();
474 const Expr *SentinelExpr = Args[Args.size() - NumArgsAfterSentinel - 1];
487 std::string NullValue;
491 NullValue =
"nullptr";
495 NullValue =
"(void*) 0";
498 Diag(
Loc, diag::warn_missing_sentinel) <<
int(CalleeKind);
500 Diag(MissingNilLoc, diag::warn_missing_sentinel)
525 assert(!Ty.
isNull() &&
"DefaultFunctionArrayConversion - missing type");
529 if (
auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl()))
534 CK_FunctionToPointerDecay).
get();
549 CK_ArrayToPointerDecay);
565 if (UO && UO->getOpcode() == UO_Deref &&
566 UO->getSubExpr()->getType()->isPointerType()) {
568 UO->getSubExpr()->getType()->getPointeeType().getAddressSpace();
571 UO->getSubExpr()->IgnoreParenCasts()->isNullPointerConstant(
573 !UO->getType().isVolatileQualified()) {
575 S.
PDiag(diag::warn_indirection_through_null)
576 << UO->getSubExpr()->getSourceRange());
578 S.
PDiag(diag::note_indirection_through_null));
610 if (ObjectSetClass) {
654 assert(!
T.isNull() &&
"r-value conversion on typeless expression?");
696 SourceRange(OISA->getOpLoc(), OISA->getIsaMemberLoc()),
")");
713 if (
T.hasQualifiers())
714 T =
T.getUnqualifiedType();
744 T =
Atomic->getValueType().getUnqualifiedType();
769 CK_FunctionToPointerDecay);
792 assert(!Ty.
isNull() &&
"UsualUnaryConversions - missing type");
799 switch (EvalMethod) {
801 llvm_unreachable(
"Unrecognized float evaluation method");
804 llvm_unreachable(
"Float evaluation method should be set by now");
812 CK_FloatingComplexCast)
821 CK_FloatingComplexCast)
869 assert(!Ty.
isNull() &&
"DefaultArgumentPromotion - missing type");
881 if (BTy && (BTy->
getKind() == BuiltinType::Half ||
882 BTy->
getKind() == BuiltinType::Float)) {
885 if (BTy->
getKind() == BuiltinType::Half) {
903 "Unexpected typesize for LongLongTy");
972 if (!
Record->hasNonTrivialCopyConstructor() &&
973 !
Record->hasNonTrivialMoveConstructor() &&
974 !
Record->hasNonTrivialDestructor())
1007 PDiag(diag::warn_cxx98_compat_pass_non_pod_arg_to_vararg) << Ty << CT);
1014 PDiag(diag::warn_pass_class_arg_to_vararg)
1022 PDiag(diag::warn_cannot_pass_non_pod_arg_to_vararg)
1029 diag::err_cannot_pass_non_trivial_c_struct_to_vararg)
1033 PDiag(diag::err_cannot_pass_objc_interface_to_vararg)
1037 << isa<InitListExpr>(
E) << Ty << CT;
1046 if (PlaceholderTy->getKind() == BuiltinType::ARCUnbridgedCast &&
1048 (FDecl && FDecl->
hasAttr<CFAuditedTransferAttr>()))) {
1087 if (
Call.isInvalid())
1092 if (Comma.isInvalid())
1099 diag::err_call_incomplete_argument))
1117 if (SkipCast)
return false;
1124 CK_IntegralComplexToFloatingComplex);
1142 bool PromotePrecision) {
1147 if (PromotePrecision) {
1152 if (LongerIsComplex)
1164 QualType RHSType,
bool IsCompAssign) {
1189 bool ConvertFloat,
bool ConvertInt) {
1194 CK_IntegralToFloating);
1205 CK_IntegralComplexToFloatingComplex);
1210 CK_FloatingRealToComplex);
1219 QualType RHSType,
bool IsCompAssign) {
1229 else if (!IsCompAssign)
1231 return LHSFloat ? LHSType : RHSType;
1236 if (LHSFloat && RHSFloat) {
1243 assert(order < 0 &&
"illegal float comparison");
1277 QualType LHSElem = LHSComplex ? LHSComplex->getElementType() : LHSType;
1283 if ((&LHSSem != &llvm::APFloat::PPCDoubleDouble() ||
1284 &RHSSem != &llvm::APFloat::IEEEquad()) &&
1285 (&LHSSem != &llvm::APFloat::IEEEquad() ||
1286 &RHSSem != &llvm::APFloat::PPCDoubleDouble()))
1303 CK_IntegralComplexCast);
1309template <PerformCastFn doLHSCast, PerformCastFn doRHSCast>
1312 QualType RHSType,
bool IsCompAssign) {
1317 if (LHSSigned == RHSSigned) {
1320 RHS = (*doRHSCast)(S, RHS.
get(), LHSType);
1322 }
else if (!IsCompAssign)
1323 LHS = (*doLHSCast)(S, LHS.
get(), RHSType);
1325 }
else if (order != (LHSSigned ? 1 : -1)) {
1329 RHS = (*doRHSCast)(S, RHS.
get(), LHSType);
1331 }
else if (!IsCompAssign)
1332 LHS = (*doLHSCast)(S, LHS.
get(), RHSType);
1339 RHS = (*doRHSCast)(S, RHS.
get(), LHSType);
1341 }
else if (!IsCompAssign)
1342 LHS = (*doLHSCast)(S, LHS.
get(), RHSType);
1351 RHS = (*doRHSCast)(S, RHS.
get(), result);
1353 LHS = (*doLHSCast)(S, LHS.
get(), result);
1363 bool IsCompAssign) {
1367 if (LHSComplexInt && RHSComplexInt) {
1371 handleIntegerConversion<doComplexIntegralCast, doComplexIntegralCast>
1372 (S, LHS, RHS, LHSEltType, RHSEltType, IsCompAssign);
1377 if (LHSComplexInt) {
1380 handleIntegerConversion<doComplexIntegralCast, doIntegralCast>
1381 (S, LHS, RHS, LHSEltType, RHSType, IsCompAssign);
1384 CK_IntegralRealToComplex);
1389 assert(RHSComplexInt);
1393 handleIntegerConversion<doIntegralCast, doComplexIntegralCast>
1394 (S, LHS, RHS, LHSType, RHSEltType, IsCompAssign);
1399 CK_IntegralRealToComplex);
1408 assert(BTy &&
"Expected a builtin type.");
1410 switch (BTy->getKind()) {
1411 case BuiltinType::ShortFract:
1412 case BuiltinType::UShortFract:
1413 case BuiltinType::SatShortFract:
1414 case BuiltinType::SatUShortFract:
1416 case BuiltinType::Fract:
1417 case BuiltinType::UFract:
1418 case BuiltinType::SatFract:
1419 case BuiltinType::SatUFract:
1421 case BuiltinType::LongFract:
1422 case BuiltinType::ULongFract:
1423 case BuiltinType::SatLongFract:
1424 case BuiltinType::SatULongFract:
1426 case BuiltinType::ShortAccum:
1427 case BuiltinType::UShortAccum:
1428 case BuiltinType::SatShortAccum:
1429 case BuiltinType::SatUShortAccum:
1431 case BuiltinType::Accum:
1432 case BuiltinType::UAccum:
1433 case BuiltinType::SatAccum:
1434 case BuiltinType::SatUAccum:
1436 case BuiltinType::LongAccum:
1437 case BuiltinType::ULongAccum:
1438 case BuiltinType::SatLongAccum:
1439 case BuiltinType::SatULongAccum:
1442 if (BTy->isInteger())
1444 llvm_unreachable(
"Unexpected fixed point or integer type");
1456 "Expected at least one of the operands to be a fixed point type");
1459 "Special fixed point arithmetic operation conversions are only "
1460 "applied to ints or other fixed point types");
1482 QualType ResultTy = LHSTyRank > RHSTyRank ? LHSTy : RHSTy;
1505 REnum = R->isUnscopedEnumerationType();
1507 if ((!IsCompAssign && LEnum && R->isFloatingType()) ||
1510 ? diag::err_arith_conv_enum_float_cxx26
1512 ? diag::warn_arith_conv_enum_float_cxx20
1513 : diag::warn_arith_conv_enum_float)
1516 }
else if (!IsCompAssign && LEnum && REnum &&
1522 DiagID = diag::err_conv_mixed_enum_types_cxx26;
1524 !R->castAs<
EnumType>()->getDecl()->hasNameForLinkage()) {
1529 ? diag::warn_arith_conv_mixed_anon_enum_types_cxx20
1530 : diag::warn_arith_conv_mixed_anon_enum_types;
1535 ? diag::warn_conditional_mixed_enum_types_cxx20
1536 : diag::warn_conditional_mixed_enum_types;
1541 ? diag::warn_comparison_mixed_enum_types_cxx20
1542 : diag::warn_comparison_mixed_enum_types;
1545 ? diag::warn_arith_conv_mixed_enum_types_cxx20
1546 : diag::warn_arith_conv_mixed_enum_types;
1549 << (
int)ACK << L << R;
1579 LHSType = AtomicLHS->getValueType();
1591 QualType LHSUnpromotedType = LHSType;
1595 if (!LHSBitfieldPromoteTy.
isNull())
1596 LHSType = LHSBitfieldPromoteTy;
1630 return handleIntegerConversion<doIntegralCast, doIntegralCast>
1641 bool PredicateIsExpr,
void *ControllingExprOrType,
1643 unsigned NumAssocs = ArgTypes.size();
1644 assert(NumAssocs == ArgExprs.size());
1647 for (
unsigned i = 0; i < NumAssocs; ++i) {
1656 if (!PredicateIsExpr) {
1660 assert(ControllingType &&
"couldn't get the type out of the parser");
1661 ControllingExprOrType = ControllingType;
1665 KeyLoc, DefaultLoc, RParenLoc, PredicateIsExpr, ControllingExprOrType,
1673 bool PredicateIsExpr,
void *ControllingExprOrType,
1675 unsigned NumAssocs = Types.size();
1676 assert(NumAssocs == Exprs.size());
1677 assert(ControllingExprOrType &&
1678 "Must have either a controlling expression or a controlling type");
1680 Expr *ControllingExpr =
nullptr;
1682 if (PredicateIsExpr) {
1689 reinterpret_cast<Expr *
>(ControllingExprOrType));
1692 ControllingExpr = R.
get();
1695 ControllingType =
reinterpret_cast<TypeSourceInfo *
>(ControllingExprOrType);
1696 if (!ControllingType)
1700 bool TypeErrorFound =
false,
1701 IsResultDependent = ControllingExpr
1704 ContainsUnexpandedParameterPack =
1714 diag::warn_side_effects_unevaluated_context);
1716 for (
unsigned i = 0; i < NumAssocs; ++i) {
1717 if (Exprs[i]->containsUnexpandedParameterPack())
1718 ContainsUnexpandedParameterPack =
true;
1721 if (Types[i]->getType()->containsUnexpandedParameterPack())
1722 ContainsUnexpandedParameterPack =
true;
1724 if (Types[i]->getType()->isDependentType()) {
1725 IsResultDependent =
true;
1738 if (ControllingExpr && Types[i]->getType()->isIncompleteType())
1739 D = diag::err_assoc_type_incomplete;
1740 else if (ControllingExpr && !Types[i]->getType()->isObjectType())
1741 D = diag::err_assoc_type_nonobject;
1742 else if (Types[i]->getType()->isVariablyModifiedType())
1743 D = diag::err_assoc_type_variably_modified;
1744 else if (ControllingExpr) {
1763 unsigned Reason = 0;
1772 Diag(Types[i]->getTypeLoc().getBeginLoc(),
1773 diag::warn_unreachable_association)
1774 << QT << (Reason - 1);
1778 Diag(Types[i]->getTypeLoc().getBeginLoc(),
D)
1779 << Types[i]->getTypeLoc().getSourceRange()
1780 << Types[i]->getType();
1781 TypeErrorFound =
true;
1786 for (
unsigned j = i+1; j < NumAssocs; ++j)
1787 if (Types[j] && !Types[j]->getType()->isDependentType() &&
1789 Types[j]->getType())) {
1790 Diag(Types[j]->getTypeLoc().getBeginLoc(),
1791 diag::err_assoc_compatible_types)
1792 << Types[j]->getTypeLoc().getSourceRange()
1793 << Types[j]->getType()
1794 << Types[i]->getType();
1795 Diag(Types[i]->getTypeLoc().getBeginLoc(),
1796 diag::note_compat_assoc)
1797 << Types[i]->getTypeLoc().getSourceRange()
1798 << Types[i]->getType();
1799 TypeErrorFound =
true;
1809 if (IsResultDependent) {
1810 if (ControllingExpr)
1812 Types, Exprs, DefaultLoc, RParenLoc,
1813 ContainsUnexpandedParameterPack);
1815 Exprs, DefaultLoc, RParenLoc,
1816 ContainsUnexpandedParameterPack);
1820 unsigned DefaultIndex = -1U;
1824 for (
unsigned i = 0; i < NumAssocs; ++i) {
1827 else if (ControllingExpr &&
1830 Types[i]->getType()))
1831 CompatIndices.push_back(i);
1832 else if (ControllingType &&
1835 Types[i]->getType()))
1836 CompatIndices.push_back(i);
1839 auto GetControllingRangeAndType = [](
Expr *ControllingExpr,
1843 if (ControllingExpr)
1852 return std::make_pair(SR, QT);
1858 if (CompatIndices.size() > 1) {
1859 auto P = GetControllingRangeAndType(ControllingExpr, ControllingType);
1862 << SR <<
P.second << (
unsigned)CompatIndices.size();
1863 for (
unsigned I : CompatIndices) {
1864 Diag(Types[I]->getTypeLoc().getBeginLoc(),
1865 diag::note_compat_assoc)
1866 << Types[I]->getTypeLoc().getSourceRange()
1867 << Types[I]->getType();
1875 if (DefaultIndex == -1U && CompatIndices.size() == 0) {
1876 auto P = GetControllingRangeAndType(ControllingExpr, ControllingType);
1878 Diag(SR.
getBegin(), diag::err_generic_sel_no_match) << SR <<
P.second;
1887 unsigned ResultIndex =
1888 CompatIndices.size() ? CompatIndices[0] : DefaultIndex;
1890 if (ControllingExpr) {
1892 Context, KeyLoc, ControllingExpr, Types, Exprs, DefaultLoc, RParenLoc,
1893 ContainsUnexpandedParameterPack, ResultIndex);
1896 Context, KeyLoc, ControllingType, Types, Exprs, DefaultLoc, RParenLoc,
1897 ContainsUnexpandedParameterPack, ResultIndex);
1903 llvm_unreachable(
"unexpected TokenKind");
1904 case tok::kw___func__:
1906 case tok::kw___FUNCTION__:
1908 case tok::kw___FUNCDNAME__:
1910 case tok::kw___FUNCSIG__:
1912 case tok::kw_L__FUNCTION__:
1914 case tok::kw_L__FUNCSIG__:
1916 case tok::kw___PRETTY_FUNCTION__:
1925 while (DC && !isa<BlockDecl, CapturedDecl, FunctionDecl, ObjCMethodDecl>(DC))
1927 return cast_or_null<Decl>(DC);
1945 assert(Args.size() <= 2 &&
"too many arguments for literal operator");
1948 for (
unsigned ArgIdx = 0; ArgIdx != Args.size(); ++ArgIdx) {
1949 ArgTy[ArgIdx] = Args[ArgIdx]->getType();
1950 if (ArgTy[ArgIdx]->isArrayType())
1971 std::vector<Token> ExpandedToks;
1977 if (Literal.hadError)
1981 for (
const Token &Tok : StringToks)
1982 StringTokLocs.push_back(Tok.getLocation());
1986 &StringTokLocs[0], StringTokLocs.size());
1988 if (!Literal.getUDSuffix().empty()) {
1991 Literal.getUDSuffixOffset());
1992 return ExprError(
Diag(UDSuffixLoc, diag::err_invalid_string_udl));
2014 std::vector<Token> ExpandedToks;
2015 ExpandedToks.reserve(Toks.size());
2016 for (
const Token &Tok : Toks) {
2019 ExpandedToks.emplace_back(Tok);
2022 if (isa<TranslationUnitDecl>(CurrentDecl))
2023 Diag(Tok.getLocation(), diag::ext_predef_outside_function);
2025 Diag(Tok.getLocation(), diag::ext_string_literal_from_predefined)
2028 llvm::raw_svector_ostream
OS(Str);
2029 Token &Exp = ExpandedToks.emplace_back();
2031 if (Tok.getKind() == tok::kw_L__FUNCTION__ ||
2032 Tok.getKind() == tok::kw_L__FUNCSIG__) {
2034 Exp.
setKind(tok::wide_string_literal);
2036 Exp.
setKind(tok::string_literal);
2044 return ExpandedToks;
2049 assert(!StringToks.empty() &&
"Must have at least one string!");
2052 std::vector<Token> ExpandedToks;
2057 if (Literal.hadError)
2061 for (
const Token &Tok : StringToks)
2062 StringTokLocs.push_back(Tok.getLocation());
2066 if (Literal.isWide()) {
2069 }
else if (Literal.isUTF8()) {
2075 }
else if (Literal.isUTF16()) {
2078 }
else if (Literal.isUTF32()) {
2081 }
else if (Literal.isPascal()) {
2094 ? diag::warn_cxx20_compat_utf8_string
2095 : diag::warn_c23_compat_utf8_string);
2101 auto RemovalDiag =
PDiag(diag::note_cxx20_c23_compat_utf8_string_remove_u8);
2103 for (
const Token &Tok : StringToks) {
2104 if (Tok.getKind() == tok::utf8_string_literal) {
2106 RemovalDiagLoc = Tok.getLocation();
2113 Diag(RemovalDiagLoc, RemovalDiag);
2121 Kind, Literal.Pascal, StrTy,
2123 StringTokLocs.size());
2124 if (Literal.getUDSuffix().empty())
2131 Literal.getUDSuffixOffset());
2135 return ExprError(
Diag(UDSuffixLoc, diag::err_invalid_string_udl));
2160 Expr *Args[] = { Lit, LenArg };
2179 llvm::APSInt
Value(CharBits, CharIsUnsigned);
2185 for (
unsigned I = 0, N = Lit->
getLength(); I != N; ++I) {
2196 llvm_unreachable(
"unexpected literal operator lookup result");
2200 llvm_unreachable(
"unexpected literal operator lookup result");
2232 auto *DRE = dyn_cast<DeclRefExpr>(VD->
getInit());
2235 auto *Referee = dyn_cast<VarDecl>(DRE->getDecl());
2236 if (!Referee || !Referee->hasGlobalStorage() ||
2237 Referee->hasAttr<CUDADeviceAttr>())
2243 auto *MD = dyn_cast_or_null<CXXMethodDecl>(S.
CurContext);
2244 if (MD && MD->getParent()->isLambda() &&
2245 MD->getOverloadedOperator() == OO_Call && MD->hasAttr<CUDADeviceAttr>() &&
2267 if (
VarDecl *VD = dyn_cast<VarDecl>(
D)) {
2268 if (VD->getType()->isReferenceType() &&
2271 VD->isUsableInConstantExpressions(
Context))
2286 bool RefersToCapturedVariable = isa<VarDecl, BindingDecl>(
D) &&
2290 Context, NNS, TemplateKWLoc,
D, RefersToCapturedVariable, NameInfo, Ty,
2318 const auto *FD = dyn_cast<FieldDecl>(
D);
2319 if (
const auto *IFD = dyn_cast<IndirectFieldDecl>(
D))
2320 FD = IFD->getAnonField();
2324 if (FD->isBitField())
2330 if (
const auto *BD = dyn_cast<BindingDecl>(
D))
2331 if (
const auto *BE = BD->getBinding())
2347 Id.TemplateId->NumArgs);
2353 TemplateArgs = &Buffer;
2356 TemplateArgs =
nullptr;
2363 unsigned DiagnosticID,
unsigned DiagnosticSuggestID) {
2370 SemaRef.
Diag(TypoLoc, diag::err_no_member) << Typo << Ctx
2373 SemaRef.
Diag(TypoLoc, DiagnosticID) << Typo;
2378 bool DroppedSpecifier =
2381 ? diag::note_implicit_param_decl
2382 : diag::note_previous_decl;
2385 SemaRef.
PDiag(NoteID));
2388 << Typo << Ctx << DroppedSpecifier
2390 SemaRef.
PDiag(NoteID));
2397 bool isDefaultArgument =
2401 const auto *CurMethod = dyn_cast<CXXMethodDecl>(
CurContext);
2402 bool isInstance = CurMethod && CurMethod->isInstance() &&
2411 unsigned DiagID = diag::err_found_in_dependent_base;
2412 unsigned NoteID = diag::note_member_declared_at;
2414 DiagID =
getLangOpts().MSVCCompat ? diag::ext_found_later_in_class
2415 : diag::err_found_later_in_class;
2417 DiagID = diag::ext_found_in_dependent_base;
2418 NoteID = diag::note_dependent_member_use;
2443 if (isDefaultArgument && ((*R.
begin())->isCXXInstanceMember())) {
2459 unsigned diagnostic = diag::err_undeclared_var_use;
2460 unsigned diagnostic_suggest = diag::err_undeclared_var_use_suggest;
2464 diagnostic = diag::err_undeclared_use;
2465 diagnostic_suggest = diag::err_undeclared_use_suggest;
2475 if (isa<CXXRecordDecl>(DC)) {
2476 if (ExplicitTemplateArgs) {
2499 R.
addDecl(Best->FoundDecl.getDecl(), Best->FoundDecl.getAccess());
2516 assert(!ExplicitTemplateArgs &&
2517 "Diagnosing an empty lookup with explicit template args!");
2521 emitEmptyLookupTypoDiagnostic(TC, *this, SS, Name, TypoLoc, Args,
2522 diagnostic, diagnostic_suggest);
2527 }
else if (S && (Corrected =
2531 bool DroppedSpecifier =
2535 bool AcceptableWithRecovery =
false;
2536 bool AcceptableWithoutRecovery =
false;
2545 dyn_cast<FunctionTemplateDecl>(CD))
2549 else if (
FunctionDecl *FD = dyn_cast<FunctionDecl>(CD))
2550 if (!ExplicitTemplateArgs || ExplicitTemplateArgs->
size() == 0)
2556 ND = Best->FoundDecl;
2557 Corrected.setCorrectionDecl(ND);
2561 Corrected.setCorrectionDecl(ND);
2573 Record = cast<CXXRecordDecl>(
2579 AcceptableWithRecovery = isa<ValueDecl>(UnderlyingND) ||
2580 isa<FunctionTemplateDecl>(UnderlyingND);
2586 AcceptableWithoutRecovery = isa<TypeDecl>(UnderlyingND) ||
2588 isa<ObjCInterfaceDecl>(UnderlyingND);
2592 AcceptableWithoutRecovery =
true;
2595 if (AcceptableWithRecovery || AcceptableWithoutRecovery) {
2597 ? diag::note_implicit_param_decl
2598 : diag::note_previous_decl;
2601 PDiag(NoteID), AcceptableWithRecovery);
2605 << DroppedSpecifier << SS.
getRange(),
2606 PDiag(NoteID), AcceptableWithRecovery);
2609 return !AcceptableWithRecovery;
2645 else if (
auto *MD = dyn_cast<CXXMethodDecl>(S.
CurContext))
2653 auto DB = S.
Diag(
Loc, diag::ext_undeclared_unqual_id_with_dependent_base);
2654 DB << NameInfo.
getName() << RD;
2656 if (!ThisType.
isNull()) {
2659 Context,
nullptr, ThisType,
true,
2661 nullptr, NameInfo, TemplateArgs);
2678 bool HasTrailingLParen,
bool IsAddressOfOperand,
2680 bool IsInlineAsmIdentifier,
Token *KeywordReplacement) {
2681 assert(!(IsAddressOfOperand && HasTrailingLParen) &&
2682 "cannot be direct & operand and have a trailing lparen");
2711 if (
auto *VD = dyn_cast<ValueDecl>(R.
getFoundDecl())) {
2725 if (TemplateKWLoc.
isValid() || TemplateArgs) {
2733 false, TemplateKWLoc,
2739 IsAddressOfOperand, TemplateArgs);
2743 !IvarLookupFollowUp);
2749 IsAddressOfOperand, TemplateArgs);
2753 if (IvarLookupFollowUp) {
2768 if (R.
empty() && HasTrailingLParen && II &&
2778 if (R.
empty() && !ADL) {
2781 TemplateKWLoc, TemplateArgs))
2786 if (IsInlineAsmIdentifier)
2796 "Typo correction callback misconfigured");
2807 {},
nullptr, &TE)) {
2808 if (TE && KeywordReplacement) {
2810 auto BestTC = State.Consumer->getNextCorrection();
2811 if (BestTC.isKeyword()) {
2812 auto *II = BestTC.getCorrectionAsIdentifierInfo();
2813 if (State.DiagHandler)
2814 State.DiagHandler(BestTC);
2818 KeywordReplacement->
setLocation(BestTC.getCorrectionRange().getBegin());
2824 return (
Expr*)
nullptr;
2826 State.Consumer->resetCorrectionStream();
2831 assert(!R.
empty() &&
2832 "DiagnoseEmptyLookup returned false but added no results");
2842 if (!
E.isInvalid() && !
E.get())
2849 assert(!R.
empty() || ADL);
2879 if (TemplateArgs || TemplateKWLoc.
isValid()) {
2887 "There should only be one declaration found.");
2915 if (
const auto *CD = dyn_cast<CXXRecordDecl>(DC))
2916 if (CD->isInvalidDecl())
2927 unsigned DiagID = diag::err_typename_missing;
2929 DiagID = diag::ext_typename_missing;
2973 const auto *RD = dyn_cast<CXXRecordDecl>(
Member->getDeclContext());
2981 bool PointerConversions =
false;
2982 if (isa<FieldDecl>(
Member)) {
2986 DestRecordType, FromPtrType
2993 PointerConversions =
true;
2995 DestType = DestRecordType;
2996 FromRecordType = FromType;
2998 }
else if (
const auto *Method = dyn_cast<CXXMethodDecl>(
Member)) {
2999 if (!Method->isImplicitObjectMemberFunction())
3002 DestType = Method->getThisType().getNonReferenceType();
3003 DestRecordType = Method->getFunctionObjectParameterType();
3007 PointerConversions =
true;
3009 FromRecordType = FromType;
3010 DestType = DestRecordType;
3015 if (FromAS != DestAS) {
3020 if (PointerConversions)
3061 if (Qualifier && Qualifier->getAsType()) {
3063 assert(QType->
isRecordType() &&
"lookup done with non-record type");
3073 FromLoc, FromRange, &BasePath))
3076 if (PointerConversions)
3079 VK, &BasePath).
get();
3082 FromRecordType = QRecordType;
3093 FromLoc, FromRange, &BasePath,
3103 bool HasTrailingLParen) {
3105 if (!HasTrailingLParen)
3123 if (
D->isCXXClassMember())
3132 if (isa<UsingShadowDecl>(
D))
3133 D = cast<UsingShadowDecl>(
D)->getTargetDecl();
3141 if (
const auto *FDecl = dyn_cast<FunctionDecl>(
D)) {
3143 if (FDecl->getBuiltinID() && FDecl->isImplicit())
3145 }
else if (!isa<FunctionTemplateDecl>(
D))
3158 bool AcceptInvalid) {
3162 if (isa<TypedefNameDecl>(
D)) {
3163 S.
Diag(
Loc, diag::err_unexpected_typedef) <<
D->getDeclName();
3167 if (isa<ObjCInterfaceDecl>(
D)) {
3168 S.
Diag(
Loc, diag::err_unexpected_interface) <<
D->getDeclName();
3172 if (isa<NamespaceDecl>(
D)) {
3173 S.
Diag(
Loc, diag::err_unexpected_namespace) <<
D->getDeclName();
3184 const auto *FD = dyn_cast<FunctionDecl>(R.
getFoundDecl());
3186 (FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion());
3191 bool AcceptInvalidDecl) {
3229 bool AcceptInvalidDecl) {
3230 assert(
D &&
"Cannot refer to a NULL declaration");
3231 assert(!isa<FunctionTemplateDecl>(
D) &&
3232 "Cannot refer unambiguously to a function template");
3250 if (!isa<ValueDecl, UnresolvedUsingIfExistsDecl>(
D)) {
3263 auto *VD = cast<ValueDecl>(
D);
3266 if (VD->isInvalidDecl() && !AcceptInvalidDecl)
3272 if (
auto *IndirectField = dyn_cast<IndirectFieldDecl>(VD);
3273 IndirectField && !IndirectField->isCXXClassMember())
3285 type =
type.getNonPackExpansionType();
3289#define ABSTRACT_DECL(kind)
3290#define VALUE(type, base)
3291#define DECL(type, base) case Decl::type:
3292#include "clang/AST/DeclNodes.inc"
3293 llvm_unreachable(
"invalid value decl kind");
3296 case Decl::ObjCAtDefsField:
3297 llvm_unreachable(
"forming non-member reference to ivar?");
3301 case Decl::EnumConstant:
3302 case Decl::UnresolvedUsingValue:
3303 case Decl::OMPDeclareReduction:
3304 case Decl::OMPDeclareMapper:
3313 case Decl::IndirectField:
3314 case Decl::ObjCIvar:
3316 "building reference to field in C?");
3326 case Decl::NonTypeTemplateParm: {
3328 type = reftype->getPointeeType();
3338 if (
type->isRecordType()) {
3339 type =
type.getUnqualifiedType().withConst();
3352 case Decl::VarTemplateSpecialization:
3353 case Decl::VarTemplatePartialSpecialization:
3354 case Decl::Decomposition:
3356 case Decl::OMPCapturedExpr:
3359 type->isVoidType()) {
3365 case Decl::ImplicitParam:
3366 case Decl::ParmVar: {
3376 if (!CapturedType.
isNull())
3377 type = CapturedType;
3382 case Decl::Function: {
3383 if (
unsigned BID = cast<FunctionDecl>(VD)->getBuiltinID()) {
3412 if (!cast<FunctionDecl>(VD)->hasPrototype() && isa<FunctionProtoType>(fty))
3421 case Decl::CXXDeductionGuide:
3422 llvm_unreachable(
"building reference to deduction guide");
3424 case Decl::MSProperty:
3426 case Decl::TemplateParamObject:
3432 case Decl::UnnamedGlobalConstant:
3436 case Decl::CXXMethod:
3441 dyn_cast<FunctionProtoType>(VD->getType()))
3449 if (cast<CXXMethodDecl>(VD)->isStatic()) {
3455 case Decl::CXXConversion:
3456 case Decl::CXXDestructor:
3457 case Decl::CXXConstructor:
3469 if (VD->isInvalidDecl() &&
E)
3476 Target.resize(CharByteWidth * (Source.size() + 1));
3477 char *ResultPtr = &
Target[0];
3478 const llvm::UTF8 *ErrorPtr;
3480 llvm::ConvertUTF8toWide(CharByteWidth, Source, ResultPtr, ErrorPtr);
3490 Diag(
Loc, diag::ext_predef_outside_function);
3496 if (cast<DeclContext>(currentDecl)->isDependentContext())
3501 bool ForceElaboratedPrinting =
3505 unsigned Length = Str.length();
3507 llvm::APInt LengthI(32, Length + 1);
3547 if (Literal.hadError())
3551 if (Literal.isWide())
3557 else if (Literal.isUTF16())
3559 else if (Literal.isUTF32())
3568 if (Literal.isWide())
3570 else if (Literal.isUTF16())
3572 else if (Literal.isUTF32())
3574 else if (Literal.isUTF8())
3580 if (Literal.getUDSuffix().empty())
3590 return ExprError(
Diag(UDSuffixLoc, diag::err_invalid_character_udl));
3601 llvm::APInt(IntSize, Val,
true),
3609 using llvm::APFloat;
3610 APFloat Val(Format);
3613 if (RM == llvm::RoundingMode::Dynamic)
3614 RM = llvm::RoundingMode::NearestTiesToEven;
3615 APFloat::opStatus result = Literal.GetFloatValue(Val, RM);
3619 if ((result & APFloat::opOverflow) ||
3620 ((result & APFloat::opUnderflow) && Val.isZero())) {
3621 unsigned diagnostic;
3623 if (result & APFloat::opOverflow) {
3624 diagnostic = diag::warn_float_overflow;
3625 APFloat::getLargest(Format).toString(buffer);
3627 diagnostic = diag::warn_float_underflow;
3628 APFloat::getSmallest(Format).toString(buffer);
3631 S.
Diag(
Loc, diagnostic) << Ty << buffer.str();
3634 bool isExact = (result == APFloat::opOK);
3639 assert(
E &&
"Invalid expression");
3646 Diag(
E->
getExprLoc(), diag::err_pragma_loop_invalid_argument_type) << QT;
3650 llvm::APSInt ValueAPS;
3661 bool ValueIsPositive =
3662 AllowZero ? ValueAPS.isNonNegative() : ValueAPS.isStrictlyPositive();
3663 if (!ValueIsPositive || ValueAPS.getActiveBits() > 31) {
3665 <<
toString(ValueAPS, 10) << ValueIsPositive;
3685 SpellingBuffer.resize(Tok.
getLength() + 1);
3696 if (Literal.hadError)
3699 if (Literal.hasUDSuffix()) {
3707 return ExprError(
Diag(UDSuffixLoc, diag::err_invalid_numeric_udl));
3710 if (Literal.isFloatingLiteral()) {
3735 !Literal.isImaginary)) {
3744 if (Literal.isFloatingLiteral()) {
3748 if (Literal.GetIntegerValue(ResultVal))
3761 unsigned Length = Literal.getUDSuffixOffset();
3768 false, StrTy, &TokLoc, 1);
3779 bool CharIsUnsigned =
Context.
CharTy->isUnsignedIntegerType();
3780 llvm::APSInt
Value(CharBits, CharIsUnsigned);
3781 for (
unsigned I = 0, N = Literal.getUDSuffixOffset(); I != N; ++I) {
3782 Value = TokSpelling[I];
3790 llvm_unreachable(
"unexpected literal operator lookup result");
3796 if (Literal.isFixedPointLiteral()) {
3799 if (Literal.isAccum) {
3800 if (Literal.isHalf) {
3802 }
else if (Literal.isLong) {
3807 }
else if (Literal.isFract) {
3808 if (Literal.isHalf) {
3810 }
else if (Literal.isLong) {
3819 bool isSigned = !Literal.isUnsigned;
3823 llvm::APInt Val(bit_width, 0, isSigned);
3824 bool Overflowed = Literal.GetFixedPointValue(Val, scale);
3825 bool ValIsZero = Val.isZero() && !Overflowed;
3828 if (Literal.isFract && Val == MaxVal + 1 && !ValIsZero)
3834 else if (Val.ugt(MaxVal) || Overflowed)
3839 }
else if (Literal.isFloatingLiteral()) {
3841 if (Literal.isHalf){
3849 }
else if (Literal.isFloat)
3851 else if (Literal.isLong)
3853 else if (Literal.isFloat16)
3855 else if (Literal.isFloat128)
3877 }
else if (!Literal.isIntegerLiteral()) {
3883 if (Literal.isSizeT)
3886 ? diag::warn_cxx20_compat_size_t_suffix
3887 : diag::ext_cxx23_size_t_suffix
3888 : diag::err_cxx23_size_t_suffix);
3895 if (Literal.isBitInt)
3899 : diag::ext_c23_bitint_suffix);
3908 unsigned BitsNeeded =
3909 Literal.isBitInt ? llvm::APInt::getSufficientBitsNeeded(
3910 Literal.getLiteralDigits(), Literal.getRadix())
3912 llvm::APInt ResultVal(BitsNeeded, 0);
3914 if (Literal.GetIntegerValue(ResultVal)) {
3920 "long long is not intmax_t?");
3927 bool AllowUnsigned = Literal.isUnsigned || Literal.getRadix() != 10;
3934 Literal.isLong =
true;
3935 Literal.isLongLong =
false;
3942 if (Literal.MicrosoftInteger) {
3943 if (Literal.MicrosoftInteger == 8 && !Literal.isUnsigned) {
3947 Width = Literal.MicrosoftInteger;
3949 !Literal.isUnsigned);
3955 if (Literal.isBitInt) {
3958 Width = std::max(ResultVal.getActiveBits(), 1u) +
3959 (Literal.isUnsigned ? 0u : 1u);
3963 unsigned int MaxBitIntWidth =
3965 if (Width > MaxBitIntWidth) {
3967 << Literal.isUnsigned;
3968 Width = MaxBitIntWidth;
3975 ResultVal = ResultVal.zextOrTrunc(Width);
3980 if (Literal.isSizeT) {
3981 assert(!Literal.MicrosoftInteger &&
3982 "size_t literals can't be Microsoft literals");
3987 if (ResultVal.isIntN(SizeTSize)) {
3989 if (!Literal.isUnsigned && ResultVal[SizeTSize - 1] == 0)
3991 else if (AllowUnsigned)
3997 if (Ty.
isNull() && !Literal.isLong && !Literal.isLongLong &&
4003 if (ResultVal.isIntN(IntSize)) {
4005 if (!Literal.isUnsigned && ResultVal[IntSize-1] == 0)
4007 else if (AllowUnsigned)
4014 if (Ty.
isNull() && !Literal.isLongLong && !Literal.isSizeT) {
4018 if (ResultVal.isIntN(LongSize)) {
4020 if (!Literal.isUnsigned && ResultVal[LongSize-1] == 0)
4022 else if (AllowUnsigned)
4027 const unsigned LongLongSize =
4032 ? diag::warn_old_implicitly_unsigned_long_cxx
4034 ext_old_implicitly_unsigned_long_cxx
4035 : diag::warn_old_implicitly_unsigned_long)
4036 << (LongLongSize > LongSize ? 0
4045 if (Ty.
isNull() && !Literal.isSizeT) {
4049 if (ResultVal.isIntN(LongLongSize)) {
4053 if (!Literal.isUnsigned && (ResultVal[LongLongSize-1] == 0 ||
4054 (
getLangOpts().MSVCCompat && Literal.isLongLong)))
4056 else if (AllowUnsigned)
4058 Width = LongLongSize;
4064 ? diag::warn_cxx98_compat_longlong
4065 : diag::ext_cxx11_longlong);
4075 if (Literal.isSizeT)
4077 << Literal.isUnsigned;
4080 diag::ext_integer_literal_too_large_for_signed);
4085 if (ResultVal.getBitWidth() != Width)
4086 ResultVal = ResultVal.trunc(Width);
4092 if (Literal.isImaginary) {
4099 DiagId = diag::ext_gnu_imaginary_constant;
4101 DiagId = diag::warn_c23_compat_imaginary_constant;
4103 DiagId = diag::ext_c2y_imaginary_constant;
4110 assert(
E &&
"ActOnParenExpr() missing expr");
4126 S.
Diag(
Loc, diag::err_vecstep_non_scalar_vector_type)
4132 "Scalar types should always be complete");
4141 return S.
Diag(
Loc, diag::err_builtin_non_vector_type)
4143 <<
"__builtin_vectorelements" <<
T << ArgRange;
4156 S.
Diag(
Loc, diag::err_ptrauth_type_disc_undiscriminated) <<
T << ArgRange;
4173 (TraitKind == UETT_SizeOf || TraitKind == UETT_AlignOf ||
4174 TraitKind == UETT_PreferredAlignOf)) {
4176 S.
Diag(
Loc, diag::ext_sizeof_alignof_function_type)
4184 unsigned DiagID = S.
LangOpts.OpenCL ? diag::err_opencl_sizeof_alignof_type
4185 : diag::ext_sizeof_alignof_void_type;
4200 S.
Diag(
Loc, diag::err_sizeof_nonfragile_interface)
4201 <<
T << (TraitKind == UETT_SizeOf)
4218 const auto *ICE = dyn_cast<ImplicitCastExpr>(
E);
4219 if (!ICE || ICE->getCastKind() != CK_ArrayToPointerDecay)
4222 S.
Diag(
Loc, diag::warn_sizeof_array_decay) << ICE->getSourceRange()
4224 << ICE->getSubExpr()->getType();
4232 bool IsUnevaluatedOperand =
4233 (ExprKind == UETT_SizeOf || ExprKind == UETT_DataSizeOf ||
4234 ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf ||
4235 ExprKind == UETT_VecStep);
4236 if (IsUnevaluatedOperand) {
4254 if (ExprKind == UETT_VecStep)
4258 if (ExprKind == UETT_VectorElements)
4280 if (ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf) {
4283 diag::err_sizeof_alignof_incomplete_or_sizeless_type,
4288 E, diag::err_sizeof_alignof_incomplete_or_sizeless_type,
4307 if (ExprKind == UETT_SizeOf) {
4308 if (
const auto *DeclRef = dyn_cast<DeclRefExpr>(
E->
IgnoreParens())) {
4309 if (
const auto *PVD = dyn_cast<ParmVarDecl>(DeclRef->getFoundDecl())) {
4310 QualType OType = PVD->getOriginalType();
4315 Diag(PVD->getLocation(), diag::note_declared_at);
4323 if (
const auto *BO = dyn_cast<BinaryOperator>(
E->
IgnoreParens())) {
4347 if (
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Inner)) {
4349 }
else if (
MemberExpr *ME = dyn_cast<MemberExpr>(Inner)) {
4350 D = ME->getMemberDecl();
4370 if (
FieldDecl *FD = dyn_cast_or_null<FieldDecl>(
D)) {
4373 if (!FD->getParent()->isCompleteDefinition()) {
4383 if (!FD->getType()->isReferenceType())
4403 assert(CSI !=
nullptr);
4407 const Type *Ty =
T.getTypePtr();
4409#define TYPE(Class, Base)
4410#define ABSTRACT_TYPE(Class, Base)
4411#define NON_CANONICAL_TYPE(Class, Base)
4412#define DEPENDENT_TYPE(Class, Base) case Type::Class:
4413#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base)
4414#include "clang/AST/TypeNodes.inc"
4421 case Type::ExtVector:
4422 case Type::ConstantMatrix:
4425 case Type::TemplateSpecialization:
4426 case Type::ObjCObject:
4427 case Type::ObjCInterface:
4428 case Type::ObjCObjectPointer:
4429 case Type::ObjCTypeParam:
4432 llvm_unreachable(
"type class is never variably-modified!");
4433 case Type::Elaborated:
4434 T = cast<ElaboratedType>(Ty)->getNamedType();
4436 case Type::Adjusted:
4437 T = cast<AdjustedType>(Ty)->getOriginalType();
4442 case Type::ArrayParameter:
4443 T = cast<ArrayParameterType>(Ty)->getElementType();
4448 case Type::BlockPointer:
4451 case Type::LValueReference:
4452 case Type::RValueReference:
4455 case Type::MemberPointer:
4458 case Type::ConstantArray:
4459 case Type::IncompleteArray:
4461 T = cast<ArrayType>(Ty)->getElementType();
4463 case Type::VariableArray: {
4471 (isa<CapturedRegionScopeInfo>(CSI) || isa<LambdaScopeInfo>(CSI)))
4477 case Type::FunctionProto:
4478 case Type::FunctionNoProto:
4483 case Type::UnaryTransform:
4484 case Type::Attributed:
4485 case Type::BTFTagAttributed:
4486 case Type::HLSLAttributedResource:
4487 case Type::SubstTemplateTypeParm:
4488 case Type::MacroQualified:
4489 case Type::CountAttributed:
4491 T =
T.getSingleStepDesugaredType(Context);
4494 T = cast<TypedefType>(Ty)->
desugar();
4496 case Type::Decltype:
4497 T = cast<DecltypeType>(Ty)->
desugar();
4499 case Type::PackIndexing:
4500 T = cast<PackIndexingType>(Ty)->
desugar();
4503 T = cast<UsingType>(Ty)->
desugar();
4506 case Type::DeducedTemplateSpecialization:
4507 T = cast<DeducedType>(Ty)->getDeducedType();
4509 case Type::TypeOfExpr:
4510 T = cast<TypeOfExprType>(Ty)->getUnderlyingExpr()->getType();
4513 T = cast<AtomicType>(Ty)->getValueType();
4539 if (ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf ||
4540 ExprKind == UETT_OpenMPRequiredSimdAlign) {
4546 ? diag::warn_c2y_compat_alignof_incomplete_array
4547 : diag::ext_c2y_alignof_incomplete_array);
4551 if (ExprKind == UETT_VecStep)
4554 if (ExprKind == UETT_VectorElements)
4558 if (ExprKind == UETT_PtrAuthTypeDiscriminator)
4568 OpLoc, ExprType, diag::err_sizeof_alignof_incomplete_or_sizeless_type,
4573 Diag(OpLoc, diag::err_sizeof_alignof_function_type) << KWName << ExprRange;
4581 Diag(OpLoc, diag::err_wasm_table_invalid_uett_operand)
4595 auto *CSI = dyn_cast<CapturingScopeInfo>(*I);
4599 if (
auto *LSI = dyn_cast<LambdaScopeInfo>(CSI))
4600 DC = LSI->CallOperator;
4601 else if (
auto *CRSI = dyn_cast<CapturedRegionScopeInfo>(CSI))
4602 DC = CRSI->TheCapturedDecl;
4603 else if (
auto *BSI = dyn_cast<BlockScopeInfo>(CSI))
4656 }
else if (ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf) {
4658 }
else if (ExprKind == UETT_VecStep) {
4660 }
else if (ExprKind == UETT_OpenMPRequiredSimdAlign) {
4666 }
else if (ExprKind == UETT_VectorElements) {
4709 UETT_AlignOf, KWName);
4722 if (
V.get()->isTypeDependent())
4734 return CT->getElementType();
4737 if (
V.get()->getType()->isArithmeticType())
4738 return V.get()->getType();
4743 if (PR.
get() !=
V.get()) {
4749 S.
Diag(
Loc, diag::err_realimag_invalid_type) <<
V.get()->getType()
4750 << (IsReal ?
"__real" :
"__imag");
4761 default: llvm_unreachable(
"Unknown unary op!");
4762 case tok::plusplus: Opc = UO_PostInc;
break;
4763 case tok::minusminus: Opc = UO_PostDec;
break;
4782 !S.
LangOpts.ObjCSubscriptingLegacyRuntime)
4785 S.
Diag(opLoc, diag::err_arithmetic_nonfragile_interface)
4792 auto *BaseNoParens =
Base->IgnoreParens();
4793 if (
auto *MSProp = dyn_cast<MSPropertyRefExpr>(BaseNoParens))
4794 return MSProp->getPropertyDecl()->getType()->isArrayType();
4795 return isa<MSPropertySubscriptExpr>(BaseNoParens);
4815 if (RTy->isIntegralOrUnscopedEnumerationType()) {
4817 Result = PT->getPointeeType();
4819 Result = AT->getElementType();
4822 Result = PT->getPointeeType();
4824 Result = AT->getElementType();
4837 auto *AS = cast<ArraySectionExpr>(base);
4838 if (AS->isOMPArraySection())
4850 if (isa<ParenListExpr>(base)) {
4854 base = result.
get();
4861 auto CheckAndReportCommaError = [
this, base, rbLoc](
Expr *
E) {
4862 if (isa<BinaryOperator>(
E) && cast<BinaryOperator>(
E)->isCommaOp()) {
4873 !isa<MatrixSubscriptExpr>(base)) {
4874 Diag(base->
getExprLoc(), diag::err_matrix_separate_incomplete_index)
4880 auto *matSubscriptE = dyn_cast<MatrixSubscriptExpr>(base);
4881 if (matSubscriptE) {
4882 assert(ArgExprs.size() == 1);
4883 if (CheckAndReportCommaError(ArgExprs.front()))
4886 assert(matSubscriptE->isIncomplete() &&
4887 "base has to be an incomplete matrix subscript");
4889 matSubscriptE->getRowIdx(),
4890 ArgExprs.front(), rbLoc);
4898 CheckInvalidBuiltinCountedByRef(base, ArraySubscriptKind);
4905 bool IsMSPropertySubscript =
false;
4908 if (!IsMSPropertySubscript) {
4912 base = result.
get();
4918 assert(ArgExprs.size() == 1);
4919 if (CheckAndReportCommaError(ArgExprs.front()))
4927 Expr *idx = ArgExprs[0];
4928 if ((isa<BinaryOperator>(idx) && cast<BinaryOperator>(idx)->isCommaOp()) ||
4929 (isa<CXXOperatorCallExpr>(idx) &&
4930 cast<CXXOperatorCallExpr>(idx)->getOperator() == OO_Comma)) {
4936 if (ArgExprs.size() == 1 &&
4937 ArgExprs[0]->getType()->isNonOverloadPlaceholderType()) {
4941 ArgExprs[0] = result.
get();
4951 !isa<PackExpansionExpr>(ArgExprs[0])) {
4953 base, ArgExprs.front(),
4966 if (IsMSPropertySubscript) {
4967 assert(ArgExprs.size() == 1);
4985 (ArgExprs.size() != 1 || isa<PackExpansionExpr>(ArgExprs[0]) ||
4986 ArgExprs[0]->getType()->isRecordType())))) {
4993 if (!Res.
isInvalid() && isa<ArraySubscriptExpr>(Res.
get()))
4994 CheckSubscriptAccessOfNoDeref(cast<ArraySubscriptExpr>(Res.
get()));
5004 return InitSeq.
Perform(*
this, Entity, Kind,
E);
5018 RowIdx = RowR.
get();
5033 ColumnIdx = ColumnR.
get();
5038 auto IsIndexValid = [&](
Expr *IndexExpr,
unsigned Dim,
5039 bool IsColumnIdx) ->
Expr * {
5047 if (std::optional<llvm::APSInt> Idx =
5049 if ((*Idx < 0 || *Idx >=
Dim)) {
5051 << IsColumnIdx <<
Dim;
5058 "should be able to convert any integer type to size type");
5059 return ConvExpr.
get();
5063 RowIdx = IsIndexValid(RowIdx, MTy->getNumRows(),
false);
5064 ColumnIdx = IsIndexValid(ColumnIdx, MTy->getNumColumns(),
true);
5065 if (!RowIdx || !ColumnIdx)
5069 MTy->getElementType(), RBLoc);
5072void Sema::CheckAddressOfNoDeref(
const Expr *
E) {
5079 while ((
Member = dyn_cast<MemberExpr>(StrippedExpr)) && !
Member->isArrow())
5080 StrippedExpr =
Member->getBase()->IgnoreParenImpCasts();
5082 LastRecord.PossibleDerefs.erase(StrippedExpr);
5093 if (isa<ArrayType>(ResultTy))
5096 if (ResultTy->
hasAttr(attr::NoDeref)) {
5097 LastRecord.PossibleDerefs.insert(
E);
5105 if (!(isa<ArrayType>(BaseTy) || isa<PointerType>(BaseTy)))
5110 while ((
Member = dyn_cast<MemberExpr>(
Base->IgnoreParenCasts())) &&
5114 if (
const auto *Ptr = dyn_cast<PointerType>(
Base->getType())) {
5115 if (Ptr->getPointeeType()->hasAttr(attr::NoDeref))
5116 LastRecord.PossibleDerefs.insert(
E);
5132 for (
auto *Op : {LHSExp, RHSExp}) {
5133 Op = Op->IgnoreImplicit();
5134 if (Op->getType()->isArrayType() && !Op->isLValue())
5157 Expr *BaseExpr, *IndexExpr;
5192 Diag(LLoc, diag::err_subscript_nonfragile_interface)
5216 LHSExp = Materialized.
get();
5225 Qualifiers Combined = BaseQuals + MemberQuals;
5226 if (Combined != MemberQuals)
5237 CK_ArrayToPointerDecay).
get();
5243 }
else if (RHSTy->isArrayType()) {
5248 CK_ArrayToPointerDecay).
get();
5255 return ExprError(
Diag(LLoc, diag::err_typecheck_subscript_value)
5260 return ExprError(
Diag(LLoc, diag::err_typecheck_subscript_not_integer)
5266 std::optional<llvm::APSInt> IntegerContantExpr =
5268 if (!IntegerContantExpr.has_value() ||
5269 IntegerContantExpr.value().isNegative())
5285 Diag(LLoc, diag::ext_gnu_subscript_void_type)
5296 diag::err_subscript_incomplete_or_sizeless_type, BaseExpr))
5309 auto *CSI = dyn_cast<CapturingScopeInfo>(*I);
5313 if (
auto *LSI = dyn_cast<LambdaScopeInfo>(CSI))
5314 DC = LSI->CallOperator;
5315 else if (
auto *CRSI = dyn_cast<CapturedRegionScopeInfo>(CSI))
5316 DC = CRSI->TheCapturedDecl;
5317 else if (
auto *BSI = dyn_cast<BlockScopeInfo>(CSI))
5335 bool SkipImmediateInvocations) {
5337 assert(!RewrittenInit &&
"Should not have a rewritten init expression yet");
5341 Diag(Param->
getBeginLoc(), diag::err_recursive_default_argument) << FD;
5342 Diag(CallLoc, diag::note_recursive_default_argument_used_here);
5347 Diag(CallLoc, diag::err_use_of_default_argument_to_function_declared_later)
5350 diag::note_default_argument_declared_here);
5355 assert(!RewrittenInit &&
"Should not have a rewitten init expression yet");
5361 assert(
Init &&
"default argument but no initializer?");
5370 if (
auto *InitWithCleanup = dyn_cast<ExprWithCleanups>(
Init)) {
5377 assert(!InitWithCleanup->getNumObjects() &&
5378 "default argument expression has capturing blocks?");
5391 SkipImmediateInvocations;
5401 ShouldVisitImplicitCode =
true;
5404 bool HasImmediateCalls =
false;
5408 HasImmediateCalls |= FD->isImmediateFunction();
5414 HasImmediateCalls |= FD->isImmediateFunction();
5423 HasImmediateCalls =
true;
5434 return VisitCXXMethodDecl(
E->getCallOperator());
5438 return TraverseStmt(
E->getExpr());
5442 return TraverseStmt(
E->getExpr());
5468 if (DC == SemaRef.CurContext)
5479 if (!SemaRef.CurrentInstantiationScope ||
5481 DC = SemaRef.CurContext;
5483 return getDerived().RebuildSourceLocExpr(
5491 assert(Param->
hasDefaultArg() &&
"can't build nonexistent default arg");
5495 std::optional<ExpressionEvaluationContextRecord::InitializationContext>
5496 InitializationContext =
5498 if (!InitializationContext.has_value())
5499 InitializationContext.emplace(CallLoc, Param,
CurContext);
5525 if (!NestedDefaultChecking)
5526 V.TraverseDecl(Param);
5530 if (
V.HasImmediateCalls ||
5531 (NeedRebuild && isa_and_present<ExprWithCleanups>(Param->
getInit()))) {
5532 if (
V.HasImmediateCalls)
5542 Res = Immediate.TransformInitializer(Param->
getInit(),
5556 CallLoc, FD, Param,
Init,
5557 NestedDefaultChecking))
5561 Init, InitializationContext->Context);
5568 auto *ParentRD = cast<CXXRecordDecl>(Field->getParent());
5571 ClassPattern->
lookup(Field->getDeclName());
5572 auto Rng = llvm::make_filter_range(
5573 Lookup, [](
auto &&L) {
return isa<FieldDecl>(*L); });
5579 return cast<FieldDecl>(*Rng.begin());
5583 assert(Field->hasInClassInitializer());
5587 auto *ParentRD = cast<CXXRecordDecl>(Field->getParent());
5589 std::optional<ExpressionEvaluationContextRecord::InitializationContext>
5590 InitializationContext =
5592 if (!InitializationContext.has_value())
5602 if (!Field->getInClassInitializer()) {
5608 assert(Pattern &&
"We must have set the Pattern!");
5612 Field->setInvalidDecl();
5624 if (!NestedDefaultChecking)
5625 V.TraverseDecl(Field);
5634 bool ContainsAnyTemporaries =
5635 isa_and_present<ExprWithCleanups>(Field->getInClassInitializer());
5636 if (Field->getInClassInitializer() &&
5637 !Field->getInClassInitializer()->containsErrors() &&
5638 (
V.HasImmediateCalls || (NeedRebuild && ContainsAnyTemporaries))) {
5642 NestedDefaultChecking;
5650 Res = Immediate.TransformInitializer(Field->getInClassInitializer(),
5656 Field->setInvalidDecl();
5662 if (Field->getInClassInitializer()) {
5664 if (!NestedDefaultChecking)
5675 Field->setInvalidDecl();
5681 Field, InitializationContext->Context,
5700 Diag(
Loc, diag::err_default_member_initializer_not_yet_parsed)
5701 << OutermostClass << Field;
5702 Diag(Field->getEndLoc(),
5703 diag::note_default_member_initializer_not_yet_parsed);
5706 Field->setInvalidDecl();
5714 if (isa_and_nonnull<CXXConstructorDecl>(FDecl))
5716 else if (Fn && Fn->getType()->isBlockPointerType())
5719 if (
CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl))
5720 if (Method->isInstance())
5735 FunctionName(FuncName) {}
5737 bool ValidateCandidate(
const TypoCorrection &candidate)
override {
5746 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
5747 return std::make_unique<FunctionCallCCC>(*
this);
5767 if (
NamedDecl *ND = Corrected.getFoundDecl()) {
5768 if (Corrected.isOverloaded()) {
5778 ND = Best->FoundDecl;
5779 Corrected.setCorrectionDecl(ND);
5785 ND = ND->getUnderlyingDecl();
5786 if (isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND))
5797 if (!isa<ParenExpr>(Fn))
5800 Fn = Fn->IgnoreParens();
5802 auto *UO = dyn_cast<UnaryOperator>(Fn);
5803 if (!UO || UO->getOpcode() != clang::UO_AddrOf)
5805 if (
auto *DRE = dyn_cast<DeclRefExpr>(UO->getSubExpr()->IgnoreParens())) {
5806 return DRE->hasQualifier();
5808 if (
auto *OVL = dyn_cast<OverloadExpr>(UO->getSubExpr()->IgnoreParens()))
5809 return OVL->getQualifier();
5819 bool IsExecConfig) {
5830 bool HasExplicitObjectParameter =
5832 unsigned ExplicitObjectParameterOffset = HasExplicitObjectParameter ? 1 : 0;
5836 unsigned FnKind = Fn->getType()->isBlockPointerType()
5843 if (Args.size() < NumParams) {
5844 if (Args.size() < MinArgs) {
5849 ? diag::err_typecheck_call_too_few_args_suggest
5850 : diag::err_typecheck_call_too_few_args_at_least_suggest;
5853 << FnKind << MinArgs - ExplicitObjectParameterOffset
5854 <<
static_cast<unsigned>(Args.size()) -
5855 ExplicitObjectParameterOffset
5857 }
else if (MinArgs - ExplicitObjectParameterOffset == 1 && FDecl &&
5862 ? diag::err_typecheck_call_too_few_args_one
5863 : diag::err_typecheck_call_too_few_args_at_least_one)
5864 << FnKind << FDecl->
getParamDecl(ExplicitObjectParameterOffset)
5865 << HasExplicitObjectParameter << Fn->getSourceRange();
5868 ? diag::err_typecheck_call_too_few_args
5869 : diag::err_typecheck_call_too_few_args_at_least)
5870 << FnKind << MinArgs - ExplicitObjectParameterOffset
5871 <<
static_cast<unsigned>(Args.size()) -
5872 ExplicitObjectParameterOffset
5873 << HasExplicitObjectParameter << Fn->getSourceRange();
5876 if (!TC && FDecl && !FDecl->
getBuiltinID() && !IsExecConfig)
5884 assert((
Call->getNumArgs() == NumParams) &&
5885 "We should have reserved space for the default arguments before!");
5890 if (Args.size() > NumParams) {
5896 ? diag::err_typecheck_call_too_many_args_suggest
5897 : diag::err_typecheck_call_too_many_args_at_most_suggest;
5900 << FnKind << NumParams - ExplicitObjectParameterOffset
5901 <<
static_cast<unsigned>(Args.size()) -
5902 ExplicitObjectParameterOffset
5904 }
else if (NumParams - ExplicitObjectParameterOffset == 1 && FDecl &&
5907 Diag(Args[NumParams]->getBeginLoc(),
5908 MinArgs == NumParams
5909 ? diag::err_typecheck_call_too_many_args_one
5910 : diag::err_typecheck_call_too_many_args_at_most_one)
5911 << FnKind << FDecl->
getParamDecl(ExplicitObjectParameterOffset)
5912 <<
static_cast<unsigned>(Args.size()) -
5913 ExplicitObjectParameterOffset
5914 << HasExplicitObjectParameter << Fn->getSourceRange()
5916 Args.back()->getEndLoc());
5918 Diag(Args[NumParams]->getBeginLoc(),
5919 MinArgs == NumParams
5920 ? diag::err_typecheck_call_too_many_args
5921 : diag::err_typecheck_call_too_many_args_at_most)
5922 << FnKind << NumParams - ExplicitObjectParameterOffset
5923 <<
static_cast<unsigned>(Args.size()) -
5924 ExplicitObjectParameterOffset
5925 << HasExplicitObjectParameter << Fn->getSourceRange()
5927 Args.back()->getEndLoc());
5930 if (!TC && FDecl && !FDecl->
getBuiltinID() && !IsExecConfig)
5935 Call->shrinkNumArgs(NumParams);
5946 unsigned TotalNumArgs = AllArgs.size();
5947 for (
unsigned i = 0; i < TotalNumArgs; ++i)
5948 Call->setArg(i, AllArgs[i]);
5950 Call->computeDependence();
5959 bool IsListInitialization) {
5964 for (
unsigned i = FirstParam; i < NumParams; i++) {
5969 if (ArgIx < Args.size()) {
5970 Arg = Args[ArgIx++];
5973 diag::err_call_incomplete_argument, Arg))
5977 bool CFAudited =
false;
5979 FDecl && FDecl->
hasAttr<CFAuditedTransferAttr>() &&
5980 (!Param || !Param->
hasAttr<CFConsumedAttr>()))
5983 FDecl && FDecl->
hasAttr<CFAuditedTransferAttr>() &&
5984 (!Param || !Param->
hasAttr<CFConsumedAttr>()))
5990 BE->getBlockDecl()->setDoesNotEscape();
6010 Entity,
SourceLocation(), Arg, IsListInitialization, AllowExplicit);
6016 assert(Param &&
"can't use default arguments without a known callee");
6028 CheckArrayAccess(Arg);
6033 AllArgs.push_back(Arg);
6042 for (
Expr *A : Args.slice(ArgIx)) {
6046 AllArgs.push_back(arg.get());
6051 for (
Expr *A : Args.slice(ArgIx)) {
6054 AllArgs.push_back(Arg.
get());
6059 for (
Expr *A : Args.slice(ArgIx))
6060 CheckArrayAccess(A);
6068 TL = DTL.getOriginalLoc();
6071 << ATL.getLocalSourceRange();
6077 const Expr *ArgExpr) {
6107 Diag(CallLoc, diag::warn_static_array_too_small)
6115 std::optional<CharUnits> ArgSize =
6117 std::optional<CharUnits> ParmSize =
6119 if (ArgSize && ParmSize && *ArgSize < *ParmSize) {
6120 Diag(CallLoc, diag::warn_static_array_too_small)
6122 << (
unsigned)ParmSize->getQuantity() << 1;
6136 if (!placeholder)
return false;
6138 switch (placeholder->
getKind()) {
6140#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
6141 case BuiltinType::Id:
6142#include "clang/Basic/OpenCLImageTypes.def"
6143#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
6144 case BuiltinType::Id:
6145#include "clang/Basic/OpenCLExtensionTypes.def"
6148#define SVE_TYPE(Name, Id, SingletonId) \
6149 case BuiltinType::Id:
6150#include "clang/Basic/AArch64SVEACLETypes.def"
6151#define PPC_VECTOR_TYPE(Name, Id, Size) \
6152 case BuiltinType::Id:
6153#include "clang/Basic/PPCTypes.def"
6154#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
6155#include "clang/Basic/RISCVVTypes.def"
6156#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
6157#include "clang/Basic/WebAssemblyReferenceTypes.def"
6158#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) case BuiltinType::Id:
6159#include "clang/Basic/AMDGPUTypes.def"
6160#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
6161#include "clang/Basic/HLSLIntangibleTypes.def"
6162#define PLACEHOLDER_TYPE(ID, SINGLETON_ID)
6163#define BUILTIN_TYPE(ID, SINGLETON_ID) case BuiltinType::ID:
6164#include "clang/AST/BuiltinTypes.def"
6167 case BuiltinType::UnresolvedTemplate:
6170 case BuiltinType::Overload:
6175 case BuiltinType::ARCUnbridgedCast:
6179 case BuiltinType::PseudoObject:
6184 case BuiltinType::UnknownAny:
6188 case BuiltinType::BoundMember:
6189 case BuiltinType::BuiltinFn:
6190 case BuiltinType::IncompleteMatrixIdx:
6191 case BuiltinType::ArraySection:
6192 case BuiltinType::OMPArrayShaping:
6193 case BuiltinType::OMPIterator:
6197 llvm_unreachable(
"bad builtin type kind");
6203 bool hasInvalid =
false;
6204 for (
size_t i = 0, e = args.size(); i != e; i++) {
6207 if (result.
isInvalid()) hasInvalid =
true;
6208 else args[i] = result.
get();
6236 bool NeedsNewDecl =
false;
6249 if (!ParamType->isPointerType() || ParamType.hasAddressSpace() ||
6253 OverloadParams.push_back(ParamType);
6261 NeedsNewDecl =
true;
6274 OverloadParams, EPI);
6283 FT = cast<FunctionProtoType>(OverloadTy);
6284 for (
unsigned i = 0, e = FT->
getNumParams(); i != e; ++i) {
6291 Params.push_back(Parm);
6293 OverloadDecl->setParams(Params);
6295 return OverloadDecl;
6306 !Callee->isVariadic())
6308 if (Callee->getMinRequiredArguments() > ArgExprs.size())
6311 if (
const EnableIfAttr *
Attr =
6312 S.
CheckEnableIf(Callee, Fn->getBeginLoc(), ArgExprs,
true)) {
6313 S.
Diag(Fn->getBeginLoc(),
6314 isa<CXXMethodDecl>(Callee)
6315 ? diag::err_ovl_no_viable_member_function_in_call
6316 : diag::err_ovl_no_viable_function_in_call)
6317 << Callee << Callee->getSourceRange();
6318 S.
Diag(Callee->getLocation(),
6319 diag::note_ovl_candidate_disabled_by_function_cond_attr)
6320 <<
Attr->getCond()->getSourceRange() <<
Attr->getMessage();
6328 const auto GetFunctionLevelDCIfCXXClass =
6336 if (
const auto *MD = dyn_cast<CXXMethodDecl>(DC))
6337 return MD->
getParent()->getCanonicalDecl();
6340 if (
const auto *RD = dyn_cast<CXXRecordDecl>(DC))
6341 return RD->getCanonicalDecl();
6348 const CXXRecordDecl *
const CurParentClass = GetFunctionLevelDCIfCXXClass(S);
6349 if (!CurParentClass)
6356 assert(NamingClass &&
"Must have naming class even for implicit access");
6362 return CurParentClass == NamingClass ||
6411 if (
Call->getNumArgs() != 1)
6414 const Expr *
E =
Call->getCallee()->IgnoreParenImpCasts();
6415 if (!
E || isa<UnresolvedLookupExpr>(
E))
6417 const DeclRefExpr *DRE = dyn_cast_if_present<DeclRefExpr>(
E);
6430 if (BuiltinID != Builtin::BImove && BuiltinID != Builtin::BIforward)
6433 S.
Diag(DRE->
getLocation(), diag::warn_unqualified_call_to_std_cast_function)
6444 if (
Call.isInvalid())
6449 if (
const auto *ULE = dyn_cast<UnresolvedLookupExpr>(Fn);
6450 ULE && ULE->hasExplicitTemplateArgs() &&
6451 ULE->decls_begin() == ULE->decls_end()) {
6453 ? diag::warn_cxx17_compat_adl_only_template_id
6454 : diag::ext_adl_only_template_id)
6462 if (
const auto *CE = dyn_cast<CallExpr>(
Call.get()))
6468 if (
auto *DRE = dyn_cast<DeclRefExpr>(Fn->IgnoreParens());
6469 DRE &&
Call.get()->isValueDependent()) {
6478 Expr *ExecConfig,
bool IsExecConfig,
6479 bool AllowRecovery) {
6490 for (
const Expr *Arg : ArgExprs)
6491 if (CheckInvalidBuiltinCountedByRef(Arg, FunctionArgKind))
6496 if (isa<CXXPseudoDestructorExpr>(Fn)) {
6497 if (!ArgExprs.empty()) {
6499 Diag(Fn->getBeginLoc(), diag::err_pseudo_dtor_call_with_args)
6502 ArgExprs.back()->getEndLoc()));
6519 cast<CallExpr>(ExecConfig), ArgExprs,
6525 *
this, dyn_cast<UnresolvedMemberExpr>(Fn->IgnoreParens()),
6534 if (Fn->getType()->isRecordType())
6546 RParenLoc, ExecConfig, IsExecConfig,
6563 Scope, Fn, ULE, LParenLoc, ArgExprs, RParenLoc, ExecConfig,
6566 RParenLoc, ExecConfig, IsExecConfig,
6578 Expr *NakedFn = Fn->IgnoreParens();
6580 bool CallingNDeclIndirectly =
false;
6582 if (
UnaryOperator *UnOp = dyn_cast<UnaryOperator>(NakedFn)) {
6583 if (UnOp->getOpcode() == UO_AddrOf) {
6584 CallingNDeclIndirectly =
true;
6589 if (
auto *DRE = dyn_cast<DeclRefExpr>(NakedFn)) {
6590 NDecl = DRE->getDecl();
6603 nullptr, DRE->isNonOdrUse());
6606 }
else if (
auto *ME = dyn_cast<MemberExpr>(NakedFn))
6607 NDecl = ME->getMemberDecl();
6609 if (
FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(NDecl)) {
6611 FD,
true, Fn->getBeginLoc()))
6623 FD->getBuiltinID()) {
6624 for (
unsigned Idx = 0; Idx < ArgExprs.size() && Idx < FD->param_size();
6628 !ArgExprs[Idx]->getType()->isPointerType())
6632 auto ArgTy = ArgExprs[Idx]->getType();
6633 auto ArgPtTy = ArgTy->getPointeeType();
6634 auto ArgAS = ArgPtTy.getAddressSpace();
6637 bool NeedImplicitASC =
6642 if (!NeedImplicitASC)
6646 if (ArgExprs[Idx]->isGLValue()) {
6648 Context, ArgExprs[Idx]->getType(), CK_NoOp, ArgExprs[Idx],
6653 Qualifiers ArgPtQuals = ArgPtTy.getQualifiers();
6663 CK_AddressSpaceConversion)
6672 assert((Fn->containsErrors() ||
6673 llvm::any_of(ArgExprs,
6674 [](
clang::Expr *
E) { return E->containsErrors(); })) &&
6675 "should only occur in error-recovery path.");
6680 ExecConfig, IsExecConfig);
6691 assert(BuiltInDecl &&
"failed to find builtin declaration");
6695 assert(DeclRef.
isUsable() &&
"Builtin reference cannot fail");
6700 assert(!
Call.isInvalid() &&
"Call to builtin cannot fail!");
6720 Diag(BuiltinLoc, diag::err_invalid_astype_of_different_size)
6738 FunctionDecl *FDecl = dyn_cast_or_null<FunctionDecl>(NDecl);
6739 unsigned BuiltinID = (FDecl ? FDecl->
getBuiltinID() : 0);
6743 if (FDecl->
hasAttr<AnyX86InterruptAttr>()) {
6744 Diag(Fn->getExprLoc(), diag::err_anyx86_interrupt_called);
6747 if (FDecl->
hasAttr<ARMInterruptAttr>()) {
6748 Diag(Fn->getExprLoc(), diag::err_arm_interrupt_called);
6757 if (Caller->hasAttr<AnyX86InterruptAttr>() ||
6758 Caller->hasAttr<AnyX86NoCallerSavedRegistersAttr>()) {
6760 bool HasNonGPRRegisters =
6762 if (HasNonGPRRegisters &&
6763 (!FDecl || !FDecl->
hasAttr<AnyX86NoCallerSavedRegistersAttr>())) {
6764 Diag(Fn->getExprLoc(), diag::warn_anyx86_excessive_regsave)
6765 << (Caller->hasAttr<AnyX86InterruptAttr>() ? 0 : 1);
6778 Fn->getType()->isSpecificBuiltinType(BuiltinType::BuiltinFn)) {
6805 return ExprError(
Diag(LParenLoc, diag::err_typecheck_call_not_function)
6806 << Fn->getType() << Fn->getSourceRange());
6820 return ExprError(
Diag(LParenLoc, diag::err_typecheck_call_not_function)
6821 << Fn->getType() << Fn->getSourceRange());
6828 const auto *Proto = dyn_cast_or_null<FunctionProtoType>(FuncT);
6829 unsigned NumParams = Proto ? Proto->getNumParams() : 0;
6833 assert(UsesADL == ADLCallKind::NotADL &&
6834 "CUDAKernelCallExpr should not use ADL");
6855 TheCall = dyn_cast<CallExpr>(
Result.get());
6856 bool CorrectedTypos = TheCall != TheOldCall;
6857 if (!TheCall)
return Result;
6864 if (CorrectedTypos && Args.size() < NumParams) {
6880 ExprResult E = CheckBuiltinFunctionCall(FDecl, BuiltinID, TheCall);
6889 if (FDecl && !FDecl->
hasAttr<CUDAGlobalAttr>())
6890 return ExprError(
Diag(LParenLoc,diag::err_kern_call_not_global_function)
6891 << FDecl << Fn->getSourceRange());
6897 return ExprError(
Diag(LParenLoc, diag::err_kern_type_not_void_return)
6898 << Fn->getType() << Fn->getSourceRange());
6901 if (FDecl && FDecl->
hasAttr<CUDAGlobalAttr>())
6902 return ExprError(
Diag(LParenLoc, diag::err_global_call_not_config)
6903 << FDecl << Fn->getSourceRange());
6918 for (
const Expr *Arg : Args) {
6919 if (Arg && Arg->getType()->isWebAssemblyTableType()) {
6921 diag::err_wasm_table_as_function_parameter));
6931 assert(isa<FunctionNoProtoType>(FuncT) &&
"Unknown FunctionType!");
6939 if (!Proto || !(Proto->isVariadic() && Args.size() >= Def->
param_size()))
6940 Diag(RParenLoc, diag::warn_call_wrong_number_of_arguments)
6941 << (Args.size() > Def->
param_size()) << FDecl << Fn->getSourceRange();
6960 if (!Proto && !Args.empty() &&
6964 Diag(LParenLoc, diag::warn_strict_uses_without_prototype)
6965 << (FDecl !=
nullptr) << FDecl;
6968 for (
unsigned i = 0, e = Args.size(); i != e; i++) {
6969 Expr *Arg = Args[i];
6971 if (Proto && i < Proto->getNumParams()) {
6973 Context, Proto->getParamType(i), Proto->isParamConsumed(i));
6991 diag::err_call_incomplete_argument, Arg))
6999 if (
CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl))
7000 if (Method->isImplicitObjectMemberFunction())
7001 return ExprError(
Diag(LParenLoc, diag::err_member_call_without_object)
7002 << Fn->getSourceRange() << 0);
7010 for (
unsigned i = 0, e = Args.size(); i != e; i++) {
7011 if (
const auto *RT =
7012 dyn_cast<RecordType>(Args[i]->getType().getCanonicalType())) {
7013 if (RT->getDecl()->isOrContainsUnion())
7014 Diag(Args[i]->getBeginLoc(), diag::warn_cmse_nonsecure_union)
7025 checkFortifiedBuiltinMemoryFunction(FDecl, TheCall);
7028 return CheckBuiltinFunctionCall(FDecl, BuiltinID, TheCall);
7030 if (CheckPointerCall(NDecl, TheCall, Proto))
7033 if (CheckOtherCall(TheCall, Proto))
7043 assert(Ty &&
"ActOnCompoundLiteral(): missing type");
7044 assert(InitExpr &&
"ActOnCompoundLiteral(): missing expression");
7062 diag::err_array_incomplete_or_sizeless_type,
7085 ? diag::err_variable_object_no_init
7086 : diag::err_compound_literal_with_vla_type;
7093 diag::err_typecheck_decl_incomplete_type,
7108 LiteralExpr =
Result.get();
7136 if (
auto ILE = dyn_cast<InitListExpr>(LiteralExpr))
7137 for (
unsigned i = 0, j = ILE->getNumInits(); i != j; i++) {
7143 VK, LiteralExpr, isFileScope);
7155 Diag(LParenLoc, diag::err_compound_literal_with_address_space)
7191 bool DiagnosedArrayDesignator =
false;
7192 bool DiagnosedNestedDesignator =
false;
7193 bool DiagnosedMixedDesignator =
false;
7197 for (
unsigned I = 0,
E = InitArgList.size(); I !=
E; ++I) {
7198 if (
auto *DIE = dyn_cast<DesignatedInitExpr>(InitArgList[I])) {
7200 FirstDesignator = DIE->getBeginLoc();
7205 if (!DiagnosedNestedDesignator && DIE->size() > 1) {
7206 DiagnosedNestedDesignator =
true;
7207 Diag(DIE->getBeginLoc(), diag::ext_designated_init_nested)
7208 << DIE->getDesignatorsSourceRange();
7211 for (
auto &Desig : DIE->designators()) {
7212 if (!Desig.isFieldDesignator() && !DiagnosedArrayDesignator) {
7213 DiagnosedArrayDesignator =
true;
7214 Diag(Desig.getBeginLoc(), diag::ext_designated_init_array)
7215 << Desig.getSourceRange();
7219 if (!DiagnosedMixedDesignator &&
7220 !isa<DesignatedInitExpr>(InitArgList[0])) {
7221 DiagnosedMixedDesignator =
true;
7222 Diag(DIE->getBeginLoc(), diag::ext_designated_init_mixed)
7223 << DIE->getSourceRange();
7224 Diag(InitArgList[0]->getBeginLoc(), diag::note_designated_init_mixed)
7225 << InitArgList[0]->getSourceRange();
7228 isa<DesignatedInitExpr>(InitArgList[0])) {
7229 DiagnosedMixedDesignator =
true;
7230 auto *DIE = cast<DesignatedInitExpr>(InitArgList[0]);
7231 Diag(DIE->getBeginLoc(), diag::ext_designated_init_mixed)
7232 << DIE->getSourceRange();
7233 Diag(InitArgList[I]->getBeginLoc(), diag::note_designated_init_mixed)
7234 << InitArgList[I]->getSourceRange();
7238 if (FirstDesignator.
isValid()) {
7242 !DiagnosedNestedDesignator && !DiagnosedMixedDesignator) {
7244 ? diag::warn_cxx17_compat_designated_init
7245 : diag::ext_cxx_designated_init);
7247 Diag(FirstDesignator, diag::ext_designated_init);
7262 for (
unsigned I = 0,
E = InitArgList.size(); I !=
E; ++I) {
7263 if (InitArgList[I]->getType()->isNonOverloadPlaceholderType()) {
7270 InitArgList[I] = result.
get();
7304 llvm_unreachable(
"member pointer type in C");
7313 if (SrcAS != DestAS)
7314 return CK_AddressSpaceConversion;
7321 ? CK_BitCast : CK_AnyPointerToBlockPointerCast);
7326 return CK_CPointerToObjCPointerCast;
7328 return CK_BlockPointerToObjCPointerCast;
7330 return CK_PointerToBoolean;
7332 return CK_PointerToIntegral;
7338 llvm_unreachable(
"illegal cast from pointer");
7340 llvm_unreachable(
"Should have returned before this");
7345 return CK_FixedPointCast;
7347 return CK_FixedPointToBoolean;
7349 return CK_FixedPointToIntegral;
7351 return CK_FixedPointToFloating;
7355 diag::err_unimplemented_conversion_with_fixed_point_type)
7357 return CK_IntegralCast;
7362 llvm_unreachable(
"illegal cast to pointer type");
7364 llvm_unreachable(
"Should have returned before this");
7374 return CK_NullToPointer;
7375 return CK_IntegralToPointer;
7377 return CK_IntegralToBoolean;
7379 return CK_IntegralCast;
7381 return CK_IntegralToFloating;
7386 return CK_IntegralRealToComplex;
7390 CK_IntegralToFloating);
7391 return CK_FloatingRealToComplex;
7393 llvm_unreachable(
"member pointer type in C");
7395 return CK_IntegralToFixedPoint;
7397 llvm_unreachable(
"Should have returned before this");
7402 return CK_FloatingCast;
7404 return CK_FloatingToBoolean;
7406 return CK_FloatingToIntegral;
7411 return CK_FloatingRealToComplex;
7415 CK_FloatingToIntegral);
7416 return CK_IntegralRealToComplex;
7420 llvm_unreachable(
"valid float->pointer cast?");
7422 llvm_unreachable(
"member pointer type in C");
7424 return CK_FloatingToFixedPoint;
7426 llvm_unreachable(
"Should have returned before this");
7431 return CK_FloatingComplexCast;
7433 return CK_FloatingComplexToIntegralComplex;
7437 return CK_FloatingComplexToReal;
7439 return CK_FloatingCast;
7442 return CK_FloatingComplexToBoolean;
7446 CK_FloatingComplexToReal);
7447 return CK_FloatingToIntegral;
7451 llvm_unreachable(
"valid complex float->pointer cast?");
7453 llvm_unreachable(
"member pointer type in C");
7456 diag::err_unimplemented_conversion_with_fixed_point_type)
7458 return CK_IntegralCast;
7460 llvm_unreachable(
"Should have returned before this");
7465 return CK_IntegralComplexToFloatingComplex;
7467 return CK_IntegralComplexCast;
7471 return CK_IntegralComplexToReal;
7473 return CK_IntegralCast;
7476 return CK_IntegralComplexToBoolean;
7480 CK_IntegralComplexToReal);
7481 return CK_IntegralToFloating;
7485 llvm_unreachable(
"valid complex int->pointer cast?");
7487 llvm_unreachable(
"member pointer type in C");
7490 diag::err_unimplemented_conversion_with_fixed_point_type)
7492 return CK_IntegralCast;
7494 llvm_unreachable(
"Should have returned before this");
7497 llvm_unreachable(
"Unhandled scalar cast");
7504 len = vecType->getNumElements();
7505 eltType = vecType->getElementType();
7512 if (!
type->isRealType())
return false;
7522 auto ValidScalableConversion = [](
QualType FirstType,
QualType SecondType) {
7526 const auto *VecTy = SecondType->getAs<
VectorType>();
7530 return ValidScalableConversion(srcTy, destTy) ||
7531 ValidScalableConversion(destTy, srcTy);
7541 return matSrcType->
getNumRows() == matDestType->getNumRows() &&
7542 matSrcType->
getNumColumns() == matDestType->getNumColumns();
7548 uint64_t SrcLen, DestLen;
7561 return (SrcLen * SrcEltSize == DestLen * DestEltSize);
7566 "expected at least one type to be a vector here");
7568 bool IsSrcTyAltivec =
7584 return (IsSrcTyAltivec || IsDestTyAltivec);
7611 if (!Vec || !Vec->getElementType()->isIntegralOrEnumerationType())
7616 if (!Vec || !Vec->getElementType()->isIntegralOrEnumerationType())
7633 return Diag(R.
getBegin(), diag::err_invalid_conversion_between_matrixes)
7634 << DestTy << SrcTy << R;
7638 diag::err_invalid_conversion_between_matrix_and_type)
7639 << SrcTy << DestTy << R;
7642 diag::err_invalid_conversion_between_matrix_and_type)
7643 << DestTy << SrcTy << R;
7646 Kind = CK_MatrixCast;
7652 assert(VectorTy->
isVectorType() &&
"Not a vector type!");
7658 diag::err_invalid_conversion_between_vectors :
7659 diag::err_invalid_conversion_between_vector_and_integer)
7660 << VectorTy << Ty << R;
7663 diag::err_invalid_conversion_between_vector_and_scalar)
7664 << VectorTy << Ty << R;
7673 if (DestElemTy == SplattedExpr->
getType())
7674 return SplattedExpr;
7687 CK_BooleanToSignedIntegral);
7688 SplattedExpr = CastExprRes.
get();
7689 CK = CK_IntegralToFloating;
7691 CK = CK_BooleanToSignedIntegral;
7698 SplattedExpr = CastExprRes.
get();
7717 Diag(R.
getBegin(),diag::err_invalid_conversion_between_ext_vectors)
7718 << DestTy << SrcTy << R;
7730 diag::err_invalid_conversion_between_vector_and_scalar)
7731 << DestTy << SrcTy << R;
7733 Kind = CK_VectorSplat;
7741 assert(!
D.isInvalidType() && (
CastExpr !=
nullptr) &&
7742 "ActOnCastExpr(): missing type or expr");
7745 if (
D.isInvalidType())
7764 bool isVectorLiteral =
false;
7779 isVectorLiteral =
true;
7782 isVectorLiteral =
true;
7787 if (isVectorLiteral)
7793 if (isa<ParenListExpr>(
CastExpr)) {
7814 assert((isa<ParenListExpr>(
E) || isa<ParenExpr>(
E)) &&
7815 "Expected paren or paren list expression");
7822 LiteralLParenLoc = PE->getLParenLoc();
7823 LiteralRParenLoc = PE->getRParenLoc();
7824 exprs = PE->getExprs();
7825 numExprs = PE->getNumExprs();
7827 LiteralLParenLoc = cast<ParenExpr>(
E)->getLParen();
7828 LiteralRParenLoc = cast<ParenExpr>(
E)->getRParen();
7829 subExpr = cast<ParenExpr>(
E)->getSubExpr();
7852 if (numExprs == 1) {
7855 if (Literal.isInvalid())
7861 else if (numExprs < numElems) {
7863 diag::err_incorrect_number_of_vector_initializers);
7867 initExprs.append(exprs, exprs + numExprs);
7876 if (Literal.isInvalid())
7883 initExprs.append(exprs, exprs + numExprs);
7888 initExprs, LiteralRParenLoc);
7901 for (
unsigned i = 1, e =
E->getNumExprs(); i != e && !
Result.isInvalid(); ++i)
7918 const Expr *NullExpr = LHSExpr;
7919 const Expr *NonPointerExpr = RHSExpr;
7926 NonPointerExpr = LHSExpr;
7948 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands_null)
7949 << NonPointerExpr->
getType() << DiagType
7961 S.
Diag(QuestionLoc, diag::err_typecheck_cond_expect_nonfloat)
7969 S.
Diag(QuestionLoc, diag::err_typecheck_cond_expect_scalar)
8003 bool IsBlockPointer =
false;
8007 IsBlockPointer =
true;
8032 ResultAddrSpace = LAddrSpace;
8034 ResultAddrSpace = RAddrSpace;
8036 S.
Diag(
Loc, diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
8043 auto LHSCastKind = CK_BitCast, RHSCastKind = CK_BitCast;
8058 LAddrSpace == ResultAddrSpace ? CK_BitCast : CK_AddressSpaceConversion;
8060 RAddrSpace == ResultAddrSpace ? CK_BitCast : CK_AddressSpaceConversion;
8068 lhptee, rhptee,
false,
false,
8071 if (CompositeTy.
isNull()) {
8088 S.
Diag(
Loc, diag::ext_typecheck_cond_incompatible_pointers)
8099 QualType ResultTy = [&, ResultAddrSpace]() {
8105 .withCVRQualifiers(MergedCVRQual);
8134 S.
Diag(
Loc, diag::err_typecheck_cond_incompatible_operands)
8187 bool IsIntFirstExpr) {
8189 !Int.get()->getType()->isIntegerType())
8192 Expr *Expr1 = IsIntFirstExpr ? Int.get() : PointerExpr;
8193 Expr *Expr2 = IsIntFirstExpr ? PointerExpr : Int.get();
8195 S.
Diag(
Loc, diag::ext_typecheck_cond_pointer_integer_mismatch)
8199 CK_IntegralToPointer);
8233 S.
Diag(QuestionLoc, diag::err_typecheck_cond_expect_int_float)
8239 S.
Diag(QuestionLoc, diag::err_typecheck_cond_expect_int_float)
8245 if (LHSType == RHSType)
8254 return handleIntegerConversion<doIntegralCast, doIntegralCast>
8255 (S, LHS, RHS, LHSType, RHSType,
false);
8289 llvm::raw_svector_ostream OS(Str);
8290 OS <<
"(vector of " << NumElements <<
" '" << EleTyName <<
"' values)";
8291 S.
Diag(QuestionLoc, diag::err_conditional_vector_element_size)
8292 << CondTy << OS.str();
8313 S.
Diag(QuestionLoc, diag::err_typecheck_cond_expect_nonfloat)
8331 S.
Diag(QuestionLoc, diag::err_conditional_vector_size)
8332 << CondTy << VecResTy;
8337 QualType RVE = RV->getElementType();
8340 S.
Diag(QuestionLoc, diag::err_conditional_vector_element_size)
8341 << CondTy << VecResTy;
8367 bool IsBoolVecLang =
8396 if (
const CallExpr *CE = dyn_cast<CallExpr>(
E)) {
8397 QualType Ty = CE->getCallee()->getType();
8435 "should only occur in error-recovery path.");
8470 Diag(QuestionLoc, diag::err_wasm_table_conditional_expression)
8479 diag::err_typecheck_cond_incompatible_operands) << LHSTy << RHSTy
8498 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
8514 if (LHSRT->getDecl() == RHSRT->getDecl())
8558 if (!compositeType.
isNull())
8559 return compositeType;
8593 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
8632 const Expr **RHSExprs) {
8637 if (
const auto *MTE = dyn_cast<MaterializeTemporaryExpr>(
E)) {
8638 E = MTE->getSubExpr();
8643 if (
const auto *OP = dyn_cast<BinaryOperator>(
E);
8645 *Opcode = OP->getOpcode();
8646 *RHSExprs = OP->getRHS();
8651 if (
const auto *
Call = dyn_cast<CXXOperatorCallExpr>(
E)) {
8652 if (
Call->getNumArgs() != 2)
8658 if (OO < OO_Plus || OO > OO_Arrow ||
8659 OO == OO_PlusPlus || OO == OO_MinusMinus)
8665 *RHSExprs =
Call->getArg(1);
8681 if (
const auto *OP = dyn_cast<BinaryOperator>(
E))
8682 return OP->isComparisonOp() || OP->isLogicalOp();
8683 if (
const auto *OP = dyn_cast<UnaryOperator>(
E))
8684 return OP->getOpcode() == UO_LNot;
8699 const Expr *RHSExpr) {
8701 const Expr *CondRHS;
8712 ? diag::warn_precedence_bitwise_conditional
8713 : diag::warn_precedence_conditional;
8715 Self.Diag(OpLoc, DiagID)
8721 Self.PDiag(diag::note_precedence_silence)
8726 Self.PDiag(diag::note_precedence_conditional_first),
8737 auto GetNullability = [](
QualType Ty) {
8738 std::optional<NullabilityKind> Kind = Ty->getNullability();
8748 auto LHSKind = GetNullability(LHSTy), RHSKind = GetNullability(RHSTy);
8756 MergedKind = RHSKind;
8763 MergedKind = RHSKind;
8765 MergedKind = LHSKind;
8771 if (GetNullability(ResTy) == MergedKind)
8805 CondExpr = CondResult.
get();
8806 LHSExpr = LHSResult.
get();
8807 RHSExpr = RHSResult.
get();
8813 Expr *commonExpr =
nullptr;
8815 commonExpr = CondExpr;
8822 commonExpr = result.
get();
8836 commonExpr = commonRes.
get();
8846 commonExpr = MatExpr.
get();
8854 LHSExpr = CondExpr = opaqueValue;
8860 ExprResult Cond = CondExpr, LHS = LHSExpr, RHS = RHSExpr;
8862 VK, OK, QuestionLoc);
8870 CheckBoolLikeConversion(Cond.
get(), QuestionLoc);
8878 RHS.get(), result, VK, OK);
8881 commonExpr, opaqueValue, Cond.
get(), LHS.get(), RHS.get(), QuestionLoc,
8882 ColonLoc, result, VK, OK);
8886 unsigned FromAttributes = 0, ToAttributes = 0;
8887 if (
const auto *FromFn =
8891 if (
const auto *ToFn =
8896 return FromAttributes != ToAttributes;
8904 if (
const auto *ToFn =
8906 if (
const auto *FromFn =
8925 assert(LHSType.
isCanonical() &&
"LHS not canonicalized!");
8926 assert(RHSType.
isCanonical() &&
"RHS not canonicalized!");
8929 const Type *lhptee, *rhptee;
8931 std::tie(lhptee, lhq) =
8932 cast<PointerType>(LHSType)->getPointeeType().split().asPair();
8933 std::tie(rhptee, rhq) =
8934 cast<PointerType>(RHSType)->getPointeeType().split().asPair();
8994 diag::warn_typecheck_convert_incompatible_function_pointer_strict,
9017 if (ltrans == rtrans) {
9031 if (isa<PointerType>(lhptee) && isa<PointerType>(rhptee)) {
9033 std::tie(lhptee, lhq) =
9034 cast<PointerType>(lhptee)->getPointeeType().split().asPair();
9035 std::tie(rhptee, rhq) =
9036 cast<PointerType>(rhptee)->getPointeeType().split().asPair();
9049 }
while (isa<PointerType>(lhptee) && isa<PointerType>(rhptee));
9051 if (lhptee == rhptee)
9077 assert(LHSType.
isCanonical() &&
"LHS not canonicalized!");
9078 assert(RHSType.
isCanonical() &&
"RHS not canonicalized!");
9099 if (LQuals != RQuals)
9128 assert(LHSType.
isCanonical() &&
"LHS was not canonicalized!");
9129 assert(RHSType.
isCanonical() &&
"RHS was not canonicalized!");
9177 return VT->getElementType().getCanonicalType() == ElementType;
9210 if (LHSType == RHSType) {
9217 if (
const auto *AT = dyn_cast<AutoType>(LHSType)) {
9218 if (AT->isGNUAutoType()) {
9226 if (
const AtomicType *AtomicTy = dyn_cast<AtomicType>(LHSType)) {
9231 if (Kind != CK_NoOp && ConvertRHS)
9233 Kind = CK_NonAtomicToAtomic;
9246 Kind = CK_LValueBitCast;
9261 Kind = CK_VectorSplat;
9287 << RHSType << LHSType;
9306 << RHSType << LHSType;
9356 if (
const PointerType *LHSPointer = dyn_cast<PointerType>(LHSType)) {
9358 if (isa<PointerType>(RHSType)) {
9359 LangAS AddrSpaceL = LHSPointer->getPointeeType().getAddressSpace();
9361 if (AddrSpaceL != AddrSpaceR)
9362 Kind = CK_AddressSpaceConversion;
9373 Kind = CK_IntegralToPointer;
9379 if (isa<ObjCObjectPointerType>(RHSType)) {
9381 if (LHSPointer->getPointeeType()->isVoidType()) {
9400 if (LHSPointer->getPointeeType()->isVoidType()) {
9401 LangAS AddrSpaceL = LHSPointer->getPointeeType().getAddressSpace();
9406 AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion : CK_BitCast;
9415 if (isa<BlockPointerType>(LHSType)) {
9424 Kind = AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion : CK_BitCast;
9430 Kind = CK_IntegralToPointer;
9436 Kind = CK_AnyPointerToBlockPointerCast;
9442 if (RHSPT->getPointeeType()->isVoidType()) {
9443 Kind = CK_AnyPointerToBlockPointerCast;
9451 if (isa<ObjCObjectPointerType>(LHSType)) {
9457 if (
getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
9459 !
ObjC().CheckObjCARCUnavailableWeakConversion(OrigLHSType, RHSType))
9466 Kind = CK_IntegralToPointer;
9472 if (isa<PointerType>(RHSType)) {
9473 Kind = CK_CPointerToObjCPointerCast;
9495 Kind = CK_BlockPointerToObjCPointerCast;
9507 Kind = CK_NullToPointer;
9512 if (isa<PointerType>(RHSType)) {
9515 Kind = CK_PointerToBoolean;
9521 Kind = CK_PointerToIntegral;
9529 if (isa<ObjCObjectPointerType>(RHSType)) {
9532 Kind = CK_PointerToBoolean;
9538 Kind = CK_PointerToIntegral;
9546 if (isa<TagType>(LHSType) && isa<TagType>(RHSType)) {
9554 Kind = CK_IntToOCLSampler;
9596 for (
auto *it : UD->
fields()) {
9597 if (it->getType()->isPointerType()) {
9636 bool DiagnoseCFAudited,
9640 assert((ConvertRHS || !
Diagnose) &&
"can't indicate whether we diagnosed");
9646 ExprResult &RHS = ConvertRHS ? CallerRHS : LocalRHS;
9650 if (RHSPtrType->getPointeeType()->hasAttr(attr::NoDeref) &&
9651 !LHSPtrType->getPointeeType()->hasAttr(attr::NoDeref)) {
9653 diag::warn_noderef_to_dereferenceable_pointer)
9672 AllowedExplicit::None,
9684 if (
getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
9685 !
ObjC().CheckObjCARCUnavailableWeakConversion(LHSType, RHSType))
9699 RHS.
get(), LHSType,
false, DAP))
9790 if (
getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
9800 ObjC().CheckConversionToObjCLiteral(LHSType,
E,
Diagnose))) {
9820struct OriginalOperand {
9821 explicit OriginalOperand(
Expr *Op) : Orig(Op), Conversion(nullptr) {
9822 if (
auto *MTE = dyn_cast<MaterializeTemporaryExpr>(Op))
9823 Op = MTE->getSubExpr();
9824 if (
auto *BTE = dyn_cast<CXXBindTemporaryExpr>(Op))
9825 Op = BTE->getSubExpr();
9826 if (
auto *ICE = dyn_cast<ImplicitCastExpr>(Op)) {
9827 Orig = ICE->getSubExprAsWritten();
9828 Conversion = ICE->getConversionFunction();
9832 QualType getType()
const {
return Orig->getType(); }
9841 OriginalOperand OrigLHS(LHS.
get()), OrigRHS(RHS.
get());
9843 Diag(
Loc, diag::err_typecheck_invalid_operands)
9844 << OrigLHS.getType() << OrigRHS.getType()
9849 if (OrigLHS.Conversion) {
9850 Diag(OrigLHS.Conversion->getLocation(),
9851 diag::note_typecheck_invalid_operands_converted)
9854 if (OrigRHS.Conversion) {
9855 Diag(OrigRHS.Conversion->getLocation(),
9856 diag::note_typecheck_invalid_operands_converted)
9871 if (!(LHSNatVec && RHSNatVec)) {
9873 Expr *NonVector = !LHSNatVec ? LHS.
get() : RHS.
get();
9874 Diag(
Loc, diag::err_typecheck_logical_vector_expr_gnu_cpp_restrict)
9876 <<
Vector->getSourceRange();
9880 Diag(
Loc, diag::err_typecheck_logical_vector_expr_gnu_cpp_restrict)
9909 scalarCast = CK_IntegralToBoolean;
9914 DiagID = diag::err_opencl_scalar_type_rank_greater_than_vector_type;
9919 scalarCast = CK_IntegralCast;
9924 DiagID = diag::err_opencl_scalar_type_rank_greater_than_vector_type;
9927 scalarCast = CK_FloatingCast;
9930 scalarCast = CK_IntegralToFloating;
9939 if (scalarCast != CK_NoOp)
9950 assert(VecTy &&
"Expression E must be a vector");
9955 VecTy->getVectorKind());
9959 if (
auto *ICE = dyn_cast<ImplicitCastExpr>(
E))
9960 if (ICE->getSubExpr()->getType() == NewVecTy)
9961 return ICE->getSubExpr();
9963 auto Cast = ElementType->
isIntegerType() ? CK_IntegralCast : CK_FloatingCast;
9971 if (Int->get()->containsErrors())
9974 QualType IntTy = Int->get()->getType().getUnqualifiedType();
9980 bool CstInt = Int->get()->EvaluateAsInt(EVResult, S.
Context);
9989 unsigned NumBits = IntSigned
9991 :
Result.getActiveBits())
9992 :
Result.getActiveBits();
9999 return (IntSigned != OtherIntSigned &&
10005 return (Order < 0);
10012 if (Int->get()->containsErrors())
10015 QualType IntTy = Int->get()->getType().getUnqualifiedType();
10020 bool CstInt = Int->get()->EvaluateAsInt(EVResult, S.
Context);
10032 llvm::APFloat::rmTowardZero);
10035 bool Ignored =
false;
10036 Float.convertToInteger(ConvertBack, llvm::APFloat::rmNearestTiesToEven,
10038 if (
Result != ConvertBack)
10044 unsigned FloatPrec = llvm::APFloat::semanticsPrecision(
10046 if (Bits > FloatPrec)
10059 QualType ScalarTy = Scalar->get()->getType().getUnqualifiedType();
10060 QualType VectorTy =
Vector->get()->getType().getUnqualifiedType();
10064 assert(!isa<ExtVectorType>(VT) &&
10065 "ExtVectorTypes should not be handled here!");
10066 VectorEltTy = VT->getElementType();
10071 llvm_unreachable(
"Only Fixed-Length and SVE Vector types are handled here");
10097 ScalarCast = CK_IntegralCast;
10101 ScalarCast = CK_FloatingToIntegral;
10109 llvm::APFloat
Result(0.0);
10115 bool CstScalar = Scalar->get()->isValueDependent() ||
10118 if (!CstScalar && Order < 0)
10124 bool Truncated =
false;
10126 llvm::APFloat::rmNearestTiesToEven, &Truncated);
10131 ScalarCast = CK_FloatingCast;
10136 ScalarCast = CK_IntegralToFloating;
10143 if (ScalarCast != CK_NoOp)
10151 bool AllowBothBool,
10152 bool AllowBoolConversions,
10153 bool AllowBoolOperation,
10154 bool ReportInvalid) {
10155 if (!IsCompAssign) {
10171 assert(LHSVecType || RHSVecType);
10179 (RHSVecType && RHSVecType->getElementType()->isMFloat8Type()))
10184 if (!AllowBothBool && LHSVecType &&
10190 if (!AllowBoolOperation &&
10199 if (LHSVecType && RHSVecType &&
10201 if (isa<ExtVectorType>(LHSVecType)) {
10214 if (AllowBoolConversions && LHSVecType && RHSVecType &&
10224 if (!IsCompAssign &&
10227 RHSVecType->getElementType()->isIntegerType()) {
10236 unsigned &SVEorRVV) {
10257 if (IsSveRVVConversion(LHSType, RHSType, SVEorRVV) ||
10258 IsSveRVVConversion(RHSType, LHSType, SVEorRVV)) {
10259 Diag(
Loc, diag::err_typecheck_sve_rvv_ambiguous)
10260 << SVEorRVV << LHSType << RHSType;
10267 unsigned &SVEorRVV) {
10272 if (FirstVecType && SecondVecType) {
10275 SecondVecType->getVectorKind() ==
10280 SecondVecType->getVectorKind() ==
10282 SecondVecType->getVectorKind() ==
10284 SecondVecType->getVectorKind() ==
10293 if (SecondVecType &&
10306 if (IsSveRVVGnuConversion(LHSType, RHSType, SVEorRVV) ||
10307 IsSveRVVGnuConversion(RHSType, LHSType, SVEorRVV)) {
10308 Diag(
Loc, diag::err_typecheck_sve_rvv_gnu_ambiguous)
10309 << SVEorRVV << LHSType << RHSType;
10315 unsigned DiagID = diag::err_typecheck_vector_not_convertable;
10317 if (isa<ExtVectorType>(LHSVecType)) {
10328 if (isa<ExtVectorType>(RHSVecType)) {
10330 LHSType, RHSVecType->getElementType(),
10343 QualType VecType = LHSVecType ? LHSType : RHSType;
10344 const VectorType *VT = LHSVecType ? LHSVecType : RHSVecType;
10345 QualType OtherType = LHSVecType ? RHSType : LHSType;
10346 ExprResult *OtherExpr = LHSVecType ? &RHS : &LHS;
10351 Diag(
Loc, diag::warn_deprecated_lax_vec_conv_all) << RHSType << LHSType;
10355 if (!IsCompAssign) {
10374 if ((!RHSVecType && !RHSType->
isRealType()) ||
10376 Diag(
Loc, diag::err_typecheck_vector_not_convertable_non_scalar)
10377 << LHSType << RHSType
10387 RHSVecType && isa<ExtVectorType>(RHSVecType) &&
10388 LHSVecType && isa<ExtVectorType>(LHSVecType)) {
10389 Diag(
Loc, diag::err_opencl_implicit_vector_conversion) << LHSType
10398 if ((RHSVecType && !isa<ExtVectorType>(RHSVecType)) ||
10399 (LHSVecType && !isa<ExtVectorType>(LHSVecType))) {
10400 QualType Scalar = LHSVecType ? RHSType : LHSType;
10402 unsigned ScalarOrVector = LHSVecType && RHSVecType ? 1 : 0;
10404 diag::err_typecheck_vector_not_convertable_implict_truncation)
10405 << ScalarOrVector << Scalar <<
Vector;
10412 << LHSType << RHSType
10421 if (!IsCompAssign) {
10436 unsigned DiagID = diag::err_typecheck_invalid_operands;
10438 ((LHSBuiltinTy && LHSBuiltinTy->
isSVEBool()) ||
10439 (RHSBuiltinTy && RHSBuiltinTy->isSVEBool()))) {
10460 Diag(
Loc, diag::err_typecheck_vector_not_convertable_non_scalar)
10469 Diag(
Loc, diag::err_typecheck_vector_lengths_not_equal)
10478 bool ScalarOrVector =
10481 Diag(
Loc, diag::err_typecheck_vector_not_convertable_implict_truncation)
10482 << ScalarOrVector << Scalar <<
Vector;
10514 S.
Diag(
Loc, diag::warn_null_in_arithmetic_operation)
10526 S.
Diag(
Loc, diag::warn_null_in_comparison_operation)
10527 << LHSNull << NonNullType
10533 const auto *LUE = dyn_cast<UnaryExprOrTypeTraitExpr>(LHS);
10534 const auto *RUE = dyn_cast<UnaryExprOrTypeTraitExpr>(RHS);
10537 if (LUE->getKind() != UETT_SizeOf || LUE->isArgumentType() ||
10538 RUE->getKind() != UETT_SizeOf)
10545 if (RUE->isArgumentType())
10546 RHSTy = RUE->getArgumentType().getNonReferenceType();
10548 RHSTy = RUE->getArgumentExpr()->IgnoreParens()->getType();
10555 if (
const auto *DRE = dyn_cast<DeclRefExpr>(LHSArg)) {
10556 if (
const ValueDecl *LHSArgDecl = DRE->getDecl())
10557 S.
Diag(LHSArgDecl->getLocation(), diag::note_pointer_declared_here)
10561 QualType ArrayElemTy = ArrayTy->getElementType();
10567 S.
Diag(
Loc, diag::warn_division_sizeof_array)
10569 if (
const auto *DRE = dyn_cast<DeclRefExpr>(LHSArg)) {
10570 if (
const ValueDecl *LHSArgDecl = DRE->getDecl())
10571 S.
Diag(LHSArgDecl->getLocation(), diag::note_array_declared_here)
10575 S.
Diag(
Loc, diag::note_precedence_silence) << RHS;
10588 S.
PDiag(diag::warn_remainder_division_by_zero)
10594 bool IsCompAssign,
bool IsDiv) {
10672 ? diag::err_typecheck_pointer_arith_void_type
10673 : diag::ext_gnu_void_ptr)
10682 ? diag::err_typecheck_pointer_arith_void_type
10683 : diag::ext_gnu_void_ptr)
10684 << 0 <<
Pointer->getSourceRange();
10695 S.
Diag(
Loc, diag::warn_gnu_null_ptr_arith)
10696 <<
Pointer->getSourceRange();
10698 S.
Diag(
Loc, diag::warn_pointer_arith_null_ptr)
10715 S.
PDiag(diag::warn_pointer_sub_null_ptr)
10717 <<
Pointer->getSourceRange());
10726 ? diag::err_typecheck_pointer_arith_function_type
10727 : diag::ext_gnu_ptr_func_arith)
10739 assert(
Pointer->getType()->isAnyPointerType());
10741 ? diag::err_typecheck_pointer_arith_function_type
10742 : diag::ext_gnu_ptr_func_arith)
10743 << 0 <<
Pointer->getType()->getPointeeType()
10745 <<
Pointer->getSourceRange();
10753 QualType ResType = Operand->getType();
10755 ResType = ResAtomicType->getValueType();
10761 diag::err_typecheck_arithmetic_incomplete_or_sizeless_type,
10762 Operand->getSourceRange());
10775 QualType ResType = Operand->getType();
10777 ResType = ResAtomicType->getValueType();
10809 if (!isLHSPointer && !isRHSPointer)
return true;
10811 QualType LHSPointeeTy, RHSPointeeTy;
10816 if (isLHSPointer && isRHSPointer) {
10820 diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
10828 bool isLHSVoidPtr = isLHSPointer && LHSPointeeTy->
isVoidType();
10829 bool isRHSVoidPtr = isRHSPointer && RHSPointeeTy->
isVoidType();
10830 if (isLHSVoidPtr || isRHSVoidPtr) {
10838 bool isLHSFuncPtr = isLHSPointer && LHSPointeeTy->
isFunctionType();
10839 bool isRHSFuncPtr = isRHSPointer && RHSPointeeTy->
isFunctionType();
10840 if (isLHSFuncPtr || isRHSFuncPtr) {
10862 Expr* IndexExpr = RHSExpr;
10865 IndexExpr = LHSExpr;
10868 bool IsStringPlusInt = StrExpr &&
10874 Self.Diag(OpLoc, diag::warn_string_plus_int)
10878 if (IndexExpr == RHSExpr) {
10880 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence)
10885 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence);
10891 const Expr *StringRefExpr = LHSExpr;
10896 CharExpr = dyn_cast<CharacterLiteral>(LHSExpr->
IgnoreImpCasts());
10897 StringRefExpr = RHSExpr;
10900 if (!CharExpr || !StringRefExpr)
10920 Self.Diag(OpLoc, diag::warn_string_plus_char)
10921 << DiagRange << Ctx.
CharTy;
10923 Self.Diag(OpLoc, diag::warn_string_plus_char)
10924 << DiagRange << CharExpr->
getType();
10930 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence)
10935 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence);
10944 S.
Diag(
Loc, diag::err_typecheck_sub_ptr_compatible)
10963 if (CompLHSTy) *CompLHSTy = compType;
10972 *CompLHSTy = compType;
10981 *CompLHSTy = compType;
10991 if (Opc == BO_Add) {
10998 if (CompLHSTy) *CompLHSTy = compType;
11012 std::swap(PExp, IExp);
11023 if (!IExp->getType()->isIntegerType())
11032 (!IExp->isValueDependent() &&
11033 (!IExp->EvaluateAsInt(KnownVal,
Context) ||
11037 Context, BO_Add, PExp, IExp);
11050 if (isa<AddrLabelExpr>(PExp) &&
getLangOpts().PointerAuthIndirectGotos) {
11051 Diag(
Loc, diag::err_ptrauth_indirect_goto_addrlabel_arithmetic)
11057 CheckArrayAccess(PExp, IExp);
11066 *CompLHSTy = LHSTy;
11086 if (CompLHSTy) *CompLHSTy = compType;
11095 *CompLHSTy = compType;
11104 *CompLHSTy = compType;
11117 if (CompLHSTy) *CompLHSTy = compType;
11132 if (isa<AddrLabelExpr>(LHS.
get()) &&
11134 Diag(
Loc, diag::err_ptrauth_indirect_goto_addrlabel_arithmetic)
11160 CheckArrayAccess(LHS.
get(), RHS.
get(),
nullptr,
11163 if (CompLHSTy) *CompLHSTy = LHS.
get()->
getType();
11207 if (ElementSize.
isZero()) {
11208 Diag(
Loc,diag::warn_sub_ptr_zero_size_types)
11214 if (CompLHSTy) *CompLHSTy = LHS.
get()->
getType();
11224 return ET->getDecl()->isScoped();
11241 llvm::APSInt Right = RHSResult.
Val.
getInt();
11243 if (Right.isNegative()) {
11245 S.
PDiag(diag::warn_shift_negative)
11256 LeftSize = FXSema.getWidth() - (
unsigned)FXSema.hasUnsignedPadding();
11258 if (Right.uge(LeftSize)) {
11260 S.
PDiag(diag::warn_shift_gt_typewidth)
11280 llvm::APSInt Left = LHSResult.
Val.
getInt();
11291 if (Left.isNegative()) {
11293 S.
PDiag(diag::warn_shift_lhs_negative)
11298 llvm::APInt ResultBits =
11299 static_cast<llvm::APInt &
>(Right) + Left.getSignificantBits();
11300 if (ResultBits.ule(LeftSize))
11302 llvm::APSInt
Result = Left.extend(ResultBits.getLimitedValue());
11308 Result.toString(HexResult, 16,
false,
true);
11314 if (ResultBits - 1 == LeftSize) {
11315 S.
Diag(
Loc, diag::warn_shift_result_sets_sign_bit)
11316 << HexResult << LHSType
11321 S.
Diag(
Loc, diag::warn_shift_result_gt_typewidth)
11322 << HexResult.str() <<
Result.getSignificantBits() << LHSType
11334 S.
Diag(
Loc, diag::err_shift_rhs_only_vector)
11340 if (!IsCompAssign) {
11362 S.
Diag(
Loc, diag::err_typecheck_invalid_operands)
11369 if (!LHSEleType->isIntegerType()) {
11370 S.
Diag(
Loc, diag::err_typecheck_expect_int)
11375 if (!RHSEleType->isIntegerType()) {
11376 S.
Diag(
Loc, diag::err_typecheck_expect_int)
11385 if (LHSEleType != RHSEleType) {
11387 LHSEleType = RHSEleType;
11393 }
else if (RHSVecTy) {
11398 S.
Diag(
Loc, diag::err_typecheck_vector_lengths_not_equal)
11406 if (LHSBT != RHSBT &&
11408 S.
Diag(
Loc, diag::warn_typecheck_vector_element_sizes_not_equal)
11425 bool IsCompAssign) {
11426 if (!IsCompAssign) {
11449 if ((LHSBuiltinTy && LHSBuiltinTy->
isSVEBool()) ||
11450 (RHSBuiltinTy && RHSBuiltinTy->
isSVEBool())) {
11451 S.
Diag(
Loc, diag::err_typecheck_invalid_operands)
11456 if (!LHSEleType->isIntegerType()) {
11457 S.
Diag(
Loc, diag::err_typecheck_expect_int)
11462 if (!RHSEleType->isIntegerType()) {
11463 S.
Diag(
Loc, diag::err_typecheck_expect_int)
11471 S.
Diag(
Loc, diag::err_typecheck_invalid_operands)
11481 if (LHSEleType != RHSEleType) {
11483 LHSEleType = RHSEleType;
11485 const llvm::ElementCount VecSize =
11494 S.
Diag(
Loc, diag::err_typecheck_vector_lengths_not_equal)
11500 const llvm::ElementCount VecSize =
11502 if (LHSEleType != RHSEleType) {
11504 RHSEleType = LHSEleType;
11517 bool IsCompAssign) {
11551 if (IsCompAssign) LHS = OldLHS;
11582 S.
Diag(
Loc, IsError ? diag::err_typecheck_comparison_of_distinct_pointers
11583 : diag::ext_typecheck_comparison_of_distinct_pointers)
11623 S.
Diag(
Loc, IsError ? diag::err_typecheck_comparison_of_fptr_to_void
11624 : diag::ext_typecheck_comparison_of_fptr_to_void)
11631 case Stmt::ObjCArrayLiteralClass:
11632 case Stmt::ObjCDictionaryLiteralClass:
11633 case Stmt::ObjCStringLiteralClass:
11634 case Stmt::ObjCBoxedExprClass:
11695 Literal = LHS.
get();
11698 Literal = RHS.
get();
11714 llvm_unreachable(
"Unknown Objective-C object literal kind");
11718 S.
Diag(
Loc, diag::warn_objc_string_literal_comparison)
11719 << Literal->getSourceRange();
11721 S.
Diag(
Loc, diag::warn_objc_literal_comparison)
11722 << LiteralKind << Literal->getSourceRange();
11731 S.
Diag(
Loc, diag::note_objc_literal_comparison_isequal)
11744 if (!UO || UO->
getOpcode() != UO_LNot)
return;
11754 bool IsBitwiseOp = Opc == BO_And || Opc == BO_Or || Opc == BO_Xor;
11756 <<
Loc << IsBitwiseOp;
11783 if (
const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(
E)) {
11785 }
else if (
const MemberExpr *Mem = dyn_cast<MemberExpr>(
E)) {
11786 if (Mem->isImplicitAccess())
11787 D = Mem->getMemberDecl();
11791 return D->getType()->isArrayType() && !
D->isWeak();
11802 return std::nullopt;
11810 std::swap(LHS, RHS);
11814 std::swap(LHS, RHS);
11818 return std::nullopt;
11821 auto *BO = dyn_cast<BinaryOperator>(LHS);
11822 if (!BO || BO->getOpcode() != BO_Add)
11823 return std::nullopt;
11827 Other = BO->getRHS();
11829 Other = BO->getLHS();
11831 return std::nullopt;
11833 if (!
Other->getType()->isUnsignedIntegerType())
11834 return std::nullopt;
11836 return Opc == BO_GE;
11890 auto IsDeprArrayComparionIgnored =
11893 ? diag::warn_array_comparison_cxx26
11894 : !S.
getLangOpts().CPlusPlus20 || IsDeprArrayComparionIgnored
11895 ? diag::warn_array_comparison
11896 : diag::warn_depr_array_comparison;
11922 Result = AlwaysConstant;
11926 S.
PDiag(diag::warn_comparison_always)
11941 Result = AlwaysConstant;
11945 S.
PDiag(diag::warn_comparison_always)
11948 }
else if (std::optional<bool> Res =
11951 S.
PDiag(diag::warn_comparison_always)
11953 << (*Res ? AlwaysTrue : AlwaysFalse));
11957 if (isa<CastExpr>(LHSStripped))
11959 if (isa<CastExpr>(RHSStripped))
11964 Expr *LiteralString =
nullptr;
11965 Expr *LiteralStringStripped =
nullptr;
11966 if ((isa<StringLiteral>(LHSStripped) || isa<ObjCEncodeExpr>(LHSStripped)) &&
11969 LiteralString = LHS;
11970 LiteralStringStripped = LHSStripped;
11971 }
else if ((isa<StringLiteral>(RHSStripped) ||
11972 isa<ObjCEncodeExpr>(RHSStripped)) &&
11975 LiteralString = RHS;
11976 LiteralStringStripped = RHSStripped;
11979 if (LiteralString) {
11981 S.
PDiag(diag::warn_stringcompare)
11982 << isa<ObjCEncodeExpr>(LiteralStringStripped)
11994 llvm_unreachable(
"unhandled cast kind");
11996 case CK_UserDefinedConversion:
11998 case CK_LValueToRValue:
12000 case CK_ArrayToPointerDecay:
12002 case CK_FunctionToPointerDecay:
12004 case CK_IntegralCast:
12006 case CK_FloatingCast:
12008 case CK_IntegralToFloating:
12009 case CK_FloatingToIntegral:
12011 case CK_IntegralComplexCast:
12012 case CK_FloatingComplexCast:
12013 case CK_FloatingComplexToIntegralComplex:
12014 case CK_IntegralComplexToFloatingComplex:
12016 case CK_FloatingComplexToReal:
12017 case CK_FloatingRealToComplex:
12018 case CK_IntegralComplexToReal:
12019 case CK_IntegralRealToComplex:
12021 case CK_HLSLArrayRValue:
12034 if (
const auto *ICE = dyn_cast<ImplicitCastExpr>(
E))
12061 << 0 << FromType << ToType;
12066 llvm_unreachable(
"unhandled case in switch");
12093 if (NumEnumArgs == 1) {
12095 QualType OtherTy = LHSIsEnum ? RHSStrippedType : LHSStrippedType;
12101 if (NumEnumArgs == 2) {
12110 LHSStrippedType->
castAs<
EnumType>()->getDecl()->getIntegerType();
12121 LHSType = RHSType = IntType;
12133 std::optional<ComparisonCategoryType> CCT =
12145 assert(!
Type.isNull() &&
"composite type for <=> has not been set");
12186 if (
const auto *CL = dyn_cast<CharacterLiteral>(
E.get())) {
12187 if (CL->getValue() == 0)
12191 NullValue ?
"NULL" :
"(void *)0");
12192 }
else if (
const auto *CE = dyn_cast<CStyleCastExpr>(
E.get())) {
12199 NullValue ?
"NULL" :
"(void *)0");
12209 bool IsThreeWay = Opc == BO_Cmp;
12210 bool IsOrdered = IsRelational || IsThreeWay;
12221 if (!IsThreeWay || IsAnyPointerType(LHS) || IsAnyPointerType(RHS)) {
12274 auto computeResultTy = [&]() {
12283 std::optional<ComparisonCategoryType> CCT =
12288 if (CompositeTy->
isPointerType() && LHSIsNull != RHSIsNull) {
12292 Diag(
Loc, diag::err_typecheck_three_way_comparison_of_pointer_and_zero)
12302 if (!IsOrdered && LHSIsNull != RHSIsNull) {
12303 bool IsEquality = Opc == BO_EQ;
12315 bool IsError = Opc == BO_Cmp;
12317 IsError ? diag::err_typecheck_ordered_comparison_of_function_pointers
12319 ? diag::warn_typecheck_ordered_comparison_of_function_pointers
12320 : diag::ext_typecheck_ordered_comparison_of_function_pointers;
12349 return computeResultTy();
12365 (IsOrdered ? 2 : 1) &&
12370 return computeResultTy();
12384 if (IsRelational) {
12389 Diag(
Loc, diag::ext_typecheck_compare_complete_incomplete_pointers)
12395 }
else if (!IsRelational &&
12399 && !LHSIsNull && !RHSIsNull)
12406 if (LCanPointeeTy != RCanPointeeTy) {
12412 diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
12413 << LHSType << RHSType << 0
12419 CastKind Kind = AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion
12421 if (LHSIsNull && !RHSIsNull)
12426 return computeResultTy();
12438 if (!IsOrdered && LHSIsNull && RHSIsNull) {
12441 return computeResultTy();
12445 return computeResultTy();
12456 return computeResultTy();
12460 return computeResultTy();
12469 return computeResultTy();
12474 return computeResultTy();
12478 if (IsRelational &&
12487 if (isa<FunctionDecl>(DC))
12489 if (
auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
12490 if (CTSD->isInStdNamespace() &&
12491 llvm::StringSwitch<bool>(CTSD->getName())
12492 .Cases(
"less",
"less_equal",
"greater",
"greater_equal",
true)
12498 return computeResultTy();
12511 return computeResultTy();
12521 if (!LHSIsNull && !RHSIsNull &&
12523 Diag(
Loc, diag::err_typecheck_comparison_of_distinct_blocks)
12528 return computeResultTy();
12535 if (!LHSIsNull && !RHSIsNull) {
12540 Diag(
Loc, diag::err_typecheck_comparison_of_distinct_blocks)
12544 if (LHSIsNull && !RHSIsNull)
12547 : CK_AnyPointerToBlockPointerCast);
12551 : CK_AnyPointerToBlockPointerCast);
12552 return computeResultTy();
12561 bool RPtrToVoid = RPT ? RPT->getPointeeType()->isVoidType() :
false;
12563 if (!LPtrToVoid && !RPtrToVoid &&
12571 if (LHSIsNull && !RHSIsNull) {
12577 RPT ? CK_BitCast :CK_CPointerToObjCPointerCast);
12587 LPT ? CK_BitCast :CK_CPointerToObjCPointerCast);
12589 return computeResultTy();
12599 if (LHSIsNull && !RHSIsNull)
12603 return computeResultTy();
12609 CK_BlockPointerToObjCPointerCast);
12610 return computeResultTy();
12611 }
else if (!IsOrdered &&
12615 CK_BlockPointerToObjCPointerCast);
12616 return computeResultTy();
12621 unsigned DiagID = 0;
12622 bool isError =
false;
12631 isError ? diag::err_typecheck_ordered_comparison_of_pointer_and_zero
12632 : diag::ext_typecheck_ordered_comparison_of_pointer_and_zero;
12635 DiagID = diag::err_typecheck_comparison_of_pointer_integer;
12637 }
else if (IsOrdered)
12638 DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_integer;
12640 DiagID = diag::ext_typecheck_comparison_of_pointer_integer;
12652 LHSIsNull ? CK_NullToPointer : CK_IntegralToPointer);
12655 RHSIsNull ? CK_NullToPointer : CK_IntegralToPointer);
12656 return computeResultTy();
12660 if (!IsOrdered && RHSIsNull
12663 return computeResultTy();
12665 if (!IsOrdered && LHSIsNull
12668 return computeResultTy();
12671 if (
getLangOpts().getOpenCLCompatibleVersion() >= 200) {
12673 return computeResultTy();
12677 return computeResultTy();
12680 if (LHSIsNull && RHSType->
isQueueT()) {
12682 return computeResultTy();
12685 if (LHSType->
isQueueT() && RHSIsNull) {
12687 return computeResultTy();
12698 if (isa<ExtVectorType>(VTy)) {
12712 "Unhandled vector element size in vector compare");
12732 "Unhandled vector element size in vector compare");
12752 if (Opc == BO_Cmp) {
12753 Diag(
Loc, diag::err_three_way_vector_comparison);
12784 Diag(
Loc, diag::warn_deprecated_altivec_src_compat);
12814 if (Opc == BO_Cmp) {
12815 Diag(
Loc, diag::err_three_way_vector_comparison);
12843 if (LHSBuiltinTy && RHSBuiltinTy && LHSBuiltinTy->
isSVEBool() &&
12844 RHSBuiltinTy->isSVEBool())
12863 bool Negative =
false;
12864 bool ExplicitPlus =
false;
12865 const auto *LHSInt = dyn_cast<IntegerLiteral>(XorLHS.
get());
12866 const auto *RHSInt = dyn_cast<IntegerLiteral>(XorRHS.
get());
12872 if (
const auto *UO = dyn_cast<UnaryOperator>(XorRHS.
get())) {
12874 if (Opc != UO_Minus && Opc != UO_Plus)
12876 RHSInt = dyn_cast<IntegerLiteral>(UO->getSubExpr());
12879 Negative = (Opc == UO_Minus);
12880 ExplicitPlus = !Negative;
12886 const llvm::APInt &LeftSideValue = LHSInt->getValue();
12887 llvm::APInt RightSideValue = RHSInt->getValue();
12888 if (LeftSideValue != 2 && LeftSideValue != 10)
12891 if (LeftSideValue.getBitWidth() != RightSideValue.getBitWidth())
12896 llvm::StringRef ExprStr =
12901 llvm::StringRef XorStr =
12904 if (XorStr ==
"xor")
12915 RightSideValue = -RightSideValue;
12916 RHSStr =
"-" + RHSStr;
12917 }
else if (ExplicitPlus) {
12918 RHSStr =
"+" + RHSStr;
12921 StringRef LHSStrRef = LHSStr;
12922 StringRef RHSStrRef = RHSStr;
12925 if (LHSStrRef.starts_with(
"0b") || LHSStrRef.starts_with(
"0B") ||
12926 RHSStrRef.starts_with(
"0b") || RHSStrRef.starts_with(
"0B") ||
12927 LHSStrRef.starts_with(
"0x") || LHSStrRef.starts_with(
"0X") ||
12928 RHSStrRef.starts_with(
"0x") || RHSStrRef.starts_with(
"0X") ||
12929 (LHSStrRef.size() > 1 && LHSStrRef.starts_with(
"0")) ||
12930 (RHSStrRef.size() > 1 && RHSStrRef.starts_with(
"0")) ||
12931 LHSStrRef.contains(
'\'') || RHSStrRef.contains(
'\''))
12936 const llvm::APInt XorValue = LeftSideValue ^ RightSideValue;
12937 int64_t RightSideIntValue = RightSideValue.getSExtValue();
12938 if (LeftSideValue == 2 && RightSideIntValue >= 0) {
12939 std::string SuggestedExpr =
"1 << " + RHSStr;
12940 bool Overflow =
false;
12941 llvm::APInt One = (LeftSideValue - 1);
12942 llvm::APInt PowValue = One.sshl_ov(RightSideValue, Overflow);
12944 if (RightSideIntValue < 64)
12945 S.
Diag(
Loc, diag::warn_xor_used_as_pow_base)
12946 << ExprStr <<
toString(XorValue, 10,
true) << (
"1LL << " + RHSStr)
12948 else if (RightSideIntValue == 64)
12949 S.
Diag(
Loc, diag::warn_xor_used_as_pow)
12950 << ExprStr <<
toString(XorValue, 10,
true);
12954 S.
Diag(
Loc, diag::warn_xor_used_as_pow_base_extra)
12955 << ExprStr <<
toString(XorValue, 10,
true) << SuggestedExpr
12958 ExprRange, (RightSideIntValue == 0) ?
"1" : SuggestedExpr);
12961 S.
Diag(
Loc, diag::note_xor_used_as_pow_silence)
12962 << (
"0x2 ^ " + RHSStr) << SuggestXor;
12963 }
else if (LeftSideValue == 10) {
12964 std::string SuggestedValue =
"1e" + std::to_string(RightSideIntValue);
12965 S.
Diag(
Loc, diag::warn_xor_used_as_pow_base)
12966 << ExprStr <<
toString(XorValue, 10,
true) << SuggestedValue
12968 S.
Diag(
Loc, diag::note_xor_used_as_pow_silence)
12969 << (
"0xA ^ " + RHSStr) << SuggestXor;
12986 getLangOpts().getOpenCLCompatibleVersion() < 120 &&
13010 bool IsCompAssign) {
13011 if (!IsCompAssign) {
13027 assert((LHSMatType || RHSMatType) &&
"At least one operand must be a matrix");
13036 if (LHSMatType && !RHSMatType) {
13044 if (!LHSMatType && RHSMatType) {
13056 bool IsCompAssign) {
13057 if (!IsCompAssign) {
13068 assert((LHSMatType || RHSMatType) &&
"At least one operand must be a matrix");
13070 if (LHSMatType && RHSMatType) {
13071 if (LHSMatType->getNumColumns() != RHSMatType->
getNumRows())
13079 QualType LHSELTy = LHSMatType->getElementType(),
13110 bool IsCompAssign =
13111 Opc == BO_AndAssign || Opc == BO_OrAssign || Opc == BO_XorAssign;
13122 LegalBoolVecOperator,
13152 ExprResult LHSResult = LHS, RHSResult = RHS;
13155 if (LHSResult.
isInvalid() || RHSResult.isInvalid())
13157 LHS = LHSResult.
get();
13158 RHS = RHSResult.
get();
13177 bool EnumConstantInBoolContext =
false;
13179 if (
const auto *DREHS = dyn_cast<DeclRefExpr>(HS.get())) {
13180 const auto *ECDHS = dyn_cast<EnumConstantDecl>(DREHS->getDecl());
13181 if (ECDHS && ECDHS->getInitVal() != 0 && ECDHS->getInitVal() != 1)
13182 EnumConstantInBoolContext =
true;
13186 if (EnumConstantInBoolContext)
13187 Diag(
Loc, diag::warn_enum_constant_in_bool_context);
13192 const auto *LHSATy = dyn_cast<ArrayType>(LHSTy);
13193 const auto *RHSATy = dyn_cast<ArrayType>(RHSTy);
13194 if ((LHSATy && LHSATy->getElementType().isWebAssemblyReferenceType()) ||
13195 (RHSATy && RHSATy->getElementType().isWebAssemblyReferenceType())) {
13217 Diag(
Loc, diag::warn_logical_instead_of_bitwise)
13220 Diag(
Loc, diag::note_logical_instead_of_bitwise_change_operator)
13221 << (Opc == BO_LAnd ?
"&" :
"|")
13224 Opc == BO_LAnd ?
"&" :
"|");
13225 if (Opc == BO_LAnd)
13227 Diag(
Loc, diag::note_logical_instead_of_bitwise_remove_constant)
13284 if (!ME)
return false;
13288 if (!
Base)
return false;
13289 return Base->getMethodDecl() !=
nullptr;
13313 assert(S.
getLangOpts().CPlusPlus &&
"BindingDecl outside of C++?");
13322 assert(Var->
hasLocalStorage() &&
"capture added 'const' to non-local?");
13330 if (
auto *FD = dyn_cast<FunctionDecl>(DC))
13373 bool DiagnosticEmitted =
false;
13377 bool IsDereference =
false;
13378 bool NextIsDereference =
false;
13382 IsDereference = NextIsDereference;
13385 if (
const MemberExpr *ME = dyn_cast<MemberExpr>(
E)) {
13386 NextIsDereference = ME->isArrow();
13387 const ValueDecl *VD = ME->getMemberDecl();
13388 if (
const FieldDecl *Field = dyn_cast<FieldDecl>(VD)) {
13390 if (Field->isMutable()) {
13391 assert(DiagnosticEmitted &&
"Expected diagnostic not emitted.");
13396 if (!DiagnosticEmitted) {
13397 S.
Diag(
Loc, diag::err_typecheck_assign_const)
13399 << Field->getType();
13400 DiagnosticEmitted =
true;
13403 <<
ConstMember <<
false << Field << Field->getType()
13404 << Field->getSourceRange();
13408 }
else if (
const VarDecl *VDecl = dyn_cast<VarDecl>(VD)) {
13409 if (VDecl->getType().isConstQualified()) {
13410 if (!DiagnosticEmitted) {
13411 S.
Diag(
Loc, diag::err_typecheck_assign_const)
13413 << VDecl->getType();
13414 DiagnosticEmitted =
true;
13417 <<
ConstMember <<
true << VDecl << VDecl->getType()
13418 << VDecl->getSourceRange();
13425 dyn_cast<ArraySubscriptExpr>(
E)) {
13429 dyn_cast<ExtVectorElementExpr>(
E)) {
13436 if (
const CallExpr *CE = dyn_cast<CallExpr>(
E)) {
13440 if (!DiagnosticEmitted) {
13441 S.
Diag(
Loc, diag::err_typecheck_assign_const) << ExprRange
13443 DiagnosticEmitted =
true;
13446 diag::note_typecheck_assign_const)
13450 }
else if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(
E)) {
13452 if (
const ValueDecl *VD = DRE->getDecl()) {
13454 if (!DiagnosticEmitted) {
13455 S.
Diag(
Loc, diag::err_typecheck_assign_const)
13457 DiagnosticEmitted =
true;
13459 S.
Diag(VD->getLocation(), diag::note_typecheck_assign_const)
13460 <<
ConstVariable << VD << VD->getType() << VD->getSourceRange();
13463 }
else if (isa<CXXThisExpr>(
E)) {
13465 if (
const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(DC)) {
13466 if (MD->isConst()) {
13467 if (!DiagnosticEmitted) {
13468 S.
Diag(
Loc, diag::err_typecheck_assign_const) << ExprRange
13470 DiagnosticEmitted =
true;
13472 S.
Diag(MD->getLocation(), diag::note_typecheck_assign_const)
13479 if (DiagnosticEmitted)
13496 bool &DiagnosticEmitted) {
13497 std::vector<const RecordType *> RecordTypeList;
13498 RecordTypeList.push_back(Ty);
13499 unsigned NextToCheckIndex = 0;
13502 while (RecordTypeList.size() > NextToCheckIndex) {
13503 bool IsNested = NextToCheckIndex > 0;
13505 RecordTypeList[NextToCheckIndex]->getDecl()->fields()) {
13507 QualType FieldTy = Field->getType();
13509 if (!DiagnosticEmitted) {
13510 S.
Diag(
Loc, diag::err_typecheck_assign_const)
13512 << IsNested << Field;
13513 DiagnosticEmitted =
true;
13515 S.
Diag(Field->getLocation(), diag::note_typecheck_assign_const)
13517 << FieldTy << Field->getSourceRange();
13523 if (!llvm::is_contained(RecordTypeList, FieldRecTy))
13524 RecordTypeList.push_back(FieldRecTy);
13527 ++NextToCheckIndex;
13536 assert(Ty->
isRecordType() &&
"lvalue was not record?");
13539 bool DiagEmitted =
false;
13541 if (
const MemberExpr *ME = dyn_cast<MemberExpr>(
E))
13544 else if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(
E))
13569 unsigned DiagID = 0;
13570 bool NeedType =
false;
13577 DiagID = diag::err_block_decl_ref_not_modifiable_lvalue;
13579 DiagID = diag::err_lambda_decl_ref_not_modifiable_lvalue;
13587 if (declRef && isa<VarDecl>(declRef->
getDecl())) {
13592 if (var->isARCPseudoStrong() &&
13593 (!var->getTypeSourceInfo() ||
13594 !var->getTypeSourceInfo()->getType().isConstQualified())) {
13600 ? diag::err_typecheck_arc_assign_self_class_method
13601 : diag::err_typecheck_arc_assign_self;
13604 }
else if (var->hasAttr<ObjCExternallyRetainedAttr>() ||
13605 isa<ParmVarDecl>(var)) {
13606 DiagID = diag::err_typecheck_arc_assign_externally_retained;
13610 DiagID = diag::err_typecheck_arr_assign_enumeration;
13614 if (
Loc != OrigLoc)
13640 DiagID = diag::err_typecheck_array_not_modifiable_lvalue;
13644 DiagID = diag::err_typecheck_non_object_not_modifiable_lvalue;
13648 DiagID = diag::err_typecheck_lvalue_casts_not_supported;
13651 llvm_unreachable(
"did not take early return for MLV_Valid");
13655 DiagID = diag::err_typecheck_expression_not_modifiable_lvalue;
13660 diag::err_typecheck_incomplete_type_not_modifiable_lvalue,
E);
13662 DiagID = diag::err_typecheck_duplicate_vector_components_not_mlvalue;
13665 llvm_unreachable(
"readonly properties should be processed differently");
13667 DiagID = diag::err_readonly_message_assignment;
13670 DiagID = diag::err_no_subobject_property_setting;
13675 if (
Loc != OrigLoc)
13697 MemberExpr *ML = dyn_cast<MemberExpr>(LHSExpr);
13698 MemberExpr *MR = dyn_cast<MemberExpr>(RHSExpr);
13700 if (!(isa<CXXThisExpr>(ML->
getBase()) && isa<CXXThisExpr>(MR->
getBase())))
13706 if (LHSDecl != RHSDecl)
13711 if (RefTy->getPointeeType().isVolatileQualified())
13714 Sema.
Diag(
Loc, diag::warn_identity_field_assign) << 0;
13724 Sema.
Diag(
Loc, diag::warn_identity_field_assign) << 1;
13748 Diag(
Loc, diag::err_opencl_half_load_store) << 1
13755 Diag(
Loc, diag::err_wasm_table_art) << 0;
13760 if (CompoundType.
isNull()) {
13779 Diag(
Loc, diag::err_objc_object_assignment)
13786 RHSCheck = ICE->getSubExpr();
13787 if (
UnaryOperator *UO = dyn_cast<UnaryOperator>(RHSCheck)) {
13788 if ((UO->getOpcode() == UO_Plus || UO->getOpcode() == UO_Minus) &&
13789 Loc.
isFileID() && UO->getOperatorLoc().isFileID() &&
13795 UO->getSubExpr()->getBeginLoc().
isFileID()) {
13796 Diag(
Loc, diag::warn_not_compound_assign)
13797 << (UO->getOpcode() == UO_Plus ?
"+" :
"-")
13798 <<
SourceRange(UO->getOperatorLoc(), UO->getOperatorLoc());
13808 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InnerLHS);
13847 if (CompoundType.
isNull()) {
13873 if (
const CastExpr *CE = dyn_cast<CastExpr>(
E)) {
13874 if (CE->getCastKind() == CK_ToVoid) {
13880 CE->getSubExpr()->getType()->isDependentType()) {
13885 if (
const auto *CE = dyn_cast<CallExpr>(
E))
13886 return CE->getCallReturnType(Context)->isVoidType();
13906 const unsigned ForIncrementFlags =
13912 if ((ScopeFlags & ForIncrementFlags) == ForIncrementFlags ||
13913 (ScopeFlags & ForInitFlags) == ForInitFlags)
13918 while (
const BinaryOperator *BO = dyn_cast<BinaryOperator>(LHS)) {
13919 if (BO->getOpcode() != BO_Comma)
13921 LHS = BO->getRHS();
13928 Diag(
Loc, diag::warn_comma_operator);
13932 LangOpts.CPlusPlus ?
"static_cast<void>("
13964 diag::err_incomplete_type);
13985 ResType = ResAtomicType->getValueType();
13987 assert(!ResType.
isNull() &&
"no type for increment/decrement expression");
13997 : diag::warn_increment_bool)
14001 S.
Diag(OpLoc, diag::err_increment_decrement_enum) << IsInc << ResType;
14017 S.
Diag(OpLoc, S.
getLangOpts().C2y ? diag::warn_c2y_compat_increment_complex
14018 : diag::ext_c2y_increment_complex)
14035 S.
Diag(OpLoc, diag::err_typecheck_illegal_increment_decrement)
14046 S.
Diag(OpLoc, diag::warn_deprecated_increment_decrement_volatile)
14047 << IsInc << ResType;
14079 case Stmt::DeclRefExprClass:
14080 return cast<DeclRefExpr>(
E)->getDecl();
14081 case Stmt::MemberExprClass:
14085 if (cast<MemberExpr>(
E)->isArrow())
14089 case Stmt::ArraySubscriptExprClass: {
14092 Expr*
Base = cast<ArraySubscriptExpr>(
E)->getBase();
14094 if (ICE->getSubExpr()->getType()->isArrayType())
14099 case Stmt::UnaryOperatorClass: {
14111 case Stmt::ParenExprClass:
14113 case Stmt::ImplicitCastExprClass:
14117 case Stmt::CXXUuidofExprClass:
14118 return cast<CXXUuidofExpr>(
E)->getGuidDecl();
14127 AO_Vector_Element = 1,
14128 AO_Property_Expansion = 2,
14129 AO_Register_Variable = 3,
14130 AO_Matrix_Element = 4,
14145 const auto *DRE = cast<DeclRefExpr>(Op->
IgnoreParens());
14148 return Diag(OpLoc, diag::err_parens_pointer_member_function)
14152 if (isa<CXXDestructorDecl>(MD))
14153 return Diag(OpLoc, diag::err_typecheck_addrof_dtor)
14154 << DRE->getSourceRange();
14156 if (DRE->getQualifier())
14160 return Diag(OpLoc, diag::err_unqualified_pointer_member_function)
14161 << DRE->getSourceRange();
14165 return Diag(OpLoc, diag::err_unqualified_pointer_member_function)
14166 << DRE->getSourceRange()
14172 if (PTy->getKind() == BuiltinType::Overload) {
14174 if (!isa<OverloadExpr>(
E)) {
14175 assert(cast<UnaryOperator>(
E)->getOpcode() == UO_AddrOf);
14176 Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof_addrof_function)
14182 if (isa<UnresolvedMemberExpr>(Ovl))
14184 Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
14192 if (PTy->getKind() == BuiltinType::UnknownAny)
14195 if (PTy->getKind() == BuiltinType::BoundMember) {
14196 Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
14219 auto* VarRef = dyn_cast<DeclRefExpr>(op);
14220 if (VarRef && VarRef->refersToEnclosingVariableOrCapture()) {
14221 Diag(op->
getExprLoc(), diag::err_opencl_taking_address_capture);
14229 if (uOp->getOpcode() == UO_Deref)
14232 return uOp->getSubExpr()->getType();
14239 if (
auto *FD = dyn_cast_or_null<FunctionDecl>(dcl))
14245 unsigned AddressOfError = AO_No_Error;
14250 : diag::ext_typecheck_addrof_temporary)
14257 }
else if (isa<ObjCSelectorExpr>(op)) {
14264 if (!isa<DeclRefExpr>(op)) {
14265 Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
14284 auto ReturnOrParamTypeIsIncomplete = [&](
QualType T,
14289 diag::note_ptrauth_virtual_function_pointer_incomplete_arg_ret);
14290 Diag(RetArgTypeLoc,
14291 diag::note_ptrauth_virtual_function_incomplete_arg_ret_type)
14298 bool IsIncomplete =
14300 ReturnOrParamTypeIsIncomplete(
14303 IsIncomplete |= ReturnOrParamTypeIsIncomplete(PVD->getType(), OpLoc,
14304 PVD->getBeginLoc());
14318 if (isa<PseudoObjectExpr>(op)) {
14319 AddressOfError = AO_Property_Expansion;
14321 Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof)
14325 }
else if (
const auto *DRE = dyn_cast<DeclRefExpr>(op)) {
14326 if (
const auto *MD = dyn_cast_or_null<CXXMethodDecl>(DRE->getDecl()))
14332 AddressOfError = AO_Bit_Field;
14335 AddressOfError = AO_Vector_Element;
14338 AddressOfError = AO_Matrix_Element;
14342 if (
const VarDecl *vd = dyn_cast<VarDecl>(dcl)) {
14347 AddressOfError = AO_Register_Variable;
14349 }
else if (isa<MSPropertyDecl>(dcl)) {
14350 AddressOfError = AO_Property_Expansion;
14351 }
else if (isa<FunctionTemplateDecl>(dcl)) {
14353 }
else if (isa<FieldDecl>(dcl) || isa<IndirectFieldDecl>(dcl)) {
14363 if (isa<DeclRefExpr>(op) && cast<DeclRefExpr>(op)->getQualifier() &&
14364 !isa<ParenExpr>(OrigOp.
get())) {
14366 if (Ctx && Ctx->isRecord()) {
14369 diag::err_cannot_form_pointer_to_member_of_reference_type)
14374 while (cast<RecordDecl>(Ctx)->isAnonymousStructOrUnion())
14375 Ctx = Ctx->getParent();
14388 llvm_unreachable(
"Unknown/unexpected decl type");
14391 if (AddressOfError != AO_No_Error) {
14411 Diag(OpLoc, diag::err_wasm_ca_reference)
14416 Diag(OpLoc, diag::err_wasm_table_pr)
14422 CheckAddressOfPackedMember(op);
14428 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Exp);
14438 if (!FD->hasAttr<NonNullAttr>() && !Param->
hasAttr<NonNullAttr>())
14441 FD->ModifiedNonNullParams.insert(Param);
14447 bool IsAfterAmp =
false) {
14451 Op = ConvResult.
get();
14455 if (isa<CXXReinterpretCastExpr>(Op)) {
14463 Result = PT->getPointeeType();
14467 Result = OPT->getPointeeType();
14471 if (PR.
get() != Op)
14476 S.
Diag(OpLoc, diag::err_typecheck_indirection_requires_pointer)
14481 if (
Result->isVoidType()) {
14487 S.
Diag(OpLoc, diag::err_typecheck_indirection_through_void_pointer_cpp)
14490 S.
Diag(OpLoc, diag::ext_typecheck_indirection_through_void_pointer)
14507 default: llvm_unreachable(
"Unknown binop!");
14508 case tok::periodstar: Opc = BO_PtrMemD;
break;
14509 case tok::arrowstar: Opc = BO_PtrMemI;
break;
14510 case tok::star: Opc = BO_Mul;
break;
14511 case tok::slash: Opc = BO_Div;
break;
14512 case tok::percent: Opc = BO_Rem;
break;
14513 case tok::plus: Opc = BO_Add;
break;
14514 case tok::minus: Opc = BO_Sub;
break;
14515 case tok::lessless: Opc = BO_Shl;
break;
14516 case tok::greatergreater: Opc = BO_Shr;
break;
14517 case tok::lessequal: Opc = BO_LE;
break;
14518 case tok::less: Opc = BO_LT;
break;
14519 case tok::greaterequal: Opc = BO_GE;
break;
14520 case tok::greater: Opc = BO_GT;
break;
14521 case tok::exclaimequal: Opc = BO_NE;
break;
14522 case tok::equalequal: Opc = BO_EQ;
break;
14523 case tok::spaceship: Opc = BO_Cmp;
break;
14524 case tok::amp: Opc = BO_And;
break;
14525 case tok::caret: Opc = BO_Xor;
break;
14526 case tok::pipe: Opc = BO_Or;
break;
14527 case tok::ampamp: Opc = BO_LAnd;
break;
14528 case tok::pipepipe: Opc = BO_LOr;
break;
14529 case tok::equal: Opc = BO_Assign;
break;
14530 case tok::starequal: Opc = BO_MulAssign;
break;
14531 case tok::slashequal: Opc = BO_DivAssign;
break;
14532 case tok::percentequal: Opc = BO_RemAssign;
break;
14533 case tok::plusequal: Opc = BO_AddAssign;
break;
14534 case tok::minusequal: Opc = BO_SubAssign;
break;
14535 case tok::lesslessequal: Opc = BO_ShlAssign;
break;
14536 case tok::greatergreaterequal: Opc = BO_ShrAssign;
break;
14537 case tok::ampequal: Opc = BO_AndAssign;
break;
14538 case tok::caretequal: Opc = BO_XorAssign;
break;
14539 case tok::pipeequal: Opc = BO_OrAssign;
break;
14540 case tok::comma: Opc = BO_Comma;
break;
14549 default: llvm_unreachable(
"Unknown unary op!");
14550 case tok::plusplus: Opc = UO_PreInc;
break;
14551 case tok::minusminus: Opc = UO_PreDec;
break;
14552 case tok::amp: Opc = UO_AddrOf;
break;
14553 case tok::star: Opc = UO_Deref;
break;
14554 case tok::plus: Opc = UO_Plus;
break;
14555 case tok::minus: Opc = UO_Minus;
break;
14556 case tok::tilde: Opc = UO_Not;
break;
14557 case tok::exclaim: Opc = UO_LNot;
break;
14558 case tok::kw___real: Opc = UO_Real;
break;
14559 case tok::kw___imag: Opc = UO_Imag;
break;
14560 case tok::kw___extension__: Opc = UO_Extension;
break;
14576 if (!isa<ParmVarDecl>(SelfAssigned))
14578 const auto *Method =
14592 llvm::find_if(
Parent->fields(),
14594 return F->getDeclName() == Name;
14596 return (Field !=
Parent->field_end()) ? *Field :
nullptr;
14611 const DeclRefExpr *LHSDeclRef = dyn_cast<DeclRefExpr>(LHSExpr);
14612 const DeclRefExpr *RHSDeclRef = dyn_cast<DeclRefExpr>(RHSExpr);
14613 if (!LHSDeclRef || !RHSDeclRef ||
14621 if (LHSDecl != RHSDecl)
14626 if (RefTy->getPointeeType().isVolatileQualified())
14629 auto Diag = S.
Diag(OpLoc, IsBuiltin ? diag::warn_self_assignment_builtin
14630 : diag::warn_self_assignment_overloaded)
14635 Diag << 1 << SelfAssignField
14648 const Expr *ObjCPointerExpr =
nullptr, *OtherExpr =
nullptr;
14653 ObjCPointerExpr = LHS;
14657 ObjCPointerExpr = RHS;
14665 if (ObjCPointerExpr && isa<IntegerLiteral>(OtherExpr->IgnoreParenCasts())) {
14666 unsigned Diag = diag::warn_objc_pointer_masking;
14674 StringRef SelArg0 = S.getNameForSlot(0);
14675 if (SelArg0.starts_with(
"performSelector"))
14676 Diag = diag::warn_objc_pointer_masking_performSelector;
14687 if (
auto *DRE = dyn_cast<DeclRefExpr>(
E))
14688 return DRE->getDecl();
14689 if (
auto *ME = dyn_cast<MemberExpr>(
E))
14690 return ME->getMemberDecl();
14691 if (
auto *IRE = dyn_cast<ObjCIvarRefExpr>(
E))
14692 return IRE->getDecl();
14707 "Result must be a vector of half or short");
14710 "both operands expected to be a half vector");
14722 ResultTy, VK, OK, OpLoc, FPFeatures,
14723 BinOpResTy, BinOpResTy);
14727 BinOpResTy, VK, OK, OpLoc, FPFeatures);
14731static std::pair<ExprResult, ExprResult>
14741 RHS,
nullptr,
false,
14742 [Opc, LHS](
Expr *
E) {
14743 if (Opc != BO_Assign)
14750 return std::make_pair(LHS, RHS);
14757 if (!OpRequiresConversion || Ctx.
getLangOpts().NativeHalfType ||
14761 auto HasVectorOfHalfType = [&Ctx](
Expr *
E) {
14771 return VT->getElementType().getCanonicalType() == Ctx.
HalfTy;
14776 return HasVectorOfHalfType(E0) && (!E1 || HasVectorOfHalfType(E1));
14795 if (
Init.isInvalid())
14797 RHSExpr =
Init.get();
14807 bool ConvertHalfVec =
false;
14810 if (!LHS.
isUsable() || !RHS.isUsable())
14820 if (BO_Assign == Opc)
14821 Diag(OpLoc, diag::err_opencl_atomic_init) << 0 << SR;
14849 if (!ResultTy.
isNull()) {
14866 if (
auto *BE = dyn_cast<BlockExpr>(RHS.get()->IgnoreParens()))
14868 if (
auto *VD = dyn_cast<VarDecl>(DRE->getDecl()))
14869 if (VD->hasLocalStorage() &&
getCurScope()->isDeclScope(VD))
14870 BE->getBlockDecl()->setCanAvoidCopyToHeap();
14881 Opc == BO_PtrMemI);
14885 ConvertHalfVec =
true;
14893 ConvertHalfVec =
true;
14897 ConvertHalfVec =
true;
14908 ConvertHalfVec =
true;
14911 if (
const auto *BI = dyn_cast<BinaryOperator>(LHSExpr);
14912 BI && BI->isComparisonOp())
14913 Diag(OpLoc, diag::warn_consecutive_comparison);
14918 ConvertHalfVec =
true;
14922 ConvertHalfVec =
true;
14935 ConvertHalfVec =
true;
14940 ConvertHalfVec =
true;
14942 Opc == BO_DivAssign);
14943 CompLHSTy = CompResultTy;
14950 CompLHSTy = CompResultTy;
14956 ConvertHalfVec =
true;
14963 ConvertHalfVec =
true;
14972 CompLHSTy = CompResultTy;
14983 CompLHSTy = CompResultTy;
14991 VK = RHS.get()->getValueKind();
14992 OK = RHS.get()->getObjectKind();
15006 "both sides are half vectors or neither sides are");
15011 CheckArrayAccess(LHS.
get());
15012 CheckArrayAccess(RHS.get());
15018 if (ObjectSetClass && isa<ObjCIsaExpr>(LHS.
get())) {
15022 "object_setClass(")
15035 if (CompResultTy.
isNull()) {
15036 if (ConvertHalfVec)
15056 if (ConvertHalfVec)
15061 Context, LHS.
get(), RHS.get(), Opc, ResultTy, VK, OK, OpLoc,
15078 if (isLeftComp == isRightComp)
15083 bool isLeftBitwise = LHSBO && LHSBO->
isBitwiseOp();
15084 bool isRightBitwise = RHSBO && RHSBO->
isBitwiseOp();
15085 if (isLeftBitwise || isRightBitwise)
15097 Self.Diag(OpLoc, diag::warn_precedence_bitwise_rel)
15100 Self.PDiag(diag::note_precedence_silence) << OpStr,
15101 (isLeftComp ? LHSExpr : RHSExpr)->getSourceRange());
15103 Self.PDiag(diag::note_precedence_bitwise_first)
15118 Self.PDiag(diag::note_precedence_silence)
15127 if (Bop->getOpcode() == BO_LAnd) {
15130 if (!isa<StringLiteral>(Bop->getLHS()->IgnoreParenImpCasts()))
15132 }
else if (Bop->getOpcode() == BO_LOr) {
15133 if (
BinaryOperator *RBop = dyn_cast<BinaryOperator>(Bop->getRHS())) {
15136 if (RBop->getOpcode() == BO_LAnd &&
15137 isa<StringLiteral>(RBop->getRHS()->IgnoreParenImpCasts()))
15148 if (Bop->getOpcode() == BO_LAnd) {
15151 if (!isa<StringLiteral>(Bop->getRHS()->IgnoreParenImpCasts()))
15163 if (Bop->isBitwiseOp() && Bop->getOpcode() < Opc) {
15164 S.
Diag(Bop->getOperatorLoc(), diag::warn_bitwise_op_in_bitwise_op)
15166 << Bop->getSourceRange() << OpLoc;
15168 S.
PDiag(diag::note_precedence_silence)
15169 << Bop->getOpcodeStr(),
15170 Bop->getSourceRange());
15176 Expr *SubExpr, StringRef Shift) {
15178 if (Bop->getOpcode() == BO_Add || Bop->getOpcode() == BO_Sub) {
15179 StringRef Op = Bop->getOpcodeStr();
15180 S.
Diag(Bop->getOperatorLoc(), diag::warn_addition_in_bitshift)
15181 << Bop->getSourceRange() << OpLoc << Shift << Op;
15183 S.
PDiag(diag::note_precedence_silence) << Op,
15184 Bop->getSourceRange());
15200 if (Kind != OO_LessLess && Kind != OO_GreaterGreater)
15203 S.
Diag(OpLoc, diag::warn_overloaded_shift_in_comparison)
15205 << (Kind == OO_LessLess);
15207 S.
PDiag(diag::note_precedence_silence)
15208 << (Kind == OO_LessLess ?
"<<" :
">>"),
15211 S, OpLoc, S.
PDiag(diag::note_evaluate_comparison_first),
15225 if ((Opc == BO_Or || Opc == BO_Xor) &&
15233 if (Opc == BO_LOr && !OpLoc.
isMacroID()) {
15239 || Opc == BO_Shr) {
15253 if (
auto *CT = Operand->getType()->getAs<
ComplexType>()) {
15254 QualType ElementType = CT->getElementType();
15255 bool IsComplexRangePromoted = S.
getLangOpts().getComplexRange() ==
15260 const llvm::fltSemantics &ElementTypeSemantics =
15262 const llvm::fltSemantics &HigherElementTypeSemantics =
15264 if (llvm::APFloat::semanticsMaxExponent(ElementTypeSemantics) * 2 + 1 >
15265 llvm::APFloat::semanticsMaxExponent(HigherElementTypeSemantics)) {
15270 if (
Type == HigherElementType) {
15286 assert(LHSExpr &&
"ActOnBinOp(): missing left expression");
15287 assert(RHSExpr &&
"ActOnBinOp(): missing right expression");
15294 if (Kind == tok::TokenKind::slash)
15297 BuiltinCountedByRefKind K =
15300 CheckInvalidBuiltinCountedByRef(LHSExpr, K);
15301 CheckInvalidBuiltinCountedByRef(RHSExpr, K);
15303 return BuildBinOp(S, TokLoc, Opc, LHSExpr, RHSExpr);
15309 if (OverOp !=
OO_None && OverOp != OO_Equal)
15363 LHSExpr = LHS.
get();
15364 RHSExpr = RHS.
get();
15375 if (pty->getKind() == BuiltinType::PseudoObject &&
15388 RHSExpr = resolvedRHS.
get();
15402 (pty->getKind() == BuiltinType::BoundMember ||
15403 pty->getKind() == BuiltinType::Overload)) {
15404 auto *OE = dyn_cast<OverloadExpr>(LHSExpr);
15405 if (OE && !OE->hasTemplateKeyword() && !OE->hasExplicitTemplateArgs() &&
15406 llvm::any_of(OE->decls(), [](
NamedDecl *ND) {
15407 return isa<FunctionTemplateDecl>(ND);
15409 Diag(OE->getQualifier() ? OE->getQualifierLoc().getBeginLoc()
15410 : OE->getNameLoc(),
15411 diag::err_template_kw_missing)
15412 << OE->getName().getAsString() <<
"";
15419 LHSExpr = LHS.
get();
15426 if (Opc == BO_Assign && pty->getKind() == BuiltinType::Overload) {
15442 RHSExpr = resolvedRHS.
get();
15458 "Should only occur in error-recovery path.");
15464 Context, LHSExpr, RHSExpr, Opc,
15484 ResultType = RHSExpr->
getType();
15516 bool CanOverflow =
false;
15518 bool ConvertHalfVec =
false;
15527 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15534 if (Opc == UO_AddrOf)
15535 return ExprError(
Diag(OpLoc, diag::err_hlsl_operator_unsupported) << 0);
15536 if (Opc == UO_Deref)
15537 return ExprError(
Diag(OpLoc, diag::err_hlsl_operator_unsupported) << 1);
15551 Opc == UO_PreInc || Opc == UO_PostInc,
15552 Opc == UO_PreInc || Opc == UO_PreDec);
15557 CheckAddressOfNoDeref(InputExpr);
15570 CanOverflow = Opc == UO_Minus &&
15582 if (ConvertHalfVec)
15599 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15610 Diag(OpLoc, diag::ext_integer_complement_complex)
15619 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15622 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15644 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15660 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15670 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15680 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15687 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15721 "the co_await expression must be non-dependant before "
15722 "building operator co_await");
15733 if (Opc != UO_AddrOf && Opc != UO_Deref)
15734 CheckArrayAccess(Input.
get());
15740 if (Opc == UO_Deref && UO->getType()->hasAttr(attr::NoDeref) &&
15741 !isa<ArrayType>(UO->getType().getDesugaredType(
Context)) &&
15746 if (ConvertHalfVec)
15753 if (!DRE->getQualifier())
15760 if (isa<FieldDecl>(VD) || isa<IndirectFieldDecl>(VD))
15763 return Method->isImplicitObjectMemberFunction();
15769 if (!ULE->getQualifier())
15774 if (Method->isImplicitObjectMemberFunction())
15795 if (pty->getKind() == BuiltinType::PseudoObject &&
15800 if (Opc == UO_Extension)
15805 if (Opc == UO_AddrOf &&
15806 (pty->getKind() == BuiltinType::Overload ||
15807 pty->getKind() == BuiltinType::UnknownAny ||
15808 pty->getKind() == BuiltinType::BoundMember))
15833 Expr *Input,
bool IsAfterAmp) {
15872 assert(SubStmt && isa<CompoundStmt>(SubStmt) &&
"Invalid action invocation!");
15878 "cleanups within StmtExpr not correctly bound!");
15888 bool StmtExprMayBindToTemp =
false;
15891 if (
const auto *LastStmt =
15893 if (
const Expr *
Value = LastStmt->getExprStmt()) {
15894 StmtExprMayBindToTemp =
true;
15902 Expr *ResStmtExpr =
15904 if (StmtExprMayBindToTemp)
15906 return ResStmtExpr;
15929 auto *Cast = dyn_cast<ImplicitCastExpr>(
E);
15930 if (Cast && Cast->getCastKind() == CK_ARCConsumeObject)
15931 return Cast->getSubExpr();
15952 return ExprError(
Diag(BuiltinLoc, diag::err_offsetof_record_type)
15953 << ArgTy << TypeRange);
15959 diag::err_offsetof_incomplete_type, TypeRange))
15962 bool DidWarnAboutNonPOD =
false;
15967 if (OC.isBrackets) {
15972 return ExprError(
Diag(OC.LocEnd, diag::err_offsetof_array_type)
15992 Comps.push_back(
OffsetOfNode(OC.LocStart, Exprs.size(), OC.LocEnd));
15993 Exprs.push_back(Idx);
16001 Comps.push_back(
OffsetOfNode(OC.LocStart, OC.U.IdentInfo, OC.LocEnd));
16008 diag::err_offsetof_incomplete_type))
16014 return ExprError(
Diag(OC.LocEnd, diag::err_offsetof_record_type)
16026 bool IsSafe =
LangOpts.CPlusPlus11? CRD->isStandardLayout() : CRD->isPOD();
16028 LangOpts.CPlusPlus11? diag::ext_offsetof_non_standardlayout_type
16029 : diag::ext_offsetof_non_pod_type;
16032 Diag(BuiltinLoc, DiagID)
16033 <<
SourceRange(Components[0].LocStart, OC.LocEnd) << CurrentType;
16034 DidWarnAboutNonPOD =
true;
16045 MemberDecl = IndirectMemberDecl->getAnonField();
16053 Diag(BuiltinLoc, diag::err_no_member)
16054 << OC.U.IdentInfo << RD <<
SourceRange(OC.LocStart, OC.LocEnd);
16063 Diag(OC.LocEnd, diag::err_offsetof_bitfield)
16071 if (IndirectMemberDecl)
16072 Parent = cast<RecordDecl>(IndirectMemberDecl->getDeclContext());
16079 if (Paths.getDetectedVirtual()) {
16080 Diag(OC.LocEnd, diag::err_offsetof_field_of_virtual_base)
16091 if (IndirectMemberDecl) {
16092 for (
auto *FI : IndirectMemberDecl->chain()) {
16093 assert(isa<FieldDecl>(FI));
16095 cast<FieldDecl>(FI), OC.LocEnd));
16098 Comps.push_back(
OffsetOfNode(OC.LocStart, MemberDecl, OC.LocEnd));
16104 Comps, Exprs, RParenLoc);
16130 assert((CondExpr && LHSExpr && RHSExpr) &&
"Missing type argument(s)");
16135 bool CondIsTrue =
false;
16140 llvm::APSInt condEval(32);
16142 CondExpr, &condEval, diag::err_typecheck_choose_expr_requires_constant);
16145 CondExpr = CondICE.
get();
16146 CondIsTrue = condEval.getZExtValue();
16149 Expr *ActiveExpr = CondIsTrue ? LHSExpr : RHSExpr;
16151 resType = ActiveExpr->
getType();
16157 resType, VK, OK, RPLoc, CondIsTrue);
16169 Decl *ManglingContextDecl;
16170 std::tie(MCtx, ManglingContextDecl) =
16174 Block->setBlockMangling(ManglingNumber, ManglingContextDecl);
16196 "block-id should have no identifier!");
16208 "GetTypeForDeclarator made a non-function block signature");
16224 unsigned Size =
Result.getFullDataSize();
16236 QualType RetTy = Fn->getReturnType();
16238 (isa<FunctionProtoType>(Fn) && cast<FunctionProtoType>(Fn)->isVariadic());
16254 if (ExplicitSignature) {
16255 for (
unsigned I = 0,
E = ExplicitSignature.
getNumParams(); I !=
E; ++I) {
16263 Params.push_back(Param);
16269 for (
const auto &I : Fn->param_types()) {
16272 Params.push_back(Param);
16277 if (!Params.empty()) {
16288 AI->setOwningFunction(CurBlock->
TheDecl);
16291 if (AI->getIdentifier()) {
16297 if (AI->isInvalidDecl())
16316 Diag(CaretLoc, diag::err_blocks_disable) <<
LangOpts.OpenCL;
16322 "cleanups within block not correctly bound!");
16337 bool NoReturn = BD->
hasAttr<NoReturnAttr>();
16345 if (NoReturn && !Ext.getNoReturn()) Ext = Ext.
withNoReturn(
true);
16348 if (isa<FunctionNoProtoType>(FTy)) {
16383 BD->
setBody(cast<CompoundStmt>(Body));
16385 if (Body &&
getCurFunction()->HasPotentialAvailabilityViolations)
16410 Expr *CopyExpr =
nullptr;
16419 if (isa<ParmVarDecl>(Var))
16438 if (!
Result.isInvalid() &&
16439 !
Result.get()->getType().isConstQualified()) {
16441 Result.get()->getType().withConst(),
16445 if (!
Result.isInvalid()) {
16455 if (!
Result.isInvalid() &&
16456 !cast<CXXConstructExpr>(
Result.get())->getConstructor()
16459 CopyExpr =
Result.get();
16466 Captures.push_back(NewCap);
16479 if (
Result->getBlockDecl()->hasCaptures()) {
16486 for (
const auto &CI :
Result->getBlockDecl()->captures()) {
16487 const VarDecl *var = CI.getVariable();
16502 {Result},
Result->getType());
16516 Expr *OrigExpr =
E;
16566 if (
Init.isInvalid())
16582 diag::err_first_argument_to_va_arg_not_of_type_va_list)
16587 diag::err_second_parameter_to_va_arg_incomplete,
16593 diag::err_second_parameter_to_va_arg_abstract,
16600 ? diag::warn_second_parameter_to_va_arg_ownership_qualified
16601 : diag::warn_second_parameter_to_va_arg_not_pod)
16608 PDiag(diag::warn_second_parameter_to_va_arg_array)
16641 UnderlyingType = ET->getDecl()->getIntegerType();
16664 if (!PromoteType.
isNull())
16666 PDiag(diag::warn_second_parameter_to_va_arg_never_compatible)
16688 llvm_unreachable(
"I don't know size of pointer!");
16705 if ((SLDecl->isCompleteDefinition() || SLDecl->isBeingDefined()) &&
16714 S.
Diag(
Loc, diag::err_std_source_location_impl_not_found);
16722 S.
Diag(
Loc, diag::err_std_source_location_impl_malformed);
16726 unsigned Count = 0;
16728 StringRef Name = F->getName();
16730 if (Name ==
"_M_file_name") {
16731 if (F->getType() !=
16735 }
else if (Name ==
"_M_function_name") {
16736 if (F->getType() !=
16740 }
else if (Name ==
"_M_line") {
16741 if (!F->getType()->isIntegerType())
16744 }
else if (Name ==
"_M_column") {
16745 if (!F->getType()->isIntegerType())
16754 S.
Diag(
Loc, diag::err_std_source_location_impl_malformed);
16805 Data->BinaryData = BinaryData;
16808 Data->getDataElementCount());
16812 const Expr *SrcExpr) {
16821 auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl());
16834 bool *Complained) {
16836 *Complained =
false;
16839 bool CheckInferredResultType =
false;
16841 unsigned DiagKind = 0;
16843 bool MayHaveConvFixit =
false;
16844 bool MayHaveFunctionDiff =
false;
16855 DiagKind = diag::err_typecheck_convert_pointer_int;
16858 DiagKind = diag::ext_typecheck_convert_pointer_int;
16861 MayHaveConvFixit =
true;
16865 DiagKind = diag::err_typecheck_convert_int_pointer;
16868 DiagKind = diag::ext_typecheck_convert_int_pointer;
16871 MayHaveConvFixit =
true;
16875 diag::warn_typecheck_convert_incompatible_function_pointer_strict;
16877 MayHaveConvFixit =
true;
16881 DiagKind = diag::err_typecheck_convert_incompatible_function_pointer;
16884 DiagKind = diag::ext_typecheck_convert_incompatible_function_pointer;
16887 MayHaveConvFixit =
true;
16891 DiagKind = diag::err_arc_typecheck_convert_incompatible_pointer;
16893 DiagKind = diag::err_typecheck_convert_incompatible_pointer;
16896 DiagKind = diag::ext_typecheck_convert_incompatible_pointer;
16900 if (CheckInferredResultType) {
16906 MayHaveConvFixit =
true;
16910 DiagKind = diag::err_typecheck_convert_incompatible_pointer_sign;
16913 DiagKind = diag::ext_typecheck_convert_incompatible_pointer_sign;
16918 DiagKind = diag::err_typecheck_convert_pointer_void_func;
16921 DiagKind = diag::ext_typecheck_convert_pointer_void_func;
16933 DiagKind = diag::err_typecheck_incompatible_address_space;
16936 DiagKind = diag::err_typecheck_incompatible_ownership;
16940 llvm_unreachable(
"unknown error case for discarding qualifiers!");
16957 DiagKind = diag::err_typecheck_convert_discards_qualifiers;
16960 DiagKind = diag::ext_typecheck_convert_discards_qualifiers;
16967 DiagKind = diag::err_nested_pointer_qualifier_mismatch;
16969 DiagKind = diag::ext_nested_pointer_qualifier_mismatch;
16973 DiagKind = diag::err_typecheck_incompatible_nested_address_space;
16977 DiagKind = diag::err_int_to_block_pointer;
16981 DiagKind = diag::err_typecheck_convert_incompatible_block_pointer;
16988 for (
auto *srcProto : srcOPT->
quals()) {
16994 IFace = IFaceT->getDecl();
16999 for (
auto *dstProto : dstOPT->
quals()) {
17005 IFace = IFaceT->getDecl();
17008 DiagKind = diag::err_incompatible_qualified_id;
17011 DiagKind = diag::warn_incompatible_qualified_id;
17017 DiagKind = diag::err_incompatible_vectors;
17020 DiagKind = diag::warn_incompatible_vectors;
17024 DiagKind = diag::err_arc_weak_unavailable_assign;
17030 *Complained =
true;
17034 DiagKind = diag::err_typecheck_convert_incompatible;
17036 MayHaveConvFixit =
true;
17038 MayHaveFunctionDiff =
true;
17047 FirstType = DstType;
17048 SecondType = SrcType;
17058 FirstType = SrcType;
17059 SecondType = DstType;
17068 FDiag << FirstType << SecondType << ActionForDiag
17071 if (DiagKind == diag::ext_typecheck_convert_incompatible_pointer_sign ||
17072 DiagKind == diag::err_typecheck_convert_incompatible_pointer_sign) {
17082 if (!ConvHints.
isNull()) {
17087 if (MayHaveConvFixit) { FDiag << (
unsigned) (ConvHints.
Kind); }
17089 if (MayHaveFunctionDiff)
17093 if ((DiagKind == diag::warn_incompatible_qualified_id ||
17094 DiagKind == diag::err_incompatible_qualified_id) &&
17096 Diag(IFace->
getLocation(), diag::note_incomplete_class_and_qualified_id)
17103 if (CheckInferredResultType)
17110 *Complained =
true;
17121 return S.
Diag(
Loc, diag::err_ice_not_integral)
17140 IDDiagnoser(
unsigned DiagID)
17146 } Diagnoser(DiagID);
17181 BaseDiagnoser(BaseDiagnoser) {}
17190 return S.
Diag(
Loc, diag::err_ice_incomplete_type) <<
T;
17195 return S.
Diag(
Loc, diag::err_ice_explicit_conversion) <<
T << ConvTy;
17206 return S.
Diag(
Loc, diag::err_ice_ambiguous_conversion) <<
T;
17217 llvm_unreachable(
"conversion functions are permitted");
17219 } ConvertDiagnoser(Diagnoser);
17225 E = Converted.
get();
17230 if (isa<RecoveryExpr>(
E))
17246 E = RValueExpr.
get();
17254 if (!isa<ConstantExpr>(
E))
17264 if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
17265 diag::note_invalid_subexpr_in_const_expr) {
17266 DiagLoc = Notes[0].first;
17288 EvalResult.
Diag = &Notes;
17297 if (!isa<ConstantExpr>(
E))
17303 if (Folded &&
getLangOpts().CPlusPlus11 && Notes.empty()) {
17312 if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
17313 diag::note_invalid_subexpr_in_const_expr) {
17314 DiagLoc = Notes[0].first;
17318 if (!Folded || !CanFold) {
17340 class TransformToPE :
public TreeTransform<TransformToPE> {
17344 TransformToPE(
Sema &SemaRef) : BaseTransform(SemaRef) { }
17347 bool AlwaysRebuild() {
return true; }
17348 bool ReplacingOriginal() {
return true; }
17358 if (isa<FieldDecl>(
E->getDecl()) &&
17359 !SemaRef.isUnevaluatedContext())
17360 return SemaRef.Diag(
E->getLocation(),
17361 diag::err_invalid_non_static_member_use)
17364 return BaseTransform::TransformDeclRefExpr(
E);
17372 return BaseTransform::TransformUnaryOperator(
E);
17380 return SkipLambdaBody(
E, Body);
17387 "Should only transform unevaluated expressions");
17392 return TransformToPE(*this).TransformExpr(
E);
17397 "Should only transform unevaluated expressions");
17401 return TransformToPE(*this).TransformType(TInfo);
17409 LambdaContextDecl, ExprContext);
17423 Prev.isImmediateFunctionContext() || Prev.isConstantEvaluated();
17426 Prev.InImmediateEscalatingFunctionContext;
17445 if (
const auto *
E = dyn_cast<UnaryOperator>(PossibleDeref)) {
17446 if (
E->getOpcode() == UO_Deref)
17447 return CheckPossibleDeref(S,
E->getSubExpr());
17448 }
else if (
const auto *
E = dyn_cast<ArraySubscriptExpr>(PossibleDeref)) {
17449 return CheckPossibleDeref(S,
E->getBase());
17450 }
else if (
const auto *
E = dyn_cast<MemberExpr>(PossibleDeref)) {
17451 return CheckPossibleDeref(S,
E->getBase());
17452 }
else if (
const auto E = dyn_cast<DeclRefExpr>(PossibleDeref)) {
17456 Inner = Ptr->getPointeeType();
17458 Inner = Arr->getElementType();
17462 if (Inner->hasAttr(attr::NoDeref))
17472 const DeclRefExpr *DeclRef = CheckPossibleDeref(*
this,
E);
17479 Diag(
E->
getExprLoc(), diag::warn_dereference_of_noderef_type_no_decl)
17494 if (BO->getOpcode() == BO_Assign) {
17496 llvm::erase(LHSs, BO->getLHS());
17504 "Cannot mark an immediate escalating expression outside of an "
17505 "immediate escalating context");
17508 if (
auto *DeclRef =
17509 dyn_cast<DeclRefExpr>(
Call->getCallee()->IgnoreImplicit()))
17510 DeclRef->setIsImmediateEscalating(
true);
17511 }
else if (
auto *Ctr = dyn_cast<CXXConstructExpr>(
E->
IgnoreImplicit())) {
17512 Ctr->setIsImmediateEscalating(
true);
17513 }
else if (
auto *DeclRef = dyn_cast<DeclRefExpr>(
E->
IgnoreImplicit())) {
17514 DeclRef->setIsImmediateEscalating(
true);
17516 assert(
false &&
"expected an immediately escalating expression");
17519 FI->FoundImmediateEscalatingExpression =
true;
17534 if (
auto *DeclRef =
17535 dyn_cast<DeclRefExpr>(
Call->getCallee()->IgnoreImplicit()))
17544 auto CheckConstantExpressionAndKeepResult = [&]() {
17547 Eval.
Diag = &Notes;
17549 Eval,
getASTContext(), ConstantExprKind::ImmediateInvocation);
17550 if (Res && Notes.empty()) {
17551 Cached = std::move(Eval.
Val);
17559 !CheckConstantExpressionAndKeepResult()) {
17594 ExprEvalContexts.back().ImmediateInvocationCandidates.emplace_back(Res, 0);
17602 Eval.
Diag = &Notes;
17606 if (!
Result || !Notes.empty()) {
17609 if (
auto *
FunctionalCast = dyn_cast<CXXFunctionalCastExpr>(InnerExpr))
17612 if (
auto *
Call = dyn_cast<CallExpr>(InnerExpr))
17613 FD = cast<FunctionDecl>(
Call->getCalleeDecl());
17614 else if (
auto *
Call = dyn_cast<CXXConstructExpr>(InnerExpr))
17615 FD =
Call->getConstructor();
17616 else if (
auto *Cast = dyn_cast<CastExpr>(InnerExpr))
17617 FD = dyn_cast_or_null<FunctionDecl>(Cast->getConversionFunction());
17620 "could not find an immediate function in this expression");
17633 for (
auto &
Note : Notes)
17645 llvm::SmallPtrSetImpl<DeclRefExpr *> &DRSet;
17649 ComplexRemove(
Sema &SemaRef, llvm::SmallPtrSetImpl<DeclRefExpr *> &DR,
17652 4>::reverse_iterator Current)
17653 :
Base(SemaRef), DRSet(DR), IISet(II), CurrentII(Current) {}
17655 auto It = std::find_if(CurrentII, IISet.rend(),
17657 return Elem.getPointer() == E;
17663 if (It == IISet.rend()) {
17665 CurrentII->setInt(1);
17671 if (!
E->isImmediateInvocation())
17672 return Base::TransformConstantExpr(
E);
17673 RemoveImmediateInvocation(
E);
17674 return Base::TransformExpr(
E->getSubExpr());
17680 return Base::TransformCXXOperatorCallExpr(
E);
17694 if (
auto *ICE = dyn_cast<ImplicitCastExpr>(
Init))
17695 Init = ICE->getSubExpr();
17696 else if (
auto *ICE = dyn_cast<MaterializeTemporaryExpr>(
Init))
17697 Init = ICE->getSubExpr();
17703 if (
auto *CE = dyn_cast<ConstantExpr>(
Init);
17704 CE && CE->isImmediateInvocation())
17705 RemoveImmediateInvocation(CE);
17706 return Base::TransformInitializer(
Init, NotCopyInit);
17717 bool AlwaysRebuild() {
return false; }
17718 bool ReplacingOriginal() {
return true; }
17719 bool AllowSkippingCXXConstructExpr() {
17720 bool Res = AllowSkippingFirstCXXConstructExpr;
17721 AllowSkippingFirstCXXConstructExpr =
true;
17724 bool AllowSkippingFirstCXXConstructExpr =
true;
17734 if (isa<CXXConstructExpr>(It->getPointer()->IgnoreImplicit()))
17735 Transformer.AllowSkippingFirstCXXConstructExpr =
false;
17737 ExprResult Res = Transformer.TransformExpr(It->getPointer()->getSubExpr());
17743 It->getPointer()->setSubExpr(Res.
get());
17778 llvm::SmallPtrSetImpl<DeclRefExpr *> &DRSet;
17779 SimpleRemove(llvm::SmallPtrSetImpl<DeclRefExpr *> &S) : DRSet(S) {}
17782 return DRSet.size();
17785 Visitor.TraverseStmt(
17795 if (DR->isImmediateEscalating())
17797 auto *FD = cast<FunctionDecl>(DR->getDecl());
17799 if (
const auto *MD = dyn_cast<CXXMethodDecl>(ND);
17801 ND = MD->getParent();
17808 bool ImmediateEscalating =
false;
17809 bool IsPotentiallyEvaluated =
17819 SemaRef.
Diag(DR->getBeginLoc(), diag::err_invalid_consteval_take_address)
17820 << ND << isa<CXXRecordDecl>(ND) << FD->isConsteval();
17821 if (!FD->getBuiltinID())
17829 if (FD->isImmediateEscalating() && !FD->isConsteval())
17845 (Rec.
ExprContext == ExpressionKind::EK_TemplateArgument ||
17853 D = diag::err_lambda_unevaluated_operand;
17859 D = diag::err_lambda_in_constant_expression;
17860 }
else if (Rec.
ExprContext == ExpressionKind::EK_TemplateArgument) {
17863 D = diag::err_lambda_in_invalid_context;
17865 llvm_unreachable(
"Couldn't infer lambda error message.");
17867 for (
const auto *L : Rec.
Lambdas)
17868 Diag(L->getBeginLoc(),
D);
17888 Diag(BO->getBeginLoc(), diag::warn_deprecated_simple_assign_volatile)
17961 llvm_unreachable(
"Invalid context");
17970 if (!TT.isOSWindows() || !TT.isX86())
18008 : FD(FD), Param(Param) {}
18015 CCName =
"stdcall";
18018 CCName =
"fastcall";
18021 CCName =
"vectorcall";
18024 llvm_unreachable(
"CC does not need mangling");
18027 S.
Diag(
Loc, diag::err_cconv_incomplete_param_type)
18033 ParamIncompleteTypeDiagnoser Diagnoser(FD, Param);
18039enum class OdrUseContext {
18061 return OdrUseContext::None;
18066 Result = OdrUseContext::Used;
18070 Result = OdrUseContext::FormallyOdrUsed;
18076 Result = OdrUseContext::FormallyOdrUsed;
18081 return OdrUseContext::Dependent;
18087 if (!
Func->isConstexpr())
18090 if (
Func->isImplicitlyInstantiable() || !
Func->isUserProvided())
18092 auto *CCD = dyn_cast<CXXConstructorDecl>(
Func);
18093 return CCD && CCD->getInheritedConstructor();
18097 bool MightBeOdrUse) {
18098 assert(
Func &&
"No function?");
18100 Func->setReferenced();
18113 OdrUseContext OdrUse =
18115 if (IsRecursiveCall && OdrUse == OdrUseContext::Used)
18116 OdrUse = OdrUseContext::FormallyOdrUsed;
18120 if (
Func->isTrivial() && !
Func->hasAttr<DLLExportAttr>() &&
18121 OdrUse == OdrUseContext::Used) {
18122 if (
auto *Constructor = dyn_cast<CXXConstructorDecl>(
Func))
18123 if (Constructor->isDefaultConstructor())
18124 OdrUse = OdrUseContext::FormallyOdrUsed;
18125 if (isa<CXXDestructorDecl>(
Func))
18126 OdrUse = OdrUseContext::FormallyOdrUsed;
18133 bool NeededForConstantEvaluation =
18158 bool NeedDefinition =
18159 !IsRecursiveCall &&
18160 (OdrUse == OdrUseContext::Used ||
18161 (NeededForConstantEvaluation && !
Func->isPureVirtual()));
18168 if (NeedDefinition &&
18170 Func->getMemberSpecializationInfo()))
18177 if (NeedDefinition && !
Func->getBody()) {
18180 dyn_cast<CXXConstructorDecl>(
Func)) {
18181 Constructor = cast<CXXConstructorDecl>(Constructor->getFirstDecl());
18182 if (Constructor->isDefaulted() && !Constructor->isDeleted()) {
18183 if (Constructor->isDefaultConstructor()) {
18184 if (Constructor->isTrivial() &&
18185 !Constructor->hasAttr<DLLExportAttr>())
18188 }
else if (Constructor->isCopyConstructor()) {
18190 }
else if (Constructor->isMoveConstructor()) {
18193 }
else if (Constructor->getInheritedConstructor()) {
18197 dyn_cast<CXXDestructorDecl>(
Func)) {
18207 if (MethodDecl->isOverloadedOperator() &&
18208 MethodDecl->getOverloadedOperator() == OO_Equal) {
18209 MethodDecl = cast<CXXMethodDecl>(MethodDecl->getFirstDecl());
18210 if (MethodDecl->isDefaulted() && !MethodDecl->isDeleted()) {
18211 if (MethodDecl->isCopyAssignmentOperator())
18213 else if (MethodDecl->isMoveAssignmentOperator())
18216 }
else if (isa<CXXConversionDecl>(MethodDecl) &&
18217 MethodDecl->getParent()->isLambda()) {
18219 cast<CXXConversionDecl>(MethodDecl->getFirstDecl());
18224 }
else if (MethodDecl->isVirtual() &&
getLangOpts().AppleKext)
18228 if (
Func->isDefaulted() && !
Func->isDeleted()) {
18236 if (
Func->isImplicitlyInstantiable()) {
18238 Func->getTemplateSpecializationKindForInstantiation();
18240 bool FirstInstantiation = PointOfInstantiation.
isInvalid();
18241 if (FirstInstantiation) {
18242 PointOfInstantiation =
Loc;
18243 if (
auto *MSI =
Func->getMemberSpecializationInfo())
18244 MSI->setPointOfInstantiation(
Loc);
18247 Func->setTemplateSpecializationKind(TSK, PointOfInstantiation);
18252 PointOfInstantiation =
Loc;
18256 Func->isConstexpr()) {
18257 if (isa<CXXRecordDecl>(
Func->getDeclContext()) &&
18258 cast<CXXRecordDecl>(
Func->getDeclContext())->isLocalClass() &&
18261 std::make_pair(
Func, PointOfInstantiation));
18262 else if (
Func->isConstexpr())
18268 Func->setInstantiationIsPending(
true);
18270 std::make_pair(
Func, PointOfInstantiation));
18271 if (llvm::isTimeTraceVerbose()) {
18272 llvm::timeTraceAddInstantEvent(
"DeferInstantiation", [&] {
18274 llvm::raw_string_ostream
OS(Name);
18286 for (
auto *i :
Func->redecls()) {
18287 if (!i->isUsed(
false) && i->isImplicitlyInstantiable())
18300 Constructor->isImmediateFunction()
18305 if (
Init->isInClassMemberInitializer())
18307 MarkDeclarationsReferencedInExpr(Init->getInit());
18328 if (
LangOpts.OffloadImplicitHostDeviceTemplates &&
LangOpts.CUDAIsDevice &&
18333 if (OdrUse == OdrUseContext::Used && !
Func->isUsed(
false)) {
18335 if (!
Func->isDefined()) {
18336 if (mightHaveNonExternalLinkage(
Func))
18338 else if (
Func->getMostRecentDecl()->isInlined() &&
18340 !
Func->getMostRecentDecl()->hasAttr<GNUInlineAttr>())
18359 if (
auto *Dtor = dyn_cast<CXXDestructorDecl>(
Func)) {
18361 if (
Parent->getNumVBases() > 0 && !Dtor->getBody())
18379 const unsigned *
const FunctionScopeIndexToStopAt =
nullptr) {
18382 VarDecl *Var =
V->getPotentiallyDecomposedVarDecl();
18383 assert(Var &&
"expected a capturable variable");
18393 QualType CaptureType, DeclRefType;
18399 DeclRefType, FunctionScopeIndexToStopAt);
18415 << llvm::to_underlying(UserTarget);
18418 ? diag::note_cuda_const_var_unpromoted
18419 : diag::note_cuda_host_var);
18422 !Var->
hasAttr<CUDASharedAttr>() &&
18438 (!FD || (!FD->getDescribedFunctionTemplate() &&
18450 unsigned CapturingScopeIndex) {
18461 if (isa<ParmVarDecl>(var) &&
18462 isa<TranslationUnitDecl>(VarDC))
18475 unsigned ValueKind = isa<BindingDecl>(var) ? 1 : 0;
18476 unsigned ContextKind = 3;
18477 if (isa<CXXMethodDecl>(VarDC) &&
18478 cast<CXXRecordDecl>(VarDC->
getParent())->isLambda()) {
18480 }
else if (isa<FunctionDecl>(VarDC)) {
18482 }
else if (isa<BlockDecl>(VarDC)) {
18486 S.
Diag(loc, diag::err_reference_to_local_in_enclosing_context)
18487 << var << ValueKind << ContextKind << VarDC;
18488 S.
Diag(var->getLocation(), diag::note_entity_declared_at)
18497 bool &SubCapturesAreNested,
18503 SubCapturesAreNested =
true;
18520 !(isa<LambdaScopeInfo>(CSI) &&
18521 !cast<LambdaScopeInfo>(CSI)->lambdaCaptureShouldBeConst()) &&
18522 !(isa<CapturedRegionScopeInfo>(CSI) &&
18523 cast<CapturedRegionScopeInfo>(CSI)->CapRegionKind ==
CR_OpenMP))
18555 assert((isa<VarDecl, BindingDecl>(Var)) &&
18556 "Only variables and structured bindings can be captured");
18558 bool IsBlock = isa<BlockScopeInfo>(CSI);
18559 bool IsLambda = isa<LambdaScopeInfo>(CSI);
18567 S.
Diag(
Loc, diag::err_lambda_capture_anonymous_var);
18576 S.
Diag(
Loc, diag::err_ref_vm_type);
18584 if (VTTy->getDecl()->hasFlexibleArrayMember()) {
18587 S.
Diag(
Loc, diag::err_ref_flexarray_type);
18589 S.
Diag(
Loc, diag::err_lambda_capture_flexarray_type) << Var;
18595 const bool HasBlocksAttr = Var->
hasAttr<BlocksAttr>();
18598 if (HasBlocksAttr && (IsLambda || isa<CapturedRegionScopeInfo>(CSI))) {
18600 S.
Diag(
Loc, diag::err_capture_block_variable) << Var << !IsLambda;
18609 S.
Diag(
Loc, diag::err_opencl_block_ref_block);
18613 if (isa<BindingDecl>(Var)) {
18620 ? diag::warn_cxx17_compat_capture_binding
18621 : diag::ext_capture_binding)
18635 bool ByRef =
false;
18641 if (BuildAndDiagnose) {
18642 S.
Diag(
Loc, diag::err_ref_array_type);
18653 if (BuildAndDiagnose) {
18654 S.
Diag(
Loc, diag::err_arc_autoreleasing_capture)
18670 if (BuildAndDiagnose) {
18672 S.
Diag(
Loc, diag::warn_block_capture_autoreleasing);
18673 S.
Diag(VarLoc, diag::note_declare_parameter_strong);
18678 const bool HasBlocksAttr = Var->
hasAttr<BlocksAttr>();
18687 DeclRefType = CaptureType;
18691 if (BuildAndDiagnose)
18701 const bool BuildAndDiagnose,
QualType &CaptureType,
QualType &DeclRefType,
18728 CaptureType = DeclRefType;
18731 if (BuildAndDiagnose)
18732 RSI->
addCapture(Var,
false, ByRef, RefersToCapturedVariable,
18742 const bool RefersToCapturedVariable,
18747 bool ByRef =
false;
18751 ByRef = (LSI->
ImpCaptureStyle == LambdaScopeInfo::ImpCap_LambdaByref);
18756 S.
Diag(
Loc, diag::err_wasm_ca_reference) << 0;
18787 if (!RefType->getPointeeType()->isFunctionType())
18794 if (BuildAndDiagnose) {
18795 S.
Diag(
Loc, diag::err_arc_autoreleasing_capture) << 1;
18805 if (!
Invalid && BuildAndDiagnose) {
18809 diag::err_capture_of_incomplete_or_sizeless_type,
18813 diag::err_capture_of_abstract_type))
18839 if (BuildAndDiagnose)
18840 LSI->
addCapture(Var,
false, ByRef, RefersToCapturedVariable,
18852 if (
T.isTriviallyCopyableType(
Context))
18856 if (!(RD = RD->getDefinition()))
18858 if (RD->hasSimpleCopyConstructor())
18860 if (RD->hasUserDeclaredCopyConstructor())
18862 if (Ctor->isCopyConstructor())
18863 return !Ctor->isDeleted();
18883 if (ShouldOfferCopyFix) {
18887 FixBuffer.assign({Separator, Var->
getName()});
18888 Sema.
Diag(VarInsertLoc, diag::note_lambda_variable_capture_fixit)
18893 FixBuffer.assign({Separator,
"&", Var->
getName()});
18894 Sema.
Diag(VarInsertLoc, diag::note_lambda_variable_capture_fixit)
18906 return !C.isThisCapture() && !C.isInitCapture();
18915 if (ShouldOfferCopyFix) {
18916 bool CanDefaultCopyCapture =
true;
18925 if (CanDefaultCopyCapture && llvm::none_of(LSI->
Captures, [](
Capture &
C) {
18926 return !C.isThisCapture() && !C.isInitCapture() && C.isCopyCapture();
18928 FixBuffer.assign({
"=", Separator});
18929 Sema.
Diag(DefaultInsertLoc, diag::note_lambda_default_capture_fixit)
18938 return !C.isInitCapture() && C.isReferenceCapture() &&
18939 !C.isThisCapture();
18941 FixBuffer.assign({
"&", Separator});
18942 Sema.
Diag(DefaultInsertLoc, diag::note_lambda_default_capture_fixit)
18951 QualType &DeclRefType,
const unsigned *
const FunctionScopeIndexToStopAt) {
18974 const auto *VD = dyn_cast<VarDecl>(Var);
18976 if (VD->isInitCapture())
18981 assert(VD &&
"Cannot capture a null variable");
18983 const unsigned MaxFunctionScopesIndex = FunctionScopeIndexToStopAt
18987 if (FunctionScopeIndexToStopAt) {
18988 assert(!
FunctionScopes.empty() &&
"No function scopes to stop at?");
18993 if (
auto *LSI = dyn_cast<LambdaScopeInfo>(
FunctionScopes[FSIndex]);
18994 FSIndex && LSI && !LSI->AfterParameterList)
18996 assert(MaxFunctionScopesIndex <= FSIndex &&
18997 "FunctionScopeIndexToStopAt should be no greater than FSIndex into "
18998 "FunctionScopes.");
18999 while (FSIndex != MaxFunctionScopesIndex) {
19007 bool IsGlobal = !VD->hasLocalStorage();
19008 if (IsGlobal && !(
LangOpts.OpenMP &&
19009 OpenMP().isOpenMPCapturedDecl(Var,
true,
19010 MaxFunctionScopesIndex)))
19013 if (isa<VarDecl>(Var))
19024 CaptureType = Var->
getType();
19026 bool Nested =
false;
19028 unsigned FunctionScopesIndex = MaxFunctionScopesIndex;
19033 LSI = dyn_cast_or_null<LambdaScopeInfo>(
19036 bool IsInScopeDeclarationContext =
19047 if (IsInScopeDeclarationContext &&
19048 FunctionScopesIndex == MaxFunctionScopesIndex && VarDC == DC)
19054 !IsInScopeDeclarationContext
19057 BuildAndDiagnose, *
this);
19063 FunctionScopesIndex = MaxFunctionScopesIndex - 1;
19082 if (
const auto *Parm = dyn_cast<ParmVarDecl>(Var);
19083 Parm && Parm->getDeclContext() == DC)
19091 if (BuildAndDiagnose) {
19094 Diag(ExprLoc, diag::err_lambda_impcap) << Var;
19109 if (
ParmVarDecl *PVD = dyn_cast_or_null<ParmVarDecl>(Var))
19110 QTy = PVD->getOriginalType();
19115 if (
auto *RSI = dyn_cast<CapturedRegionScopeInfo>(CSI)) {
19121 if (isa<BindingDecl>(Var)) {
19122 if (BuildAndDiagnose) {
19123 Diag(ExprLoc, diag::err_capture_binding_openmp) << Var;
19129 Var, RSI->OpenMPLevel, RSI->OpenMPCaptureLevel);
19134 if (IsOpenMPPrivateDecl != OMPC_unknown &&
19137 if (
ParmVarDecl *PVD = dyn_cast_or_null<ParmVarDecl>(Var))
19138 QTy = PVD->getOriginalType();
19140 E =
OpenMP().getNumberOfConstructScopes(RSI->OpenMPLevel);
19142 auto *OuterRSI = cast<CapturedRegionScopeInfo>(
19144 assert(RSI->OpenMPLevel == OuterRSI->OpenMPLevel &&
19145 "Wrong number of captured regions associated with the "
19146 "OpenMP construct.");
19151 IsOpenMPPrivateDecl != OMPC_private &&
19153 RSI->OpenMPCaptureLevel);
19157 Var, RSI->OpenMPLevel, RSI->OpenMPCaptureLevel);
19163 OpenMP().adjustOpenMPTargetScopeIndex(FunctionScopesIndex,
19166 if (IsTargetCap || IsOpenMPPrivateDecl == OMPC_private ||
19167 (IsGlobal && !IsGlobalCap)) {
19168 Nested = !IsTargetCap;
19183 if (BuildAndDiagnose) {
19184 Diag(ExprLoc, diag::err_lambda_impcap) << Var;
19186 auto *LSI = cast<LambdaScopeInfo>(CSI);
19206 FunctionScopesIndex--;
19207 if (IsInScopeDeclarationContext)
19209 }
while (!VarDC->
Equals(DC));
19217 for (
unsigned I = ++FunctionScopesIndex, N = MaxFunctionScopesIndex + 1; I != N;
19230 if (
Invalid && !BuildAndDiagnose)
19235 DeclRefType, Nested, *
this,
Invalid);
19239 RSI, Var, ExprLoc, BuildAndDiagnose, CaptureType, DeclRefType, Nested,
19240 Kind, I == N - 1, *
this,
Invalid);
19246 DeclRefType, Nested, Kind, EllipsisLoc,
19251 if (
Invalid && !BuildAndDiagnose)
19263 DeclRefType,
nullptr);
19270 false, CaptureType,
19271 DeclRefType,
nullptr);
19275 assert(Var &&
"Null value cannot be captured");
19282 false, CaptureType,
19283 DeclRefType,
nullptr))
19286 return DeclRefType;
19294class CopiedTemplateArgs {
19298 template<
typename RefExpr>
19299 CopiedTemplateArgs(RefExpr *
E) : HasArgs(
E->hasExplicitTemplateArgs()) {
19301 E->copyTemplateArgumentsInto(TemplateArgStorage);
19304#ifdef __has_cpp_attribute
19305#
if __has_cpp_attribute(clang::lifetimebound)
19306 [[clang::lifetimebound]]
19310 return HasArgs ? &TemplateArgStorage :
nullptr;
19336 auto Rebuild = [&](
Expr *Sub) {
19341 auto IsPotentialResultOdrUsed = [&](
NamedDecl *
D) {
19344 auto *VD = dyn_cast<VarDecl>(
D);
19367 llvm_unreachable(
"unexpected non-odr-use-reason");
19371 if (VD->getType()->isReferenceType())
19373 if (
auto *RD = VD->getType()->getAsCXXRecordDecl())
19374 if (RD->hasDefinition() && RD->hasMutableFields())
19376 if (!VD->isUsableInConstantExpressions(S.
Context))
19381 if (VD->getType()->isReferenceType())
19389 auto MarkNotOdrUsed = [&] {
19392 LSI->markVariableExprAsNonODRUsed(
E);
19399 case Expr::DeclRefExprClass: {
19400 auto *DRE = cast<DeclRefExpr>(
E);
19401 if (DRE->isNonOdrUse() || IsPotentialResultOdrUsed(DRE->getDecl()))
19407 S.
Context, DRE->getQualifierLoc(), DRE->getTemplateKeywordLoc(),
19408 DRE->getDecl(), DRE->refersToEnclosingVariableOrCapture(),
19409 DRE->getNameInfo(), DRE->getType(), DRE->getValueKind(),
19410 DRE->getFoundDecl(), CopiedTemplateArgs(DRE), NOUR);
19413 case Expr::FunctionParmPackExprClass: {
19414 auto *FPPE = cast<FunctionParmPackExpr>(
E);
19418 if (IsPotentialResultOdrUsed(
D))
19429 case Expr::ArraySubscriptExprClass: {
19430 auto *ASE = cast<ArraySubscriptExpr>(
E);
19435 if (!
Base.isUsable())
19437 Expr *LHS = ASE->getBase() == ASE->getLHS() ?
Base.get() : ASE->getLHS();
19438 Expr *RHS = ASE->getBase() == ASE->getRHS() ?
Base.get() : ASE->getRHS();
19441 ASE->getRBracketLoc());
19444 case Expr::MemberExprClass: {
19445 auto *ME = cast<MemberExpr>(
E);
19448 if (isa<FieldDecl>(ME->getMemberDecl())) {
19450 if (!
Base.isUsable())
19453 S.
Context,
Base.get(), ME->isArrow(), ME->getOperatorLoc(),
19454 ME->getQualifierLoc(), ME->getTemplateKeywordLoc(),
19455 ME->getMemberDecl(), ME->getFoundDecl(), ME->getMemberNameInfo(),
19456 CopiedTemplateArgs(ME), ME->getType(), ME->getValueKind(),
19457 ME->getObjectKind(), ME->isNonOdrUse());
19460 if (ME->getMemberDecl()->isCXXInstanceMember())
19465 if (ME->isNonOdrUse() || IsPotentialResultOdrUsed(ME->getMemberDecl()))
19471 S.
Context, ME->getBase(), ME->isArrow(), ME->getOperatorLoc(),
19472 ME->getQualifierLoc(), ME->getTemplateKeywordLoc(), ME->getMemberDecl(),
19473 ME->getFoundDecl(), ME->getMemberNameInfo(), CopiedTemplateArgs(ME),
19474 ME->getType(), ME->getValueKind(), ME->getObjectKind(), NOUR);
19477 case Expr::BinaryOperatorClass: {
19478 auto *BO = cast<BinaryOperator>(
E);
19479 Expr *LHS = BO->getLHS();
19480 Expr *RHS = BO->getRHS();
19482 if (BO->getOpcode() == BO_PtrMemD) {
19484 if (!Sub.isUsable())
19486 BO->setLHS(Sub.get());
19488 }
else if (BO->getOpcode() == BO_Comma) {
19490 if (!Sub.isUsable())
19492 BO->setRHS(Sub.get());
19500 case Expr::ParenExprClass: {
19501 auto *PE = cast<ParenExpr>(
E);
19503 if (!Sub.isUsable())
19505 return S.
ActOnParenExpr(PE->getLParen(), PE->getRParen(), Sub.get());
19510 case Expr::ConditionalOperatorClass: {
19511 auto *CO = cast<ConditionalOperator>(
E);
19521 LHS = CO->getLHS();
19523 RHS = CO->getRHS();
19525 CO->getCond(), LHS.
get(), RHS.
get());
19530 case Expr::UnaryOperatorClass: {
19531 auto *UO = cast<UnaryOperator>(
E);
19532 if (UO->getOpcode() != UO_Extension)
19535 if (!Sub.isUsable())
19537 return S.
BuildUnaryOp(
nullptr, UO->getOperatorLoc(), UO_Extension,
19544 case Expr::GenericSelectionExprClass: {
19545 auto *GSE = cast<GenericSelectionExpr>(
E);
19548 bool AnyChanged =
false;
19549 for (
Expr *OrigAssocExpr : GSE->getAssocExprs()) {
19550 ExprResult AssocExpr = Rebuild(OrigAssocExpr);
19554 AssocExprs.push_back(AssocExpr.
get());
19557 AssocExprs.push_back(OrigAssocExpr);
19561 void *ExOrTy =
nullptr;
19562 bool IsExpr = GSE->isExprPredicate();
19564 ExOrTy = GSE->getControllingExpr();
19566 ExOrTy = GSE->getControllingType();
19568 GSE->getGenericLoc(), GSE->getDefaultLoc(),
19569 GSE->getRParenLoc(), IsExpr, ExOrTy,
19570 GSE->getAssocTypeSourceInfos(), AssocExprs)
19578 case Expr::ChooseExprClass: {
19579 auto *CE = cast<ChooseExpr>(
E);
19589 if (!LHS.
get() && !RHS.
get())
19592 LHS = CE->getLHS();
19594 RHS = CE->getRHS();
19597 RHS.
get(), CE->getRParenLoc());
19601 case Expr::ConstantExprClass: {
19602 auto *CE = cast<ConstantExpr>(
E);
19604 if (!Sub.isUsable())
19611 case Expr::ImplicitCastExprClass: {
19612 auto *ICE = cast<ImplicitCastExpr>(
E);
19616 switch (ICE->getCastKind()) {
19618 case CK_DerivedToBase:
19619 case CK_UncheckedDerivedToBase: {
19620 ExprResult Sub = Rebuild(ICE->getSubExpr());
19621 if (!Sub.isUsable())
19625 ICE->getValueKind(), &
Path);
19684 for (
Expr *
E : LocalMaybeODRUseExprs) {
19685 if (
auto *DRE = dyn_cast<DeclRefExpr>(
E)) {
19687 DRE->getLocation(), *
this);
19688 }
else if (
auto *ME = dyn_cast<MemberExpr>(
E)) {
19691 }
else if (
auto *FP = dyn_cast<FunctionParmPackExpr>(
E)) {
19695 llvm_unreachable(
"Unexpected expression");
19700 "MarkVarDeclODRUsed failed to cleanup MaybeODRUseExprs?");
19709 const bool RefersToEnclosingScope =
19712 if (RefersToEnclosingScope) {
19727 assert(
E &&
"Capture variable should be used in an expression.");
19738 assert((!
E || isa<DeclRefExpr>(
E) || isa<MemberExpr>(
E) ||
19739 isa<FunctionParmPackExpr>(
E)) &&
19740 "Invalid Expr argument to DoMarkVarDeclReferenced");
19751 bool UsableInConstantExpr =
19763 bool NeededForConstantEvaluation =
19766 bool NeedDefinition =
19767 OdrUse == OdrUseContext::Used || NeededForConstantEvaluation;
19769 assert(!isa<VarTemplatePartialSpecializationDecl>(Var) &&
19770 "Can't instantiate a partial template specialization.");
19776 !isa<VarTemplateSpecializationDecl>(Var))
19787 bool TryInstantiating =
19791 if (TryInstantiating) {
19794 bool FirstInstantiation = PointOfInstantiation.
isInvalid();
19795 if (FirstInstantiation) {
19796 PointOfInstantiation =
Loc;
19798 MSI->setPointOfInstantiation(PointOfInstantiation);
19804 if (UsableInConstantExpr) {
19813 if (
auto *DRE = dyn_cast_or_null<DeclRefExpr>(
E))
19814 DRE->setDecl(DRE->getDecl());
19815 else if (
auto *ME = dyn_cast_or_null<MemberExpr>(
E))
19816 ME->setMemberDecl(ME->getMemberDecl());
19817 }
else if (FirstInstantiation) {
19819 .push_back(std::make_pair(Var, PointOfInstantiation));
19821 bool Inserted =
false;
19823 auto Iter = llvm::find_if(
19825 return P.first == Var;
19827 if (
Iter != I.end()) {
19840 if (isa<VarTemplateSpecializationDecl>(Var) && !Inserted)
19842 .push_back(std::make_pair(Var, PointOfInstantiation));
19866 if (
DeclRefExpr *DRE = dyn_cast_or_null<DeclRefExpr>(
E))
19867 if (DRE->isNonOdrUse())
19869 if (
MemberExpr *ME = dyn_cast_or_null<MemberExpr>(
E))
19870 if (ME->isNonOdrUse())
19874 case OdrUseContext::None:
19877 assert((!
E || isa<FunctionParmPackExpr>(
E) ||
19879 "missing non-odr-use marking for unevaluated decl ref");
19882 case OdrUseContext::FormallyOdrUsed:
19887 case OdrUseContext::Used:
19896 case OdrUseContext::Dependent:
19914 if (OdrUse == OdrUseContext::Used) {
19915 QualType CaptureType, DeclRefType;
19921 }
else if (OdrUse == OdrUseContext::Dependent) {
19937 auto *ID = dyn_cast<DeclRefExpr>(
E);
19938 if (!ID || ID->isTypeDependent() || !ID->refersToEnclosingVariableOrCapture())
19945 auto IsDependent = [&]() {
19947 auto *LSI = dyn_cast<sema::LambdaScopeInfo>(
Scope);
19952 LSI->AfterParameterList)
19955 const auto *MD = LSI->CallOperator;
19956 if (MD->getType().isNull())
19960 if (!Ty || !MD->isExplicitObjectMemberFunction() ||
19964 if (
auto *
C = LSI->CaptureMap.count(
D) ? &LSI->getCapture(
D) :
nullptr) {
19965 if (
C->isCopyCapture())
19970 if (LSI->ImpCaptureStyle == LambdaScopeInfo::ImpCap_LambdaByval)
19976 ID->setCapturedByCopyInLambdaWithExplicitObjectParameter(
19982 bool MightBeOdrUse,
19987 if (
VarDecl *Var = dyn_cast<VarDecl>(
D)) {
20013 bool IsVirtualCall = MD->
isVirtual() &&
20015 if (!IsVirtualCall)
20030 bool OdrUse =
true;
20031 if (
const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(
E->getDecl()))
20032 if (Method->isVirtual() &&
20036 if (
auto *FD = dyn_cast<FunctionDecl>(
E->getDecl())) {
20041 !FD->isDependentContext())
20055 bool MightBeOdrUse =
true;
20057 if (
CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(
E->getMemberDecl()))
20058 if (Method->isPureVirtual())
20059 MightBeOdrUse =
false;
20062 E->getMemberLoc().isValid() ?
E->getMemberLoc() :
E->
getBeginLoc();
20078 bool MightBeOdrUse) {
20079 if (MightBeOdrUse) {
20080 if (
auto *VD = dyn_cast<VarDecl>(
D)) {
20085 if (
auto *FD = dyn_cast<FunctionDecl>(
D)) {
20111bool MarkReferencedDecls::TraverseTemplateArgument(
20129 MarkReferencedDecls Marker(*
this,
Loc);
20130 Marker.TraverseType(
T);
20136class EvaluatedExprMarker :
public UsedDeclVisitor<EvaluatedExprMarker> {
20139 bool SkipLocalVariables;
20142 EvaluatedExprMarker(
Sema &S,
bool SkipLocalVariables,
20144 : Inherited(S), SkipLocalVariables(SkipLocalVariables), StopAt(StopAt) {}
20150 void Visit(
Expr *
E) {
20151 if (llvm::is_contained(StopAt,
E))
20153 Inherited::Visit(
E);
20163 if (SkipLocalVariables) {
20164 if (
VarDecl *VD = dyn_cast<VarDecl>(
E->getDecl()))
20165 if (VD->hasLocalStorage())
20177 Visit(
E->getBase());
20183 bool SkipLocalVariables,
20185 EvaluatedExprMarker(*
this, SkipLocalVariables, StopAt).Visit(
E);
20207 if (
auto *VD = dyn_cast_or_null<VarDecl>(
20209 if (VD->isConstexpr() ||
20210 (VD->isStaticDataMember() && VD->isFirstDecl() && !VD->isInline()))
20283 class CallReturnIncompleteDiagnoser :
public TypeDiagnoser {
20289 : FD(FD), CE(CE) { }
20293 S.
Diag(
Loc, diag::err_call_incomplete_return)
20298 S.
Diag(
Loc, diag::err_call_function_incomplete_return)
20303 } Diagnoser(FD, CE);
20316 unsigned diagnostic = diag::warn_condition_is_assignment;
20317 bool IsOrAssign =
false;
20320 if (Op->getOpcode() != BO_Assign && Op->getOpcode() != BO_OrAssign)
20323 IsOrAssign = Op->getOpcode() == BO_OrAssign;
20331 if (
ObjC().isSelfExpr(Op->getLHS()) && ME->getMethodFamily() ==
OMF_init)
20332 diagnostic = diag::warn_condition_is_idiomatic_assignment;
20336 diagnostic = diag::warn_condition_is_idiomatic_assignment;
20339 Loc = Op->getOperatorLoc();
20341 if (Op->getOperator() != OO_Equal && Op->getOperator() != OO_PipeEqual)
20344 IsOrAssign = Op->getOperator() == OO_PipeEqual;
20345 Loc = Op->getOperatorLoc();
20357 Diag(
Loc, diag::note_condition_assign_silence)
20362 Diag(
Loc, diag::note_condition_or_assign_to_comparison)
20365 Diag(
Loc, diag::note_condition_assign_to_comparison)
20383 if (opE->getOpcode() == BO_EQ &&
20384 opE->getLHS()->IgnoreParenImpCasts()->isModifiableLvalue(
Context)
20390 Diag(
Loc, diag::note_equality_comparison_silence)
20393 Diag(
Loc, diag::note_equality_comparison_to_assign)
20399 bool IsConstexpr) {
20401 if (
ParenExpr *parenE = dyn_cast<ParenExpr>(
E))
20419 Diag(
Loc, diag::err_typecheck_statement_requires_scalar)
20423 CheckBoolLikeConversion(
E,
Loc);
20469 struct RebuildUnknownAnyFunction
20470 :
StmtVisitor<RebuildUnknownAnyFunction, ExprResult> {
20474 RebuildUnknownAnyFunction(
Sema &S) : S(S) {}
20477 llvm_unreachable(
"unexpected statement!");
20488 template <
class T>
ExprResult rebuildSugarExpr(
T *
E) {
20492 Expr *SubExpr = SubResult.
get();
20493 E->setSubExpr(SubExpr);
20501 return rebuildSugarExpr(
E);
20505 return rebuildSugarExpr(
E);
20512 Expr *SubExpr = SubResult.
get();
20513 E->setSubExpr(SubExpr);
20521 if (!isa<FunctionDecl>(VD))
return VisitExpr(
E);
20527 !(isa<CXXMethodDecl>(VD) &&
20528 cast<CXXMethodDecl>(VD)->isInstance()))
20535 return resolveDecl(
E,
E->getMemberDecl());
20539 return resolveDecl(
E,
E->getDecl());
20557 struct RebuildUnknownAnyExpr
20558 :
StmtVisitor<RebuildUnknownAnyExpr, ExprResult> {
20569 llvm_unreachable(
"unexpected statement!");
20583 template <
class T>
ExprResult rebuildSugarExpr(
T *
E) {
20586 Expr *SubExpr = SubResult.
get();
20587 E->setSubExpr(SubExpr);
20595 return rebuildSugarExpr(
E);
20599 return rebuildSugarExpr(
E);
20605 S.
Diag(
E->getOperatorLoc(), diag::err_unknown_any_addrof)
20610 if (isa<CallExpr>(
E->getSubExpr())) {
20611 S.
Diag(
E->getOperatorLoc(), diag::err_unknown_any_addrof_call)
20624 E->setSubExpr(SubResult.
get());
20633 return resolveDecl(
E,
E->getMemberDecl());
20637 return resolveDecl(
E,
E->getDecl());
20644 Expr *CalleeExpr =
E->getCallee();
20648 FK_FunctionPointer,
20655 assert(isa<CXXMemberCallExpr>(
E) || isa<CXXOperatorCallExpr>(
E));
20656 Kind = FK_MemberFunction;
20660 Kind = FK_FunctionPointer;
20663 Kind = FK_BlockPointer;
20669 unsigned diagID = diag::err_func_returning_array_function;
20670 if (Kind == FK_BlockPointer)
20671 diagID = diag::err_block_returning_array_function;
20707 if (ParamTypes.empty() && Proto->
isVariadic()) {
20708 ArgTypes.reserve(
E->getNumArgs());
20709 for (
unsigned i = 0, e =
E->getNumArgs(); i != e; ++i) {
20712 ParamTypes = ArgTypes;
20723 case FK_MemberFunction:
20727 case FK_FunctionPointer:
20731 case FK_BlockPointer:
20737 ExprResult CalleeResult = Visit(CalleeExpr);
20739 E->setCallee(CalleeResult.
get());
20756 Method->setReturnType(DestType);
20768 if (
E->getCastKind() == CK_FunctionToPointerDecay) {
20782 }
else if (
E->getCastKind() == CK_LValueToRValue) {
20786 assert(isa<BlockPointerType>(
E->
getType()));
20799 llvm_unreachable(
"Unhandled cast type!");
20832 if (DRE && Proto && Proto->getParamTypes().empty() && Proto->isVariadic()) {
20836 FD->getNameInfo().getName(), DestType, FD->getTypeSourceInfo(),
20838 false , FD->hasPrototype(),
20841 if (FD->getQualifier())
20845 for (
const auto &AI : FT->param_types()) {
20849 Params.push_back(Param);
20851 NewFD->setParams(Params);
20858 if (MD->isInstance()) {
20868 }
else if (isa<VarDecl>(VD)) {
20898 diag::err_typecheck_cast_to_incomplete))
20913 return RebuildUnknownAnyExpr(*
this, ToType).Visit(
E);
20920 ExplicitCastExpr *castArg = dyn_cast<ExplicitCastExpr>(arg->IgnoreParens());
20929 assert(!arg->hasPlaceholderType());
20941 unsigned diagID = diag::err_uncasted_use_of_unknown_any;
20944 if (
CallExpr *call = dyn_cast<CallExpr>(
E)) {
20945 E = call->getCallee();
20946 diagID = diag::err_uncasted_call_of_unknown_any;
20955 loc = ref->getLocation();
20956 d = ref->getDecl();
20957 }
else if (
MemberExpr *mem = dyn_cast<MemberExpr>(
E)) {
20958 loc = mem->getMemberLoc();
20959 d = mem->getMemberDecl();
20961 diagID = diag::err_uncasted_call_of_unknown_any;
20962 loc = msg->getSelectorStartLoc();
20963 d = msg->getMethodDecl();
20965 S.
Diag(loc, diag::err_uncasted_send_to_unknown_any_method)
20966 <<
static_cast<unsigned>(msg->isClassMessage()) << msg->getSelector()
20993 if (!placeholderType)
return E;
20995 switch (placeholderType->
getKind()) {
20996 case BuiltinType::UnresolvedTemplate: {
20997 auto *ULE = cast<UnresolvedLookupExpr>(
E);
21002 const bool IsTypeAliasTemplateDecl = isa<TypeAliasTemplateDecl>(Temp);
21005 Diag(NameInfo.
getLoc(), diag::err_template_kw_refers_to_type_template)
21007 <<
Loc.getSourceRange() << IsTypeAliasTemplateDecl;
21009 Diag(NameInfo.
getLoc(), diag::err_template_kw_refers_to_type_template)
21011 << IsTypeAliasTemplateDecl;
21013 << IsTypeAliasTemplateDecl;
21019 case BuiltinType::Overload: {
21039 case BuiltinType::BoundMember: {
21044 if (isa<CXXPseudoDestructorExpr>(BME)) {
21045 PD =
PDiag(diag::err_dtor_expr_without_call) << 1;
21046 }
else if (
const auto *ME = dyn_cast<MemberExpr>(BME)) {
21047 if (ME->getMemberNameInfo().getName().getNameKind() ==
21049 PD =
PDiag(diag::err_dtor_expr_without_call) << 0;
21057 case BuiltinType::ARCUnbridgedCast: {
21064 case BuiltinType::UnknownAny:
21068 case BuiltinType::PseudoObject:
21071 case BuiltinType::BuiltinFn: {
21075 auto *FD = cast<FunctionDecl>(DRE->
getDecl());
21076 unsigned BuiltinID = FD->getBuiltinID();
21077 if (BuiltinID == Builtin::BI__noop) {
21079 CK_BuiltinFnToFnPtr)
21092 ? diag::err_use_of_unaddressable_function
21093 : diag::warn_cxx20_compat_use_of_unaddressable_function);
21094 if (FD->isImplicitlyInstantiable()) {
21121 case BuiltinType::IncompleteMatrixIdx:
21125 diag::err_matrix_incomplete_index);
21129 case BuiltinType::ArraySection:
21131 << cast<ArraySectionExpr>(
E)->isOMPArraySection();
21135 case BuiltinType::OMPArrayShaping:
21138 case BuiltinType::OMPIterator:
21142#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
21143 case BuiltinType::Id:
21144#include "clang/Basic/OpenCLImageTypes.def"
21145#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
21146 case BuiltinType::Id:
21147#include "clang/Basic/OpenCLExtensionTypes.def"
21148#define SVE_TYPE(Name, Id, SingletonId) \
21149 case BuiltinType::Id:
21150#include "clang/Basic/AArch64SVEACLETypes.def"
21151#define PPC_VECTOR_TYPE(Name, Id, Size) \
21152 case BuiltinType::Id:
21153#include "clang/Basic/PPCTypes.def"
21154#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
21155#include "clang/Basic/RISCVVTypes.def"
21156#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
21157#include "clang/Basic/WebAssemblyReferenceTypes.def"
21158#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) case BuiltinType::Id:
21159#include "clang/Basic/AMDGPUTypes.def"
21160#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
21161#include "clang/Basic/HLSLIntangibleTypes.def"
21162#define BUILTIN_TYPE(Id, SingletonId) case BuiltinType::Id:
21163#define PLACEHOLDER_TYPE(Id, SingletonId)
21164#include "clang/AST/BuiltinTypes.def"
21168 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 isParenthetizedAndQualifiedAddressOfExpr(Expr *Fn)
static bool isCapturingReferenceToHostVarInCUDADeviceLambda(const Sema &S, VarDecl *VD)
static UnaryOperatorKind ConvertTokenKindToUnaryOpcode(tok::TokenKind Kind)
static void DetectPrecisionLossInComplexDivision(Sema &S, SourceLocation OpLoc, Expr *Operand)
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)
static FieldDecl * FindFieldDeclInstantiationPattern(const ASTContext &Ctx, FieldDecl *Field)
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 std::optional< bool > isTautologicalBoundsCheck(Sema &S, const Expr *LHS, const Expr *RHS, BinaryOperatorKind Opc)
Detect patterns ptr + size >= ptr and ptr + size < ptr, where ptr is a pointer and size is an unsigne...
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 bool checkPtrAuthTypeDiscriminatorOperandType(Sema &S, QualType T, SourceLocation Loc, SourceRange ArgRange)
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 HLSL constructs.
This file declares semantic analysis for Objective-C.
This file declares semantic analysis for OpenMP constructs and clauses.
This file declares semantic analysis for expressions involving.
static bool isInvalid(LocType Loc, bool *Invalid)
Defines the SourceManager interface.
Defines various enumerations that describe declaration and type specifiers.
static QualType getPointeeType(const MemRegion *R)
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
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 getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType, const Attr *attr=nullptr) const
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...
const QualType GetHigherPrecisionFPType(QualType ElementType) const
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>.
llvm::SetVector< const ValueDecl * > CUDAExternalDeviceDeclODRUsedByHost
Keep track of CUDA/HIP external kernels or device variables ODR-used by host code.
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.
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...
FieldDecl * getInstantiatedFromUnnamedFieldDecl(FieldDecl *Field) const
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.
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
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 isImmediate(unsigned ID) const
Returns true if this is an immediate (consteval) function.
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.
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.
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 isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
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...
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)
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 isRequiresExprBody() const
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)
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
DeclContext * getDeclContext()
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
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...
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
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
Recursive AST visitor that supports extension via dynamic dispatch.
virtual bool VisitStmt(Stmt *S)
virtual bool TraverseTemplateArgument(const TemplateArgument &Arg)
Recursively visit a template argument and dispatch to the appropriate method for the argument type.
void setElaboratedKeywordLoc(SourceLocation Loc)
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Represents a reference to #emded data.
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...
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
ParameterABI getABI() const
Return the ABI treatment of this parameter.
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...
@ CX_Promoted
Implementation of complex division using algebraic formulas at higher precision.
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.
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.
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.
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
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.
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 parenthesized expression, e.g.
SourceLocation getBeginLoc() const LLVM_READONLY
const Expr * getSubExpr() const
bool isProducedByFoldExpansion() 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.
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.
uint8_t getSpellingOfSingleCharacterNumericConstant(const Token &Tok, bool *Invalid=nullptr) const
Given a Token Tok that is a numeric constant with length 1, return the value of constant as an unsign...
SourceManager & getSourceManager() const
bool isMacroDefined(StringRef Id)
const TargetInfo & getTargetInfo() const
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
bool isAddressSpaceOverlapping(QualType T, const ASTContext &Ctx) const
Returns true if address space qualifiers overlap with T address space qualifiers.
QualType withConst() const
void addConst()
Add the const type qualifier to this QualType.
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 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).
bool isAtLeastAsQualifiedAs(QualType Other, const ASTContext &Ctx) const
Determine whether this type is at least as qualified as the other given type, requiring exact equalit...
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()
bool compatiblyIncludes(Qualifiers other, const ASTContext &Ctx) const
Determines if these qualifiers compatibly include another set.
static bool isAddressSpaceSupersetOf(LangAS A, LangAS B, const ASTContext &Ctx)
Returns true if address space A is equal to or a superset of B.
void removeAddressSpace()
void setAddressSpace(LangAS space)
ObjCLifetime getObjCLifetime() const
Qualifiers withoutObjCLifetime() const
Qualifiers withoutObjCGCAttr() const
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)
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
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.
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial 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.
ExprResult ActOnOutParamExpr(ParmVarDecl *Param, Expr *Arg)
void emitLogicalOperatorFixIt(Expr *LHS, Expr *RHS, BinaryOperatorKind Opc)
QualType handleVectorBinOpConversion(ExprResult &LHS, ExprResult &RHS, QualType LHSType, QualType RHSType, bool IsCompAssign)
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
ExprResult checkAssignment(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opcode, Expr *LHS, Expr *RHS)
ExprResult checkIncDec(Scope *S, SourceLocation OpLoc, UnaryOperatorKind Opcode, Expr *Op)
Check an increment or decrement of a pseudo-object expression.
ExprResult checkRValue(Expr *E)
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.
ExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc, tok::TokenKind Op, Expr *Input, bool IsAfterAmp=false)
Unary Operators. 'Tok' is the token for the operator.
bool RequireCompleteSizedExprType(Expr *E, unsigned DiagID, const Ts &...Args)
ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *InputExpr, bool IsAfterAmp=false)
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...
bool isAttrContext() const
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)
bool DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R, CorrectionCandidateCallback &CCC, TemplateArgumentListInfo *ExplicitTemplateArgs=nullptr, ArrayRef< Expr * > Args={}, DeclContext *LookupCtx=nullptr, TypoExpr **Out=nullptr)
Diagnose an empty lookup.
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()
void MarkDeclarationsReferencedInExpr(Expr *E, bool SkipLocalVariables=false, ArrayRef< const Expr * > StopAt={})
Mark any declarations that appear within this expression or any potentially-evaluated subexpressions ...
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'.
ExprResult ActOnIdExpression(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, UnqualifiedId &Id, bool HasTrailingLParen, bool IsAddressOfOperand, CorrectionCandidateCallback *CCC=nullptr, bool IsInlineAsmIdentifier=false, Token *KeywordReplacement=nullptr)
bool needsRebuildOfDefaultArgOrInit() const
SourceLocation LocationOfExcessPrecisionNotSatisfied
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
const ExpressionEvaluationContextRecord & currentEvaluationContext() 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.
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.
bool CheckConceptUseInDefinition(ConceptDecl *Concept, SourceLocation Loc)
ExprResult BuildVAArgExpr(SourceLocation BuiltinLoc, Expr *E, TypeSourceInfo *TInfo, SourceLocation RPLoc)
ExpressionEvaluationContextRecord & parentEvaluationContext()
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....
bool checkPointerAuthEnabled(SourceLocation Loc, SourceRange Range)
ExprResult CheckUnevaluatedOperand(Expr *E)
ExprResult DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT, FunctionDecl *FDecl)
void DiagnoseCommaOperator(const Expr *LHS, SourceLocation Loc)
Look for instances where it is likely the comma operator is confused with another operator.
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 CheckVectorLogicalOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc)
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)
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={}, OverloadCandidateParamOrder PO={}, bool AggregateCandidateDeduction=false, bool HasMatchedPackOnParmToNonPackOnArg=false)
AddOverloadCandidate - Adds the given function to the set of candidate functions, using the given fun...
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...
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)
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)
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
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)
DiagnoseSelfMove - Emits a warning 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...
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)
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 maybeAddDeclWithEffects(FuncOrBlockDecl *D)
Inline checks from the start of maybeAddDeclWithEffects, to minimize performance impact on code not u...
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)
Diagnose cases where a scalar was implicitly converted to a vector and diagnose the underlying types.
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.
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, bool ForDefaultArgumentSubstitution=false)
Retrieve the template argument list(s) that should be used to instantiate the definition of the given...
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 BuildQualifiedDeclarationNameExpr(CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, bool IsAddressOfOperand, TypeSourceInfo **RecoveryTSI=nullptr)
BuildQualifiedDeclarationNameExpr - Build a C++ qualified declaration name, generally during template...
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.
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)
std::vector< std::pair< QualType, unsigned > > ExcessPrecisionNotSatisfied
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.
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 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)
Binary Operators. 'Tok' is the token for the operator.
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)
ExprResult ActOnEmbedExpr(SourceLocation EmbedKeywordLoc, StringLiteral *BinaryData)
QualType GetSignedVectorType(QualType V)
Return a signed ext_vector_type that is of identical size and number of elements.
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)
Parse a __builtin_astype expression.
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...
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 ActOnIntegerConstant(SourceLocation Loc, int64_t Val)
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)
ActOnConvertVectorExpr - create a new convert-vector expression from the provided arguments.
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)
SemaPseudoObject & PseudoObject()
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"...
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 isFunctionReferenceType() const
bool isObjCBuiltinType() const
bool isMFloat8Type() 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 isIncompleteArrayType() const
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 isMemberFunctionPointerType() const
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
bool isSubscriptableVectorType() 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, bool KnownInstantiationDependent)
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)
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 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.
bool ContainsUnexpandedParameterPack
Whether this contains an unexpanded parameter pack.
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.
void checkAssignmentLifetime(Sema &SemaRef, const AssignedEntity &Entity, Expr *Init)
Check that the lifetime of the given expr (and its subobjects) is sufficient for assigning to the ent...
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.
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.
@ Vector
'vector' clause, allowed on 'loop', Combined, and 'routine' directives.
@ Self
'self' clause, allowed on Compute and Combined Constructs, plus 'update'.
@ 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
Stores data related to a single #embed directive.
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 HasUndefinedBehavior
Whether the evaluation hit undefined behavior.
bool HasSideEffects
Whether the evaluated expression has side effects.
Extra information about a function prototype.
FunctionType::ExtInfo ExtInfo
bool IsAddressOfOperandWithParen
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
bool isDiscardedStatementContext() 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.
Describes an entity that is being assigned.