57#include "llvm/ADT/STLExtras.h"
58#include "llvm/ADT/STLForwardCompat.h"
59#include "llvm/ADT/StringExtras.h"
60#include "llvm/Support/Casting.h"
61#include "llvm/Support/ConvertUTF.h"
62#include "llvm/Support/SaveAndRestore.h"
63#include "llvm/Support/TypeSize.h"
89 if (TreatUnavailableAsInvalid &&
99 if (isa<UnresolvedUsingIfExistsDecl>(D))
107 if (
const auto *A = D->
getAttr<UnusedAttr>()) {
110 if (A->getSemanticSpelling() != UnusedAttr::CXX11_maybe_unused &&
111 A->getSemanticSpelling() != UnusedAttr::C23_maybe_unused) {
113 if (DC && !DC->
hasAttr<UnusedAttr>())
114 S.
Diag(Loc, diag::warn_used_but_marked_unused) << D;
123 if (
Decl->isDefaulted()) {
134 auto *Ctor = dyn_cast<CXXConstructorDecl>(
Decl);
135 if (Ctor && Ctor->isInheritingConstructor())
146 if (I->getStorageClass() !=
SC_None)
173 if (!Current->isInlined())
175 if (!Current->isExternallyVisible())
191 if (!DowngradeWarning && UsedFn)
194 S.
Diag(Loc, DowngradeWarning ? diag::ext_internal_in_extern_inline_quiet
195 : diag::ext_internal_in_extern_inline)
210 Diag(DeclBegin, diag::note_convert_inline_to_static)
229 bool ObjCPropertyAccess,
230 bool AvoidPartialAvailabilityChecks,
232 bool SkipTrailingRequiresClause) {
240 Diag(Suppressed.first, Suppressed.second);
251 if (cast<FunctionDecl>(D)->isMain())
252 Diag(Loc, diag::ext_main_used);
259 if (isa<BindingDecl>(D)) {
260 Diag(Loc, diag::err_binding_cannot_appear_in_own_initializer)
263 Diag(Loc, diag::err_auto_variable_cannot_appear_in_own_initializer)
264 << D->
getDeclName() << cast<VarDecl>(D)->getType();
271 if (FD->isDeleted()) {
272 auto *Ctor = dyn_cast<CXXConstructorDecl>(FD);
273 if (Ctor && Ctor->isInheritingConstructor())
274 Diag(Loc, diag::err_deleted_inherited_ctor_use)
276 << Ctor->getInheritedConstructor().getConstructor()->getParent();
279 Diag(Loc, diag::err_deleted_function_use)
280 << (Msg !=
nullptr) << (Msg ? Msg->
getString() : StringRef());
294 if (!SkipTrailingRequiresClause && FD->getTrailingRequiresClause()) {
303 diag::err_reference_to_function_with_unsatisfied_constraints)
321 if (
auto *MD = dyn_cast<CXXMethodDecl>(D)) {
323 if (MD->getParent()->isLambda() &&
324 ((isa<CXXConstructorDecl>(MD) &&
325 cast<CXXConstructorDecl>(MD)->isDefaultConstructor()) ||
326 MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator())) {
327 Diag(Loc, diag::warn_cxx17_compat_lambda_def_ctor_assign)
328 << !isa<CXXConstructorDecl>(MD);
332 auto getReferencedObjCProp = [](
const NamedDecl *D) ->
334 if (
const auto *MD = dyn_cast<ObjCMethodDecl>(D))
349 auto *DRD = dyn_cast<OMPDeclareReductionDecl>(
CurContext);
352 Diag(Loc, diag::err_omp_wrong_var_in_declare_reduction)
363 if (
LangOpts.OpenMP && isa<VarDecl>(D) &&
364 !
OpenMP().isOpenMPDeclareMapperVarDeclAllowed(cast<VarDecl>(D))) {
365 Diag(Loc, diag::err_omp_declare_mapper_wrong_var)
371 if (
const auto *EmptyD = dyn_cast<UnresolvedUsingIfExistsDecl>(D)) {
372 Diag(Loc, diag::err_use_of_empty_using_if_exists);
373 Diag(EmptyD->getLocation(), diag::note_empty_using_if_exists_here);
378 AvoidPartialAvailabilityChecks, ClassReceiver);
384 if (D->
hasAttr<AvailableOnlyInDefaultEvalMethodAttr>()) {
390 diag::err_type_available_only_in_default_eval_method)
394 if (
auto *VD = dyn_cast<ValueDecl>(D))
400 if (
const auto *VD = dyn_cast<VarDecl>(D))
402 targetDiag(*Locs.begin(), diag::err_thread_unsupported);
405 if (isa<ParmVarDecl>(D) && isa<RequiresExprBodyDecl>(D->
getDeclContext()) &&
410 Diag(Loc, diag::err_requires_expr_parameter_referenced_in_evaluated_context)
425 const SentinelAttr *
Attr = D->
getAttr<SentinelAttr>();
430 unsigned NumFormalParams;
434 enum { CK_Function, CK_Method, CK_Block } CalleeKind;
436 if (
const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
437 NumFormalParams = MD->param_size();
438 CalleeKind = CK_Method;
439 }
else if (
const auto *FD = dyn_cast<FunctionDecl>(D)) {
440 NumFormalParams = FD->param_size();
441 CalleeKind = CK_Function;
442 }
else if (
const auto *VD = dyn_cast<VarDecl>(D)) {
449 CalleeKind = CK_Function;
452 CalleeKind = CK_Block;
457 if (
const auto *proto = dyn_cast<FunctionProtoType>(Fn))
458 NumFormalParams = proto->getNumParams();
469 unsigned NullPos =
Attr->getNullPos();
470 assert((NullPos == 0 || NullPos == 1) &&
"invalid null position on sentinel");
471 NumFormalParams = (NullPos > NumFormalParams ? 0 : NumFormalParams - NullPos);
474 unsigned NumArgsAfterSentinel =
Attr->getSentinel();
478 if (Args.size() < NumFormalParams + NumArgsAfterSentinel + 1) {
485 const Expr *SentinelExpr = Args[Args.size() - NumArgsAfterSentinel - 1];
498 std::string NullValue;
502 NullValue =
"nullptr";
506 NullValue =
"(void*) 0";
509 Diag(Loc, diag::warn_missing_sentinel) <<
int(CalleeKind);
511 Diag(MissingNilLoc, diag::warn_missing_sentinel)
536 assert(!Ty.
isNull() &&
"DefaultFunctionArrayConversion - missing type");
540 if (
auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl()))
545 CK_FunctionToPointerDecay).
get();
560 CK_ArrayToPointerDecay);
576 if (UO && UO->getOpcode() == UO_Deref &&
577 UO->getSubExpr()->getType()->isPointerType()) {
579 UO->getSubExpr()->getType()->getPointeeType().getAddressSpace();
582 UO->getSubExpr()->IgnoreParenCasts()->isNullPointerConstant(
584 !UO->getType().isVolatileQualified()) {
586 S.
PDiag(diag::warn_indirection_through_null)
587 << UO->getSubExpr()->getSourceRange());
589 S.
PDiag(diag::note_indirection_through_null));
621 if (ObjectSetClass) {
665 assert(!
T.isNull() &&
"r-value conversion on typeless expression?");
706 SourceRange(OISA->getOpLoc(), OISA->getIsaMemberLoc()),
")");
723 if (
T.hasQualifiers())
724 T =
T.getUnqualifiedType();
754 T =
Atomic->getValueType().getUnqualifiedType();
781 CK_FunctionToPointerDecay);
804 assert(!Ty.
isNull() &&
"UsualUnaryConversions - missing type");
811 switch (EvalMethod) {
813 llvm_unreachable(
"Unrecognized float evaluation method");
816 llvm_unreachable(
"Float evaluation method should be set by now");
824 CK_FloatingComplexCast)
833 CK_FloatingComplexCast)
881 assert(!Ty.
isNull() &&
"DefaultArgumentPromotion - missing type");
893 if (BTy && (BTy->
getKind() == BuiltinType::Half ||
894 BTy->
getKind() == BuiltinType::Float)) {
897 if (BTy->
getKind() == BuiltinType::Half) {
915 "Unexpected typesize for LongLongTy");
980 if (!
Record->hasNonTrivialCopyConstructor() &&
981 !
Record->hasNonTrivialMoveConstructor() &&
982 !
Record->hasNonTrivialDestructor())
1009 PDiag(diag::warn_cxx98_compat_pass_non_pod_arg_to_vararg) << Ty << CT);
1016 PDiag(diag::warn_pass_class_arg_to_vararg)
1024 PDiag(diag::warn_cannot_pass_non_pod_arg_to_vararg)
1031 diag::err_cannot_pass_non_trivial_c_struct_to_vararg)
1035 PDiag(diag::err_cannot_pass_objc_interface_to_vararg)
1039 << isa<InitListExpr>(E) << Ty << CT;
1050 if (PlaceholderTy->getKind() == BuiltinType::ARCUnbridgedCast &&
1052 (FDecl && FDecl->
hasAttr<CFAuditedTransferAttr>()))) {
1091 if (
Call.isInvalid())
1096 if (Comma.isInvalid())
1103 diag::err_call_incomplete_argument))
1121 if (SkipCast)
return false;
1128 CK_IntegralComplexToFloatingComplex);
1146 bool PromotePrecision) {
1151 if (PromotePrecision) {
1156 if (LongerIsComplex)
1168 QualType RHSType,
bool IsCompAssign) {
1193 bool ConvertFloat,
bool ConvertInt) {
1198 CK_IntegralToFloating);
1209 CK_IntegralComplexToFloatingComplex);
1214 CK_FloatingRealToComplex);
1223 QualType RHSType,
bool IsCompAssign) {
1233 else if (!IsCompAssign)
1235 return LHSFloat ? LHSType : RHSType;
1240 if (LHSFloat && RHSFloat) {
1247 assert(order < 0 &&
"illegal float comparison");
1281 QualType LHSElem = LHSComplex ? LHSComplex->getElementType() : LHSType;
1287 if ((&LHSSem != &llvm::APFloat::PPCDoubleDouble() ||
1288 &RHSSem != &llvm::APFloat::IEEEquad()) &&
1289 (&LHSSem != &llvm::APFloat::IEEEquad() ||
1290 &RHSSem != &llvm::APFloat::PPCDoubleDouble()))
1307 CK_IntegralComplexCast);
1313template <PerformCastFn doLHSCast, PerformCastFn doRHSCast>
1316 QualType RHSType,
bool IsCompAssign) {
1321 if (LHSSigned == RHSSigned) {
1324 RHS = (*doRHSCast)(S, RHS.
get(), LHSType);
1326 }
else if (!IsCompAssign)
1327 LHS = (*doLHSCast)(S, LHS.
get(), RHSType);
1329 }
else if (order != (LHSSigned ? 1 : -1)) {
1333 RHS = (*doRHSCast)(S, RHS.
get(), LHSType);
1335 }
else if (!IsCompAssign)
1336 LHS = (*doLHSCast)(S, LHS.
get(), RHSType);
1343 RHS = (*doRHSCast)(S, RHS.
get(), LHSType);
1345 }
else if (!IsCompAssign)
1346 LHS = (*doLHSCast)(S, LHS.
get(), RHSType);
1355 RHS = (*doRHSCast)(S, RHS.
get(), result);
1357 LHS = (*doLHSCast)(S, LHS.
get(), result);
1367 bool IsCompAssign) {
1371 if (LHSComplexInt && RHSComplexInt) {
1375 handleIntegerConversion<doComplexIntegralCast, doComplexIntegralCast>
1376 (S, LHS, RHS, LHSEltType, RHSEltType, IsCompAssign);
1381 if (LHSComplexInt) {
1384 handleIntegerConversion<doComplexIntegralCast, doIntegralCast>
1385 (S, LHS, RHS, LHSEltType, RHSType, IsCompAssign);
1388 CK_IntegralRealToComplex);
1393 assert(RHSComplexInt);
1397 handleIntegerConversion<doIntegralCast, doComplexIntegralCast>
1398 (S, LHS, RHS, LHSType, RHSEltType, IsCompAssign);
1403 CK_IntegralRealToComplex);
1412 assert(BTy &&
"Expected a builtin type.");
1414 switch (BTy->getKind()) {
1415 case BuiltinType::ShortFract:
1416 case BuiltinType::UShortFract:
1417 case BuiltinType::SatShortFract:
1418 case BuiltinType::SatUShortFract:
1420 case BuiltinType::Fract:
1421 case BuiltinType::UFract:
1422 case BuiltinType::SatFract:
1423 case BuiltinType::SatUFract:
1425 case BuiltinType::LongFract:
1426 case BuiltinType::ULongFract:
1427 case BuiltinType::SatLongFract:
1428 case BuiltinType::SatULongFract:
1430 case BuiltinType::ShortAccum:
1431 case BuiltinType::UShortAccum:
1432 case BuiltinType::SatShortAccum:
1433 case BuiltinType::SatUShortAccum:
1435 case BuiltinType::Accum:
1436 case BuiltinType::UAccum:
1437 case BuiltinType::SatAccum:
1438 case BuiltinType::SatUAccum:
1440 case BuiltinType::LongAccum:
1441 case BuiltinType::ULongAccum:
1442 case BuiltinType::SatLongAccum:
1443 case BuiltinType::SatULongAccum:
1446 if (BTy->isInteger())
1448 llvm_unreachable(
"Unexpected fixed point or integer type");
1460 "Expected at least one of the operands to be a fixed point type");
1463 "Special fixed point arithmetic operation conversions are only "
1464 "applied to ints or other fixed point types");
1486 QualType ResultTy = LHSTyRank > RHSTyRank ? LHSTy : RHSTy;
1509 REnum = R->isUnscopedEnumerationType();
1511 if ((!IsCompAssign && LEnum && R->isFloatingType()) ||
1514 ? diag::err_arith_conv_enum_float_cxx26
1516 ? diag::warn_arith_conv_enum_float_cxx20
1517 : diag::warn_arith_conv_enum_float)
1520 }
else if (!IsCompAssign && LEnum && REnum &&
1526 DiagID = diag::err_conv_mixed_enum_types_cxx26;
1528 !R->castAs<
EnumType>()->getDecl()->hasNameForLinkage()) {
1533 ? diag::warn_arith_conv_mixed_anon_enum_types_cxx20
1534 : diag::warn_arith_conv_mixed_anon_enum_types;
1539 ? diag::warn_conditional_mixed_enum_types_cxx20
1540 : diag::warn_conditional_mixed_enum_types;
1545 ? diag::warn_comparison_mixed_enum_types_cxx20
1546 : diag::warn_comparison_mixed_enum_types;
1549 ? diag::warn_arith_conv_mixed_enum_types_cxx20
1550 : diag::warn_arith_conv_mixed_enum_types;
1553 << (
int)ACK << L << R;
1583 LHSType = AtomicLHS->getValueType();
1595 QualType LHSUnpromotedType = LHSType;
1599 if (!LHSBitfieldPromoteTy.
isNull())
1600 LHSType = LHSBitfieldPromoteTy;
1634 return handleIntegerConversion<doIntegralCast, doIntegralCast>
1645 bool PredicateIsExpr,
void *ControllingExprOrType,
1647 unsigned NumAssocs = ArgTypes.size();
1648 assert(NumAssocs == ArgExprs.size());
1651 for (
unsigned i = 0; i < NumAssocs; ++i) {
1660 if (!PredicateIsExpr) {
1664 assert(ControllingType &&
"couldn't get the type out of the parser");
1665 ControllingExprOrType = ControllingType;
1669 KeyLoc, DefaultLoc, RParenLoc, PredicateIsExpr, ControllingExprOrType,
1677 bool PredicateIsExpr,
void *ControllingExprOrType,
1679 unsigned NumAssocs = Types.size();
1680 assert(NumAssocs == Exprs.size());
1681 assert(ControllingExprOrType &&
1682 "Must have either a controlling expression or a controlling type");
1684 Expr *ControllingExpr =
nullptr;
1686 if (PredicateIsExpr) {
1693 reinterpret_cast<Expr *
>(ControllingExprOrType));
1696 ControllingExpr = R.
get();
1699 ControllingType =
reinterpret_cast<TypeSourceInfo *
>(ControllingExprOrType);
1700 if (!ControllingType)
1704 bool TypeErrorFound =
false,
1705 IsResultDependent = ControllingExpr
1708 ContainsUnexpandedParameterPack =
1718 diag::warn_side_effects_unevaluated_context);
1720 for (
unsigned i = 0; i < NumAssocs; ++i) {
1721 if (Exprs[i]->containsUnexpandedParameterPack())
1722 ContainsUnexpandedParameterPack =
true;
1725 if (Types[i]->getType()->containsUnexpandedParameterPack())
1726 ContainsUnexpandedParameterPack =
true;
1728 if (Types[i]->getType()->isDependentType()) {
1729 IsResultDependent =
true;
1742 if (ControllingExpr && Types[i]->getType()->isIncompleteType())
1743 D = diag::err_assoc_type_incomplete;
1744 else if (ControllingExpr && !Types[i]->getType()->isObjectType())
1745 D = diag::err_assoc_type_nonobject;
1746 else if (Types[i]->getType()->isVariablyModifiedType())
1747 D = diag::err_assoc_type_variably_modified;
1748 else if (ControllingExpr) {
1767 unsigned Reason = 0;
1776 Diag(Types[i]->getTypeLoc().getBeginLoc(),
1777 diag::warn_unreachable_association)
1778 << QT << (Reason - 1);
1782 Diag(Types[i]->getTypeLoc().getBeginLoc(), D)
1783 << Types[i]->getTypeLoc().getSourceRange()
1784 << Types[i]->getType();
1785 TypeErrorFound =
true;
1790 for (
unsigned j = i+1; j < NumAssocs; ++j)
1791 if (Types[j] && !Types[j]->getType()->isDependentType() &&
1793 Types[j]->getType())) {
1794 Diag(Types[j]->getTypeLoc().getBeginLoc(),
1795 diag::err_assoc_compatible_types)
1796 << Types[j]->getTypeLoc().getSourceRange()
1797 << Types[j]->getType()
1798 << Types[i]->getType();
1799 Diag(Types[i]->getTypeLoc().getBeginLoc(),
1800 diag::note_compat_assoc)
1801 << Types[i]->getTypeLoc().getSourceRange()
1802 << Types[i]->getType();
1803 TypeErrorFound =
true;
1813 if (IsResultDependent) {
1814 if (ControllingExpr)
1816 Types, Exprs, DefaultLoc, RParenLoc,
1817 ContainsUnexpandedParameterPack);
1819 Exprs, DefaultLoc, RParenLoc,
1820 ContainsUnexpandedParameterPack);
1824 unsigned DefaultIndex = -1U;
1828 for (
unsigned i = 0; i < NumAssocs; ++i) {
1831 else if (ControllingExpr &&
1834 Types[i]->getType()))
1835 CompatIndices.push_back(i);
1836 else if (ControllingType &&
1839 Types[i]->getType()))
1840 CompatIndices.push_back(i);
1843 auto GetControllingRangeAndType = [](
Expr *ControllingExpr,
1847 if (ControllingExpr)
1856 return std::make_pair(SR, QT);
1862 if (CompatIndices.size() > 1) {
1863 auto P = GetControllingRangeAndType(ControllingExpr, ControllingType);
1866 << SR <<
P.second << (
unsigned)CompatIndices.size();
1867 for (
unsigned I : CompatIndices) {
1868 Diag(Types[I]->getTypeLoc().getBeginLoc(),
1869 diag::note_compat_assoc)
1870 << Types[I]->getTypeLoc().getSourceRange()
1871 << Types[I]->getType();
1879 if (DefaultIndex == -1U && CompatIndices.size() == 0) {
1880 auto P = GetControllingRangeAndType(ControllingExpr, ControllingType);
1882 Diag(SR.
getBegin(), diag::err_generic_sel_no_match) << SR <<
P.second;
1891 unsigned ResultIndex =
1892 CompatIndices.size() ? CompatIndices[0] : DefaultIndex;
1894 if (ControllingExpr) {
1896 Context, KeyLoc, ControllingExpr, Types, Exprs, DefaultLoc, RParenLoc,
1897 ContainsUnexpandedParameterPack, ResultIndex);
1900 Context, KeyLoc, ControllingType, Types, Exprs, DefaultLoc, RParenLoc,
1901 ContainsUnexpandedParameterPack, ResultIndex);
1907 llvm_unreachable(
"unexpected TokenKind");
1908 case tok::kw___func__:
1910 case tok::kw___FUNCTION__:
1912 case tok::kw___FUNCDNAME__:
1914 case tok::kw___FUNCSIG__:
1916 case tok::kw_L__FUNCTION__:
1918 case tok::kw_L__FUNCSIG__:
1920 case tok::kw___PRETTY_FUNCTION__:
1929 while (DC && !isa<BlockDecl, CapturedDecl, FunctionDecl, ObjCMethodDecl>(DC))
1931 return cast_or_null<Decl>(DC);
1949 assert(Args.size() <= 2 &&
"too many arguments for literal operator");
1952 for (
unsigned ArgIdx = 0; ArgIdx != Args.size(); ++ArgIdx) {
1953 ArgTy[ArgIdx] = Args[ArgIdx]->getType();
1954 if (ArgTy[ArgIdx]->isArrayType())
1975 std::vector<Token> ExpandedToks;
1981 if (Literal.hadError)
1985 for (
const Token &Tok : StringToks)
1986 StringTokLocs.push_back(Tok.getLocation());
1990 &StringTokLocs[0], StringTokLocs.size());
1992 if (!Literal.getUDSuffix().empty()) {
1995 Literal.getUDSuffixOffset());
1996 return ExprError(
Diag(UDSuffixLoc, diag::err_invalid_string_udl));
2018 std::vector<Token> ExpandedToks;
2019 ExpandedToks.reserve(Toks.size());
2020 for (
const Token &Tok : Toks) {
2023 ExpandedToks.emplace_back(Tok);
2026 if (isa<TranslationUnitDecl>(CurrentDecl))
2027 Diag(Tok.getLocation(), diag::ext_predef_outside_function);
2029 Diag(Tok.getLocation(), diag::ext_string_literal_from_predefined)
2032 llvm::raw_svector_ostream
OS(Str);
2033 Token &Exp = ExpandedToks.emplace_back();
2035 if (Tok.getKind() == tok::kw_L__FUNCTION__ ||
2036 Tok.getKind() == tok::kw_L__FUNCSIG__) {
2038 Exp.
setKind(tok::wide_string_literal);
2040 Exp.
setKind(tok::string_literal);
2048 return ExpandedToks;
2059 assert(!StringToks.empty() &&
"Must have at least one string!");
2062 std::vector<Token> ExpandedToks;
2067 if (Literal.hadError)
2071 for (
const Token &Tok : StringToks)
2072 StringTokLocs.push_back(Tok.getLocation());
2076 if (Literal.isWide()) {
2079 }
else if (Literal.isUTF8()) {
2083 }
else if (Literal.isUTF16()) {
2086 }
else if (Literal.isUTF32()) {
2089 }
else if (Literal.isPascal()) {
2097 Diag(StringTokLocs.front(), diag::warn_cxx20_compat_utf8_string);
2103 auto RemovalDiag =
PDiag(diag::note_cxx20_compat_utf8_string_remove_u8);
2105 for (
const Token &Tok : StringToks) {
2106 if (Tok.getKind() == tok::utf8_string_literal) {
2108 RemovalDiagLoc = Tok.getLocation();
2115 Diag(RemovalDiagLoc, RemovalDiag);
2123 Kind, Literal.Pascal, StrTy,
2125 StringTokLocs.size());
2126 if (Literal.getUDSuffix().empty())
2133 Literal.getUDSuffixOffset());
2137 return ExprError(
Diag(UDSuffixLoc, diag::err_invalid_string_udl));
2162 Expr *Args[] = { Lit, LenArg };
2173 StringTokLocs.back(), &ExplicitArgs);
2181 llvm::APSInt
Value(CharBits, CharIsUnsigned);
2187 for (
unsigned I = 0, N = Lit->
getLength(); I != N; ++I) {
2194 StringTokLocs.back(), &ExplicitArgs);
2198 llvm_unreachable(
"unexpected literal operator lookup result");
2202 llvm_unreachable(
"unexpected literal operator lookup result");
2234 auto *DRE = dyn_cast<DeclRefExpr>(VD->
getInit());
2237 auto *Referee = dyn_cast<VarDecl>(DRE->getDecl());
2238 if (!Referee || !Referee->hasGlobalStorage() ||
2239 Referee->hasAttr<CUDADeviceAttr>())
2245 auto *MD = dyn_cast_or_null<CXXMethodDecl>(S.
CurContext);
2246 if (MD && MD->getParent()->isLambda() &&
2247 MD->getOverloadedOperator() == OO_Call && MD->hasAttr<CUDADeviceAttr>() &&
2269 if (
VarDecl *VD = dyn_cast<VarDecl>(D)) {
2270 if (VD->getType()->isReferenceType() &&
2273 VD->isUsableInConstantExpressions(
Context))
2290 bool RefersToCapturedVariable = isa<VarDecl, BindingDecl>(D) &&
2294 Context, NNS, TemplateKWLoc, D, RefersToCapturedVariable, NameInfo, Ty,
2322 const auto *FD = dyn_cast<FieldDecl>(D);
2323 if (
const auto *IFD = dyn_cast<IndirectFieldDecl>(D))
2324 FD = IFD->getAnonField();
2328 if (FD->isBitField())
2334 if (
const auto *BD = dyn_cast<BindingDecl>(D))
2335 if (
const auto *BE = BD->getBinding())
2360 Id.TemplateId->NumArgs);
2366 TemplateArgs = &Buffer;
2369 TemplateArgs =
nullptr;
2376 unsigned DiagnosticID,
unsigned DiagnosticSuggestID) {
2383 SemaRef.
Diag(TypoLoc, diag::err_no_member) << Typo << Ctx
2386 SemaRef.
Diag(TypoLoc, DiagnosticID) << Typo;
2391 bool DroppedSpecifier =
2394 ? diag::note_implicit_param_decl
2395 : diag::note_previous_decl;
2398 SemaRef.
PDiag(NoteID));
2401 << Typo << Ctx << DroppedSpecifier
2403 SemaRef.
PDiag(NoteID));
2418 bool isDefaultArgument =
2422 const auto *CurMethod = dyn_cast<CXXMethodDecl>(
CurContext);
2423 bool isInstance = CurMethod && CurMethod->isInstance() &&
2432 unsigned DiagID = diag::err_found_in_dependent_base;
2433 unsigned NoteID = diag::note_member_declared_at;
2435 DiagID =
getLangOpts().MSVCCompat ? diag::ext_found_later_in_class
2436 : diag::err_found_later_in_class;
2438 DiagID = diag::ext_found_in_dependent_base;
2439 NoteID = diag::note_dependent_member_use;
2455 Diag(D->getLocation(), NoteID);
2464 if (isDefaultArgument && ((*R.
begin())->isCXXInstanceMember())) {
2483 unsigned diagnostic = diag::err_undeclared_var_use;
2484 unsigned diagnostic_suggest = diag::err_undeclared_var_use_suggest;
2488 diagnostic = diag::err_undeclared_use;
2489 diagnostic_suggest = diag::err_undeclared_use_suggest;
2499 if (isa<CXXRecordDecl>(DC)) {
2515 R.
addDecl(Best->FoundDecl.getDecl(), Best->FoundDecl.getAccess());
2532 assert(!ExplicitTemplateArgs &&
2533 "Diagnosing an empty lookup with explicit template args!");
2537 emitEmptyLookupTypoDiagnostic(TC, *this, SS, Name, TypoLoc, Args,
2538 diagnostic, diagnostic_suggest);
2543 }
else if (S && (Corrected =
2547 bool DroppedSpecifier =
2551 bool AcceptableWithRecovery =
false;
2552 bool AcceptableWithoutRecovery =
false;
2561 dyn_cast<FunctionTemplateDecl>(CD))
2565 else if (
FunctionDecl *FD = dyn_cast<FunctionDecl>(CD))
2566 if (!ExplicitTemplateArgs || ExplicitTemplateArgs->
size() == 0)
2572 ND = Best->FoundDecl;
2573 Corrected.setCorrectionDecl(ND);
2577 Corrected.setCorrectionDecl(ND);
2589 Record = cast<CXXRecordDecl>(
2595 AcceptableWithRecovery = isa<ValueDecl>(UnderlyingND) ||
2596 isa<FunctionTemplateDecl>(UnderlyingND);
2602 AcceptableWithoutRecovery = isa<TypeDecl>(UnderlyingND) ||
2604 isa<ObjCInterfaceDecl>(UnderlyingND);
2608 AcceptableWithoutRecovery =
true;
2611 if (AcceptableWithRecovery || AcceptableWithoutRecovery) {
2613 ? diag::note_implicit_param_decl
2614 : diag::note_previous_decl;
2617 PDiag(NoteID), AcceptableWithRecovery);
2621 << DroppedSpecifier << SS.
getRange(),
2622 PDiag(NoteID), AcceptableWithRecovery);
2625 return !AcceptableWithRecovery;
2661 else if (
auto *MD = dyn_cast<CXXMethodDecl>(S.
CurContext))
2669 auto DB = S.
Diag(Loc, diag::ext_undeclared_unqual_id_with_dependent_base);
2670 DB << NameInfo.
getName() << RD;
2672 if (!ThisType.
isNull()) {
2675 Context,
nullptr, ThisType,
true,
2677 nullptr, NameInfo, TemplateArgs);
2694 bool HasTrailingLParen,
bool IsAddressOfOperand,
2696 bool IsInlineAsmIdentifier,
Token *KeywordReplacement) {
2697 assert(!(IsAddressOfOperand && HasTrailingLParen) &&
2698 "cannot be direct & operand and have a trailing lparen");
2730 bool DependentID =
false;
2732 Name.getCXXNameType()->isDependentType()) {
2734 }
else if (SS.
isSet()) {
2745 IsAddressOfOperand, TemplateArgs);
2756 if (
auto *VD = dyn_cast<ValueDecl>(R.
getFoundDecl())) {
2770 if (TemplateKWLoc.
isValid() || TemplateArgs) {
2776 bool MemberOfUnknownSpecialization;
2779 MemberOfUnknownSpecialization, TemplateKWLoc,
2783 if (MemberOfUnknownSpecialization ||
2786 IsAddressOfOperand, TemplateArgs);
2795 IsAddressOfOperand, TemplateArgs);
2799 if (IvarLookupFollowUp) {
2814 if (R.
empty() && HasTrailingLParen && II &&
2824 if (R.
empty() && !ADL) {
2827 TemplateKWLoc, TemplateArgs))
2832 if (IsInlineAsmIdentifier)
2842 "Typo correction callback misconfigured");
2853 std::nullopt,
nullptr, &TE)) {
2854 if (TE && KeywordReplacement) {
2856 auto BestTC = State.Consumer->getNextCorrection();
2857 if (BestTC.isKeyword()) {
2858 auto *II = BestTC.getCorrectionAsIdentifierInfo();
2859 if (State.DiagHandler)
2860 State.DiagHandler(BestTC);
2864 KeywordReplacement->
setLocation(BestTC.getCorrectionRange().getBegin());
2870 return (
Expr*)
nullptr;
2872 State.Consumer->resetCorrectionStream();
2877 assert(!R.
empty() &&
2878 "DiagnoseEmptyLookup returned false but added no results");
2895 assert(!R.
empty() || ADL);
2925 if (TemplateArgs || TemplateKWLoc.
isValid()) {
2933 "There should only be one declaration found.");
2976 if (
const auto *CD = dyn_cast<CXXRecordDecl>(DC))
2977 if (CD->isInvalidDecl())
2988 unsigned DiagID = diag::err_typename_missing;
2990 DiagID = diag::ext_typename_missing;
2992 auto D =
Diag(Loc, DiagID);
3023 if (!R.
empty() && (*R.
begin())->isCXXClassMember() && !IsAddressOfOperand)
3059 LookForIvars =
true;
3060 else if (IsClassMethod)
3061 LookForIvars =
false;
3072 if (IsClassMethod) {
3093 Diag(Loc, diag::warn_ivar_use_hidden) << IV->getDeclName();
3101 Diag(Loc, diag::err_ivar_use_in_class_method) << IV->getDeclName();
3114 "should not reference ivar from this context");
3117 assert(IFace &&
"should not reference ivar from this context");
3182 cast<ObjCIvarDecl>(Ivar.
get()));
3184 if (Lookup.
empty() && II && AllowBuiltinCreation)
3216 const auto *RD = dyn_cast<CXXRecordDecl>(
Member->getDeclContext());
3224 bool PointerConversions =
false;
3225 if (isa<FieldDecl>(
Member)) {
3229 DestRecordType, FromPtrType
3236 PointerConversions =
true;
3238 DestType = DestRecordType;
3239 FromRecordType = FromType;
3241 }
else if (
const auto *Method = dyn_cast<CXXMethodDecl>(
Member)) {
3242 if (!Method->isImplicitObjectMemberFunction())
3245 DestType = Method->getThisType().getNonReferenceType();
3246 DestRecordType = Method->getFunctionObjectParameterType();
3250 PointerConversions =
true;
3252 FromRecordType = FromType;
3253 DestType = DestRecordType;
3258 if (FromAS != DestAS) {
3263 if (PointerConversions)
3304 if (Qualifier && Qualifier->getAsType()) {
3306 assert(QType->
isRecordType() &&
"lookup done with non-record type");
3316 FromLoc, FromRange, &BasePath))
3319 if (PointerConversions)
3322 VK, &BasePath).
get();
3325 FromRecordType = QRecordType;
3336 FromLoc, FromRange, &BasePath,
3346 bool HasTrailingLParen) {
3348 if (!HasTrailingLParen)
3366 if (D->isCXXClassMember())
3375 if (isa<UsingShadowDecl>(D))
3376 D = cast<UsingShadowDecl>(D)->getTargetDecl();
3377 else if (D->getLexicalDeclContext()->isFunctionOrMethod())
3384 if (
const auto *FDecl = dyn_cast<FunctionDecl>(D)) {
3386 if (FDecl->getBuiltinID() && FDecl->isImplicit())
3388 }
else if (!isa<FunctionTemplateDecl>(D))
3401 bool AcceptInvalid) {
3405 if (isa<TypedefNameDecl>(D)) {
3410 if (isa<ObjCInterfaceDecl>(D)) {
3415 if (isa<NamespaceDecl>(D)) {
3427 const auto *FD = dyn_cast<FunctionDecl>(R.
getFoundDecl());
3429 (FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion());
3434 bool AcceptInvalidDecl) {
3473 bool AcceptInvalidDecl) {
3474 assert(D &&
"Cannot refer to a NULL declaration");
3475 assert(!isa<FunctionTemplateDecl>(D) &&
3476 "Cannot refer unambiguously to a function template");
3486 if (
TemplateDecl *Template = dyn_cast<TemplateDecl>(D)) {
3494 if (!isa<ValueDecl, UnresolvedUsingIfExistsDecl>(D)) {
3495 Diag(Loc, diag::err_ref_non_value) << D << SS.
getRange();
3507 auto *VD = cast<ValueDecl>(D);
3510 if (VD->isInvalidDecl() && !AcceptInvalidDecl)
3516 if (
auto *IndirectField = dyn_cast<IndirectFieldDecl>(VD);
3517 IndirectField && !IndirectField->isCXXClassMember())
3529 type =
type.getNonPackExpansionType();
3533#define ABSTRACT_DECL(kind)
3534#define VALUE(type, base)
3535#define DECL(type, base) case Decl::type:
3536#include "clang/AST/DeclNodes.inc"
3537 llvm_unreachable(
"invalid value decl kind");
3540 case Decl::ObjCAtDefsField:
3541 llvm_unreachable(
"forming non-member reference to ivar?");
3545 case Decl::EnumConstant:
3546 case Decl::UnresolvedUsingValue:
3547 case Decl::OMPDeclareReduction:
3548 case Decl::OMPDeclareMapper:
3557 case Decl::IndirectField:
3558 case Decl::ObjCIvar:
3560 "building reference to field in C?");
3570 case Decl::NonTypeTemplateParm: {
3572 type = reftype->getPointeeType();
3582 if (
type->isRecordType()) {
3583 type =
type.getUnqualifiedType().withConst();
3596 case Decl::VarTemplateSpecialization:
3597 case Decl::VarTemplatePartialSpecialization:
3598 case Decl::Decomposition:
3599 case Decl::OMPCapturedExpr:
3602 type->isVoidType()) {
3608 case Decl::ImplicitParam:
3609 case Decl::ParmVar: {
3619 if (!CapturedType.
isNull())
3620 type = CapturedType;
3632 case Decl::Function: {
3633 if (
unsigned BID = cast<FunctionDecl>(VD)->getBuiltinID()) {
3662 if (!cast<FunctionDecl>(VD)->hasPrototype() && isa<FunctionProtoType>(fty))
3671 case Decl::CXXDeductionGuide:
3672 llvm_unreachable(
"building reference to deduction guide");
3674 case Decl::MSProperty:
3676 case Decl::TemplateParamObject:
3682 case Decl::UnnamedGlobalConstant:
3686 case Decl::CXXMethod:
3691 dyn_cast<FunctionProtoType>(VD->getType()))
3699 if (cast<CXXMethodDecl>(VD)->isStatic()) {
3705 case Decl::CXXConversion:
3706 case Decl::CXXDestructor:
3707 case Decl::CXXConstructor:
3719 if (VD->isInvalidDecl() && E)
3726 Target.resize(CharByteWidth * (Source.size() + 1));
3727 char *ResultPtr = &
Target[0];
3728 const llvm::UTF8 *ErrorPtr;
3730 llvm::ConvertUTF8toWide(CharByteWidth, Source, ResultPtr, ErrorPtr);
3740 Diag(Loc, diag::ext_predef_outside_function);
3746 if (cast<DeclContext>(currentDecl)->isDependentContext())
3751 bool ForceElaboratedPrinting =
3755 unsigned Length = Str.length();
3757 llvm::APInt LengthI(32, Length + 1);
3797 if (Literal.hadError())
3801 if (Literal.isWide())
3807 else if (Literal.isUTF16())
3809 else if (Literal.isUTF32())
3818 if (Literal.isWide())
3820 else if (Literal.isUTF16())
3822 else if (Literal.isUTF32())
3824 else if (Literal.isUTF8())
3830 if (Literal.getUDSuffix().empty())
3840 return ExprError(
Diag(UDSuffixLoc, diag::err_invalid_character_udl));
3858 using llvm::APFloat;
3859 APFloat Val(Format);
3861 APFloat::opStatus result = Literal.GetFloatValue(Val);
3865 if ((result & APFloat::opOverflow) ||
3866 ((result & APFloat::opUnderflow) && Val.isZero())) {
3867 unsigned diagnostic;
3869 if (result & APFloat::opOverflow) {
3870 diagnostic = diag::warn_float_overflow;
3871 APFloat::getLargest(Format).toString(buffer);
3873 diagnostic = diag::warn_float_underflow;
3874 APFloat::getSmallest(Format).toString(buffer);
3877 S.
Diag(Loc, diagnostic)
3879 << StringRef(buffer.data(), buffer.size());
3882 bool isExact = (result == APFloat::opOK);
3887 assert(E &&
"Invalid expression");
3894 Diag(E->
getExprLoc(), diag::err_pragma_loop_invalid_argument_type) << QT;
3898 llvm::APSInt ValueAPS;
3909 bool ValueIsPositive =
3910 AllowZero ? ValueAPS.isNonNegative() : ValueAPS.isStrictlyPositive();
3911 if (!ValueIsPositive || ValueAPS.getActiveBits() > 31) {
3912 Diag(E->
getExprLoc(), diag::err_pragma_loop_invalid_argument_value)
3913 <<
toString(ValueAPS, 10) << ValueIsPositive;
3933 SpellingBuffer.resize(Tok.
getLength() + 1);
3944 if (Literal.hadError)
3947 if (Literal.hasUDSuffix()) {
3955 return ExprError(
Diag(UDSuffixLoc, diag::err_invalid_numeric_udl));
3958 if (Literal.isFloatingLiteral()) {
3983 !Literal.isImaginary)) {
3992 if (Literal.isFloatingLiteral()) {
3996 if (Literal.GetIntegerValue(ResultVal))
4009 unsigned Length = Literal.getUDSuffixOffset();
4016 false, StrTy, &TokLoc, 1);
4027 bool CharIsUnsigned =
Context.
CharTy->isUnsignedIntegerType();
4028 llvm::APSInt
Value(CharBits, CharIsUnsigned);
4029 for (
unsigned I = 0, N = Literal.getUDSuffixOffset(); I != N; ++I) {
4030 Value = TokSpelling[I];
4039 llvm_unreachable(
"unexpected literal operator lookup result");
4045 if (Literal.isFixedPointLiteral()) {
4048 if (Literal.isAccum) {
4049 if (Literal.isHalf) {
4051 }
else if (Literal.isLong) {
4056 }
else if (Literal.isFract) {
4057 if (Literal.isHalf) {
4059 }
else if (Literal.isLong) {
4068 bool isSigned = !Literal.isUnsigned;
4072 llvm::APInt Val(bit_width, 0, isSigned);
4073 bool Overflowed = Literal.GetFixedPointValue(Val, scale);
4074 bool ValIsZero = Val.isZero() && !Overflowed;
4077 if (Literal.isFract && Val == MaxVal + 1 && !ValIsZero)
4083 else if (Val.ugt(MaxVal) || Overflowed)
4088 }
else if (Literal.isFloatingLiteral()) {
4090 if (Literal.isHalf){
4098 }
else if (Literal.isFloat)
4100 else if (Literal.isLong)
4102 else if (Literal.isFloat16)
4104 else if (Literal.isFloat128)
4124 }
else if (!Literal.isIntegerLiteral()) {
4130 if (Literal.isSizeT)
4133 ? diag::warn_cxx20_compat_size_t_suffix
4134 : diag::ext_cxx23_size_t_suffix
4135 : diag::err_cxx23_size_t_suffix);
4142 if (Literal.isBitInt)
4146 : diag::ext_c23_bitint_suffix);
4155 unsigned BitsNeeded =
4156 Literal.isBitInt ? llvm::APInt::getSufficientBitsNeeded(
4157 Literal.getLiteralDigits(), Literal.getRadix())
4159 llvm::APInt ResultVal(BitsNeeded, 0);
4161 if (Literal.GetIntegerValue(ResultVal)) {
4167 "long long is not intmax_t?");
4174 bool AllowUnsigned = Literal.isUnsigned || Literal.getRadix() != 10;
4180 if (Literal.MicrosoftInteger) {
4181 if (Literal.MicrosoftInteger == 8 && !Literal.isUnsigned) {
4185 Width = Literal.MicrosoftInteger;
4187 !Literal.isUnsigned);
4193 if (Literal.isBitInt) {
4196 Width = std::max(ResultVal.getActiveBits(), 1u) +
4197 (Literal.isUnsigned ? 0u : 1u);
4201 unsigned int MaxBitIntWidth =
4203 if (Width > MaxBitIntWidth) {
4205 << Literal.isUnsigned;
4206 Width = MaxBitIntWidth;
4213 ResultVal = ResultVal.zextOrTrunc(Width);
4218 if (Literal.isSizeT) {
4219 assert(!Literal.MicrosoftInteger &&
4220 "size_t literals can't be Microsoft literals");
4225 if (ResultVal.isIntN(SizeTSize)) {
4227 if (!Literal.isUnsigned && ResultVal[SizeTSize - 1] == 0)
4229 else if (AllowUnsigned)
4235 if (Ty.
isNull() && !Literal.isLong && !Literal.isLongLong &&
4241 if (ResultVal.isIntN(IntSize)) {
4243 if (!Literal.isUnsigned && ResultVal[IntSize-1] == 0)
4245 else if (AllowUnsigned)
4252 if (Ty.
isNull() && !Literal.isLongLong && !Literal.isSizeT) {
4256 if (ResultVal.isIntN(LongSize)) {
4258 if (!Literal.isUnsigned && ResultVal[LongSize-1] == 0)
4260 else if (AllowUnsigned)
4265 const unsigned LongLongSize =
4270 ? diag::warn_old_implicitly_unsigned_long_cxx
4272 ext_old_implicitly_unsigned_long_cxx
4273 : diag::warn_old_implicitly_unsigned_long)
4274 << (LongLongSize > LongSize ? 0
4283 if (Ty.
isNull() && !Literal.isSizeT) {
4287 if (ResultVal.isIntN(LongLongSize)) {
4291 if (!Literal.isUnsigned && (ResultVal[LongLongSize-1] == 0 ||
4292 (
getLangOpts().MSVCCompat && Literal.isLongLong)))
4294 else if (AllowUnsigned)
4296 Width = LongLongSize;
4302 ? diag::warn_cxx98_compat_longlong
4303 : diag::ext_cxx11_longlong);
4313 if (Literal.isSizeT)
4315 << Literal.isUnsigned;
4318 diag::ext_integer_literal_too_large_for_signed);
4323 if (ResultVal.getBitWidth() != Width)
4324 ResultVal = ResultVal.trunc(Width);
4330 if (Literal.isImaginary) {
4340 assert(E &&
"ActOnParenExpr() missing expr");
4356 S.
Diag(Loc, diag::err_vecstep_non_scalar_vector_type)
4362 "Scalar types should always be complete");
4371 return S.
Diag(Loc, diag::err_builtin_non_vector_type)
4373 <<
"__builtin_vectorelements" <<
T << ArgRange;
4388 (TraitKind == UETT_SizeOf || TraitKind == UETT_AlignOf ||
4389 TraitKind == UETT_PreferredAlignOf)) {
4391 S.
Diag(Loc, diag::ext_sizeof_alignof_function_type)
4399 unsigned DiagID = S.
LangOpts.OpenCL ? diag::err_opencl_sizeof_alignof_type
4400 : diag::ext_sizeof_alignof_void_type;
4415 S.
Diag(Loc, diag::err_sizeof_nonfragile_interface)
4416 <<
T << (TraitKind == UETT_SizeOf)
4433 const auto *ICE = dyn_cast<ImplicitCastExpr>(E);
4434 if (!ICE || ICE->getCastKind() != CK_ArrayToPointerDecay)
4437 S.
Diag(Loc, diag::warn_sizeof_array_decay) << ICE->getSourceRange()
4439 << ICE->getSubExpr()->getType();
4454 bool IsUnevaluatedOperand =
4455 (ExprKind == UETT_SizeOf || ExprKind == UETT_DataSizeOf ||
4456 ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf ||
4457 ExprKind == UETT_VecStep);
4458 if (IsUnevaluatedOperand) {
4474 Diag(E->
getExprLoc(), diag::warn_side_effects_unevaluated_context);
4476 if (ExprKind == UETT_VecStep)
4480 if (ExprKind == UETT_VectorElements)
4502 if (ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf) {
4505 diag::err_sizeof_alignof_incomplete_or_sizeless_type,
4510 E, diag::err_sizeof_alignof_incomplete_or_sizeless_type,
4529 if (ExprKind == UETT_SizeOf) {
4530 if (
const auto *DeclRef = dyn_cast<DeclRefExpr>(E->
IgnoreParens())) {
4531 if (
const auto *PVD = dyn_cast<ParmVarDecl>(DeclRef->getFoundDecl())) {
4532 QualType OType = PVD->getOriginalType();
4537 Diag(PVD->getLocation(), diag::note_declared_at);
4545 if (
const auto *BO = dyn_cast<BinaryOperator>(E->
IgnoreParens())) {
4562 S.
Diag(E->
getExprLoc(), diag::err_sizeof_alignof_typeof_bitfield)
4569 if (
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Inner)) {
4571 }
else if (
MemberExpr *ME = dyn_cast<MemberExpr>(Inner)) {
4572 D = ME->getMemberDecl();
4592 if (
FieldDecl *FD = dyn_cast_or_null<FieldDecl>(D)) {
4595 if (!FD->getParent()->isCompleteDefinition()) {
4596 S.
Diag(E->
getExprLoc(), diag::err_alignof_member_of_incomplete_type)
4605 if (!FD->getType()->isReferenceType())
4625 assert(CSI !=
nullptr);
4629 const Type *Ty =
T.getTypePtr();
4631#define TYPE(Class, Base)
4632#define ABSTRACT_TYPE(Class, Base)
4633#define NON_CANONICAL_TYPE(Class, Base)
4634#define DEPENDENT_TYPE(Class, Base) case Type::Class:
4635#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base)
4636#include "clang/AST/TypeNodes.inc"
4643 case Type::ExtVector:
4644 case Type::ConstantMatrix:
4647 case Type::TemplateSpecialization:
4648 case Type::ObjCObject:
4649 case Type::ObjCInterface:
4650 case Type::ObjCObjectPointer:
4651 case Type::ObjCTypeParam:
4654 llvm_unreachable(
"type class is never variably-modified!");
4655 case Type::Elaborated:
4656 T = cast<ElaboratedType>(Ty)->getNamedType();
4658 case Type::Adjusted:
4659 T = cast<AdjustedType>(Ty)->getOriginalType();
4664 case Type::ArrayParameter:
4665 T = cast<ArrayParameterType>(Ty)->getElementType();
4670 case Type::BlockPointer:
4673 case Type::LValueReference:
4674 case Type::RValueReference:
4677 case Type::MemberPointer:
4680 case Type::ConstantArray:
4681 case Type::IncompleteArray:
4683 T = cast<ArrayType>(Ty)->getElementType();
4685 case Type::VariableArray: {
4693 (isa<CapturedRegionScopeInfo>(CSI) || isa<LambdaScopeInfo>(CSI)))
4699 case Type::FunctionProto:
4700 case Type::FunctionNoProto:
4705 case Type::UnaryTransform:
4706 case Type::Attributed:
4707 case Type::BTFTagAttributed:
4708 case Type::SubstTemplateTypeParm:
4709 case Type::MacroQualified:
4710 case Type::CountAttributed:
4712 T =
T.getSingleStepDesugaredType(Context);
4715 T = cast<TypedefType>(Ty)->
desugar();
4717 case Type::Decltype:
4718 T = cast<DecltypeType>(Ty)->
desugar();
4720 case Type::PackIndexing:
4721 T = cast<PackIndexingType>(Ty)->
desugar();
4724 T = cast<UsingType>(Ty)->
desugar();
4727 case Type::DeducedTemplateSpecialization:
4728 T = cast<DeducedType>(Ty)->getDeducedType();
4730 case Type::TypeOfExpr:
4731 T = cast<TypeOfExprType>(Ty)->getUnderlyingExpr()->getType();
4734 T = cast<AtomicType>(Ty)->getValueType();
4775 if (ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf ||
4776 ExprKind == UETT_OpenMPRequiredSimdAlign)
4779 if (ExprKind == UETT_VecStep)
4782 if (ExprKind == UETT_VectorElements)
4792 OpLoc, ExprType, diag::err_sizeof_alignof_incomplete_or_sizeless_type,
4797 Diag(OpLoc, diag::err_sizeof_alignof_function_type) << KWName << ExprRange;
4805 Diag(OpLoc, diag::err_wasm_table_invalid_uett_operand)
4819 auto *CSI = dyn_cast<CapturingScopeInfo>(*I);
4823 if (
auto *LSI = dyn_cast<LambdaScopeInfo>(CSI))
4824 DC = LSI->CallOperator;
4825 else if (
auto *CRSI = dyn_cast<CapturedRegionScopeInfo>(CSI))
4826 DC = CRSI->TheCapturedDecl;
4827 else if (
auto *BSI = dyn_cast<BlockScopeInfo>(CSI))
4882 }
else if (ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf) {
4884 }
else if (ExprKind == UETT_VecStep) {
4886 }
else if (ExprKind == UETT_OpenMPRequiredSimdAlign) {
4890 Diag(E->
getExprLoc(), diag::err_sizeof_alignof_typeof_bitfield) << 0;
4892 }
else if (ExprKind == UETT_VectorElements) {
4938 UETT_AlignOf, KWName);
4958 if (
V.get()->isTypeDependent())
4970 return CT->getElementType();
4973 if (
V.get()->getType()->isArithmeticType())
4974 return V.get()->getType();
4979 if (PR.
get() !=
V.get()) {
4985 S.
Diag(Loc, diag::err_realimag_invalid_type) <<
V.get()->getType()
4986 << (IsReal ?
"__real" :
"__imag");
4997 default: llvm_unreachable(
"Unknown unary op!");
4998 case tok::plusplus: Opc = UO_PostInc;
break;
4999 case tok::minusminus: Opc = UO_PostDec;
break;
5018 !S.
LangOpts.ObjCSubscriptingLegacyRuntime)
5021 S.
Diag(opLoc, diag::err_arithmetic_nonfragile_interface)
5028 auto *BaseNoParens =
Base->IgnoreParens();
5029 if (
auto *MSProp = dyn_cast<MSPropertyRefExpr>(BaseNoParens))
5030 return MSProp->getPropertyDecl()->getType()->isArrayType();
5031 return isa<MSPropertySubscriptExpr>(BaseNoParens);
5051 if (RTy->isIntegralOrUnscopedEnumerationType()) {
5053 Result = PT->getPointeeType();
5055 Result = AT->getElementType();
5058 Result = PT->getPointeeType();
5060 Result = AT->getElementType();
5073 auto *AS = cast<ArraySectionExpr>(base);
5074 if (AS->isOMPArraySection())
5086 if (isa<ParenListExpr>(base)) {
5090 base = result.
get();
5097 auto CheckAndReportCommaError = [
this, base, rbLoc](
Expr *E) {
5098 if (isa<BinaryOperator>(E) && cast<BinaryOperator>(E)->isCommaOp()) {
5099 Diag(E->getExprLoc(), diag::err_matrix_subscript_comma)
5109 !isa<MatrixSubscriptExpr>(base)) {
5110 Diag(base->
getExprLoc(), diag::err_matrix_separate_incomplete_index)
5116 auto *matSubscriptE = dyn_cast<MatrixSubscriptExpr>(base);
5117 if (matSubscriptE) {
5118 assert(ArgExprs.size() == 1);
5119 if (CheckAndReportCommaError(ArgExprs.front()))
5122 assert(matSubscriptE->isIncomplete() &&
5123 "base has to be an incomplete matrix subscript");
5125 matSubscriptE->getRowIdx(),
5126 ArgExprs.front(), rbLoc);
5139 bool IsMSPropertySubscript =
false;
5142 if (!IsMSPropertySubscript) {
5146 base = result.
get();
5152 assert(ArgExprs.size() == 1);
5153 if (CheckAndReportCommaError(ArgExprs.front()))
5161 Expr *idx = ArgExprs[0];
5162 if ((isa<BinaryOperator>(idx) && cast<BinaryOperator>(idx)->isCommaOp()) ||
5163 (isa<CXXOperatorCallExpr>(idx) &&
5164 cast<CXXOperatorCallExpr>(idx)->getOperator() == OO_Comma)) {
5170 if (ArgExprs.size() == 1 &&
5171 ArgExprs[0]->getType()->isNonOverloadPlaceholderType()) {
5175 ArgExprs[0] = result.
get();
5185 !isa<PackExpansionExpr>(ArgExprs[0])) {
5187 base, ArgExprs.front(),
5200 if (IsMSPropertySubscript) {
5201 assert(ArgExprs.size() == 1);
5219 (ArgExprs.size() != 1 || isa<PackExpansionExpr>(ArgExprs[0]) ||
5220 ArgExprs[0]->getType()->isRecordType())))) {
5227 if (!Res.
isInvalid() && isa<ArraySubscriptExpr>(Res.
get()))
5228 CheckSubscriptAccessOfNoDeref(cast<ArraySubscriptExpr>(Res.
get()));
5238 return InitSeq.
Perform(*
this, Entity, Kind, E);
5252 RowIdx = RowR.
get();
5267 ColumnIdx = ColumnR.
get();
5272 auto IsIndexValid = [&](
Expr *IndexExpr,
unsigned Dim,
5273 bool IsColumnIdx) ->
Expr * {
5281 if (std::optional<llvm::APSInt> Idx =
5283 if ((*Idx < 0 || *Idx >= Dim)) {
5285 << IsColumnIdx << Dim;
5293 "should be able to convert any integer type to size type");
5294 return ConvExpr.
get();
5298 RowIdx = IsIndexValid(RowIdx, MTy->getNumRows(),
false);
5299 ColumnIdx = IsIndexValid(ColumnIdx, MTy->getNumColumns(),
true);
5300 if (!RowIdx || !ColumnIdx)
5304 MTy->getElementType(), RBLoc);
5307void Sema::CheckAddressOfNoDeref(
const Expr *E) {
5314 while ((
Member = dyn_cast<MemberExpr>(StrippedExpr)) && !
Member->isArrow())
5315 StrippedExpr =
Member->getBase()->IgnoreParenImpCasts();
5317 LastRecord.PossibleDerefs.erase(StrippedExpr);
5328 if (isa<ArrayType>(ResultTy))
5331 if (ResultTy->
hasAttr(attr::NoDeref)) {
5332 LastRecord.PossibleDerefs.insert(E);
5340 if (!(isa<ArrayType>(BaseTy) || isa<PointerType>(BaseTy)))
5345 while ((
Member = dyn_cast<MemberExpr>(
Base->IgnoreParenCasts())) &&
5349 if (
const auto *Ptr = dyn_cast<PointerType>(
Base->getType())) {
5350 if (Ptr->getPointeeType()->hasAttr(attr::NoDeref))
5351 LastRecord.PossibleDerefs.insert(E);
5367 for (
auto *Op : {LHSExp, RHSExp}) {
5368 Op = Op->IgnoreImplicit();
5369 if (Op->getType()->isArrayType() && !Op->isLValue())
5392 Expr *BaseExpr, *IndexExpr;
5427 Diag(LLoc, diag::err_subscript_nonfragile_interface)
5439 LHSExp = Materialized.
get();
5445 ResultType = VTy->getElementType();
5449 Qualifiers Combined = BaseQuals + MemberQuals;
5450 if (Combined != MemberQuals)
5465 LHSExp = Materialized.
get();
5476 Qualifiers Combined = BaseQuals + MemberQuals;
5477 if (Combined != MemberQuals)
5488 CK_ArrayToPointerDecay).
get();
5494 }
else if (RHSTy->isArrayType()) {
5499 CK_ArrayToPointerDecay).
get();
5506 return ExprError(
Diag(LLoc, diag::err_typecheck_subscript_value)
5511 return ExprError(
Diag(LLoc, diag::err_typecheck_subscript_not_integer)
5517 std::optional<llvm::APSInt> IntegerContantExpr =
5519 if (!IntegerContantExpr.has_value() ||
5520 IntegerContantExpr.value().isNegative())
5536 Diag(LLoc, diag::ext_gnu_subscript_void_type)
5547 diag::err_subscript_incomplete_or_sizeless_type, BaseExpr))
5560 auto *CSI = dyn_cast<CapturingScopeInfo>(*I);
5564 if (
auto *LSI = dyn_cast<LambdaScopeInfo>(CSI))
5565 DC = LSI->CallOperator;
5566 else if (
auto *CRSI = dyn_cast<CapturedRegionScopeInfo>(CSI))
5567 DC = CRSI->TheCapturedDecl;
5568 else if (
auto *BSI = dyn_cast<BlockScopeInfo>(CSI))
5586 bool SkipImmediateInvocations) {
5588 assert(!RewrittenInit &&
"Should not have a rewritten init expression yet");
5592 Diag(Param->
getBeginLoc(), diag::err_recursive_default_argument) << FD;
5593 Diag(CallLoc, diag::note_recursive_default_argument_used_here);
5598 Diag(CallLoc, diag::err_use_of_default_argument_to_function_declared_later)
5601 diag::note_default_argument_declared_here);
5606 assert(!RewrittenInit &&
"Should not have a rewitten init expression yet");
5612 assert(
Init &&
"default argument but no initializer?");
5621 if (
auto *InitWithCleanup = dyn_cast<ExprWithCleanups>(
Init)) {
5628 assert(!InitWithCleanup->getNumObjects() &&
5629 "default argument expression has capturing blocks?");
5642 SkipImmediateInvocations;
5653 bool HasImmediateCalls =
false;
5658 HasImmediateCalls |= FD->isImmediateFunction();
5664 HasImmediateCalls |= FD->isImmediateFunction();
5673 HasImmediateCalls =
true;
5688 return TraverseStmt(E->
getExpr());
5692 return TraverseStmt(E->
getExpr());
5717 assert(Param->
hasDefaultArg() &&
"can't build nonexistent default arg");
5721 std::optional<ExpressionEvaluationContextRecord::InitializationContext>
5722 InitializationContext =
5724 if (!InitializationContext.has_value())
5725 InitializationContext.emplace(CallLoc, Param,
CurContext);
5751 if (!NestedDefaultChecking)
5752 V.TraverseDecl(Param);
5756 if (
V.HasImmediateCalls || InLifetimeExtendingContext) {
5757 if (
V.HasImmediateCalls)
5766 Res = Immediate.TransformInitializer(Param->
getInit(),
5780 CallLoc, FD, Param,
Init,
5781 NestedDefaultChecking))
5785 Init, InitializationContext->Context);
5789 assert(Field->hasInClassInitializer());
5792 if (Field->isInvalidDecl())
5797 auto *ParentRD = cast<CXXRecordDecl>(Field->getParent());
5799 std::optional<ExpressionEvaluationContextRecord::InitializationContext>
5800 InitializationContext =
5802 if (!InitializationContext.has_value())
5803 InitializationContext.emplace(Loc, Field,
CurContext);
5812 if (!Field->getInClassInitializer()) {
5818 ClassPattern->
lookup(Field->getDeclName());
5821 for (
auto *L : Lookup) {
5822 if ((Pattern = dyn_cast<FieldDecl>(L)))
5825 assert(Pattern &&
"We must have set the Pattern!");
5829 Field->setInvalidDecl();
5841 if (!NestedDefaultChecking)
5842 V.TraverseDecl(Field);
5843 if (
V.HasImmediateCalls) {
5847 NestedDefaultChecking;
5852 Res = Immediate.TransformInitializer(Field->getInClassInitializer(),
5858 Field->setInvalidDecl();
5864 if (Field->getInClassInitializer()) {
5865 Expr *E =
Init ?
Init : Field->getInClassInitializer();
5866 if (!NestedDefaultChecking)
5874 if (Res.isInvalid()) {
5875 Field->setInvalidDecl();
5881 Field, InitializationContext->Context,
5900 Diag(Loc, diag::err_default_member_initializer_not_yet_parsed)
5901 << OutermostClass << Field;
5902 Diag(Field->getEndLoc(),
5903 diag::note_default_member_initializer_not_yet_parsed);
5906 Field->setInvalidDecl();
5914 if (isa_and_nonnull<CXXConstructorDecl>(FDecl))
5919 if (
CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl))
5920 if (Method->isInstance())
5935 FunctionName(FuncName) {}
5937 bool ValidateCandidate(
const TypoCorrection &candidate)
override {
5946 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
5947 return std::make_unique<FunctionCallCCC>(*
this);
5967 if (
NamedDecl *ND = Corrected.getFoundDecl()) {
5968 if (Corrected.isOverloaded()) {
5978 ND = Best->FoundDecl;
5979 Corrected.setCorrectionDecl(ND);
5985 ND = ND->getUnderlyingDecl();
5986 if (isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND))
6005 bool IsExecConfig) {
6014 bool HasExplicitObjectParameter =
6016 unsigned ExplicitObjectParameterOffset = HasExplicitObjectParameter ? 1 : 0;
6027 if (Args.size() < NumParams) {
6028 if (Args.size() < MinArgs) {
6033 ? diag::err_typecheck_call_too_few_args_suggest
6034 : diag::err_typecheck_call_too_few_args_at_least_suggest;
6037 << FnKind << MinArgs - ExplicitObjectParameterOffset
6038 <<
static_cast<unsigned>(Args.size()) -
6039 ExplicitObjectParameterOffset
6041 }
else if (MinArgs - ExplicitObjectParameterOffset == 1 && FDecl &&
6046 ? diag::err_typecheck_call_too_few_args_one
6047 : diag::err_typecheck_call_too_few_args_at_least_one)
6048 << FnKind << FDecl->
getParamDecl(ExplicitObjectParameterOffset)
6052 ? diag::err_typecheck_call_too_few_args
6053 : diag::err_typecheck_call_too_few_args_at_least)
6054 << FnKind << MinArgs - ExplicitObjectParameterOffset
6055 <<
static_cast<unsigned>(Args.size()) -
6056 ExplicitObjectParameterOffset
6060 if (!TC && FDecl && !FDecl->
getBuiltinID() && !IsExecConfig)
6068 assert((
Call->getNumArgs() == NumParams) &&
6069 "We should have reserved space for the default arguments before!");
6074 if (Args.size() > NumParams) {
6080 ? diag::err_typecheck_call_too_many_args_suggest
6081 : diag::err_typecheck_call_too_many_args_at_most_suggest;
6084 << FnKind << NumParams - ExplicitObjectParameterOffset
6085 <<
static_cast<unsigned>(Args.size()) -
6086 ExplicitObjectParameterOffset
6088 }
else if (NumParams - ExplicitObjectParameterOffset == 1 && FDecl &&
6091 Diag(Args[NumParams]->getBeginLoc(),
6092 MinArgs == NumParams
6093 ? diag::err_typecheck_call_too_many_args_one
6094 : diag::err_typecheck_call_too_many_args_at_most_one)
6095 << FnKind << FDecl->
getParamDecl(ExplicitObjectParameterOffset)
6096 <<
static_cast<unsigned>(Args.size()) -
6097 ExplicitObjectParameterOffset
6100 Args.back()->getEndLoc());
6102 Diag(Args[NumParams]->getBeginLoc(),
6103 MinArgs == NumParams
6104 ? diag::err_typecheck_call_too_many_args
6105 : diag::err_typecheck_call_too_many_args_at_most)
6106 << FnKind << NumParams - ExplicitObjectParameterOffset
6107 <<
static_cast<unsigned>(Args.size()) -
6108 ExplicitObjectParameterOffset
6111 Args.back()->getEndLoc());
6114 if (!TC && FDecl && !FDecl->
getBuiltinID() && !IsExecConfig)
6119 Call->shrinkNumArgs(NumParams);
6130 unsigned TotalNumArgs = AllArgs.size();
6131 for (
unsigned i = 0; i < TotalNumArgs; ++i)
6132 Call->setArg(i, AllArgs[i]);
6134 Call->computeDependence();
6143 bool IsListInitialization) {
6148 for (
unsigned i = FirstParam; i < NumParams; i++) {
6153 if (ArgIx < Args.size()) {
6154 Arg = Args[ArgIx++];
6157 diag::err_call_incomplete_argument, Arg))
6161 bool CFAudited =
false;
6163 FDecl && FDecl->
hasAttr<CFAuditedTransferAttr>() &&
6164 (!Param || !Param->
hasAttr<CFConsumedAttr>()))
6167 FDecl && FDecl->
hasAttr<CFAuditedTransferAttr>() &&
6168 (!Param || !Param->
hasAttr<CFConsumedAttr>()))
6174 BE->getBlockDecl()->setDoesNotEscape();
6187 Entity,
SourceLocation(), Arg, IsListInitialization, AllowExplicit);
6193 assert(Param &&
"can't use default arguments without a known callee");
6205 CheckArrayAccess(Arg);
6210 AllArgs.push_back(Arg);
6219 for (
Expr *A : Args.slice(ArgIx)) {
6223 AllArgs.push_back(arg.get());
6228 for (
Expr *A : Args.slice(ArgIx)) {
6231 AllArgs.push_back(Arg.
get());
6236 for (
Expr *A : Args.slice(ArgIx))
6237 CheckArrayAccess(A);
6245 TL = DTL.getOriginalLoc();
6248 << ATL.getLocalSourceRange();
6262 const Expr *ArgExpr) {
6292 Diag(CallLoc, diag::warn_static_array_too_small)
6300 std::optional<CharUnits> ArgSize =
6302 std::optional<CharUnits> ParmSize =
6304 if (ArgSize && ParmSize && *ArgSize < *ParmSize) {
6305 Diag(CallLoc, diag::warn_static_array_too_small)
6307 << (
unsigned)ParmSize->getQuantity() << 1;
6321 if (!placeholder)
return false;
6323 switch (placeholder->
getKind()) {
6325#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
6326 case BuiltinType::Id:
6327#include "clang/Basic/OpenCLImageTypes.def"
6328#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
6329 case BuiltinType::Id:
6330#include "clang/Basic/OpenCLExtensionTypes.def"
6333#define SVE_TYPE(Name, Id, SingletonId) \
6334 case BuiltinType::Id:
6335#include "clang/Basic/AArch64SVEACLETypes.def"
6336#define PPC_VECTOR_TYPE(Name, Id, Size) \
6337 case BuiltinType::Id:
6338#include "clang/Basic/PPCTypes.def"
6339#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
6340#include "clang/Basic/RISCVVTypes.def"
6341#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
6342#include "clang/Basic/WebAssemblyReferenceTypes.def"
6343#define PLACEHOLDER_TYPE(ID, SINGLETON_ID)
6344#define BUILTIN_TYPE(ID, SINGLETON_ID) case BuiltinType::ID:
6345#include "clang/AST/BuiltinTypes.def"
6350 case BuiltinType::Overload:
6355 case BuiltinType::ARCUnbridgedCast:
6359 case BuiltinType::PseudoObject:
6364 case BuiltinType::UnknownAny:
6368 case BuiltinType::BoundMember:
6369 case BuiltinType::BuiltinFn:
6370 case BuiltinType::IncompleteMatrixIdx:
6371 case BuiltinType::ArraySection:
6372 case BuiltinType::OMPArrayShaping:
6373 case BuiltinType::OMPIterator:
6377 llvm_unreachable(
"bad builtin type kind");
6383 bool hasInvalid =
false;
6384 for (
size_t i = 0, e = args.size(); i != e; i++) {
6387 if (result.
isInvalid()) hasInvalid =
true;
6388 else args[i] = result.
get();
6416 bool NeedsNewDecl =
false;
6429 if (!ParamType->isPointerType() || ParamType.hasAddressSpace() ||
6433 OverloadParams.push_back(ParamType);
6441 NeedsNewDecl =
true;
6454 OverloadParams, EPI);
6463 FT = cast<FunctionProtoType>(OverloadTy);
6464 for (
unsigned i = 0, e = FT->
getNumParams(); i != e; ++i) {
6471 Params.push_back(Parm);
6473 OverloadDecl->setParams(Params);
6475 return OverloadDecl;
6486 !Callee->isVariadic())
6488 if (Callee->getMinRequiredArguments() > ArgExprs.size())
6491 if (
const EnableIfAttr *
Attr =
6494 isa<CXXMethodDecl>(Callee)
6495 ? diag::err_ovl_no_viable_member_function_in_call
6496 : diag::err_ovl_no_viable_function_in_call)
6497 << Callee << Callee->getSourceRange();
6498 S.
Diag(Callee->getLocation(),
6499 diag::note_ovl_candidate_disabled_by_function_cond_attr)
6500 <<
Attr->getCond()->getSourceRange() <<
Attr->getMessage();
6508 const auto GetFunctionLevelDCIfCXXClass =
6516 if (
const auto *MD = dyn_cast<CXXMethodDecl>(DC))
6517 return MD->
getParent()->getCanonicalDecl();
6520 if (
const auto *RD = dyn_cast<CXXRecordDecl>(DC))
6521 return RD->getCanonicalDecl();
6528 const CXXRecordDecl *
const CurParentClass = GetFunctionLevelDCIfCXXClass(S);
6529 if (!CurParentClass)
6536 assert(NamingClass &&
"Must have naming class even for implicit access");
6542 return CurParentClass == NamingClass ||
6591 if (
Call->getNumArgs() != 1)
6594 const Expr *E =
Call->getCallee()->IgnoreParenImpCasts();
6595 if (!E || isa<UnresolvedLookupExpr>(E))
6597 const DeclRefExpr *DRE = dyn_cast_if_present<DeclRefExpr>(E);
6610 if (BuiltinID != Builtin::BImove && BuiltinID != Builtin::BIforward)
6613 S.
Diag(DRE->
getLocation(), diag::warn_unqualified_call_to_std_cast_function)
6624 if (
Call.isInvalid())
6629 if (
const auto *ULE = dyn_cast<UnresolvedLookupExpr>(Fn);
6630 ULE && ULE->hasExplicitTemplateArgs() &&
6631 ULE->decls_begin() == ULE->decls_end()) {
6633 ? diag::warn_cxx17_compat_adl_only_template_id
6634 : diag::ext_adl_only_template_id)
6642 if (
const auto *CE = dyn_cast<CallExpr>(
Call.get()))
6653 Expr *ExecConfig,
bool IsExecConfig,
6654 bool AllowRecovery) {
6665 if (isa<CXXPseudoDestructorExpr>(Fn)) {
6666 if (!ArgExprs.empty()) {
6671 ArgExprs.back()->getEndLoc()));
6688 cast<CallExpr>(ExecConfig), ArgExprs,
6694 *
this, dyn_cast<UnresolvedMemberExpr>(Fn->
IgnoreParens()),
6715 RParenLoc, ExecConfig, IsExecConfig,
6732 Scope, Fn, ULE, LParenLoc, ArgExprs, RParenLoc, ExecConfig,
6735 RParenLoc, ExecConfig, IsExecConfig,
6749 bool CallingNDeclIndirectly =
false;
6751 if (
UnaryOperator *UnOp = dyn_cast<UnaryOperator>(NakedFn)) {
6752 if (UnOp->getOpcode() == UO_AddrOf) {
6753 CallingNDeclIndirectly =
true;
6758 if (
auto *DRE = dyn_cast<DeclRefExpr>(NakedFn)) {
6759 NDecl = DRE->getDecl();
6772 nullptr, DRE->isNonOdrUse());
6775 }
else if (
auto *ME = dyn_cast<MemberExpr>(NakedFn))
6776 NDecl = ME->getMemberDecl();
6778 if (
FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(NDecl)) {
6792 FD->getBuiltinID()) {
6793 for (
unsigned Idx = 0; Idx < FD->param_size(); ++Idx) {
6796 !ArgExprs[Idx]->getType()->isPointerType())
6800 auto ArgTy = ArgExprs[Idx]->getType();
6801 auto ArgPtTy = ArgTy->getPointeeType();
6802 auto ArgAS = ArgPtTy.getAddressSpace();
6805 bool NeedImplicitASC =
6810 if (!NeedImplicitASC)
6814 if (ArgExprs[Idx]->isGLValue()) {
6816 Context, ArgExprs[Idx]->getType(), CK_NoOp, ArgExprs[Idx],
6821 Qualifiers ArgPtQuals = ArgPtTy.getQualifiers();
6831 CK_AddressSpaceConversion)
6841 llvm::any_of(ArgExprs,
6842 [](
clang::Expr *E) { return E->containsErrors(); })) &&
6843 "should only occur in error-recovery path.");
6848 ExecConfig, IsExecConfig);
6861 assert(BuiltInDecl &&
"failed to find builtin declaration");
6865 assert(DeclRef.
isUsable() &&
"Builtin reference cannot fail");
6870 assert(!
Call.isInvalid() &&
"Call to builtin cannot fail!");
6895 Diag(BuiltinLoc, diag::err_invalid_astype_of_different_size)
6924 FunctionDecl *FDecl = dyn_cast_or_null<FunctionDecl>(NDecl);
6925 unsigned BuiltinID = (FDecl ? FDecl->
getBuiltinID() : 0);
6928 if (FDecl && FDecl->
hasAttr<AnyX86InterruptAttr>()) {
6941 if (Caller->hasAttr<ARMInterruptAttr>()) {
6943 if (VFP && (!FDecl || !FDecl->
hasAttr<ARMInterruptAttr>())) {
6944 Diag(Fn->
getExprLoc(), diag::warn_arm_interrupt_calling_convention);
6949 if (Caller->hasAttr<AnyX86InterruptAttr>() ||
6950 Caller->hasAttr<AnyX86NoCallerSavedRegistersAttr>()) {
6952 bool HasNonGPRRegisters =
6954 if (HasNonGPRRegisters &&
6955 (!FDecl || !FDecl->
hasAttr<AnyX86NoCallerSavedRegistersAttr>())) {
6957 << (Caller->hasAttr<AnyX86InterruptAttr>() ? 0 : 1);
6997 return ExprError(
Diag(LParenLoc, diag::err_typecheck_call_not_function)
7012 return ExprError(
Diag(LParenLoc, diag::err_typecheck_call_not_function)
7020 const auto *Proto = dyn_cast_or_null<FunctionProtoType>(FuncT);
7021 unsigned NumParams = Proto ? Proto->getNumParams() : 0;
7025 assert(UsesADL == ADLCallKind::NotADL &&
7026 "CUDAKernelCallExpr should not use ADL");
7047 TheCall = dyn_cast<CallExpr>(
Result.get());
7048 bool CorrectedTypos = TheCall != TheOldCall;
7049 if (!TheCall)
return Result;
7056 if (CorrectedTypos && Args.size() < NumParams) {
7072 return CheckBuiltinFunctionCall(FDecl, BuiltinID, TheCall);
7077 if (FDecl && !FDecl->
hasAttr<CUDAGlobalAttr>())
7078 return ExprError(
Diag(LParenLoc,diag::err_kern_call_not_global_function)
7085 return ExprError(
Diag(LParenLoc, diag::err_kern_type_not_void_return)
7089 if (FDecl && FDecl->
hasAttr<CUDAGlobalAttr>())
7090 return ExprError(
Diag(LParenLoc, diag::err_global_call_not_config)
7106 for (
const Expr *Arg : Args) {
7107 if (Arg && Arg->getType()->isWebAssemblyTableType()) {
7109 diag::err_wasm_table_as_function_parameter));
7119 assert(isa<FunctionNoProtoType>(FuncT) &&
"Unknown FunctionType!");
7127 if (!Proto || !(Proto->isVariadic() && Args.size() >= Def->
param_size()))
7128 Diag(RParenLoc, diag::warn_call_wrong_number_of_arguments)
7148 if (!Proto && !Args.empty() &&
7152 Diag(LParenLoc, diag::warn_strict_uses_without_prototype)
7153 << (FDecl !=
nullptr) << FDecl;
7156 for (
unsigned i = 0, e = Args.size(); i != e; i++) {
7157 Expr *Arg = Args[i];
7159 if (Proto && i < Proto->getNumParams()) {
7161 Context, Proto->getParamType(i), Proto->isParamConsumed(i));
7179 diag::err_call_incomplete_argument, Arg))
7187 if (
CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl))
7188 if (!isa<RequiresExprBodyDecl>(
CurContext) &&
7189 Method->isImplicitObjectMemberFunction())
7190 return ExprError(
Diag(LParenLoc, diag::err_member_call_without_object)
7199 for (
unsigned i = 0, e = Args.size(); i != e; i++) {
7200 if (
const auto *RT =
7201 dyn_cast<RecordType>(Args[i]->getType().getCanonicalType())) {
7202 if (RT->getDecl()->isOrContainsUnion())
7203 Diag(Args[i]->getBeginLoc(), diag::warn_cmse_nonsecure_union)
7214 checkFortifiedBuiltinMemoryFunction(FDecl, TheCall);
7217 return CheckBuiltinFunctionCall(FDecl, BuiltinID, TheCall);
7219 if (CheckPointerCall(NDecl, TheCall, Proto))
7222 if (CheckOtherCall(TheCall, Proto))
7232 assert(Ty &&
"ActOnCompoundLiteral(): missing type");
7233 assert(InitExpr &&
"ActOnCompoundLiteral(): missing expression");
7251 diag::err_array_incomplete_or_sizeless_type,
7265 std::optional<unsigned> NumInits;
7266 if (
const auto *ILE = dyn_cast<InitListExpr>(LiteralExpr))
7267 NumInits = ILE->getNumInits();
7268 if ((
LangOpts.CPlusPlus || NumInits.value_or(0)) &&
7270 diag::err_variable_object_no_init))
7275 diag::err_typecheck_decl_incomplete_type,
7290 LiteralExpr =
Result.get();
7318 if (
auto ILE = dyn_cast<InitListExpr>(LiteralExpr))
7319 for (
unsigned i = 0, j = ILE->getNumInits(); i != j; i++) {
7325 VK, LiteralExpr, isFileScope);
7337 Diag(LParenLoc, diag::err_compound_literal_with_address_space)
7373 bool DiagnosedArrayDesignator =
false;
7374 bool DiagnosedNestedDesignator =
false;
7375 bool DiagnosedMixedDesignator =
false;
7379 for (
unsigned I = 0, E = InitArgList.size(); I != E; ++I) {
7380 if (
auto *DIE = dyn_cast<DesignatedInitExpr>(InitArgList[I])) {
7382 FirstDesignator = DIE->getBeginLoc();
7387 if (!DiagnosedNestedDesignator && DIE->size() > 1) {
7388 DiagnosedNestedDesignator =
true;
7389 Diag(DIE->getBeginLoc(), diag::ext_designated_init_nested)
7390 << DIE->getDesignatorsSourceRange();
7393 for (
auto &Desig : DIE->designators()) {
7394 if (!Desig.isFieldDesignator() && !DiagnosedArrayDesignator) {
7395 DiagnosedArrayDesignator =
true;
7396 Diag(Desig.getBeginLoc(), diag::ext_designated_init_array)
7397 << Desig.getSourceRange();
7401 if (!DiagnosedMixedDesignator &&
7402 !isa<DesignatedInitExpr>(InitArgList[0])) {
7403 DiagnosedMixedDesignator =
true;
7404 Diag(DIE->getBeginLoc(), diag::ext_designated_init_mixed)
7405 << DIE->getSourceRange();
7406 Diag(InitArgList[0]->getBeginLoc(), diag::note_designated_init_mixed)
7407 << InitArgList[0]->getSourceRange();
7410 isa<DesignatedInitExpr>(InitArgList[0])) {
7411 DiagnosedMixedDesignator =
true;
7412 auto *DIE = cast<DesignatedInitExpr>(InitArgList[0]);
7413 Diag(DIE->getBeginLoc(), diag::ext_designated_init_mixed)
7414 << DIE->getSourceRange();
7415 Diag(InitArgList[I]->getBeginLoc(), diag::note_designated_init_mixed)
7416 << InitArgList[I]->getSourceRange();
7420 if (FirstDesignator.
isValid()) {
7424 !DiagnosedNestedDesignator && !DiagnosedMixedDesignator) {
7426 ? diag::warn_cxx17_compat_designated_init
7427 : diag::ext_cxx_designated_init);
7429 Diag(FirstDesignator, diag::ext_designated_init);
7444 for (
unsigned I = 0, E = InitArgList.size(); I != E; ++I) {
7445 if (InitArgList[I]->getType()->isNonOverloadPlaceholderType()) {
7452 InitArgList[I] = result.
get();
7480 if (
type->isObjCObjectPointerType()) {
7482 }
else if (
type->isBlockPointerType()) {
7484 return CK_BlockPointerToObjCPointerCast;
7486 assert(
type->isPointerType());
7487 return CK_CPointerToObjCPointerCast;
7504 llvm_unreachable(
"member pointer type in C");
7513 if (SrcAS != DestAS)
7514 return CK_AddressSpaceConversion;
7521 ? CK_BitCast : CK_AnyPointerToBlockPointerCast);
7526 return CK_CPointerToObjCPointerCast;
7528 return CK_BlockPointerToObjCPointerCast;
7530 return CK_PointerToBoolean;
7532 return CK_PointerToIntegral;
7538 llvm_unreachable(
"illegal cast from pointer");
7540 llvm_unreachable(
"Should have returned before this");
7545 return CK_FixedPointCast;
7547 return CK_FixedPointToBoolean;
7549 return CK_FixedPointToIntegral;
7551 return CK_FixedPointToFloating;
7555 diag::err_unimplemented_conversion_with_fixed_point_type)
7557 return CK_IntegralCast;
7562 llvm_unreachable(
"illegal cast to pointer type");
7564 llvm_unreachable(
"Should have returned before this");
7574 return CK_NullToPointer;
7575 return CK_IntegralToPointer;
7577 return CK_IntegralToBoolean;
7579 return CK_IntegralCast;
7581 return CK_IntegralToFloating;
7586 return CK_IntegralRealToComplex;
7590 CK_IntegralToFloating);
7591 return CK_FloatingRealToComplex;
7593 llvm_unreachable(
"member pointer type in C");
7595 return CK_IntegralToFixedPoint;
7597 llvm_unreachable(
"Should have returned before this");
7602 return CK_FloatingCast;
7604 return CK_FloatingToBoolean;
7606 return CK_FloatingToIntegral;
7611 return CK_FloatingRealToComplex;
7615 CK_FloatingToIntegral);
7616 return CK_IntegralRealToComplex;
7620 llvm_unreachable(
"valid float->pointer cast?");
7622 llvm_unreachable(
"member pointer type in C");
7624 return CK_FloatingToFixedPoint;
7626 llvm_unreachable(
"Should have returned before this");
7631 return CK_FloatingComplexCast;
7633 return CK_FloatingComplexToIntegralComplex;
7637 return CK_FloatingComplexToReal;
7639 return CK_FloatingCast;
7642 return CK_FloatingComplexToBoolean;
7646 CK_FloatingComplexToReal);
7647 return CK_FloatingToIntegral;
7651 llvm_unreachable(
"valid complex float->pointer cast?");
7653 llvm_unreachable(
"member pointer type in C");
7656 diag::err_unimplemented_conversion_with_fixed_point_type)
7658 return CK_IntegralCast;
7660 llvm_unreachable(
"Should have returned before this");
7665 return CK_IntegralComplexToFloatingComplex;
7667 return CK_IntegralComplexCast;
7671 return CK_IntegralComplexToReal;
7673 return CK_IntegralCast;
7676 return CK_IntegralComplexToBoolean;
7680 CK_IntegralComplexToReal);
7681 return CK_IntegralToFloating;
7685 llvm_unreachable(
"valid complex int->pointer cast?");
7687 llvm_unreachable(
"member pointer type in C");
7690 diag::err_unimplemented_conversion_with_fixed_point_type)
7692 return CK_IntegralCast;
7694 llvm_unreachable(
"Should have returned before this");
7697 llvm_unreachable(
"Unhandled scalar cast");
7704 len = vecType->getNumElements();
7705 eltType = vecType->getElementType();
7712 if (!
type->isRealType())
return false;
7728 auto ValidScalableConversion = [](
QualType FirstType,
QualType SecondType) {
7732 const auto *VecTy = SecondType->getAs<
VectorType>();
7736 return ValidScalableConversion(srcTy, destTy) ||
7737 ValidScalableConversion(destTy, srcTy);
7749 auto ValidScalableConversion = [](
QualType FirstType,
QualType SecondType) {
7753 const auto *VecTy = SecondType->getAs<
VectorType>();
7757 return ValidScalableConversion(srcTy, destTy) ||
7758 ValidScalableConversion(destTy, srcTy);
7770 return matSrcType->
getNumRows() == matDestType->getNumRows() &&
7771 matSrcType->
getNumColumns() == matDestType->getNumColumns();
7777 uint64_t SrcLen, DestLen;
7790 return (SrcLen * SrcEltSize == DestLen * DestEltSize);
7796 "expected at least one type to be a vector here");
7798 bool IsSrcTyAltivec =
7814 return (IsSrcTyAltivec || IsDestTyAltivec);
7850 if (!Vec || !Vec->getElementType()->isIntegralOrEnumerationType())
7855 if (!Vec || !Vec->getElementType()->isIntegralOrEnumerationType())
7872 return Diag(R.
getBegin(), diag::err_invalid_conversion_between_matrixes)
7873 << DestTy << SrcTy << R;
7877 diag::err_invalid_conversion_between_matrix_and_type)
7878 << SrcTy << DestTy << R;
7881 diag::err_invalid_conversion_between_matrix_and_type)
7882 << DestTy << SrcTy << R;
7885 Kind = CK_MatrixCast;
7891 assert(VectorTy->
isVectorType() &&
"Not a vector type!");
7897 diag::err_invalid_conversion_between_vectors :
7898 diag::err_invalid_conversion_between_vector_and_integer)
7899 << VectorTy << Ty << R;
7902 diag::err_invalid_conversion_between_vector_and_scalar)
7903 << VectorTy << Ty << R;
7912 if (DestElemTy == SplattedExpr->
getType())
7913 return SplattedExpr;
7926 CK_BooleanToSignedIntegral);
7927 SplattedExpr = CastExprRes.
get();
7928 CK = CK_IntegralToFloating;
7930 CK = CK_BooleanToSignedIntegral;
7937 SplattedExpr = CastExprRes.
get();
7956 Diag(R.
getBegin(),diag::err_invalid_conversion_between_ext_vectors)
7957 << DestTy << SrcTy << R;
7969 diag::err_invalid_conversion_between_vector_and_scalar)
7970 << DestTy << SrcTy << R;
7972 Kind = CK_VectorSplat;
7981 "ActOnCastExpr(): missing type or expr");
8003 bool isVectorLiteral =
false;
8018 isVectorLiteral =
true;
8021 isVectorLiteral =
true;
8026 if (isVectorLiteral)
8032 if (isa<ParenListExpr>(
CastExpr)) {
8053 assert((isa<ParenListExpr>(E) || isa<ParenExpr>(E)) &&
8054 "Expected paren or paren list expression");
8061 LiteralLParenLoc = PE->getLParenLoc();
8062 LiteralRParenLoc = PE->getRParenLoc();
8063 exprs = PE->getExprs();
8064 numExprs = PE->getNumExprs();
8066 LiteralLParenLoc = cast<ParenExpr>(E)->getLParen();
8067 LiteralRParenLoc = cast<ParenExpr>(E)->getRParen();
8068 subExpr = cast<ParenExpr>(E)->getSubExpr();
8091 if (numExprs == 1) {
8094 if (Literal.isInvalid())
8100 else if (numExprs < numElems) {
8102 diag::err_incorrect_number_of_vector_initializers);
8106 initExprs.append(exprs, exprs + numExprs);
8115 if (Literal.isInvalid())
8122 initExprs.append(exprs, exprs + numExprs);
8127 initExprs, LiteralRParenLoc);
8162 const Expr *NullExpr = LHSExpr;
8163 const Expr *NonPointerExpr = RHSExpr;
8170 NonPointerExpr = LHSExpr;
8192 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands_null)
8193 << NonPointerExpr->
getType() << DiagType
8205 S.
Diag(QuestionLoc, diag::err_typecheck_cond_expect_nonfloat)
8213 S.
Diag(QuestionLoc, diag::err_typecheck_cond_expect_scalar)
8247 bool IsBlockPointer =
false;
8251 IsBlockPointer =
true;
8276 ResultAddrSpace = LAddrSpace;
8278 ResultAddrSpace = RAddrSpace;
8280 S.
Diag(Loc, diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
8287 auto LHSCastKind = CK_BitCast, RHSCastKind = CK_BitCast;
8302 LAddrSpace == ResultAddrSpace ? CK_BitCast : CK_AddressSpaceConversion;
8304 RAddrSpace == ResultAddrSpace ? CK_BitCast : CK_AddressSpaceConversion;
8312 lhptee, rhptee,
false,
false,
8315 if (CompositeTy.
isNull()) {
8332 S.
Diag(Loc, diag::ext_typecheck_cond_incompatible_pointers)
8343 QualType ResultTy = [&, ResultAddrSpace]() {
8349 .withCVRQualifiers(MergedCVRQual);
8378 S.
Diag(Loc, diag::err_typecheck_cond_incompatible_operands)
8431 bool IsIntFirstExpr) {
8433 !Int.get()->getType()->isIntegerType())
8436 Expr *Expr1 = IsIntFirstExpr ? Int.get() : PointerExpr;
8437 Expr *Expr2 = IsIntFirstExpr ? PointerExpr : Int.get();
8439 S.
Diag(Loc, diag::ext_typecheck_cond_pointer_integer_mismatch)
8443 CK_IntegralToPointer);
8477 S.
Diag(QuestionLoc, diag::err_typecheck_cond_expect_int_float)
8483 S.
Diag(QuestionLoc, diag::err_typecheck_cond_expect_int_float)
8489 if (LHSType == RHSType)
8498 return handleIntegerConversion<doIntegralCast, doIntegralCast>
8499 (S, LHS, RHS, LHSType, RHSType,
false);
8533 llvm::raw_svector_ostream OS(Str);
8534 OS <<
"(vector of " << NumElements <<
" '" << EleTyName <<
"' values)";
8535 S.
Diag(QuestionLoc, diag::err_conditional_vector_element_size)
8536 << CondTy << OS.str();
8557 S.
Diag(QuestionLoc, diag::err_typecheck_cond_expect_nonfloat)
8575 S.
Diag(QuestionLoc, diag::err_conditional_vector_size)
8576 << CondTy << VecResTy;
8581 QualType RVE = RV->getElementType();
8584 S.
Diag(QuestionLoc, diag::err_conditional_vector_element_size)
8585 << CondTy << VecResTy;
8611 bool IsBoolVecLang =
8635 if (
const CallExpr *CE = dyn_cast<CallExpr>(E)) {
8636 QualType Ty = CE->getCallee()->getType();
8674 "should only occur in error-recovery path.");
8709 Diag(QuestionLoc, diag::err_wasm_table_conditional_expression)
8718 diag::err_typecheck_cond_incompatible_operands) << LHSTy << RHSTy
8737 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
8753 if (LHSRT->getDecl() == RHSRT->getDecl())
8797 if (!compositeType.
isNull())
8798 return compositeType;
8832 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
8904 if (!(compositeType =
8912 RHSOPT->isObjCQualifiedIdType()) &&
8923 Diag(QuestionLoc, diag::ext_typecheck_cond_incompatible_operands)
8934 return compositeType;
8941 Diag(QuestionLoc, diag::err_cond_voidptr_arc) << LHSTy << RHSTy
8961 Diag(QuestionLoc, diag::err_cond_voidptr_arc) << LHSTy << RHSTy
8993 Self.Diag(Loc,
Note) << ParenRange;
9013 const Expr **RHSExprs) {
9018 if (
const auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E)) {
9019 E = MTE->getSubExpr();
9024 if (
const auto *OP = dyn_cast<BinaryOperator>(E);
9026 *Opcode = OP->getOpcode();
9027 *RHSExprs = OP->getRHS();
9032 if (
const auto *
Call = dyn_cast<CXXOperatorCallExpr>(E)) {
9033 if (
Call->getNumArgs() != 2)
9039 if (OO < OO_Plus || OO > OO_Arrow ||
9040 OO == OO_PlusPlus || OO == OO_MinusMinus)
9046 *RHSExprs =
Call->getArg(1);
9062 if (
const auto *OP = dyn_cast<BinaryOperator>(E))
9063 return OP->isComparisonOp() || OP->isLogicalOp();
9064 if (
const auto *OP = dyn_cast<UnaryOperator>(E))
9065 return OP->getOpcode() == UO_LNot;
9080 const Expr *RHSExpr) {
9082 const Expr *CondRHS;
9093 ? diag::warn_precedence_bitwise_conditional
9094 : diag::warn_precedence_conditional;
9096 Self.Diag(OpLoc, DiagID)
9102 Self.PDiag(diag::note_precedence_silence)
9107 Self.PDiag(diag::note_precedence_conditional_first),
9118 auto GetNullability = [](
QualType Ty) {
9119 std::optional<NullabilityKind> Kind = Ty->getNullability();
9129 auto LHSKind = GetNullability(LHSTy), RHSKind = GetNullability(RHSTy);
9137 MergedKind = RHSKind;
9144 MergedKind = RHSKind;
9146 MergedKind = LHSKind;
9152 if (GetNullability(ResTy) == MergedKind)
9189 CondExpr = CondResult.
get();
9190 LHSExpr = LHSResult.
get();
9191 RHSExpr = RHSResult.
get();
9197 Expr *commonExpr =
nullptr;
9199 commonExpr = CondExpr;
9206 commonExpr = result.
get();
9220 commonExpr = commonRes.
get();
9230 commonExpr = MatExpr.
get();
9238 LHSExpr = CondExpr = opaqueValue;
9244 ExprResult Cond = CondExpr, LHS = LHSExpr, RHS = RHSExpr;
9246 VK, OK, QuestionLoc);
9254 CheckBoolLikeConversion(Cond.
get(), QuestionLoc);
9262 RHS.get(), result, VK, OK);
9265 commonExpr, opaqueValue, Cond.
get(), LHS.get(), RHS.get(), QuestionLoc,
9266 ColonLoc, result, VK, OK);
9271 unsigned FromAttributes = 0, ToAttributes = 0;
9272 if (
const auto *FromFn =
9276 if (
const auto *ToFn =
9281 return FromAttributes != ToAttributes;
9289 if (
const auto *ToFn =
9291 if (
const auto *FromFn =
9310 assert(LHSType.
isCanonical() &&
"LHS not canonicalized!");
9311 assert(RHSType.
isCanonical() &&
"RHS not canonicalized!");
9314 const Type *lhptee, *rhptee;
9316 std::tie(lhptee, lhq) =
9317 cast<PointerType>(LHSType)->getPointeeType().split().asPair();
9318 std::tie(rhptee, rhq) =
9319 cast<PointerType>(RHSType)->getPointeeType().split().asPair();
9379 diag::warn_typecheck_convert_incompatible_function_pointer_strict,
9402 if (ltrans == rtrans) {
9416 if (isa<PointerType>(lhptee) && isa<PointerType>(rhptee)) {
9418 std::tie(lhptee, lhq) =
9419 cast<PointerType>(lhptee)->getPointeeType().split().asPair();
9420 std::tie(rhptee, rhq) =
9421 cast<PointerType>(rhptee)->getPointeeType().split().asPair();
9434 }
while (isa<PointerType>(lhptee) && isa<PointerType>(rhptee));
9436 if (lhptee == rhptee)
9462 assert(LHSType.
isCanonical() &&
"LHS not canonicalized!");
9463 assert(RHSType.
isCanonical() &&
"RHS not canonicalized!");
9484 if (LQuals != RQuals)
9513 assert(LHSType.
isCanonical() &&
"LHS was not canonicalized!");
9514 assert(RHSType.
isCanonical() &&
"RHS was not canonicalized!");
9562 return VT->getElementType().getCanonicalType() == ElementType;
9595 if (LHSType == RHSType) {
9602 if (
const auto *AT = dyn_cast<AutoType>(LHSType)) {
9603 if (AT->isGNUAutoType()) {
9611 if (
const AtomicType *AtomicTy = dyn_cast<AtomicType>(LHSType)) {
9616 if (Kind != CK_NoOp && ConvertRHS)
9618 Kind = CK_NonAtomicToAtomic;
9631 Kind = CK_LValueBitCast;
9646 Kind = CK_VectorSplat;
9672 << RHSType << LHSType;
9691 << RHSType << LHSType;
9741 if (
const PointerType *LHSPointer = dyn_cast<PointerType>(LHSType)) {
9743 if (isa<PointerType>(RHSType)) {
9744 LangAS AddrSpaceL = LHSPointer->getPointeeType().getAddressSpace();
9746 if (AddrSpaceL != AddrSpaceR)
9747 Kind = CK_AddressSpaceConversion;
9758 Kind = CK_IntegralToPointer;
9764 if (isa<ObjCObjectPointerType>(RHSType)) {
9766 if (LHSPointer->getPointeeType()->isVoidType()) {
9785 if (LHSPointer->getPointeeType()->isVoidType()) {
9786 LangAS AddrSpaceL = LHSPointer->getPointeeType().getAddressSpace();
9791 AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion : CK_BitCast;
9800 if (isa<BlockPointerType>(LHSType)) {
9809 Kind = AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion : CK_BitCast;
9815 Kind = CK_IntegralToPointer;
9821 Kind = CK_AnyPointerToBlockPointerCast;
9827 if (RHSPT->getPointeeType()->isVoidType()) {
9828 Kind = CK_AnyPointerToBlockPointerCast;
9836 if (isa<ObjCObjectPointerType>(LHSType)) {
9842 if (
getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
9851 Kind = CK_IntegralToPointer;
9857 if (isa<PointerType>(RHSType)) {
9858 Kind = CK_CPointerToObjCPointerCast;
9880 Kind = CK_BlockPointerToObjCPointerCast;
9892 Kind = CK_NullToPointer;
9897 if (isa<PointerType>(RHSType)) {
9900 Kind = CK_PointerToBoolean;
9906 Kind = CK_PointerToIntegral;
9914 if (isa<ObjCObjectPointerType>(RHSType)) {
9917 Kind = CK_PointerToBoolean;
9923 Kind = CK_PointerToIntegral;
9931 if (isa<TagType>(LHSType) && isa<TagType>(RHSType)) {
9939 Kind = CK_IntToOCLSampler;
9981 for (
auto *it : UD->
fields()) {
9982 if (it->getType()->isPointerType()) {
10021 bool DiagnoseCFAudited,
10025 assert((ConvertRHS || !
Diagnose) &&
"can't indicate whether we diagnosed");
10031 ExprResult &RHS = ConvertRHS ? CallerRHS : LocalRHS;
10035 if (RHSPtrType->getPointeeType()->hasAttr(attr::NoDeref) &&
10036 !LHSPtrType->getPointeeType()->hasAttr(attr::NoDeref)) {
10038 diag::warn_noderef_to_dereferenceable_pointer)
10057 AllowedExplicit::None,
10069 if (
getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
10084 RHS.
get(), LHSType,
false, DAP))
10175 if (
getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
10205struct OriginalOperand {
10206 explicit OriginalOperand(
Expr *Op) : Orig(Op), Conversion(nullptr) {
10207 if (
auto *MTE = dyn_cast<MaterializeTemporaryExpr>(Op))
10208 Op = MTE->getSubExpr();
10209 if (
auto *BTE = dyn_cast<CXXBindTemporaryExpr>(Op))
10210 Op = BTE->getSubExpr();
10211 if (
auto *ICE = dyn_cast<ImplicitCastExpr>(Op)) {
10212 Orig = ICE->getSubExprAsWritten();
10213 Conversion = ICE->getConversionFunction();
10217 QualType getType()
const {
return Orig->getType(); }
10226 OriginalOperand OrigLHS(LHS.
get()), OrigRHS(RHS.
get());
10228 Diag(Loc, diag::err_typecheck_invalid_operands)
10229 << OrigLHS.getType() << OrigRHS.getType()
10234 if (OrigLHS.Conversion) {
10235 Diag(OrigLHS.Conversion->getLocation(),
10236 diag::note_typecheck_invalid_operands_converted)
10239 if (OrigRHS.Conversion) {
10240 Diag(OrigRHS.Conversion->getLocation(),
10241 diag::note_typecheck_invalid_operands_converted)
10259 if (!(LHSNatVec && RHSNatVec)) {
10261 Expr *NonVector = !LHSNatVec ? LHS.
get() : RHS.
get();
10262 Diag(Loc, diag::err_typecheck_logical_vector_expr_gnu_cpp_restrict)
10264 <<
Vector->getSourceRange();
10268 Diag(Loc, diag::err_typecheck_logical_vector_expr_gnu_cpp_restrict)
10291 unsigned &DiagID) {
10300 DiagID = diag::err_opencl_scalar_type_rank_greater_than_vector_type;
10305 scalarCast = CK_IntegralCast;
10310 DiagID = diag::err_opencl_scalar_type_rank_greater_than_vector_type;
10313 scalarCast = CK_FloatingCast;
10316 scalarCast = CK_IntegralToFloating;
10325 if (scalarCast != CK_NoOp)
10336 assert(VecTy &&
"Expression E must be a vector");
10341 VecTy->getVectorKind());
10345 if (
auto *ICE = dyn_cast<ImplicitCastExpr>(E))
10346 if (ICE->getSubExpr()->getType() == NewVecTy)
10347 return ICE->getSubExpr();
10349 auto Cast = ElementType->
isIntegerType() ? CK_IntegralCast : CK_FloatingCast;
10357 QualType IntTy = Int->get()->getType().getUnqualifiedType();
10363 bool CstInt = Int->get()->EvaluateAsInt(EVResult, S.
Context);
10372 unsigned NumBits = IntSigned
10374 :
Result.getActiveBits())
10375 :
Result.getActiveBits();
10382 return (IntSigned != OtherIntSigned &&
10388 return (Order < 0);
10395 QualType IntTy = Int->get()->getType().getUnqualifiedType();
10400 bool CstInt = Int->get()->EvaluateAsInt(EVResult, S.
Context);
10412 llvm::APFloat::rmTowardZero);
10415 bool Ignored =
false;
10416 Float.convertToInteger(ConvertBack, llvm::APFloat::rmNearestTiesToEven,
10418 if (
Result != ConvertBack)
10424 unsigned FloatPrec = llvm::APFloat::semanticsPrecision(
10426 if (Bits > FloatPrec)
10439 QualType ScalarTy = Scalar->get()->getType().getUnqualifiedType();
10440 QualType VectorTy =
Vector->get()->getType().getUnqualifiedType();
10444 assert(!isa<ExtVectorType>(VT) &&
10445 "ExtVectorTypes should not be handled here!");
10446 VectorEltTy = VT->getElementType();
10451 llvm_unreachable(
"Only Fixed-Length and SVE Vector types are handled here");
10477 ScalarCast = CK_IntegralCast;
10481 ScalarCast = CK_FloatingToIntegral;
10489 llvm::APFloat
Result(0.0);
10495 bool CstScalar = Scalar->get()->isValueDependent() ||
10498 if (!CstScalar && Order < 0)
10504 bool Truncated =
false;
10506 llvm::APFloat::rmNearestTiesToEven, &Truncated);
10511 ScalarCast = CK_FloatingCast;
10516 ScalarCast = CK_IntegralToFloating;
10523 if (ScalarCast != CK_NoOp)
10531 bool AllowBothBool,
10532 bool AllowBoolConversions,
10533 bool AllowBoolOperation,
10534 bool ReportInvalid) {
10535 if (!IsCompAssign) {
10551 assert(LHSVecType || RHSVecType);
10555 if (!AllowBothBool && LHSVecType &&
10561 if (!AllowBoolOperation &&
10570 if (LHSVecType && RHSVecType &&
10572 if (isa<ExtVectorType>(LHSVecType)) {
10585 if (AllowBoolConversions && LHSVecType && RHSVecType &&
10595 if (!IsCompAssign &&
10598 RHSVecType->getElementType()->isIntegerType()) {
10607 unsigned &SVEorRVV) {
10625 if (IsSveRVVConversion(LHSType, RHSType, SVEorRVV) ||
10626 IsSveRVVConversion(RHSType, LHSType, SVEorRVV)) {
10627 Diag(Loc, diag::err_typecheck_sve_rvv_ambiguous)
10628 << SVEorRVV << LHSType << RHSType;
10635 unsigned &SVEorRVV) {
10640 if (FirstVecType && SecondVecType) {
10643 SecondVecType->getVectorKind() ==
10655 if (SecondVecType &&
10668 if (IsSveRVVGnuConversion(LHSType, RHSType, SVEorRVV) ||
10669 IsSveRVVGnuConversion(RHSType, LHSType, SVEorRVV)) {
10670 Diag(Loc, diag::err_typecheck_sve_rvv_gnu_ambiguous)
10671 << SVEorRVV << LHSType << RHSType;
10677 unsigned DiagID = diag::err_typecheck_vector_not_convertable;
10679 if (isa<ExtVectorType>(LHSVecType)) {
10690 if (isa<ExtVectorType>(RHSVecType)) {
10692 LHSType, RHSVecType->getElementType(),
10705 QualType VecType = LHSVecType ? LHSType : RHSType;
10706 const VectorType *VT = LHSVecType ? LHSVecType : RHSVecType;
10707 QualType OtherType = LHSVecType ? RHSType : LHSType;
10708 ExprResult *OtherExpr = LHSVecType ? &RHS : &LHS;
10713 Diag(Loc, diag::warn_deprecated_lax_vec_conv_all) << RHSType << LHSType;
10717 if (!IsCompAssign) {
10736 if ((!RHSVecType && !RHSType->
isRealType()) ||
10738 Diag(Loc, diag::err_typecheck_vector_not_convertable_non_scalar)
10739 << LHSType << RHSType
10749 RHSVecType && isa<ExtVectorType>(RHSVecType) &&
10750 LHSVecType && isa<ExtVectorType>(LHSVecType)) {
10751 Diag(Loc, diag::err_opencl_implicit_vector_conversion) << LHSType
10760 if ((RHSVecType && !isa<ExtVectorType>(RHSVecType)) ||
10761 (LHSVecType && !isa<ExtVectorType>(LHSVecType))) {
10762 QualType Scalar = LHSVecType ? RHSType : LHSType;
10764 unsigned ScalarOrVector = LHSVecType && RHSVecType ? 1 : 0;
10766 diag::err_typecheck_vector_not_convertable_implict_truncation)
10767 << ScalarOrVector << Scalar <<
Vector;
10774 << LHSType << RHSType
10783 if (!IsCompAssign) {
10798 unsigned DiagID = diag::err_typecheck_invalid_operands;
10800 ((LHSBuiltinTy && LHSBuiltinTy->
isSVEBool()) ||
10801 (RHSBuiltinTy && RHSBuiltinTy->isSVEBool()))) {
10822 Diag(Loc, diag::err_typecheck_vector_not_convertable_non_scalar)
10831 Diag(Loc, diag::err_typecheck_vector_lengths_not_equal)
10840 bool ScalarOrVector =
10843 Diag(Loc, diag::err_typecheck_vector_not_convertable_implict_truncation)
10844 << ScalarOrVector << Scalar <<
Vector;
10876 S.
Diag(Loc, diag::warn_null_in_arithmetic_operation)
10888 S.
Diag(Loc, diag::warn_null_in_comparison_operation)
10889 << LHSNull << NonNullType
10895 const auto *LUE = dyn_cast<UnaryExprOrTypeTraitExpr>(LHS);
10896 const auto *RUE = dyn_cast<UnaryExprOrTypeTraitExpr>(RHS);
10899 if (LUE->getKind() != UETT_SizeOf || LUE->isArgumentType() ||
10900 RUE->getKind() != UETT_SizeOf)
10907 if (RUE->isArgumentType())
10908 RHSTy = RUE->getArgumentType().getNonReferenceType();
10910 RHSTy = RUE->getArgumentExpr()->IgnoreParens()->getType();
10917 if (
const auto *DRE = dyn_cast<DeclRefExpr>(LHSArg)) {
10918 if (
const ValueDecl *LHSArgDecl = DRE->getDecl())
10919 S.
Diag(LHSArgDecl->getLocation(), diag::note_pointer_declared_here)
10923 QualType ArrayElemTy = ArrayTy->getElementType();
10929 S.
Diag(Loc, diag::warn_division_sizeof_array)
10931 if (
const auto *DRE = dyn_cast<DeclRefExpr>(LHSArg)) {
10932 if (
const ValueDecl *LHSArgDecl = DRE->getDecl())
10933 S.
Diag(LHSArgDecl->getLocation(), diag::note_array_declared_here)
10937 S.
Diag(Loc, diag::note_precedence_silence) << RHS;
10950 S.
PDiag(diag::warn_remainder_division_by_zero)
10956 bool IsCompAssign,
bool IsDiv) {
11034 ? diag::err_typecheck_pointer_arith_void_type
11035 : diag::ext_gnu_void_ptr)
11044 ? diag::err_typecheck_pointer_arith_void_type
11045 : diag::ext_gnu_void_ptr)
11046 << 0 <<
Pointer->getSourceRange();
11057 S.
Diag(Loc, diag::warn_gnu_null_ptr_arith)
11058 <<
Pointer->getSourceRange();
11060 S.
Diag(Loc, diag::warn_pointer_arith_null_ptr)
11077 S.
PDiag(diag::warn_pointer_sub_null_ptr)
11079 <<
Pointer->getSourceRange());
11088 ? diag::err_typecheck_pointer_arith_function_type
11089 : diag::ext_gnu_ptr_func_arith)
11101 assert(
Pointer->getType()->isAnyPointerType());
11103 ? diag::err_typecheck_pointer_arith_function_type
11104 : diag::ext_gnu_ptr_func_arith)
11105 << 0 <<
Pointer->getType()->getPointeeType()
11107 <<
Pointer->getSourceRange();
11115 QualType ResType = Operand->getType();
11117 ResType = ResAtomicType->getValueType();
11123 diag::err_typecheck_arithmetic_incomplete_or_sizeless_type,
11124 Operand->getSourceRange());
11137 QualType ResType = Operand->getType();
11139 ResType = ResAtomicType->getValueType();
11171 if (!isLHSPointer && !isRHSPointer)
return true;
11173 QualType LHSPointeeTy, RHSPointeeTy;
11178 if (isLHSPointer && isRHSPointer) {
11181 diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
11189 bool isLHSVoidPtr = isLHSPointer && LHSPointeeTy->
isVoidType();
11190 bool isRHSVoidPtr = isRHSPointer && RHSPointeeTy->
isVoidType();
11191 if (isLHSVoidPtr || isRHSVoidPtr) {
11199 bool isLHSFuncPtr = isLHSPointer && LHSPointeeTy->
isFunctionType();
11200 bool isRHSFuncPtr = isRHSPointer && RHSPointeeTy->
isFunctionType();
11201 if (isLHSFuncPtr || isRHSFuncPtr) {
11223 Expr* IndexExpr = RHSExpr;
11226 IndexExpr = LHSExpr;
11229 bool IsStringPlusInt = StrExpr &&
11235 Self.Diag(OpLoc, diag::warn_string_plus_int)
11239 if (IndexExpr == RHSExpr) {
11241 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence)
11246 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence);
11252 const Expr *StringRefExpr = LHSExpr;
11257 CharExpr = dyn_cast<CharacterLiteral>(LHSExpr->
IgnoreImpCasts());
11258 StringRefExpr = RHSExpr;
11261 if (!CharExpr || !StringRefExpr)
11281 Self.Diag(OpLoc, diag::warn_string_plus_char)
11282 << DiagRange << Ctx.
CharTy;
11284 Self.Diag(OpLoc, diag::warn_string_plus_char)
11285 << DiagRange << CharExpr->
getType();
11291 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence)
11296 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence);
11305 S.
Diag(Loc, diag::err_typecheck_sub_ptr_compatible)
11324 if (CompLHSTy) *CompLHSTy = compType;
11333 *CompLHSTy = compType;
11342 *CompLHSTy = compType;
11352 if (Opc == BO_Add) {
11359 if (CompLHSTy) *CompLHSTy = compType;
11373 std::swap(PExp, IExp);
11384 if (!IExp->getType()->isIntegerType())
11393 (!IExp->isValueDependent() &&
11394 (!IExp->EvaluateAsInt(KnownVal,
Context) ||
11398 Context, BO_Add, PExp, IExp);
11410 CheckArrayAccess(PExp, IExp);
11419 *CompLHSTy = LHSTy;
11439 if (CompLHSTy) *CompLHSTy = compType;
11448 *CompLHSTy = compType;
11457 *CompLHSTy = compType;
11470 if (CompLHSTy) *CompLHSTy = compType;
11504 CheckArrayAccess(LHS.
get(), RHS.
get(),
nullptr,
11507 if (CompLHSTy) *CompLHSTy = LHS.
get()->
getType();
11551 if (ElementSize.
isZero()) {
11552 Diag(Loc,diag::warn_sub_ptr_zero_size_types)
11558 if (CompLHSTy) *CompLHSTy = LHS.
get()->
getType();
11568 return ET->getDecl()->isScoped();
11585 llvm::APSInt Right = RHSResult.
Val.
getInt();
11587 if (Right.isNegative()) {
11589 S.
PDiag(diag::warn_shift_negative)
11600 LeftSize = FXSema.getWidth() - (
unsigned)FXSema.hasUnsignedPadding();
11602 if (Right.uge(LeftSize)) {
11604 S.
PDiag(diag::warn_shift_gt_typewidth)
11624 llvm::APSInt Left = LHSResult.
Val.
getInt();
11635 if (Left.isNegative()) {
11637 S.
PDiag(diag::warn_shift_lhs_negative)
11642 llvm::APInt ResultBits =
11643 static_cast<llvm::APInt &
>(Right) + Left.getSignificantBits();
11644 if (ResultBits.ule(LeftSize))
11646 llvm::APSInt
Result = Left.extend(ResultBits.getLimitedValue());
11652 Result.toString(HexResult, 16,
false,
true);
11658 if (ResultBits - 1 == LeftSize) {
11659 S.
Diag(Loc, diag::warn_shift_result_sets_sign_bit)
11660 << HexResult << LHSType
11665 S.
Diag(Loc, diag::warn_shift_result_gt_typewidth)
11666 << HexResult.str() <<
Result.getSignificantBits() << LHSType
11678 S.
Diag(Loc, diag::err_shift_rhs_only_vector)
11684 if (!IsCompAssign) {
11706 S.
Diag(Loc, diag::err_typecheck_invalid_operands)
11713 if (!LHSEleType->isIntegerType()) {
11714 S.
Diag(Loc, diag::err_typecheck_expect_int)
11719 if (!RHSEleType->isIntegerType()) {
11720 S.
Diag(Loc, diag::err_typecheck_expect_int)
11729 if (LHSEleType != RHSEleType) {
11731 LHSEleType = RHSEleType;
11737 }
else if (RHSVecTy) {
11742 S.
Diag(Loc, diag::err_typecheck_vector_lengths_not_equal)
11750 if (LHSBT != RHSBT &&
11752 S.
Diag(Loc, diag::warn_typecheck_vector_element_sizes_not_equal)
11769 bool IsCompAssign) {
11770 if (!IsCompAssign) {
11793 if ((LHSBuiltinTy && LHSBuiltinTy->
isSVEBool()) ||
11794 (RHSBuiltinTy && RHSBuiltinTy->
isSVEBool())) {
11795 S.
Diag(Loc, diag::err_typecheck_invalid_operands)
11800 if (!LHSEleType->isIntegerType()) {
11801 S.
Diag(Loc, diag::err_typecheck_expect_int)
11806 if (!RHSEleType->isIntegerType()) {
11807 S.
Diag(Loc, diag::err_typecheck_expect_int)
11815 S.
Diag(Loc, diag::err_typecheck_invalid_operands)
11825 if (LHSEleType != RHSEleType) {
11827 LHSEleType = RHSEleType;
11829 const llvm::ElementCount VecSize =
11838 S.
Diag(Loc, diag::err_typecheck_vector_lengths_not_equal)
11844 const llvm::ElementCount VecSize =
11846 if (LHSEleType != RHSEleType) {
11848 RHSEleType = LHSEleType;
11861 bool IsCompAssign) {
11895 if (IsCompAssign) LHS = OldLHS;
11926 S.
Diag(Loc, IsError ? diag::err_typecheck_comparison_of_distinct_pointers
11927 : diag::ext_typecheck_comparison_of_distinct_pointers)
11967 S.
Diag(Loc, IsError ? diag::err_typecheck_comparison_of_fptr_to_void
11968 : diag::ext_typecheck_comparison_of_fptr_to_void)
11975 case Stmt::ObjCArrayLiteralClass:
11976 case Stmt::ObjCDictionaryLiteralClass:
11977 case Stmt::ObjCStringLiteralClass:
11978 case Stmt::ObjCBoxedExprClass:
12037 case Stmt::ObjCStringLiteralClass:
12040 case Stmt::ObjCArrayLiteralClass:
12043 case Stmt::ObjCDictionaryLiteralClass:
12046 case Stmt::BlockExprClass:
12048 case Stmt::ObjCBoxedExprClass: {
12049 Expr *Inner = cast<ObjCBoxedExpr>(FromE)->getSubExpr()->IgnoreParens();
12050 switch (Inner->getStmtClass()) {
12051 case Stmt::IntegerLiteralClass:
12052 case Stmt::FloatingLiteralClass:
12053 case Stmt::CharacterLiteralClass:
12054 case Stmt::ObjCBoolLiteralExprClass:
12055 case Stmt::CXXBoolLiteralExprClass:
12058 case Stmt::ImplicitCastExprClass: {
12059 CastKind CK = cast<CastExpr>(Inner)->getCastKind();
12061 if (CK == CK_IntegralToBoolean || CK == CK_IntegralCast)
12080 Literal = LHS.
get();
12083 Literal = RHS.
get();
12099 llvm_unreachable(
"Unknown Objective-C object literal kind");
12103 S.
Diag(Loc, diag::warn_objc_string_literal_comparison)
12104 << Literal->getSourceRange();
12106 S.
Diag(Loc, diag::warn_objc_literal_comparison)
12107 << LiteralKind << Literal->getSourceRange();
12116 S.
Diag(Loc, diag::note_objc_literal_comparison_isequal)
12129 if (!UO || UO->
getOpcode() != UO_LNot)
return;
12139 bool IsBitwiseOp = Opc == BO_And || Opc == BO_Or || Opc == BO_Xor;
12141 << Loc << IsBitwiseOp;
12168 if (
const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(E)) {
12170 }
else if (
const MemberExpr *Mem = dyn_cast<MemberExpr>(E)) {
12171 if (Mem->isImplicitAccess())
12172 D = Mem->getMemberDecl();
12227 S.
Diag(Loc, diag::warn_depr_array_comparison)
12253 Result = AlwaysConstant;
12257 S.
PDiag(diag::warn_comparison_always)
12272 Result = AlwaysConstant;
12276 S.
PDiag(diag::warn_comparison_always)
12282 if (isa<CastExpr>(LHSStripped))
12284 if (isa<CastExpr>(RHSStripped))
12289 Expr *LiteralString =
nullptr;
12290 Expr *LiteralStringStripped =
nullptr;
12291 if ((isa<StringLiteral>(LHSStripped) || isa<ObjCEncodeExpr>(LHSStripped)) &&
12294 LiteralString = LHS;
12295 LiteralStringStripped = LHSStripped;
12296 }
else if ((isa<StringLiteral>(RHSStripped) ||
12297 isa<ObjCEncodeExpr>(RHSStripped)) &&
12300 LiteralString = RHS;
12301 LiteralStringStripped = RHSStripped;
12304 if (LiteralString) {
12306 S.
PDiag(diag::warn_stringcompare)
12307 << isa<ObjCEncodeExpr>(LiteralStringStripped)
12319 llvm_unreachable(
"unhandled cast kind");
12321 case CK_UserDefinedConversion:
12323 case CK_LValueToRValue:
12325 case CK_ArrayToPointerDecay:
12327 case CK_FunctionToPointerDecay:
12329 case CK_IntegralCast:
12331 case CK_FloatingCast:
12333 case CK_IntegralToFloating:
12334 case CK_FloatingToIntegral:
12336 case CK_IntegralComplexCast:
12337 case CK_FloatingComplexCast:
12338 case CK_FloatingComplexToIntegralComplex:
12339 case CK_IntegralComplexToFloatingComplex:
12341 case CK_FloatingComplexToReal:
12342 case CK_FloatingRealToComplex:
12343 case CK_IntegralComplexToReal:
12344 case CK_IntegralRealToComplex:
12346 case CK_HLSLArrayRValue:
12359 if (
const auto *ICE = dyn_cast<ImplicitCastExpr>(E))
12386 << 0 << FromType << ToType;
12391 llvm_unreachable(
"unhandled case in switch");
12418 if (NumEnumArgs == 1) {
12420 QualType OtherTy = LHSIsEnum ? RHSStrippedType : LHSStrippedType;
12426 if (NumEnumArgs == 2) {
12435 LHSStrippedType->
castAs<
EnumType>()->getDecl()->getIntegerType();
12446 LHSType = RHSType = IntType;
12458 std::optional<ComparisonCategoryType> CCT =
12470 assert(!
Type.isNull() &&
"composite type for <=> has not been set");
12511 if (
const auto *CL = dyn_cast<CharacterLiteral>(E.
get())) {
12512 if (CL->getValue() == 0)
12516 NullValue ?
"NULL" :
"(void *)0");
12517 }
else if (
const auto *CE = dyn_cast<CStyleCastExpr>(E.
get())) {
12524 NullValue ?
"NULL" :
"(void *)0");
12534 bool IsThreeWay = Opc == BO_Cmp;
12535 bool IsOrdered = IsRelational || IsThreeWay;
12546 if (!IsThreeWay || IsAnyPointerType(LHS) || IsAnyPointerType(RHS)) {
12599 auto computeResultTy = [&]() {
12608 std::optional<ComparisonCategoryType> CCT =
12613 if (CompositeTy->
isPointerType() && LHSIsNull != RHSIsNull) {
12617 Diag(Loc, diag::err_typecheck_three_way_comparison_of_pointer_and_zero)
12627 if (!IsOrdered && LHSIsNull != RHSIsNull) {
12628 bool IsEquality = Opc == BO_EQ;
12640 bool IsError = Opc == BO_Cmp;
12642 IsError ? diag::err_typecheck_ordered_comparison_of_function_pointers
12644 ? diag::warn_typecheck_ordered_comparison_of_function_pointers
12645 : diag::ext_typecheck_ordered_comparison_of_function_pointers;
12674 return computeResultTy();
12690 (IsOrdered ? 2 : 1) &&
12695 return computeResultTy();
12709 if (IsRelational) {
12714 Diag(Loc, diag::ext_typecheck_compare_complete_incomplete_pointers)
12720 }
else if (!IsRelational &&
12724 && !LHSIsNull && !RHSIsNull)
12731 if (LCanPointeeTy != RCanPointeeTy) {
12736 diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
12737 << LHSType << RHSType << 0
12743 CastKind Kind = AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion
12745 if (LHSIsNull && !RHSIsNull)
12750 return computeResultTy();
12762 if (!IsOrdered && LHSIsNull && RHSIsNull) {
12765 return computeResultTy();
12769 return computeResultTy();
12780 return computeResultTy();
12784 return computeResultTy();
12793 return computeResultTy();
12798 return computeResultTy();
12802 if (IsRelational &&
12811 if (isa<FunctionDecl>(DC))
12813 if (
auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
12814 if (CTSD->isInStdNamespace() &&
12815 llvm::StringSwitch<bool>(CTSD->getName())
12816 .Cases(
"less",
"less_equal",
"greater",
"greater_equal",
true)
12822 return computeResultTy();
12835 return computeResultTy();
12845 if (!LHSIsNull && !RHSIsNull &&
12847 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks)
12852 return computeResultTy();
12859 if (!LHSIsNull && !RHSIsNull) {
12864 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks)
12868 if (LHSIsNull && !RHSIsNull)
12871 : CK_AnyPointerToBlockPointerCast);
12875 : CK_AnyPointerToBlockPointerCast);
12876 return computeResultTy();
12885 bool RPtrToVoid = RPT ? RPT->getPointeeType()->isVoidType() :
false;
12887 if (!LPtrToVoid && !RPtrToVoid &&
12895 if (LHSIsNull && !RHSIsNull) {
12901 RPT ? CK_BitCast :CK_CPointerToObjCPointerCast);
12911 LPT ? CK_BitCast :CK_CPointerToObjCPointerCast);
12913 return computeResultTy();
12923 if (LHSIsNull && !RHSIsNull)
12927 return computeResultTy();
12933 CK_BlockPointerToObjCPointerCast);
12934 return computeResultTy();
12935 }
else if (!IsOrdered &&
12939 CK_BlockPointerToObjCPointerCast);
12940 return computeResultTy();
12945 unsigned DiagID = 0;
12946 bool isError =
false;
12955 isError ? diag::err_typecheck_ordered_comparison_of_pointer_and_zero
12956 : diag::ext_typecheck_ordered_comparison_of_pointer_and_zero;
12959 DiagID = diag::err_typecheck_comparison_of_pointer_integer;
12961 }
else if (IsOrdered)
12962 DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_integer;
12964 DiagID = diag::ext_typecheck_comparison_of_pointer_integer;
12976 LHSIsNull ? CK_NullToPointer : CK_IntegralToPointer);
12979 RHSIsNull ? CK_NullToPointer : CK_IntegralToPointer);
12980 return computeResultTy();
12984 if (!IsOrdered && RHSIsNull
12987 return computeResultTy();
12989 if (!IsOrdered && LHSIsNull
12992 return computeResultTy();
12995 if (
getLangOpts().getOpenCLCompatibleVersion() >= 200) {
12997 return computeResultTy();
13001 return computeResultTy();
13004 if (LHSIsNull && RHSType->
isQueueT()) {
13006 return computeResultTy();
13009 if (LHSType->
isQueueT() && RHSIsNull) {
13011 return computeResultTy();
13027 if (isa<ExtVectorType>(VTy)) {
13041 "Unhandled vector element size in vector compare");
13061 "Unhandled vector element size in vector compare");
13085 if (Opc == BO_Cmp) {
13086 Diag(Loc, diag::err_three_way_vector_comparison);
13117 Diag(Loc, diag::warn_deprecated_altivec_src_compat);
13147 if (Opc == BO_Cmp) {
13148 Diag(Loc, diag::err_three_way_vector_comparison);
13176 if (LHSBuiltinTy && RHSBuiltinTy && LHSBuiltinTy->
isSVEBool() &&
13177 RHSBuiltinTy->isSVEBool())
13196 bool Negative =
false;
13197 bool ExplicitPlus =
false;
13198 const auto *LHSInt = dyn_cast<IntegerLiteral>(XorLHS.
get());
13199 const auto *RHSInt = dyn_cast<IntegerLiteral>(XorRHS.
get());
13205 if (
const auto *UO = dyn_cast<UnaryOperator>(XorRHS.
get())) {
13207 if (Opc != UO_Minus && Opc != UO_Plus)
13209 RHSInt = dyn_cast<IntegerLiteral>(UO->getSubExpr());
13212 Negative = (Opc == UO_Minus);
13213 ExplicitPlus = !Negative;
13219 const llvm::APInt &LeftSideValue = LHSInt->getValue();
13220 llvm::APInt RightSideValue = RHSInt->getValue();
13221 if (LeftSideValue != 2 && LeftSideValue != 10)
13224 if (LeftSideValue.getBitWidth() != RightSideValue.getBitWidth())
13229 llvm::StringRef ExprStr =
13234 llvm::StringRef XorStr =
13237 if (XorStr ==
"xor")
13248 RightSideValue = -RightSideValue;
13249 RHSStr =
"-" + RHSStr;
13250 }
else if (ExplicitPlus) {
13251 RHSStr =
"+" + RHSStr;
13254 StringRef LHSStrRef = LHSStr;
13255 StringRef RHSStrRef = RHSStr;
13258 if (LHSStrRef.starts_with(
"0b") || LHSStrRef.starts_with(
"0B") ||
13259 RHSStrRef.starts_with(
"0b") || RHSStrRef.starts_with(
"0B") ||
13260 LHSStrRef.starts_with(
"0x") || LHSStrRef.starts_with(
"0X") ||
13261 RHSStrRef.starts_with(
"0x") || RHSStrRef.starts_with(
"0X") ||
13262 (LHSStrRef.size() > 1 && LHSStrRef.starts_with(
"0")) ||
13263 (RHSStrRef.size() > 1 && RHSStrRef.starts_with(
"0")) ||
13264 LHSStrRef.contains(
'\'') || RHSStrRef.contains(
'\''))
13269 const llvm::APInt XorValue = LeftSideValue ^ RightSideValue;
13270 int64_t RightSideIntValue = RightSideValue.getSExtValue();
13271 if (LeftSideValue == 2 && RightSideIntValue >= 0) {
13272 std::string SuggestedExpr =
"1 << " + RHSStr;
13273 bool Overflow =
false;
13274 llvm::APInt One = (LeftSideValue - 1);
13275 llvm::APInt PowValue = One.sshl_ov(RightSideValue, Overflow);
13277 if (RightSideIntValue < 64)
13278 S.
Diag(Loc, diag::warn_xor_used_as_pow_base)
13279 << ExprStr <<
toString(XorValue, 10,
true) << (
"1LL << " + RHSStr)
13281 else if (RightSideIntValue == 64)
13282 S.
Diag(Loc, diag::warn_xor_used_as_pow)
13283 << ExprStr <<
toString(XorValue, 10,
true);
13287 S.
Diag(Loc, diag::warn_xor_used_as_pow_base_extra)
13288 << ExprStr <<
toString(XorValue, 10,
true) << SuggestedExpr
13291 ExprRange, (RightSideIntValue == 0) ?
"1" : SuggestedExpr);
13294 S.
Diag(Loc, diag::note_xor_used_as_pow_silence)
13295 << (
"0x2 ^ " + RHSStr) << SuggestXor;
13296 }
else if (LeftSideValue == 10) {
13297 std::string SuggestedValue =
"1e" + std::to_string(RightSideIntValue);
13298 S.
Diag(Loc, diag::warn_xor_used_as_pow_base)
13299 << ExprStr <<
toString(XorValue, 10,
true) << SuggestedValue
13301 S.
Diag(Loc, diag::note_xor_used_as_pow_silence)
13302 << (
"0xA ^ " + RHSStr) << SuggestXor;
13318 getLangOpts().getOpenCLCompatibleVersion() < 120 &&
13333 bool IsCompAssign) {
13334 if (!IsCompAssign) {
13350 assert((LHSMatType || RHSMatType) &&
"At least one operand must be a matrix");
13359 if (LHSMatType && !RHSMatType) {
13367 if (!LHSMatType && RHSMatType) {
13379 bool IsCompAssign) {
13380 if (!IsCompAssign) {
13391 assert((LHSMatType || RHSMatType) &&
"At least one operand must be a matrix");
13393 if (LHSMatType && RHSMatType) {
13394 if (LHSMatType->getNumColumns() != RHSMatType->
getNumRows())
13402 QualType LHSELTy = LHSMatType->getElementType(),
13433 bool IsCompAssign =
13434 Opc == BO_AndAssign || Opc == BO_OrAssign || Opc == BO_XorAssign;
13445 LegalBoolVecOperator,
13475 ExprResult LHSResult = LHS, RHSResult = RHS;
13478 if (LHSResult.
isInvalid() || RHSResult.isInvalid())
13480 LHS = LHSResult.
get();
13481 RHS = RHSResult.
get();
13500 bool EnumConstantInBoolContext =
false;
13502 if (
const auto *DREHS = dyn_cast<DeclRefExpr>(HS.get())) {
13503 const auto *ECDHS = dyn_cast<EnumConstantDecl>(DREHS->getDecl());
13504 if (ECDHS && ECDHS->getInitVal() != 0 && ECDHS->getInitVal() != 1)
13505 EnumConstantInBoolContext =
true;
13509 if (EnumConstantInBoolContext)
13510 Diag(Loc, diag::warn_enum_constant_in_bool_context);
13515 const auto *LHSATy = dyn_cast<ArrayType>(LHSTy);
13516 const auto *RHSATy = dyn_cast<ArrayType>(RHSTy);
13517 if ((LHSATy && LHSATy->getElementType().isWebAssemblyReferenceType()) ||
13518 (RHSATy && RHSATy->getElementType().isWebAssemblyReferenceType())) {
13540 Diag(Loc, diag::warn_logical_instead_of_bitwise)
13543 Diag(Loc, diag::note_logical_instead_of_bitwise_change_operator)
13544 << (Opc == BO_LAnd ?
"&" :
"|")
13547 Opc == BO_LAnd ?
"&" :
"|");
13548 if (Opc == BO_LAnd)
13550 Diag(Loc, diag::note_logical_instead_of_bitwise_remove_constant)
13606 const MemberExpr *ME = dyn_cast<MemberExpr>(E);
13607 if (!ME)
return false;
13611 if (!
Base)
return false;
13612 return Base->getMethodDecl() !=
nullptr;
13632 assert(var->
hasLocalStorage() &&
"capture added 'const' to non-local?");
13640 if (
auto *FD = dyn_cast<FunctionDecl>(DC))
13683 bool DiagnosticEmitted =
false;
13687 bool IsDereference =
false;
13688 bool NextIsDereference =
false;
13692 IsDereference = NextIsDereference;
13695 if (
const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
13696 NextIsDereference = ME->isArrow();
13697 const ValueDecl *VD = ME->getMemberDecl();
13698 if (
const FieldDecl *Field = dyn_cast<FieldDecl>(VD)) {
13700 if (Field->isMutable()) {
13701 assert(DiagnosticEmitted &&
"Expected diagnostic not emitted.");
13706 if (!DiagnosticEmitted) {
13707 S.
Diag(Loc, diag::err_typecheck_assign_const)
13709 << Field->getType();
13710 DiagnosticEmitted =
true;
13713 <<
ConstMember <<
false << Field << Field->getType()
13714 << Field->getSourceRange();
13718 }
else if (
const VarDecl *VDecl = dyn_cast<VarDecl>(VD)) {
13719 if (VDecl->getType().isConstQualified()) {
13720 if (!DiagnosticEmitted) {
13721 S.
Diag(Loc, diag::err_typecheck_assign_const)
13723 << VDecl->getType();
13724 DiagnosticEmitted =
true;
13727 <<
ConstMember <<
true << VDecl << VDecl->getType()
13728 << VDecl->getSourceRange();
13735 dyn_cast<ArraySubscriptExpr>(E)) {
13739 dyn_cast<ExtVectorElementExpr>(E)) {
13746 if (
const CallExpr *CE = dyn_cast<CallExpr>(E)) {
13750 if (!DiagnosticEmitted) {
13751 S.
Diag(Loc, diag::err_typecheck_assign_const) << ExprRange
13753 DiagnosticEmitted =
true;
13756 diag::note_typecheck_assign_const)
13760 }
else if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
13762 if (
const ValueDecl *VD = DRE->getDecl()) {
13764 if (!DiagnosticEmitted) {
13765 S.
Diag(Loc, diag::err_typecheck_assign_const)
13767 DiagnosticEmitted =
true;
13769 S.
Diag(VD->getLocation(), diag::note_typecheck_assign_const)
13770 <<
ConstVariable << VD << VD->getType() << VD->getSourceRange();
13773 }
else if (isa<CXXThisExpr>(E)) {
13775 if (
const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(DC)) {
13776 if (MD->isConst()) {
13777 if (!DiagnosticEmitted) {
13778 S.
Diag(Loc, diag::err_typecheck_assign_const) << ExprRange
13780 DiagnosticEmitted =
true;
13782 S.
Diag(MD->getLocation(), diag::note_typecheck_assign_const)
13789 if (DiagnosticEmitted)
13793 S.
Diag(Loc, diag::err_typecheck_assign_const) << ExprRange <<
ConstUnknown;
13806 bool &DiagnosticEmitted) {
13807 std::vector<const RecordType *> RecordTypeList;
13808 RecordTypeList.push_back(Ty);
13809 unsigned NextToCheckIndex = 0;
13812 while (RecordTypeList.size() > NextToCheckIndex) {
13813 bool IsNested = NextToCheckIndex > 0;
13815 RecordTypeList[NextToCheckIndex]->getDecl()->fields()) {
13817 QualType FieldTy = Field->getType();
13819 if (!DiagnosticEmitted) {
13820 S.
Diag(Loc, diag::err_typecheck_assign_const)
13822 << IsNested << Field;
13823 DiagnosticEmitted =
true;
13825 S.
Diag(Field->getLocation(), diag::note_typecheck_assign_const)
13827 << FieldTy << Field->getSourceRange();
13833 if (!llvm::is_contained(RecordTypeList, FieldRecTy))
13834 RecordTypeList.push_back(FieldRecTy);
13837 ++NextToCheckIndex;
13846 assert(Ty->
isRecordType() &&
"lvalue was not record?");
13849 bool DiagEmitted =
false;
13851 if (
const MemberExpr *ME = dyn_cast<MemberExpr>(E))
13854 else if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
13879 unsigned DiagID = 0;
13880 bool NeedType =
false;
13887 DiagID = diag::err_block_decl_ref_not_modifiable_lvalue;
13889 DiagID = diag::err_lambda_decl_ref_not_modifiable_lvalue;
13897 if (declRef && isa<VarDecl>(declRef->
getDecl())) {
13910 ? diag::err_typecheck_arc_assign_self_class_method
13911 : diag::err_typecheck_arc_assign_self;
13914 }
else if (var->
hasAttr<ObjCExternallyRetainedAttr>() ||
13915 isa<ParmVarDecl>(var)) {
13916 DiagID = diag::err_typecheck_arc_assign_externally_retained;
13920 DiagID = diag::err_typecheck_arr_assign_enumeration;
13924 if (Loc != OrigLoc)
13950 DiagID = diag::err_typecheck_array_not_modifiable_lvalue;
13954 DiagID = diag::err_typecheck_non_object_not_modifiable_lvalue;
13958 DiagID = diag::err_typecheck_lvalue_casts_not_supported;
13961 llvm_unreachable(
"did not take early return for MLV_Valid");
13965 DiagID = diag::err_typecheck_expression_not_modifiable_lvalue;
13970 diag::err_typecheck_incomplete_type_not_modifiable_lvalue, E);
13972 DiagID = diag::err_typecheck_duplicate_vector_components_not_mlvalue;
13975 llvm_unreachable(
"readonly properties should be processed differently");
13977 DiagID = diag::err_readonly_message_assignment;
13980 DiagID = diag::err_no_subobject_property_setting;
13985 if (Loc != OrigLoc)
14007 MemberExpr *ML = dyn_cast<MemberExpr>(LHSExpr);
14008 MemberExpr *MR = dyn_cast<MemberExpr>(RHSExpr);
14010 if (!(isa<CXXThisExpr>(ML->
getBase()) && isa<CXXThisExpr>(MR->
getBase())))
14016 if (LHSDecl != RHSDecl)
14021 if (RefTy->getPointeeType().isVolatileQualified())
14024 Sema.
Diag(Loc, diag::warn_identity_field_assign) << 0;
14034 Sema.
Diag(Loc, diag::warn_identity_field_assign) << 1;
14058 Diag(Loc, diag::err_opencl_half_load_store) << 1
14065 Diag(Loc, diag::err_wasm_table_art) << 0;
14070 if (CompoundType.
isNull()) {
14089 Diag(Loc, diag::err_objc_object_assignment)
14096 RHSCheck = ICE->getSubExpr();
14097 if (
UnaryOperator *UO = dyn_cast<UnaryOperator>(RHSCheck)) {
14098 if ((UO->getOpcode() == UO_Plus || UO->getOpcode() == UO_Minus) &&
14099 Loc.
isFileID() && UO->getOperatorLoc().isFileID() &&
14105 UO->getSubExpr()->getBeginLoc().
isFileID()) {
14106 Diag(Loc, diag::warn_not_compound_assign)
14107 << (UO->getOpcode() == UO_Plus ?
"+" :
"-")
14108 <<
SourceRange(UO->getOperatorLoc(), UO->getOperatorLoc());
14118 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InnerLHS);
14154 if (CompoundType.
isNull()) {
14180 if (
const CastExpr *CE = dyn_cast<CastExpr>(E)) {
14181 if (CE->getCastKind() == CK_ToVoid) {
14187 CE->getSubExpr()->getType()->isDependentType()) {
14192 if (
const auto *CE = dyn_cast<CallExpr>(E))
14193 return CE->getCallReturnType(Context)->isVoidType();
14216 const unsigned ForIncrementFlags =
14222 if ((ScopeFlags & ForIncrementFlags) == ForIncrementFlags ||
14223 (ScopeFlags & ForInitFlags) == ForInitFlags)
14228 while (
const BinaryOperator *BO = dyn_cast<BinaryOperator>(LHS)) {
14229 if (BO->getOpcode() != BO_Comma)
14231 LHS = BO->getRHS();
14238 Diag(Loc, diag::warn_comma_operator);
14242 LangOpts.CPlusPlus ?
"static_cast<void>("
14274 diag::err_incomplete_type);
14289 bool IsInc,
bool IsPrefix) {
14298 ResType = ResAtomicType->getValueType();
14300 assert(!ResType.
isNull() &&
"no type for increment/decrement expression");
14310 : diag::warn_increment_bool)
14314 S.
Diag(OpLoc, diag::err_increment_decrement_enum) << IsInc << ResType;
14330 S.
Diag(OpLoc, diag::ext_increment_complex)
14347 S.
Diag(OpLoc, diag::err_typecheck_illegal_increment_decrement)
14358 S.
Diag(OpLoc, diag::warn_deprecated_increment_decrement_volatile)
14359 << IsInc << ResType;
14392 case Stmt::DeclRefExprClass:
14393 return cast<DeclRefExpr>(E)->getDecl();
14394 case Stmt::MemberExprClass:
14398 if (cast<MemberExpr>(E)->isArrow())
14402 case Stmt::ArraySubscriptExprClass: {
14405 Expr*
Base = cast<ArraySubscriptExpr>(E)->getBase();
14407 if (ICE->getSubExpr()->getType()->isArrayType())
14412 case Stmt::UnaryOperatorClass: {
14424 case Stmt::ParenExprClass:
14426 case Stmt::ImplicitCastExprClass:
14430 case Stmt::CXXUuidofExprClass:
14431 return cast<CXXUuidofExpr>(E)->getGuidDecl();
14440 AO_Vector_Element = 1,
14441 AO_Property_Expansion = 2,
14442 AO_Register_Variable = 3,
14443 AO_Matrix_Element = 4,
14458 const auto *DRE = cast<DeclRefExpr>(Op->
IgnoreParens());
14461 return Diag(OpLoc, diag::err_parens_pointer_member_function)
14465 if (isa<CXXDestructorDecl>(MD))
14466 return Diag(OpLoc, diag::err_typecheck_addrof_dtor)
14467 << DRE->getSourceRange();
14469 if (DRE->getQualifier())
14473 return Diag(OpLoc, diag::err_unqualified_pointer_member_function)
14474 << DRE->getSourceRange();
14478 return Diag(OpLoc, diag::err_unqualified_pointer_member_function)
14479 << DRE->getSourceRange()
14492 if (PTy->getKind() == BuiltinType::Overload) {
14494 if (!isa<OverloadExpr>(E)) {
14495 assert(cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf);
14496 Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof_addrof_function)
14502 if (isa<UnresolvedMemberExpr>(Ovl))
14504 Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
14512 if (PTy->getKind() == BuiltinType::UnknownAny)
14515 if (PTy->getKind() == BuiltinType::BoundMember) {
14516 Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
14539 auto* VarRef = dyn_cast<DeclRefExpr>(op);
14540 if (VarRef && VarRef->refersToEnclosingVariableOrCapture()) {
14541 Diag(op->
getExprLoc(), diag::err_opencl_taking_address_capture);
14549 if (uOp->getOpcode() == UO_Deref)
14552 return uOp->getSubExpr()->getType();
14559 if (
auto *FD = dyn_cast_or_null<FunctionDecl>(dcl))
14565 unsigned AddressOfError = AO_No_Error;
14570 : diag::ext_typecheck_addrof_temporary)
14577 }
else if (isa<ObjCSelectorExpr>(op)) {
14584 if (!isa<DeclRefExpr>(op)) {
14585 Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
14605 if (isa<PseudoObjectExpr>(op)) {
14606 AddressOfError = AO_Property_Expansion;
14608 Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof)
14612 }
else if (
const auto *DRE = dyn_cast<DeclRefExpr>(op)) {
14613 if (
const auto *MD = dyn_cast_or_null<CXXMethodDecl>(DRE->getDecl()))
14619 AddressOfError = AO_Bit_Field;
14622 AddressOfError = AO_Vector_Element;
14625 AddressOfError = AO_Matrix_Element;
14629 if (
const VarDecl *vd = dyn_cast<VarDecl>(dcl)) {
14634 AddressOfError = AO_Register_Variable;
14636 }
else if (isa<MSPropertyDecl>(dcl)) {
14637 AddressOfError = AO_Property_Expansion;
14638 }
else if (isa<FunctionTemplateDecl>(dcl)) {
14640 }
else if (isa<FieldDecl>(dcl) || isa<IndirectFieldDecl>(dcl)) {
14644 if (isa<DeclRefExpr>(op) && cast<DeclRefExpr>(op)->getQualifier()) {
14649 diag::err_cannot_form_pointer_to_member_of_reference_type)
14654 while (cast<RecordDecl>(Ctx)->isAnonymousStructOrUnion())
14668 llvm_unreachable(
"Unknown/unexpected decl type");
14671 if (AddressOfError != AO_No_Error) {
14691 Diag(OpLoc, diag::err_wasm_ca_reference)
14696 Diag(OpLoc, diag::err_wasm_table_pr)
14702 CheckAddressOfPackedMember(op);
14708 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Exp);
14714 const ParmVarDecl *Param = dyn_cast<ParmVarDecl>(D);
14718 if (!FD->hasAttr<NonNullAttr>() && !Param->
hasAttr<NonNullAttr>())
14721 FD->ModifiedNonNullParams.insert(Param);
14727 bool IsAfterAmp =
false) {
14734 Op = ConvResult.
get();
14738 if (isa<CXXReinterpretCastExpr>(Op)) {
14746 Result = PT->getPointeeType();
14750 Result = OPT->getPointeeType();
14754 if (PR.
get() != Op)
14759 S.
Diag(OpLoc, diag::err_typecheck_indirection_requires_pointer)
14764 if (
Result->isVoidType()) {
14770 S.
Diag(OpLoc, diag::err_typecheck_indirection_through_void_pointer_cpp)
14773 S.
Diag(OpLoc, diag::ext_typecheck_indirection_through_void_pointer)
14790 default: llvm_unreachable(
"Unknown binop!");
14791 case tok::periodstar: Opc = BO_PtrMemD;
break;
14792 case tok::arrowstar: Opc = BO_PtrMemI;
break;
14793 case tok::star: Opc = BO_Mul;
break;
14794 case tok::slash: Opc = BO_Div;
break;
14795 case tok::percent: Opc = BO_Rem;
break;
14796 case tok::plus: Opc = BO_Add;
break;
14797 case tok::minus: Opc = BO_Sub;
break;
14798 case tok::lessless: Opc = BO_Shl;
break;
14799 case tok::greatergreater: Opc = BO_Shr;
break;
14800 case tok::lessequal: Opc = BO_LE;
break;
14801 case tok::less: Opc = BO_LT;
break;
14802 case tok::greaterequal: Opc = BO_GE;
break;
14803 case tok::greater: Opc = BO_GT;
break;
14804 case tok::exclaimequal: Opc = BO_NE;
break;
14805 case tok::equalequal: Opc = BO_EQ;
break;
14806 case tok::spaceship: Opc = BO_Cmp;
break;
14807 case tok::amp: Opc = BO_And;
break;
14808 case tok::caret: Opc = BO_Xor;
break;
14809 case tok::pipe: Opc = BO_Or;
break;
14810 case tok::ampamp: Opc = BO_LAnd;
break;
14811 case tok::pipepipe: Opc = BO_LOr;
break;
14812 case tok::equal: Opc = BO_Assign;
break;
14813 case tok::starequal: Opc = BO_MulAssign;
break;
14814 case tok::slashequal: Opc = BO_DivAssign;
break;
14815 case tok::percentequal: Opc = BO_RemAssign;
break;
14816 case tok::plusequal: Opc = BO_AddAssign;
break;
14817 case tok::minusequal: Opc = BO_SubAssign;
break;
14818 case tok::lesslessequal: Opc = BO_ShlAssign;
break;
14819 case tok::greatergreaterequal: Opc = BO_ShrAssign;
break;
14820 case tok::ampequal: Opc = BO_AndAssign;
break;
14821 case tok::caretequal: Opc = BO_XorAssign;
break;
14822 case tok::pipeequal: Opc = BO_OrAssign;
break;
14823 case tok::comma: Opc = BO_Comma;
break;
14832 default: llvm_unreachable(
"Unknown unary op!");
14833 case tok::plusplus: Opc = UO_PreInc;
break;
14834 case tok::minusminus: Opc = UO_PreDec;
break;
14835 case tok::amp: Opc = UO_AddrOf;
break;
14836 case tok::star: Opc = UO_Deref;
break;
14837 case tok::plus: Opc = UO_Plus;
break;
14838 case tok::minus: Opc = UO_Minus;
break;
14839 case tok::tilde: Opc = UO_Not;
break;
14840 case tok::exclaim: Opc = UO_LNot;
break;
14841 case tok::kw___real: Opc = UO_Real;
break;
14842 case tok::kw___imag: Opc = UO_Imag;
break;
14843 case tok::kw___extension__: Opc = UO_Extension;
break;
14859 if (!isa<ParmVarDecl>(SelfAssigned))
14861 const auto *Method =
14875 llvm::find_if(
Parent->fields(),
14877 return F->getDeclName() == Name;
14879 return (Field !=
Parent->field_end()) ? *Field :
nullptr;
14894 const DeclRefExpr *LHSDeclRef = dyn_cast<DeclRefExpr>(LHSExpr);
14895 const DeclRefExpr *RHSDeclRef = dyn_cast<DeclRefExpr>(RHSExpr);
14896 if (!LHSDeclRef || !RHSDeclRef ||
14904 if (LHSDecl != RHSDecl)
14909 if (RefTy->getPointeeType().isVolatileQualified())
14912 auto Diag = S.
Diag(OpLoc, IsBuiltin ? diag::warn_self_assignment_builtin
14913 : diag::warn_self_assignment_overloaded)
14918 Diag << 1 << SelfAssignField
14931 const Expr *ObjCPointerExpr =
nullptr, *OtherExpr =
nullptr;
14936 ObjCPointerExpr = LHS;
14940 ObjCPointerExpr = RHS;
14948 if (ObjCPointerExpr && isa<IntegerLiteral>(OtherExpr->IgnoreParenCasts())) {
14949 unsigned Diag = diag::warn_objc_pointer_masking;
14957 StringRef SelArg0 = S.getNameForSlot(0);
14958 if (SelArg0.starts_with(
"performSelector"))
14959 Diag = diag::warn_objc_pointer_masking_performSelector;
14970 if (
auto *DRE = dyn_cast<DeclRefExpr>(E))
14971 return DRE->getDecl();
14972 if (
auto *ME = dyn_cast<MemberExpr>(E))
14973 return ME->getMemberDecl();
14974 if (
auto *IRE = dyn_cast<ObjCIvarRefExpr>(E))
14975 return IRE->getDecl();
14990 "Result must be a vector of half or short");
14993 "both operands expected to be a half vector");
15005 ResultTy, VK, OK, OpLoc, FPFeatures,
15006 BinOpResTy, BinOpResTy);
15010 BinOpResTy, VK, OK, OpLoc, FPFeatures);
15014static std::pair<ExprResult, ExprResult>
15024 RHS,
nullptr,
false,
15025 [Opc, LHS](
Expr *E) {
15026 if (Opc != BO_Assign)
15033 return std::make_pair(LHS, RHS);
15040 if (!OpRequiresConversion || Ctx.
getLangOpts().NativeHalfType ||
15044 auto HasVectorOfHalfType = [&Ctx](
Expr *E) {
15054 return VT->getElementType().getCanonicalType() == Ctx.
HalfTy;
15059 return HasVectorOfHalfType(E0) && (!E1 || HasVectorOfHalfType(E1));
15081 if (
Init.isInvalid())
15083 RHSExpr =
Init.get();
15093 bool ConvertHalfVec =
false;
15096 if (!LHS.
isUsable() || !RHS.isUsable())
15106 if (BO_Assign == Opc)
15107 Diag(OpLoc, diag::err_opencl_atomic_init) << 0 << SR;
15135 if (!ResultTy.
isNull()) {
15152 if (
auto *BE = dyn_cast<BlockExpr>(RHS.get()->IgnoreParens()))
15154 if (
auto *VD = dyn_cast<VarDecl>(DRE->getDecl()))
15155 if (VD->hasLocalStorage() &&
getCurScope()->isDeclScope(VD))
15156 BE->getBlockDecl()->setCanAvoidCopyToHeap();
15167 Opc == BO_PtrMemI);
15171 ConvertHalfVec =
true;
15179 ConvertHalfVec =
true;
15183 ConvertHalfVec =
true;
15194 ConvertHalfVec =
true;
15199 ConvertHalfVec =
true;
15203 ConvertHalfVec =
true;
15216 ConvertHalfVec =
true;
15221 ConvertHalfVec =
true;
15223 Opc == BO_DivAssign);
15224 CompLHSTy = CompResultTy;
15231 CompLHSTy = CompResultTy;
15237 ConvertHalfVec =
true;
15244 ConvertHalfVec =
true;
15253 CompLHSTy = CompResultTy;
15264 CompLHSTy = CompResultTy;
15272 VK = RHS.get()->getValueKind();
15273 OK = RHS.get()->getObjectKind();
15287 "both sides are half vectors or neither sides are");
15292 CheckArrayAccess(LHS.
get());
15293 CheckArrayAccess(RHS.get());
15299 if (ObjectSetClass && isa<ObjCIsaExpr>(LHS.
get())) {
15303 "object_setClass(")
15316 if (CompResultTy.
isNull()) {
15317 if (ConvertHalfVec)
15337 if (ConvertHalfVec)
15342 Context, LHS.
get(), RHS.get(), Opc, ResultTy, VK, OK, OpLoc,
15359 if (isLeftComp == isRightComp)
15364 bool isLeftBitwise = LHSBO && LHSBO->
isBitwiseOp();
15365 bool isRightBitwise = RHSBO && RHSBO->
isBitwiseOp();
15366 if (isLeftBitwise || isRightBitwise)
15378 Self.Diag(OpLoc, diag::warn_precedence_bitwise_rel)
15381 Self.PDiag(diag::note_precedence_silence) << OpStr,
15382 (isLeftComp ? LHSExpr : RHSExpr)->getSourceRange());
15384 Self.PDiag(diag::note_precedence_bitwise_first)
15399 Self.PDiag(diag::note_precedence_silence)
15408 if (Bop->getOpcode() == BO_LAnd) {
15411 if (!isa<StringLiteral>(Bop->getLHS()->IgnoreParenImpCasts()))
15413 }
else if (Bop->getOpcode() == BO_LOr) {
15414 if (
BinaryOperator *RBop = dyn_cast<BinaryOperator>(Bop->getRHS())) {
15417 if (RBop->getOpcode() == BO_LAnd &&
15418 isa<StringLiteral>(RBop->getRHS()->IgnoreParenImpCasts()))
15429 if (Bop->getOpcode() == BO_LAnd) {
15432 if (!isa<StringLiteral>(Bop->getRHS()->IgnoreParenImpCasts()))
15444 if (Bop->isBitwiseOp() && Bop->getOpcode() < Opc) {
15445 S.
Diag(Bop->getOperatorLoc(), diag::warn_bitwise_op_in_bitwise_op)
15447 << Bop->getSourceRange() << OpLoc;
15449 S.
PDiag(diag::note_precedence_silence)
15450 << Bop->getOpcodeStr(),
15451 Bop->getSourceRange());
15457 Expr *SubExpr, StringRef Shift) {
15459 if (Bop->getOpcode() == BO_Add || Bop->getOpcode() == BO_Sub) {
15460 StringRef Op = Bop->getOpcodeStr();
15461 S.
Diag(Bop->getOperatorLoc(), diag::warn_addition_in_bitshift)
15462 << Bop->getSourceRange() << OpLoc << Shift << Op;
15464 S.
PDiag(diag::note_precedence_silence) << Op,
15465 Bop->getSourceRange());
15481 if (Kind != OO_LessLess && Kind != OO_GreaterGreater)
15484 S.
Diag(OpLoc, diag::warn_overloaded_shift_in_comparison)
15486 << (Kind == OO_LessLess);
15488 S.
PDiag(diag::note_precedence_silence)
15489 << (Kind == OO_LessLess ?
"<<" :
">>"),
15492 S, OpLoc, S.
PDiag(diag::note_evaluate_comparison_first),
15506 if ((Opc == BO_Or || Opc == BO_Xor) &&
15514 if (Opc == BO_LOr && !OpLoc.
isMacroID()) {
15520 || Opc == BO_Shr) {
15537 assert(LHSExpr &&
"ActOnBinOp(): missing left expression");
15538 assert(RHSExpr &&
"ActOnBinOp(): missing right expression");
15543 return BuildBinOp(S, TokLoc, Opc, LHSExpr, RHSExpr);
15549 if (OverOp !=
OO_None && OverOp != OO_Equal)
15603 LHSExpr = LHS.
get();
15604 RHSExpr = RHS.
get();
15615 if (pty->getKind() == BuiltinType::PseudoObject &&
15628 RHSExpr = resolvedRHS.
get();
15642 (pty->getKind() == BuiltinType::BoundMember ||
15643 pty->getKind() == BuiltinType::Overload)) {
15644 auto *OE = dyn_cast<OverloadExpr>(LHSExpr);
15645 if (OE && !OE->hasTemplateKeyword() && !OE->hasExplicitTemplateArgs() &&
15646 llvm::any_of(OE->decls(), [](
NamedDecl *ND) {
15647 return isa<FunctionTemplateDecl>(ND);
15649 Diag(OE->getQualifier() ? OE->getQualifierLoc().getBeginLoc()
15650 : OE->getNameLoc(),
15651 diag::err_template_kw_missing)
15652 << OE->getName().getAsString() <<
"";
15659 LHSExpr = LHS.
get();
15666 if (Opc == BO_Assign && pty->getKind() == BuiltinType::Overload) {
15682 RHSExpr = resolvedRHS.
get();
15702 "Should only occur in error-recovery path.");
15708 Context, LHSExpr, RHSExpr, Opc,
15728 ResultType = RHSExpr->
getType();
15760 bool CanOverflow =
false;
15762 bool ConvertHalfVec =
false;
15771 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15778 if (Opc == UO_AddrOf)
15779 return ExprError(
Diag(OpLoc, diag::err_hlsl_operator_unsupported) << 0);
15780 if (Opc == UO_Deref)
15781 return ExprError(
Diag(OpLoc, diag::err_hlsl_operator_unsupported) << 1);
15791 Opc == UO_PreInc ||
15793 Opc == UO_PreInc ||
15799 CheckAddressOfNoDeref(InputExpr);
15811 CanOverflow = Opc == UO_Minus &&
15822 if (ConvertHalfVec)
15842 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15855 Diag(OpLoc, diag::ext_integer_complement_complex)
15864 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15867 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15887 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15905 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15915 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15924 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15931 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15963 "the co_await expression must be non-dependant before "
15964 "building operator co_await");
15974 if (Opc != UO_AddrOf && Opc != UO_Deref)
15975 CheckArrayAccess(Input.
get());
15981 if (Opc == UO_Deref && UO->getType()->hasAttr(attr::NoDeref) &&
15982 !isa<ArrayType>(UO->getType().getDesugaredType(
Context)) &&
15987 if (ConvertHalfVec)
15996 if (
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
15997 if (!DRE->getQualifier())
16004 if (isa<FieldDecl>(VD) || isa<IndirectFieldDecl>(VD))
16007 return Method->isImplicitObjectMemberFunction();
16013 if (!ULE->getQualifier())
16018 if (Method->isImplicitObjectMemberFunction())
16039 if (pty->getKind() == BuiltinType::PseudoObject &&
16044 if (Opc == UO_Extension)
16049 if (Opc == UO_AddrOf &&
16050 (pty->getKind() == BuiltinType::Overload ||
16051 pty->getKind() == BuiltinType::UnknownAny ||
16052 pty->getKind() == BuiltinType::BoundMember))
16078 Expr *Input,
bool IsAfterAmp) {
16118 assert(SubStmt && isa<CompoundStmt>(SubStmt) &&
"Invalid action invocation!");
16124 "cleanups within StmtExpr not correctly bound!");
16134 bool StmtExprMayBindToTemp =
false;
16137 if (
const auto *LastStmt =
16139 if (
const Expr *
Value = LastStmt->getExprStmt()) {
16140 StmtExprMayBindToTemp =
true;
16148 Expr *ResStmtExpr =
16150 if (StmtExprMayBindToTemp)
16152 return ResStmtExpr;
16175 auto *Cast = dyn_cast<ImplicitCastExpr>(E);
16176 if (Cast && Cast->getCastKind() == CK_ARCConsumeObject)
16177 return Cast->getSubExpr();
16198 return ExprError(
Diag(BuiltinLoc, diag::err_offsetof_record_type)
16199 << ArgTy << TypeRange);
16205 diag::err_offsetof_incomplete_type, TypeRange))
16208 bool DidWarnAboutNonPOD =
false;
16213 if (OC.isBrackets) {
16218 return ExprError(
Diag(OC.LocEnd, diag::err_offsetof_array_type)
16238 Comps.push_back(
OffsetOfNode(OC.LocStart, Exprs.size(), OC.LocEnd));
16239 Exprs.push_back(Idx);
16247 Comps.push_back(
OffsetOfNode(OC.LocStart, OC.U.IdentInfo, OC.LocEnd));
16254 diag::err_offsetof_incomplete_type))
16260 return ExprError(
Diag(OC.LocEnd, diag::err_offsetof_record_type)
16272 bool IsSafe =
LangOpts.CPlusPlus11? CRD->isStandardLayout() : CRD->isPOD();
16274 LangOpts.CPlusPlus11? diag::ext_offsetof_non_standardlayout_type
16275 : diag::ext_offsetof_non_pod_type;
16278 Diag(BuiltinLoc, DiagID)
16279 <<
SourceRange(Components[0].LocStart, OC.LocEnd) << CurrentType;
16280 DidWarnAboutNonPOD =
true;
16291 MemberDecl = IndirectMemberDecl->getAnonField();
16299 Diag(BuiltinLoc, diag::err_no_member)
16300 << OC.U.IdentInfo << RD <<
SourceRange(OC.LocStart, OC.LocEnd);
16309 Diag(OC.LocEnd, diag::err_offsetof_bitfield)
16317 if (IndirectMemberDecl)
16318 Parent = cast<RecordDecl>(IndirectMemberDecl->getDeclContext());
16325 if (Paths.getDetectedVirtual()) {
16326 Diag(OC.LocEnd, diag::err_offsetof_field_of_virtual_base)
16337 if (IndirectMemberDecl) {
16338 for (
auto *FI : IndirectMemberDecl->chain()) {
16339 assert(isa<FieldDecl>(FI));
16341 cast<FieldDecl>(FI), OC.LocEnd));
16344 Comps.push_back(
OffsetOfNode(OC.LocStart, MemberDecl, OC.LocEnd));
16350 Comps, Exprs, RParenLoc);
16376 assert((CondExpr && LHSExpr && RHSExpr) &&
"Missing type argument(s)");
16381 bool CondIsTrue =
false;
16386 llvm::APSInt condEval(32);
16388 CondExpr, &condEval, diag::err_typecheck_choose_expr_requires_constant);
16391 CondExpr = CondICE.
get();
16392 CondIsTrue = condEval.getZExtValue();
16395 Expr *ActiveExpr = CondIsTrue ? LHSExpr : RHSExpr;
16397 resType = ActiveExpr->
getType();
16403 resType, VK, OK, RPLoc, CondIsTrue);
16416 Decl *ManglingContextDecl;
16417 std::tie(MCtx, ManglingContextDecl) =
16421 Block->setBlockMangling(ManglingNumber, ManglingContextDecl);
16443 "block-id should have no identifier!");
16465 "GetTypeForDeclarator made a non-function block signature");
16481 unsigned Size =
Result.getFullDataSize();
16493 QualType RetTy = Fn->getReturnType();
16495 (isa<FunctionProtoType>(Fn) && cast<FunctionProtoType>(Fn)->isVariadic());
16511 if (ExplicitSignature) {
16512 for (
unsigned I = 0, E = ExplicitSignature.
getNumParams(); I != E; ++I) {
16520 Params.push_back(Param);
16526 for (
const auto &I : Fn->param_types()) {
16529 Params.push_back(Param);
16534 if (!Params.empty()) {
16545 AI->setOwningFunction(CurBlock->
TheDecl);
16548 if (AI->getIdentifier()) {
16554 if (AI->isInvalidDecl())
16577 Diag(CaretLoc, diag::err_blocks_disable) <<
LangOpts.OpenCL;
16583 "cleanups within block not correctly bound!");
16596 bool NoReturn = BD->
hasAttr<NoReturnAttr>();
16604 if (NoReturn && !Ext.getNoReturn()) Ext = Ext.
withNoReturn(
true);
16607 if (isa<FunctionNoProtoType>(FTy)) {
16642 BD->
setBody(cast<CompoundStmt>(Body));
16644 if (Body &&
getCurFunction()->HasPotentialAvailabilityViolations)
16669 Expr *CopyExpr =
nullptr;
16678 if (isa<ParmVarDecl>(Var))
16697 if (!
Result.isInvalid() &&
16698 !
Result.get()->getType().isConstQualified()) {
16700 Result.get()->getType().withConst(),
16704 if (!
Result.isInvalid()) {
16714 if (!
Result.isInvalid() &&
16715 !cast<CXXConstructExpr>(
Result.get())->getConstructor()
16718 CopyExpr =
Result.get();
16725 Captures.push_back(NewCap);
16737 if (
Result->getBlockDecl()->hasCaptures()) {
16744 for (
const auto &CI :
Result->getBlockDecl()->captures()) {
16745 const VarDecl *var = CI.getVariable();
16758 {Result},
Result->getType());
16772 Expr *OrigExpr = E;
16822 if (
Init.isInvalid())
16838 diag::err_first_argument_to_va_arg_not_of_type_va_list)
16843 diag::err_second_parameter_to_va_arg_incomplete,
16849 diag::err_second_parameter_to_va_arg_abstract,
16856 ? diag::warn_second_parameter_to_va_arg_ownership_qualified
16857 : diag::warn_second_parameter_to_va_arg_not_pod)
16890 UnderlyingType = ET->getDecl()->getIntegerType();
16913 if (!PromoteType.
isNull())
16915 PDiag(diag::warn_second_parameter_to_va_arg_never_compatible)
16937 llvm_unreachable(
"I don't know size of pointer!");
16954 if ((SLDecl->isCompleteDefinition() || SLDecl->isBeingDefined()) &&
16963 S.
Diag(Loc, diag::err_std_source_location_impl_not_found);
16971 S.
Diag(Loc, diag::err_std_source_location_impl_malformed);
16975 unsigned Count = 0;
16977 StringRef Name = F->getName();
16979 if (Name ==
"_M_file_name") {
16980 if (F->getType() !=
16984 }
else if (Name ==
"_M_function_name") {
16985 if (F->getType() !=
16989 }
else if (Name ==
"_M_line") {
16990 if (!F->getType()->isIntegerType())
16993 }
else if (Name ==
"_M_column") {
16994 if (!F->getType()->isIntegerType())
17003 S.
Diag(Loc, diag::err_std_source_location_impl_malformed);
17066 if (OV->getSourceExpr())
17069 if (
auto *SL = dyn_cast<StringLiteral>(SrcExpr)) {
17071 !(ID && ID->getIdentifier()->isStr(
"NSString")))
17073 if (!SL->isOrdinary())
17077 Diag(SL->getBeginLoc(), diag::err_missing_atsign_prefix)
17084 if ((isa<IntegerLiteral>(SrcExpr) || isa<CharacterLiteral>(SrcExpr) ||
17085 isa<FloatingLiteral>(SrcExpr) || isa<ObjCBoolLiteralExpr>(SrcExpr) ||
17086 isa<CXXBoolLiteralExpr>(SrcExpr)) &&
17089 if (!ID || !ID->getIdentifier()->isStr(
"NSNumber"))
17107 const Expr *SrcExpr) {
17116 auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl());
17129 bool *Complained) {
17131 *Complained =
false;
17134 bool CheckInferredResultType =
false;
17136 unsigned DiagKind = 0;
17138 bool MayHaveConvFixit =
false;
17139 bool MayHaveFunctionDiff =
false;
17150 DiagKind = diag::err_typecheck_convert_pointer_int;
17153 DiagKind = diag::ext_typecheck_convert_pointer_int;
17156 MayHaveConvFixit =
true;
17160 DiagKind = diag::err_typecheck_convert_int_pointer;
17163 DiagKind = diag::ext_typecheck_convert_int_pointer;
17166 MayHaveConvFixit =
true;
17170 diag::warn_typecheck_convert_incompatible_function_pointer_strict;
17172 MayHaveConvFixit =
true;
17176 DiagKind = diag::err_typecheck_convert_incompatible_function_pointer;
17179 DiagKind = diag::ext_typecheck_convert_incompatible_function_pointer;
17182 MayHaveConvFixit =
true;
17186 DiagKind = diag::err_arc_typecheck_convert_incompatible_pointer;
17188 DiagKind = diag::err_typecheck_convert_incompatible_pointer;
17191 DiagKind = diag::ext_typecheck_convert_incompatible_pointer;
17195 if (!CheckInferredResultType) {
17197 }
else if (CheckInferredResultType) {
17201 MayHaveConvFixit =
true;
17205 DiagKind = diag::err_typecheck_convert_incompatible_pointer_sign;
17208 DiagKind = diag::ext_typecheck_convert_incompatible_pointer_sign;
17213 DiagKind = diag::err_typecheck_convert_pointer_void_func;
17216 DiagKind = diag::ext_typecheck_convert_pointer_void_func;
17228 DiagKind = diag::err_typecheck_incompatible_address_space;
17231 DiagKind = diag::err_typecheck_incompatible_ownership;
17235 llvm_unreachable(
"unknown error case for discarding qualifiers!");
17252 DiagKind = diag::err_typecheck_convert_discards_qualifiers;
17255 DiagKind = diag::ext_typecheck_convert_discards_qualifiers;
17262 DiagKind = diag::err_nested_pointer_qualifier_mismatch;
17264 DiagKind = diag::ext_nested_pointer_qualifier_mismatch;
17268 DiagKind = diag::err_typecheck_incompatible_nested_address_space;
17272 DiagKind = diag::err_int_to_block_pointer;
17276 DiagKind = diag::err_typecheck_convert_incompatible_block_pointer;
17283 for (
auto *srcProto : srcOPT->
quals()) {
17289 IFace = IFaceT->getDecl();
17294 for (
auto *dstProto : dstOPT->
quals()) {
17300 IFace = IFaceT->getDecl();
17303 DiagKind = diag::err_incompatible_qualified_id;
17306 DiagKind = diag::warn_incompatible_qualified_id;
17312 DiagKind = diag::err_incompatible_vectors;
17315 DiagKind = diag::warn_incompatible_vectors;
17319 DiagKind = diag::err_arc_weak_unavailable_assign;
17325 *Complained =
true;
17329 DiagKind = diag::err_typecheck_convert_incompatible;
17331 MayHaveConvFixit =
true;
17333 MayHaveFunctionDiff =
true;
17342 FirstType = DstType;
17343 SecondType = SrcType;
17353 FirstType = SrcType;
17354 SecondType = DstType;
17363 FDiag << FirstType << SecondType << ActionForDiag
17366 if (DiagKind == diag::ext_typecheck_convert_incompatible_pointer_sign ||
17367 DiagKind == diag::err_typecheck_convert_incompatible_pointer_sign) {
17377 if (!ConvHints.
isNull()) {
17382 if (MayHaveConvFixit) { FDiag << (
unsigned) (ConvHints.
Kind); }
17384 if (MayHaveFunctionDiff)
17388 if ((DiagKind == diag::warn_incompatible_qualified_id ||
17389 DiagKind == diag::err_incompatible_qualified_id) &&
17391 Diag(IFace->
getLocation(), diag::note_incomplete_class_and_qualified_id)
17398 if (CheckInferredResultType)
17405 *Complained =
true;
17416 return S.
Diag(Loc, diag::err_ice_not_integral)
17420 return S.
Diag(Loc, diag::err_expr_not_ice) << S.
LangOpts.CPlusPlus;
17435 IDDiagnoser(
unsigned DiagID)
17439 return S.
Diag(Loc, DiagID);
17441 } Diagnoser(DiagID);
17454 return S.
Diag(Loc, diag::ext_expr_not_ice) << S.
LangOpts.CPlusPlus;
17476 BaseDiagnoser(BaseDiagnoser) {}
17485 return S.
Diag(Loc, diag::err_ice_incomplete_type) <<
T;
17490 return S.
Diag(Loc, diag::err_ice_explicit_conversion) <<
T << ConvTy;
17501 return S.
Diag(Loc, diag::err_ice_ambiguous_conversion) <<
T;
17512 llvm_unreachable(
"conversion functions are permitted");
17514 } ConvertDiagnoser(Diagnoser);
17520 E = Converted.
get();
17525 if (isa<RecoveryExpr>(E))
17541 E = RValueExpr.
get();
17548 if (!isa<ConstantExpr>(E))
17556 EvalResult.
Diag = &Notes;
17564 if (!isa<ConstantExpr>(E))
17579 if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
17580 diag::note_invalid_subexpr_in_const_expr) {
17581 DiagLoc = Notes[0].first;
17585 if (!Folded || !CanFold) {
17607 class TransformToPE :
public TreeTransform<TransformToPE> {
17611 TransformToPE(
Sema &SemaRef) : BaseTransform(SemaRef) { }
17614 bool AlwaysRebuild() {
return true; }
17615 bool ReplacingOriginal() {
return true; }
17625 if (isa<FieldDecl>(E->
getDecl()) &&
17626 !SemaRef.isUnevaluatedContext())
17628 diag::err_invalid_non_static_member_use)
17631 return BaseTransform::TransformDeclRefExpr(E);
17639 return BaseTransform::TransformUnaryOperator(E);
17647 return SkipLambdaBody(E, Body);
17654 "Should only transform unevaluated expressions");
17659 return TransformToPE(*this).TransformExpr(E);
17664 "Should only transform unevaluated expressions");
17669 return TransformToPE(*this).TransformType(TInfo);
17677 LambdaContextDecl, ExprContext);
17684 .isDiscardedStatementContext();
17692 Prev.isImmediateFunctionContext() || Prev.isConstantEvaluated();
17695 Prev.InImmediateEscalatingFunctionContext;
17714 if (
const auto *E = dyn_cast<UnaryOperator>(PossibleDeref)) {
17715 if (E->getOpcode() == UO_Deref)
17716 return CheckPossibleDeref(S, E->getSubExpr());
17717 }
else if (
const auto *E = dyn_cast<ArraySubscriptExpr>(PossibleDeref)) {
17718 return CheckPossibleDeref(S, E->getBase());
17719 }
else if (
const auto *E = dyn_cast<MemberExpr>(PossibleDeref)) {
17720 return CheckPossibleDeref(S, E->getBase());
17721 }
else if (
const auto E = dyn_cast<DeclRefExpr>(PossibleDeref)) {
17725 Inner = Ptr->getPointeeType();
17727 Inner = Arr->getElementType();
17731 if (Inner->hasAttr(attr::NoDeref))
17741 const DeclRefExpr *DeclRef = CheckPossibleDeref(*
this, E);
17748 Diag(E->
getExprLoc(), diag::warn_dereference_of_noderef_type_no_decl)
17767 if (BO->getOpcode() == BO_Assign) {
17769 llvm::erase(LHSs, BO->getLHS());
17777 "Cannot mark an immediate escalating expression outside of an "
17778 "immediate escalating context");
17781 if (
auto *DeclRef =
17782 dyn_cast<DeclRefExpr>(
Call->getCallee()->IgnoreImplicit()))
17783 DeclRef->setIsImmediateEscalating(
true);
17784 }
else if (
auto *Ctr = dyn_cast<CXXConstructExpr>(E->
IgnoreImplicit())) {
17785 Ctr->setIsImmediateEscalating(
true);
17786 }
else if (
auto *DeclRef = dyn_cast<DeclRefExpr>(E->
IgnoreImplicit())) {
17787 DeclRef->setIsImmediateEscalating(
true);
17789 assert(
false &&
"expected an immediately escalating expression");
17792 FI->FoundImmediateEscalatingExpression =
true;
17807 if (
auto *DeclRef =
17808 dyn_cast<DeclRefExpr>(
Call->getCallee()->IgnoreImplicit()))
17817 auto CheckConstantExpressionAndKeepResult = [&]() {
17820 Eval.
Diag = &Notes;
17822 Eval,
getASTContext(), ConstantExprKind::ImmediateInvocation);
17823 if (Res && Notes.empty()) {
17824 Cached = std::move(Eval.
Val);
17832 !CheckConstantExpressionAndKeepResult()) {
17867 ExprEvalContexts.back().ImmediateInvocationCandidates.emplace_back(Res, 0);
17875 Eval.
Diag = &Notes;
17879 if (!
Result || !Notes.empty()) {
17882 if (
auto *
FunctionalCast = dyn_cast<CXXFunctionalCastExpr>(InnerExpr))
17885 if (
auto *
Call = dyn_cast<CallExpr>(InnerExpr))
17886 FD = cast<FunctionDecl>(
Call->getCalleeDecl());
17887 else if (
auto *
Call = dyn_cast<CXXConstructExpr>(InnerExpr))
17888 FD =
Call->getConstructor();
17889 else if (
auto *Cast = dyn_cast<CastExpr>(InnerExpr))
17890 FD = dyn_cast_or_null<FunctionDecl>(Cast->getConversionFunction());
17893 "could not find an immediate function in this expression");
17906 for (
auto &
Note : Notes)
17918 llvm::SmallPtrSetImpl<DeclRefExpr *> &DRSet;
17922 ComplexRemove(
Sema &SemaRef, llvm::SmallPtrSetImpl<DeclRefExpr *> &DR,
17925 4>::reverse_iterator Current)
17926 :
Base(SemaRef), DRSet(DR), IISet(II), CurrentII(Current) {}
17928 auto It = std::find_if(CurrentII, IISet.rend(),
17930 return Elem.getPointer() == E;
17936 if (It == IISet.rend()) {
17938 CurrentII->setInt(1);
17945 return Base::TransformConstantExpr(E);
17946 RemoveImmediateInvocation(E);
17947 return Base::TransformExpr(E->
getSubExpr());
17953 return Base::TransformCXXOperatorCallExpr(E);
17965 if (
auto *CE = dyn_cast<ConstantExpr>(
Init))
17966 if (CE->isImmediateInvocation())
17967 RemoveImmediateInvocation(CE);
17968 return Base::TransformInitializer(
Init, NotCopyInit);
17979 bool AlwaysRebuild() {
return false; }
17980 bool ReplacingOriginal() {
return true; }
17981 bool AllowSkippingCXXConstructExpr() {
17982 bool Res = AllowSkippingFirstCXXConstructExpr;
17983 AllowSkippingFirstCXXConstructExpr =
true;
17986 bool AllowSkippingFirstCXXConstructExpr =
true;
17996 if (isa<CXXConstructExpr>(It->getPointer()->IgnoreImplicit()))
17997 Transformer.AllowSkippingFirstCXXConstructExpr =
false;
17999 ExprResult Res = Transformer.TransformExpr(It->getPointer()->getSubExpr());
18005 It->getPointer()->setSubExpr(Res.
get());
18040 llvm::SmallPtrSetImpl<DeclRefExpr *> &DRSet;
18041 SimpleRemove(llvm::SmallPtrSetImpl<DeclRefExpr *> &S) : DRSet(S) {}
18044 return DRSet.size();
18047 Visitor.TraverseStmt(
18057 if (DR->isImmediateEscalating())
18059 auto *FD = cast<FunctionDecl>(DR->getDecl());
18061 if (
const auto *MD = dyn_cast<CXXMethodDecl>(ND);
18063 ND = MD->getParent();
18070 bool ImmediateEscalating =
false;
18071 bool IsPotentiallyEvaluated =
18081 SemaRef.
Diag(DR->getBeginLoc(), diag::err_invalid_consteval_take_address)
18082 << ND << isa<CXXRecordDecl>(ND) << FD->isConsteval();
18090 if (FD->isImmediateEscalating() && !FD->isConsteval())
18106 (Rec.
ExprContext == ExpressionKind::EK_TemplateArgument ||
18114 D = diag::err_lambda_unevaluated_operand;
18120 D = diag::err_lambda_in_constant_expression;
18121 }
else if (Rec.
ExprContext == ExpressionKind::EK_TemplateArgument) {
18124 D = diag::err_lambda_in_invalid_context;
18126 llvm_unreachable(
"Couldn't infer lambda error message.");
18128 for (
const auto *L : Rec.
Lambdas)
18129 Diag(L->getBeginLoc(), D);
18137 PrevRecord.InLifetimeExtendingContext &&
18139 PrevRecord.ForRangeLifetimeExtendTemps.append(
18150 Diag(BO->getBeginLoc(), diag::warn_deprecated_simple_assign_volatile)
18223 llvm_unreachable(
"Invalid context");
18232 if (!TT.isOSWindows() || !TT.isX86())
18270 : FD(FD), Param(Param) {}
18277 CCName =
"stdcall";
18280 CCName =
"fastcall";
18283 CCName =
"vectorcall";
18286 llvm_unreachable(
"CC does not need mangling");
18289 S.
Diag(Loc, diag::err_cconv_incomplete_param_type)
18295 ParamIncompleteTypeDiagnoser Diagnoser(FD, Param);
18301enum class OdrUseContext {
18323 return OdrUseContext::None;
18328 Result = OdrUseContext::Used;
18332 Result = OdrUseContext::FormallyOdrUsed;
18338 Result = OdrUseContext::FormallyOdrUsed;
18343 return OdrUseContext::Dependent;
18349 if (!
Func->isConstexpr())
18352 if (
Func->isImplicitlyInstantiable() || !
Func->isUserProvided())
18354 auto *CCD = dyn_cast<CXXConstructorDecl>(
Func);
18355 return CCD && CCD->getInheritedConstructor();
18361 bool MightBeOdrUse) {
18362 assert(
Func &&
"No function?");
18364 Func->setReferenced();
18377 OdrUseContext OdrUse =
18379 if (IsRecursiveCall && OdrUse == OdrUseContext::Used)
18380 OdrUse = OdrUseContext::FormallyOdrUsed;
18384 if (
Func->isTrivial() && !
Func->hasAttr<DLLExportAttr>() &&
18385 OdrUse == OdrUseContext::Used) {
18386 if (
auto *Constructor = dyn_cast<CXXConstructorDecl>(
Func))
18387 if (Constructor->isDefaultConstructor())
18388 OdrUse = OdrUseContext::FormallyOdrUsed;
18389 if (isa<CXXDestructorDecl>(
Func))
18390 OdrUse = OdrUseContext::FormallyOdrUsed;
18397 bool NeededForConstantEvaluation =
18422 bool NeedDefinition =
18423 !IsRecursiveCall &&
18424 (OdrUse == OdrUseContext::Used ||
18425 (NeededForConstantEvaluation && !
Func->isPureVirtual()));
18432 if (NeedDefinition &&
18434 Func->getMemberSpecializationInfo()))
18441 if (NeedDefinition && !
Func->getBody()) {
18444 dyn_cast<CXXConstructorDecl>(
Func)) {
18445 Constructor = cast<CXXConstructorDecl>(Constructor->getFirstDecl());
18446 if (Constructor->isDefaulted() && !Constructor->isDeleted()) {
18447 if (Constructor->isDefaultConstructor()) {
18448 if (Constructor->isTrivial() &&
18449 !Constructor->hasAttr<DLLExportAttr>())
18452 }
else if (Constructor->isCopyConstructor()) {
18454 }
else if (Constructor->isMoveConstructor()) {
18457 }
else if (Constructor->getInheritedConstructor()) {
18461 dyn_cast<CXXDestructorDecl>(
Func)) {
18471 if (MethodDecl->isOverloadedOperator() &&
18472 MethodDecl->getOverloadedOperator() == OO_Equal) {
18473 MethodDecl = cast<CXXMethodDecl>(MethodDecl->getFirstDecl());
18474 if (MethodDecl->isDefaulted() && !MethodDecl->isDeleted()) {
18475 if (MethodDecl->isCopyAssignmentOperator())
18477 else if (MethodDecl->isMoveAssignmentOperator())
18480 }
else if (isa<CXXConversionDecl>(MethodDecl) &&
18481 MethodDecl->getParent()->isLambda()) {
18483 cast<CXXConversionDecl>(MethodDecl->getFirstDecl());
18488 }
else if (MethodDecl->isVirtual() &&
getLangOpts().AppleKext)
18492 if (
Func->isDefaulted() && !
Func->isDeleted()) {
18500 if (
Func->isImplicitlyInstantiable()) {
18502 Func->getTemplateSpecializationKindForInstantiation();
18504 bool FirstInstantiation = PointOfInstantiation.
isInvalid();
18505 if (FirstInstantiation) {
18506 PointOfInstantiation = Loc;
18507 if (
auto *MSI =
Func->getMemberSpecializationInfo())
18508 MSI->setPointOfInstantiation(Loc);
18511 Func->setTemplateSpecializationKind(TSK, PointOfInstantiation);
18516 PointOfInstantiation = Loc;
18520 Func->isConstexpr()) {
18521 if (isa<CXXRecordDecl>(
Func->getDeclContext()) &&
18522 cast<CXXRecordDecl>(
Func->getDeclContext())->isLocalClass() &&
18525 std::make_pair(
Func, PointOfInstantiation));
18526 else if (
Func->isConstexpr())
18532 Func->setInstantiationIsPending(
true);
18534 std::make_pair(
Func, PointOfInstantiation));
18541 for (
auto *i :
Func->redecls()) {
18542 if (!i->isUsed(
false) && i->isImplicitlyInstantiable())
18555 Constructor->isImmediateFunction()
18560 if (
Init->isInClassMemberInitializer())
18562 MarkDeclarationsReferencedInExpr(Init->getInit());
18583 if (
LangOpts.OffloadImplicitHostDeviceTemplates &&
LangOpts.CUDAIsDevice &&
18588 if (OdrUse == OdrUseContext::Used && !
Func->isUsed(
false)) {
18590 if (!
Func->isDefined()) {
18591 if (mightHaveNonExternalLinkage(
Func))
18593 else if (
Func->getMostRecentDecl()->isInlined() &&
18595 !
Func->getMostRecentDecl()->hasAttr<GNUInlineAttr>())
18614 if (
auto *Dtor = dyn_cast<CXXDestructorDecl>(
Func)) {
18616 if (
Parent->getNumVBases() > 0 && !Dtor->getBody())
18634 const unsigned *
const FunctionScopeIndexToStopAt =
nullptr) {
18637 VarDecl *Var =
V->getPotentiallyDecomposedVarDecl();
18638 assert(Var &&
"expected a capturable variable");
18648 QualType CaptureType, DeclRefType;
18654 DeclRefType, FunctionScopeIndexToStopAt);
18670 << llvm::to_underlying(UserTarget);
18673 ? diag::note_cuda_const_var_unpromoted
18674 : diag::note_cuda_host_var);
18677 !Var->
hasAttr<CUDASharedAttr>() &&
18693 (!FD || (!FD->getDescribedFunctionTemplate() &&
18705 unsigned CapturingScopeIndex) {
18716 if (isa<ParmVarDecl>(var) &&
18717 isa<TranslationUnitDecl>(VarDC))
18730 unsigned ValueKind = isa<BindingDecl>(var) ? 1 : 0;
18731 unsigned ContextKind = 3;
18732 if (isa<CXXMethodDecl>(VarDC) &&
18733 cast<CXXRecordDecl>(VarDC->
getParent())->isLambda()) {
18735 }
else if (isa<FunctionDecl>(VarDC)) {
18737 }
else if (isa<BlockDecl>(VarDC)) {
18741 S.
Diag(loc, diag::err_reference_to_local_in_enclosing_context)
18742 << var << ValueKind << ContextKind << VarDC;
18752 bool &SubCapturesAreNested,
18758 SubCapturesAreNested =
true;
18771 !(isa<LambdaScopeInfo>(CSI) &&
18772 !cast<LambdaScopeInfo>(CSI)->lambdaCaptureShouldBeConst()) &&
18773 !(isa<CapturedRegionScopeInfo>(CSI) &&
18774 cast<CapturedRegionScopeInfo>(CSI)->CapRegionKind ==
CR_OpenMP))
18806 assert((isa<VarDecl, BindingDecl>(Var)) &&
18807 "Only variables and structured bindings can be captured");
18809 bool IsBlock = isa<BlockScopeInfo>(CSI);
18810 bool IsLambda = isa<LambdaScopeInfo>(CSI);
18818 S.
Diag(Loc, diag::err_lambda_capture_anonymous_var);
18827 S.
Diag(Loc, diag::err_ref_vm_type);
18835 if (VTTy->getDecl()->hasFlexibleArrayMember()) {
18838 S.
Diag(Loc, diag::err_ref_flexarray_type);
18840 S.
Diag(Loc, diag::err_lambda_capture_flexarray_type) << Var;
18846 const bool HasBlocksAttr = Var->
hasAttr<BlocksAttr>();
18849 if (HasBlocksAttr && (IsLambda || isa<CapturedRegionScopeInfo>(CSI))) {
18851 S.
Diag(Loc, diag::err_capture_block_variable) << Var << !IsLambda;
18860 S.
Diag(Loc, diag::err_opencl_block_ref_block);
18864 if (isa<BindingDecl>(Var)) {
18871 ? diag::warn_cxx17_compat_capture_binding
18872 : diag::ext_capture_binding)
18886 bool ByRef =
false;
18892 if (BuildAndDiagnose) {
18893 S.
Diag(Loc, diag::err_ref_array_type);
18904 if (BuildAndDiagnose) {
18905 S.
Diag(Loc, diag::err_arc_autoreleasing_capture)
18921 if (BuildAndDiagnose) {
18923 S.
Diag(Loc, diag::warn_block_capture_autoreleasing);
18924 S.
Diag(VarLoc, diag::note_declare_parameter_strong);
18929 const bool HasBlocksAttr = Var->
hasAttr<BlocksAttr>();
18938 DeclRefType = CaptureType;
18942 if (BuildAndDiagnose)
18952 const bool BuildAndDiagnose,
QualType &CaptureType,
QualType &DeclRefType,
18979 CaptureType = DeclRefType;
18982 if (BuildAndDiagnose)
18983 RSI->
addCapture(Var,
false, ByRef, RefersToCapturedVariable,
18993 const bool RefersToCapturedVariable,
18998 bool ByRef =
false;
19002 ByRef = (LSI->
ImpCaptureStyle == LambdaScopeInfo::ImpCap_LambdaByref);
19007 S.
Diag(Loc, diag::err_wasm_ca_reference) << 0;
19038 if (!RefType->getPointeeType()->isFunctionType())
19045 if (BuildAndDiagnose) {
19046 S.
Diag(Loc, diag::err_arc_autoreleasing_capture) << 1;
19056 if (!
Invalid && BuildAndDiagnose) {
19060 diag::err_capture_of_incomplete_or_sizeless_type,
19064 diag::err_capture_of_abstract_type))
19085 if (BuildAndDiagnose)
19086 LSI->
addCapture(Var,
false, ByRef, RefersToCapturedVariable,
19087 Loc, EllipsisLoc, CaptureType,
Invalid);
19098 if (
T.isTriviallyCopyableType(
Context))
19102 if (!(RD = RD->getDefinition()))
19104 if (RD->hasSimpleCopyConstructor())
19106 if (RD->hasUserDeclaredCopyConstructor())
19108 if (Ctor->isCopyConstructor())
19109 return !Ctor->isDeleted();
19129 if (ShouldOfferCopyFix) {
19133 FixBuffer.assign({Separator, Var->
getName()});
19134 Sema.
Diag(VarInsertLoc, diag::note_lambda_variable_capture_fixit)
19139 FixBuffer.assign({Separator,
"&", Var->
getName()});
19140 Sema.
Diag(VarInsertLoc, diag::note_lambda_variable_capture_fixit)
19152 return !C.isThisCapture() && !C.isInitCapture();
19161 if (ShouldOfferCopyFix) {
19162 bool CanDefaultCopyCapture =
true;
19171 if (CanDefaultCopyCapture && llvm::none_of(LSI->
Captures, [](
Capture &
C) {
19172 return !C.isThisCapture() && !C.isInitCapture() && C.isCopyCapture();
19174 FixBuffer.assign({
"=", Separator});
19175 Sema.
Diag(DefaultInsertLoc, diag::note_lambda_default_capture_fixit)
19184 return !C.isInitCapture() && C.isReferenceCapture() &&
19185 !C.isThisCapture();
19187 FixBuffer.assign({
"&", Separator});
19188 Sema.
Diag(DefaultInsertLoc, diag::note_lambda_default_capture_fixit)
19197 QualType &DeclRefType,
const unsigned *
const FunctionScopeIndexToStopAt) {
19210 const auto *VD = dyn_cast<VarDecl>(Var);
19212 if (VD->isInitCapture())
19217 assert(VD &&
"Cannot capture a null variable");
19219 const unsigned MaxFunctionScopesIndex = FunctionScopeIndexToStopAt
19223 if (FunctionScopeIndexToStopAt) {
19225 while (FSIndex != MaxFunctionScopesIndex) {
19233 bool IsGlobal = !VD->hasLocalStorage();
19234 if (IsGlobal && !(
LangOpts.OpenMP &&
19235 OpenMP().isOpenMPCapturedDecl(Var,
true,
19236 MaxFunctionScopesIndex)))
19239 if (isa<VarDecl>(Var))
19250 CaptureType = Var->
getType();
19252 bool Nested =
false;
19254 unsigned FunctionScopesIndex = MaxFunctionScopesIndex;
19259 LSI = dyn_cast_or_null<LambdaScopeInfo>(
19262 bool IsInScopeDeclarationContext =
19273 if (IsInScopeDeclarationContext &&
19274 FunctionScopesIndex == MaxFunctionScopesIndex && VarDC == DC)
19280 !IsInScopeDeclarationContext
19283 BuildAndDiagnose, *
this);
19289 FunctionScopesIndex = MaxFunctionScopesIndex - 1;
19308 if (
const auto *Parm = dyn_cast<ParmVarDecl>(Var);
19309 Parm && Parm->getDeclContext() == DC)
19317 if (BuildAndDiagnose) {
19320 Diag(ExprLoc, diag::err_lambda_impcap) << Var;
19335 if (
ParmVarDecl *PVD = dyn_cast_or_null<ParmVarDecl>(Var))
19336 QTy = PVD->getOriginalType();
19341 if (
auto *RSI = dyn_cast<CapturedRegionScopeInfo>(CSI)) {
19347 if (isa<BindingDecl>(Var)) {
19348 if (BuildAndDiagnose) {
19349 Diag(ExprLoc, diag::err_capture_binding_openmp) << Var;
19355 Var, RSI->OpenMPLevel, RSI->OpenMPCaptureLevel);
19360 if (IsOpenMPPrivateDecl != OMPC_unknown &&
19363 if (
ParmVarDecl *PVD = dyn_cast_or_null<ParmVarDecl>(Var))
19364 QTy = PVD->getOriginalType();
19366 E =
OpenMP().getNumberOfConstructScopes(RSI->OpenMPLevel);
19368 auto *OuterRSI = cast<CapturedRegionScopeInfo>(
19370 assert(RSI->OpenMPLevel == OuterRSI->OpenMPLevel &&
19371 "Wrong number of captured regions associated with the "
19372 "OpenMP construct.");
19377 IsOpenMPPrivateDecl != OMPC_private &&
19379 RSI->OpenMPCaptureLevel);
19383 Var, RSI->OpenMPLevel, RSI->OpenMPCaptureLevel);
19389 OpenMP().adjustOpenMPTargetScopeIndex(FunctionScopesIndex,
19392 if (IsTargetCap || IsOpenMPPrivateDecl == OMPC_private ||
19393 (IsGlobal && !IsGlobalCap)) {
19394 Nested = !IsTargetCap;
19409 if (BuildAndDiagnose) {
19410 Diag(ExprLoc, diag::err_lambda_impcap) << Var;
19412 auto *LSI = cast<LambdaScopeInfo>(CSI);
19432 FunctionScopesIndex--;
19433 if (IsInScopeDeclarationContext)
19435 }
while (!VarDC->
Equals(DC));
19443 for (
unsigned I = ++FunctionScopesIndex, N = MaxFunctionScopesIndex + 1; I != N;
19456 if (
Invalid && !BuildAndDiagnose)
19461 DeclRefType, Nested, *
this,
Invalid);
19465 RSI, Var, ExprLoc, BuildAndDiagnose, CaptureType, DeclRefType, Nested,
19466 Kind, I == N - 1, *
this,
Invalid);
19472 DeclRefType, Nested, Kind, EllipsisLoc,
19477 if (
Invalid && !BuildAndDiagnose)
19489 DeclRefType,
nullptr);
19496 false, CaptureType,
19497 DeclRefType,
nullptr);
19506 false, CaptureType,
19507 DeclRefType,
nullptr))
19510 return DeclRefType;
19518class CopiedTemplateArgs {
19522 template<
typename RefExpr>
19523 CopiedTemplateArgs(RefExpr *E) : HasArgs(E->hasExplicitTemplateArgs()) {
19525 E->copyTemplateArgumentsInto(TemplateArgStorage);
19528#ifdef __has_cpp_attribute
19529#
if __has_cpp_attribute(clang::lifetimebound)
19530 [[clang::lifetimebound]]
19534 return HasArgs ? &TemplateArgStorage :
nullptr;
19560 auto Rebuild = [&](
Expr *Sub) {
19565 auto IsPotentialResultOdrUsed = [&](
NamedDecl *D) {
19568 auto *VD = dyn_cast<VarDecl>(D);
19591 llvm_unreachable(
"unexpected non-odr-use-reason");
19595 if (VD->getType()->isReferenceType())
19597 if (
auto *RD = VD->getType()->getAsCXXRecordDecl())
19598 if (RD->hasMutableFields())
19600 if (!VD->isUsableInConstantExpressions(S.
Context))
19605 if (VD->getType()->isReferenceType())
19613 auto MarkNotOdrUsed = [&] {
19616 LSI->markVariableExprAsNonODRUsed(E);
19623 case Expr::DeclRefExprClass: {
19624 auto *DRE = cast<DeclRefExpr>(E);
19625 if (DRE->isNonOdrUse() || IsPotentialResultOdrUsed(DRE->getDecl()))
19631 S.
Context, DRE->getQualifierLoc(), DRE->getTemplateKeywordLoc(),
19632 DRE->getDecl(), DRE->refersToEnclosingVariableOrCapture(),
19633 DRE->getNameInfo(), DRE->getType(), DRE->getValueKind(),
19634 DRE->getFoundDecl(), CopiedTemplateArgs(DRE), NOUR);
19637 case Expr::FunctionParmPackExprClass: {
19638 auto *FPPE = cast<FunctionParmPackExpr>(E);
19642 if (IsPotentialResultOdrUsed(D))
19653 case Expr::ArraySubscriptExprClass: {
19654 auto *ASE = cast<ArraySubscriptExpr>(E);
19659 if (!
Base.isUsable())
19661 Expr *LHS = ASE->getBase() == ASE->getLHS() ?
Base.get() : ASE->getLHS();
19662 Expr *RHS = ASE->getBase() == ASE->getRHS() ?
Base.get() : ASE->getRHS();
19665 ASE->getRBracketLoc());
19668 case Expr::MemberExprClass: {
19669 auto *ME = cast<MemberExpr>(E);
19672 if (isa<FieldDecl>(ME->getMemberDecl())) {
19674 if (!
Base.isUsable())
19677 S.
Context,
Base.get(), ME->isArrow(), ME->getOperatorLoc(),
19678 ME->getQualifierLoc(), ME->getTemplateKeywordLoc(),
19679 ME->getMemberDecl(), ME->getFoundDecl(), ME->getMemberNameInfo(),
19680 CopiedTemplateArgs(ME), ME->getType(), ME->getValueKind(),
19681 ME->getObjectKind(), ME->isNonOdrUse());
19684 if (ME->getMemberDecl()->isCXXInstanceMember())
19689 if (ME->isNonOdrUse() || IsPotentialResultOdrUsed(ME->getMemberDecl()))
19695 S.
Context, ME->getBase(), ME->isArrow(), ME->getOperatorLoc(),
19696 ME->getQualifierLoc(), ME->getTemplateKeywordLoc(), ME->getMemberDecl(),
19697 ME->getFoundDecl(), ME->getMemberNameInfo(), CopiedTemplateArgs(ME),
19698 ME->getType(), ME->getValueKind(), ME->getObjectKind(), NOUR);
19701 case Expr::BinaryOperatorClass: {
19702 auto *BO = cast<BinaryOperator>(E);
19703 Expr *LHS = BO->getLHS();
19704 Expr *RHS = BO->getRHS();
19706 if (BO->getOpcode() == BO_PtrMemD) {
19708 if (!Sub.isUsable())
19712 }
else if (BO->getOpcode() == BO_Comma) {
19714 if (!Sub.isUsable())
19720 return S.
BuildBinOp(
nullptr, BO->getOperatorLoc(), BO->getOpcode(),
19725 case Expr::ParenExprClass: {
19726 auto *PE = cast<ParenExpr>(E);
19728 if (!Sub.isUsable())
19730 return S.
ActOnParenExpr(PE->getLParen(), PE->getRParen(), Sub.get());
19735 case Expr::ConditionalOperatorClass: {
19736 auto *CO = cast<ConditionalOperator>(E);
19746 LHS = CO->getLHS();
19748 RHS = CO->getRHS();
19750 CO->getCond(), LHS.
get(), RHS.
get());
19755 case Expr::UnaryOperatorClass: {
19756 auto *UO = cast<UnaryOperator>(E);
19757 if (UO->getOpcode() != UO_Extension)
19760 if (!Sub.isUsable())
19762 return S.
BuildUnaryOp(
nullptr, UO->getOperatorLoc(), UO_Extension,
19769 case Expr::GenericSelectionExprClass: {
19770 auto *GSE = cast<GenericSelectionExpr>(E);
19773 bool AnyChanged =
false;
19774 for (
Expr *OrigAssocExpr : GSE->getAssocExprs()) {
19775 ExprResult AssocExpr = Rebuild(OrigAssocExpr);
19779 AssocExprs.push_back(AssocExpr.
get());
19782 AssocExprs.push_back(OrigAssocExpr);
19786 void *ExOrTy =
nullptr;
19787 bool IsExpr = GSE->isExprPredicate();
19789 ExOrTy = GSE->getControllingExpr();
19791 ExOrTy = GSE->getControllingType();
19793 GSE->getGenericLoc(), GSE->getDefaultLoc(),
19794 GSE->getRParenLoc(), IsExpr, ExOrTy,
19795 GSE->getAssocTypeSourceInfos(), AssocExprs)
19803 case Expr::ChooseExprClass: {
19804 auto *CE = cast<ChooseExpr>(E);
19814 if (!LHS.
get() && !RHS.
get())
19817 LHS = CE->getLHS();
19819 RHS = CE->getRHS();
19822 RHS.
get(), CE->getRParenLoc());
19826 case Expr::ConstantExprClass: {
19827 auto *CE = cast<ConstantExpr>(E);
19829 if (!Sub.isUsable())
19836 case Expr::ImplicitCastExprClass: {
19837 auto *ICE = cast<ImplicitCastExpr>(E);
19841 switch (ICE->getCastKind()) {
19843 case CK_DerivedToBase:
19844 case CK_UncheckedDerivedToBase: {
19845 ExprResult Sub = Rebuild(ICE->getSubExpr());
19846 if (!Sub.isUsable())
19850 ICE->getValueKind(), &Path);
19909 for (
Expr *E : LocalMaybeODRUseExprs) {
19910 if (
auto *DRE = dyn_cast<DeclRefExpr>(E)) {
19912 DRE->getLocation(), *
this);
19913 }
else if (
auto *ME = dyn_cast<MemberExpr>(E)) {
19916 }
else if (
auto *FP = dyn_cast<FunctionParmPackExpr>(E)) {
19920 llvm_unreachable(
"Unexpected expression");
19925 "MarkVarDeclODRUsed failed to cleanup MaybeODRUseExprs?");
19934 const bool RefersToEnclosingScope =
19937 if (RefersToEnclosingScope) {
19952 assert(E &&
"Capture variable should be used in an expression.");
19963 assert((!E || isa<DeclRefExpr>(E) || isa<MemberExpr>(E) ||
19964 isa<FunctionParmPackExpr>(E)) &&
19965 "Invalid Expr argument to DoMarkVarDeclReferenced");
19976 bool UsableInConstantExpr =
19988 bool NeededForConstantEvaluation =
19991 bool NeedDefinition =
19992 OdrUse == OdrUseContext::Used || NeededForConstantEvaluation;
19994 assert(!isa<VarTemplatePartialSpecializationDecl>(Var) &&
19995 "Can't instantiate a partial template specialization.");
20001 !isa<VarTemplateSpecializationDecl>(Var))
20012 bool TryInstantiating =
20016 if (TryInstantiating) {
20019 bool FirstInstantiation = PointOfInstantiation.
isInvalid();
20020 if (FirstInstantiation) {
20021 PointOfInstantiation = Loc;
20023 MSI->setPointOfInstantiation(PointOfInstantiation);
20029 if (UsableInConstantExpr) {
20038 if (
auto *DRE = dyn_cast_or_null<DeclRefExpr>(E))
20039 DRE->setDecl(DRE->getDecl());
20040 else if (
auto *ME = dyn_cast_or_null<MemberExpr>(E))
20041 ME->setMemberDecl(ME->getMemberDecl());
20042 }
else if (FirstInstantiation) {
20044 .push_back(std::make_pair(Var, PointOfInstantiation));
20046 bool Inserted =
false;
20048 auto Iter = llvm::find_if(
20050 return P.first == Var;
20052 if (
Iter != I.end()) {
20065 if (isa<VarTemplateSpecializationDecl>(Var) && !Inserted)
20067 .push_back(std::make_pair(Var, PointOfInstantiation));
20091 if (
DeclRefExpr *DRE = dyn_cast_or_null<DeclRefExpr>(E))
20092 if (DRE->isNonOdrUse())
20094 if (
MemberExpr *ME = dyn_cast_or_null<MemberExpr>(E))
20095 if (ME->isNonOdrUse())
20099 case OdrUseContext::None:
20102 assert((!E || isa<FunctionParmPackExpr>(E) ||
20104 "missing non-odr-use marking for unevaluated decl ref");
20107 case OdrUseContext::FormallyOdrUsed:
20112 case OdrUseContext::Used:
20121 case OdrUseContext::Dependent:
20139 if (OdrUse == OdrUseContext::Used) {
20140 QualType CaptureType, DeclRefType;
20146 }
else if (OdrUse == OdrUseContext::Dependent) {
20165 auto *ID = dyn_cast<DeclRefExpr>(E);
20166 if (!ID || ID->isTypeDependent() || !ID->refersToEnclosingVariableOrCapture())
20173 auto IsDependent = [&]() {
20175 auto *LSI = dyn_cast<sema::LambdaScopeInfo>(
Scope);
20180 LSI->AfterParameterList)
20183 const auto *MD = LSI->CallOperator;
20184 if (MD->getType().isNull())
20188 if (!Ty || !MD->isExplicitObjectMemberFunction() ||
20192 if (
auto *
C = LSI->CaptureMap.count(D) ? &LSI->getCapture(D) :
nullptr) {
20193 if (
C->isCopyCapture())
20198 if (LSI->ImpCaptureStyle == LambdaScopeInfo::ImpCap_LambdaByval)
20204 ID->setCapturedByCopyInLambdaWithExplicitObjectParameter(
20210 bool MightBeOdrUse,
20215 if (
VarDecl *Var = dyn_cast<VarDecl>(D)) {
20234 const MemberExpr *ME = dyn_cast<MemberExpr>(E);
20241 bool IsVirtualCall = MD->
isVirtual() &&
20243 if (!IsVirtualCall)
20262 bool OdrUse =
true;
20264 if (Method->isVirtual() &&
20268 if (
auto *FD = dyn_cast<FunctionDecl>(E->
getDecl())) {
20273 !FD->isDependentContext())
20288 bool MightBeOdrUse =
true;
20291 if (Method->isPureVirtual())
20292 MightBeOdrUse =
false;
20312 bool MightBeOdrUse) {
20313 if (MightBeOdrUse) {
20314 if (
auto *VD = dyn_cast<VarDecl>(D)) {
20319 if (
auto *FD = dyn_cast<FunctionDecl>(D)) {
20347bool MarkReferencedDecls::TraverseTemplateArgument(
20361 return Inherited::TraverseTemplateArgument(Arg);
20365 MarkReferencedDecls Marker(*
this, Loc);
20366 Marker.TraverseType(
T);
20372class EvaluatedExprMarker :
public UsedDeclVisitor<EvaluatedExprMarker> {
20375 bool SkipLocalVariables;
20378 EvaluatedExprMarker(
Sema &S,
bool SkipLocalVariables,
20380 : Inherited(S), SkipLocalVariables(SkipLocalVariables), StopAt(StopAt) {}
20386 void Visit(
Expr *E) {
20387 if (llvm::is_contained(StopAt, E))
20389 Inherited::Visit(E);
20399 if (SkipLocalVariables) {
20401 if (VD->hasLocalStorage())
20425 bool SkipLocalVariables,
20427 EvaluatedExprMarker(*
this, SkipLocalVariables, StopAt).Visit(E);
20449 if (
auto *VD = dyn_cast_or_null<VarDecl>(
20451 if (VD->isConstexpr() ||
20452 (VD->isStaticDataMember() && VD->isFirstDecl() && !VD->isInline()))
20524 class CallReturnIncompleteDiagnoser :
public TypeDiagnoser {
20530 : FD(FD), CE(CE) { }
20534 S.
Diag(Loc, diag::err_call_incomplete_return)
20539 S.
Diag(Loc, diag::err_call_function_incomplete_return)
20544 } Diagnoser(FD, CE);
20557 unsigned diagnostic = diag::warn_condition_is_assignment;
20558 bool IsOrAssign =
false;
20561 if (Op->getOpcode() != BO_Assign && Op->getOpcode() != BO_OrAssign)
20564 IsOrAssign = Op->getOpcode() == BO_OrAssign;
20573 diagnostic = diag::warn_condition_is_idiomatic_assignment;
20577 diagnostic = diag::warn_condition_is_idiomatic_assignment;
20580 Loc = Op->getOperatorLoc();
20582 if (Op->getOperator() != OO_Equal && Op->getOperator() != OO_PipeEqual)
20585 IsOrAssign = Op->getOperator() == OO_PipeEqual;
20586 Loc = Op->getOperatorLoc();
20598 Diag(Loc, diag::note_condition_assign_silence)
20603 Diag(Loc, diag::note_condition_or_assign_to_comparison)
20606 Diag(Loc, diag::note_condition_assign_to_comparison)
20624 if (opE->getOpcode() == BO_EQ &&
20625 opE->getLHS()->IgnoreParenImpCasts()->isModifiableLvalue(
Context)
20631 Diag(Loc, diag::note_equality_comparison_silence)
20634 Diag(Loc, diag::note_equality_comparison_to_assign)
20640 bool IsConstexpr) {
20642 if (
ParenExpr *parenE = dyn_cast<ParenExpr>(E))
20660 Diag(Loc, diag::err_typecheck_statement_requires_scalar)
20664 CheckBoolLikeConversion(E, Loc);
20710 struct RebuildUnknownAnyFunction
20711 :
StmtVisitor<RebuildUnknownAnyFunction, ExprResult> {
20715 RebuildUnknownAnyFunction(
Sema &S) : S(S) {}
20718 llvm_unreachable(
"unexpected statement!");
20729 template <
class T>
ExprResult rebuildSugarExpr(
T *E) {
20730 ExprResult SubResult = Visit(E->getSubExpr());
20733 Expr *SubExpr = SubResult.
get();
20734 E->setSubExpr(SubExpr);
20742 return rebuildSugarExpr(E);
20746 return rebuildSugarExpr(E);
20753 Expr *SubExpr = SubResult.
get();
20762 if (!isa<FunctionDecl>(VD))
return VisitExpr(E);
20768 !(isa<CXXMethodDecl>(VD) &&
20769 cast<CXXMethodDecl>(VD)->isInstance()))
20780 return resolveDecl(E, E->
getDecl());
20798 struct RebuildUnknownAnyExpr
20799 :
StmtVisitor<RebuildUnknownAnyExpr, ExprResult> {
20810 llvm_unreachable(
"unexpected statement!");
20824 template <
class T>
ExprResult rebuildSugarExpr(
T *E) {
20825 ExprResult SubResult = Visit(E->getSubExpr());
20827 Expr *SubExpr = SubResult.
get();
20828 E->setSubExpr(SubExpr);
20836 return rebuildSugarExpr(E);
20840 return rebuildSugarExpr(E);
20878 return resolveDecl(E, E->
getDecl());
20889 FK_FunctionPointer,
20896 assert(isa<CXXMemberCallExpr>(E) || isa<CXXOperatorCallExpr>(E));
20897 Kind = FK_MemberFunction;
20901 Kind = FK_FunctionPointer;
20904 Kind = FK_BlockPointer;
20910 unsigned diagID = diag::err_func_returning_array_function;
20911 if (Kind == FK_BlockPointer)
20912 diagID = diag::err_block_returning_array_function;
20948 if (ParamTypes.empty() && Proto->
isVariadic()) {
20950 for (
unsigned i = 0, e = E->
getNumArgs(); i != e; ++i) {
20953 ParamTypes = ArgTypes;
20964 case FK_MemberFunction:
20968 case FK_FunctionPointer:
20972 case FK_BlockPointer:
20978 ExprResult CalleeResult = Visit(CalleeExpr);
20989 S.
Diag(E->
getExprLoc(), diag::err_func_returning_array_function)
20997 Method->setReturnType(DestType);
21009 if (E->
getCastKind() == CK_FunctionToPointerDecay) {
21023 }
else if (E->
getCastKind() == CK_LValueToRValue) {
21027 assert(isa<BlockPointerType>(E->
getType()));
21040 llvm_unreachable(
"Unhandled cast type!");
21073 if (DRE && Proto && Proto->getParamTypes().empty() && Proto->isVariadic()) {
21076 S.
Context, FD->getDeclContext(), Loc, Loc,
21077 FD->getNameInfo().getName(), DestType, FD->getTypeSourceInfo(),
21079 false , FD->hasPrototype(),
21082 if (FD->getQualifier())
21086 for (
const auto &AI : FT->param_types()) {
21090 Params.push_back(Param);
21092 NewFD->setParams(Params);
21099 if (MD->isInstance()) {
21109 }
else if (isa<VarDecl>(VD)) {
21113 S.
Diag(E->
getExprLoc(), diag::err_unknown_any_var_function_type)
21141 diag::err_typecheck_cast_to_incomplete))
21156 return RebuildUnknownAnyExpr(*
this, ToType).Visit(E);
21163 ExplicitCastExpr *castArg = dyn_cast<ExplicitCastExpr>(arg->IgnoreParens());
21172 assert(!arg->hasPlaceholderType());
21184 unsigned diagID = diag::err_uncasted_use_of_unknown_any;
21187 if (
CallExpr *call = dyn_cast<CallExpr>(E)) {
21188 E = call->getCallee();
21189 diagID = diag::err_uncasted_call_of_unknown_any;
21197 if (
DeclRefExpr *ref = dyn_cast<DeclRefExpr>(E)) {
21198 loc = ref->getLocation();
21199 d = ref->getDecl();
21200 }
else if (
MemberExpr *mem = dyn_cast<MemberExpr>(E)) {
21201 loc = mem->getMemberLoc();
21202 d = mem->getMemberDecl();
21204 diagID = diag::err_uncasted_call_of_unknown_any;
21205 loc = msg->getSelectorStartLoc();
21206 d = msg->getMethodDecl();
21208 S.
Diag(loc, diag::err_uncasted_send_to_unknown_any_method)
21209 <<
static_cast<unsigned>(msg->isClassMessage()) << msg->getSelector()
21238 if (!placeholderType)
return E;
21240 switch (placeholderType->
getKind()) {
21243 case BuiltinType::Overload: {
21263 case BuiltinType::BoundMember: {
21268 if (isa<CXXPseudoDestructorExpr>(BME)) {
21269 PD =
PDiag(diag::err_dtor_expr_without_call) << 1;
21270 }
else if (
const auto *ME = dyn_cast<MemberExpr>(BME)) {
21271 if (ME->getMemberNameInfo().getName().getNameKind() ==
21273 PD =
PDiag(diag::err_dtor_expr_without_call) << 0;
21281 case BuiltinType::ARCUnbridgedCast: {
21288 case BuiltinType::UnknownAny:
21292 case BuiltinType::PseudoObject:
21295 case BuiltinType::BuiltinFn: {
21299 auto *FD = cast<FunctionDecl>(DRE->
getDecl());
21300 unsigned BuiltinID = FD->getBuiltinID();
21301 if (BuiltinID == Builtin::BI__noop) {
21303 CK_BuiltinFnToFnPtr)
21316 ? diag::err_use_of_unaddressable_function
21317 : diag::warn_cxx20_compat_use_of_unaddressable_function);
21318 if (FD->isImplicitlyInstantiable()) {
21345 case BuiltinType::IncompleteMatrixIdx:
21349 diag::err_matrix_incomplete_index);
21353 case BuiltinType::ArraySection:
21355 << cast<ArraySectionExpr>(E)->isOMPArraySection();
21359 case BuiltinType::OMPArrayShaping:
21362 case BuiltinType::OMPIterator:
21366#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
21367 case BuiltinType::Id:
21368#include "clang/Basic/OpenCLImageTypes.def"
21369#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
21370 case BuiltinType::Id:
21371#include "clang/Basic/OpenCLExtensionTypes.def"
21372#define SVE_TYPE(Name, Id, SingletonId) \
21373 case BuiltinType::Id:
21374#include "clang/Basic/AArch64SVEACLETypes.def"
21375#define PPC_VECTOR_TYPE(Name, Id, Size) \
21376 case BuiltinType::Id:
21377#include "clang/Basic/PPCTypes.def"
21378#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
21379#include "clang/Basic/RISCVVTypes.def"
21380#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
21381#include "clang/Basic/WebAssemblyReferenceTypes.def"
21382#define BUILTIN_TYPE(Id, SingletonId) case BuiltinType::Id:
21383#define PLACEHOLDER_TYPE(Id, SingletonId)
21384#include "clang/AST/BuiltinTypes.def"
21388 llvm_unreachable(
"invalid placeholder type!");
21402 assert((Kind == tok::kw___objc_yes || Kind == tok::kw___objc_no) &&
21403 "Unknown Objective-C Boolean value!");
21423 auto FindSpecVersion =
21424 [&](StringRef Platform) -> std::optional<VersionTuple> {
21430 if (Spec == AvailSpecs.end() && Platform ==
"maccatalyst") {
21435 if (Spec == AvailSpecs.end())
21436 return std::nullopt;
21440 VersionTuple Version;
21441 if (
auto MaybeVersion =
21443 Version = *MaybeVersion;
21448 Context->HasPotentialAvailabilityViolations =
true;
Defines the clang::ASTContext interface.
This file provides some common utility functions for processing Lambda related AST Constructs.
static bool isObjCPointer(const MemRegion *R)
Defines enum values for all the target-independent builtin functions.
Defines the C++ template declaration subclasses.
Defines the classes clang::DelayedDiagnostic and clang::AccessedEntity.
Defines the clang::Expr interface and subclasses for C++ expressions.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
llvm::MachO::Target Target
llvm::MachO::Record Record
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.
Defines the clang::Preprocessor interface.
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
This file declares semantic analysis for CUDA constructs.
static Sema::AssignConvertType checkObjCPointerTypesForAssignment(Sema &S, QualType LHSType, QualType RHSType)
checkObjCPointerTypesForAssignment - Compares two objective-c pointer types for assignment compatibil...
static void HandleImmediateInvocations(Sema &SemaRef, Sema::ExpressionEvaluationContextRecord &Rec)
static ExprResult BuildCookedLiteralOperatorCall(Sema &S, Scope *Scope, IdentifierInfo *UDSuffix, SourceLocation UDSuffixLoc, ArrayRef< Expr * > Args, SourceLocation LitEndLoc)
BuildCookedLiteralOperatorCall - A user-defined literal was found.
static ExprResult BuildOverloadedBinOp(Sema &S, Scope *Sc, SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHS, Expr *RHS)
Build an overloaded binary operator expression in the given scope.
static bool canConvertIntTyToFloatTy(Sema &S, ExprResult *Int, QualType FloatTy)
Test if a (constant) integer Int can be casted to floating point type FloatTy without losing precisio...
static bool captureInCapturedRegion(CapturedRegionScopeInfo *RSI, ValueDecl *Var, SourceLocation Loc, const bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType, const bool RefersToCapturedVariable, Sema::TryCaptureKind Kind, bool IsTopScope, Sema &S, bool Invalid)
Capture the given variable in the captured region.
static bool checkArithmeticOpPointerOperand(Sema &S, SourceLocation Loc, Expr *Operand)
Check the validity of an arithmetic pointer operand.
static void DiagnoseBitwisePrecedence(Sema &Self, BinaryOperatorKind Opc, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr)
DiagnoseBitwisePrecedence - Emit a warning when bitwise and comparison operators are mixed in a way t...
static bool isPlaceholderToRemoveAsArg(QualType type)
Is the given type a placeholder that we need to lower out immediately during argument processing?
static void diagnoseArithmeticOnNullPointer(Sema &S, SourceLocation Loc, Expr *Pointer, bool IsGNUIdiom)
Diagnose invalid arithmetic on a null pointer.
static void DiagnoseConditionalPrecedence(Sema &Self, SourceLocation OpLoc, Expr *Condition, const Expr *LHSExpr, const Expr *RHSExpr)
DiagnoseConditionalPrecedence - Emit a warning when a conditional operator and binary operator are mi...
static bool CheckDeclInExpr(Sema &S, SourceLocation Loc, NamedDecl *D, bool AcceptInvalid)
Diagnoses obvious problems with the use of the given declaration as an expression.
static QualType checkConditionalObjectPointersCompatibility(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc)
Return the resulting type when the operands are both pointers.
static QualType OpenCLCheckVectorConditional(Sema &S, ExprResult &Cond, ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
Return the resulting type for the conditional operator in OpenCL (aka "ternary selection operator",...
static void diagnoseLogicalNotOnLHSofCheck(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc)
Warns on !x < y, !x & y where !(x < y), !(x & y) was probably intended.
static void diagnoseArithmeticOnFunctionPointer(Sema &S, SourceLocation Loc, Expr *Pointer)
Diagnose invalid arithmetic on a function pointer.
static void diagnoseObjCLiteralComparison(Sema &S, SourceLocation Loc, ExprResult &LHS, ExprResult &RHS, BinaryOperator::Opcode Opc)
static bool isCapturingReferenceToHostVarInCUDADeviceLambda(const Sema &S, VarDecl *VD)
static UnaryOperatorKind ConvertTokenKindToUnaryOpcode(tok::TokenKind Kind)
static bool isImplicitlyDefinableConstexprFunction(FunctionDecl *Func)
NonConstCaptureKind
Is the given expression (which must be 'const') a reference to a variable which was originally non-co...
static bool tryVectorConvertAndSplat(Sema &S, ExprResult *scalar, QualType scalarTy, QualType vectorEltTy, QualType vectorTy, unsigned &DiagID)
Try to convert a value of non-vector type to a vector type by converting the type to the element type...
static bool isVector(QualType QT, QualType ElementType)
This helper function returns true if QT is a vector type that has element type ElementType.
static void DiagnoseCalleeStaticArrayParam(Sema &S, ParmVarDecl *PVD)
static Expr * recoverFromMSUnqualifiedLookup(Sema &S, ASTContext &Context, DeclarationNameInfo &NameInfo, SourceLocation TemplateKWLoc, const TemplateArgumentListInfo *TemplateArgs)
In Microsoft mode, if we are inside a template class whose parent class has dependent base classes,...
static void FixDependencyOfIdExpressionsInLambdaWithDependentObjectParameter(Sema &SemaRef, ValueDecl *D, Expr *E)
static bool isVariableCapturable(CapturingScopeInfo *CSI, ValueDecl *Var, SourceLocation Loc, const bool Diagnose, Sema &S)
static bool maybeDiagnoseAssignmentToFunction(Sema &S, QualType DstType, const Expr *SrcExpr)
static void SuggestParentheses(Sema &Self, SourceLocation Loc, const PartialDiagnostic &Note, SourceRange ParenRange)
SuggestParentheses - Emit a note with a fixit hint that wraps ParenRange in parentheses.
static Decl * getPredefinedExprDecl(DeclContext *DC)
getPredefinedExprDecl - Returns Decl of a given DeclContext that can be used to determine the value o...
static CXXRecordDecl * LookupStdSourceLocationImpl(Sema &S, SourceLocation Loc)
static bool IgnoreCommaOperand(const Expr *E, const ASTContext &Context)
static QualType CheckRealImagOperand(Sema &S, ExprResult &V, SourceLocation Loc, bool IsReal)
static QualType checkArithmeticOrEnumeralCompare(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc)
static QualType CheckIndirectionOperand(Sema &S, Expr *Op, ExprValueKind &VK, SourceLocation OpLoc, bool IsAfterAmp=false)
CheckIndirectionOperand - Type check unary indirection (prefix '*').
static bool CheckAlignOfExpr(Sema &S, Expr *E, UnaryExprOrTypeTrait ExprKind)
static bool ExprLooksBoolean(const Expr *E)
ExprLooksBoolean - Returns true if E looks boolean, i.e.
static bool isPotentiallyConstantEvaluatedContext(Sema &SemaRef)
Are we in a context that is potentially constant evaluated per C++20 [expr.const]p12?
static void DiagnoseSelfAssignment(Sema &S, Expr *LHSExpr, Expr *RHSExpr, SourceLocation OpLoc, bool IsBuiltin)
DiagnoseSelfAssignment - Emits a warning if a value is assigned to itself.
static void diagnoseStringPlusInt(Sema &Self, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr)
diagnoseStringPlusInt - Emit a warning when adding an integer to a string literal.
static QualType checkConditionalPointerCompatibility(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc)
Checks compatibility between two pointers and return the resulting type.
static void DoMarkVarDeclReferenced(Sema &SemaRef, SourceLocation Loc, VarDecl *Var, Expr *E, llvm::DenseMap< const VarDecl *, int > &RefsMinusAssignments)
static bool ShouldLookupResultBeMultiVersionOverload(const LookupResult &R)
static bool checkCondition(Sema &S, const Expr *Cond, SourceLocation QuestionLoc)
Return false if the condition expression is valid, true otherwise.
static bool checkForArray(const Expr *E)
static void DiagnosedUnqualifiedCallsToStdFunctions(Sema &S, const CallExpr *Call)
static void DiagnoseRecursiveConstFields(Sema &S, const ValueDecl *VD, const RecordType *Ty, SourceLocation Loc, SourceRange Range, OriginalExprKind OEK, bool &DiagnosticEmitted)
static void MarkExprReferenced(Sema &SemaRef, SourceLocation Loc, Decl *D, Expr *E, bool MightBeOdrUse, llvm::DenseMap< const VarDecl *, int > &RefsMinusAssignments)
static ExprResult convertVector(Expr *E, QualType ElementType, Sema &S)
Convert vector E to a vector with the same number of elements but different element type.
static void DoMarkPotentialCapture(Sema &SemaRef, SourceLocation Loc, ValueDecl *Var, Expr *E)
static void RecordModifiableNonNullParam(Sema &S, const Expr *Exp)
static void EvaluateAndDiagnoseImmediateInvocation(Sema &SemaRef, Sema::ImmediateInvocationCandidate Candidate)
static bool checkThreeWayNarrowingConversion(Sema &S, QualType ToType, Expr *E, QualType FromType, SourceLocation Loc)
static bool IsArithmeticBinaryExpr(const Expr *E, BinaryOperatorKind *Opcode, const Expr **RHSExprs)
IsArithmeticBinaryExpr - Returns true if E is an arithmetic binary expression, either using a built-i...
static ExprResult convertHalfVecBinOp(Sema &S, ExprResult LHS, ExprResult RHS, BinaryOperatorKind Opc, QualType ResultTy, ExprValueKind VK, ExprObjectKind OK, bool IsCompAssign, SourceLocation OpLoc, FPOptionsOverride FPFeatures)
static QualType handleIntegerConversion(Sema &S, ExprResult &LHS, ExprResult &RHS, QualType LHSType, QualType RHSType, bool IsCompAssign)
Handle integer arithmetic conversions.
static void checkDirectCallValidity(Sema &S, const Expr *Fn, FunctionDecl *Callee, MultiExprArg ArgExprs)
static void ConstructTransparentUnion(Sema &S, ASTContext &C, ExprResult &EResult, QualType UnionType, FieldDecl *Field)
Constructs a transparent union from an expression that is used to initialize the transparent union.
static QualType OpenCLConvertScalarsToVectors(Sema &S, ExprResult &LHS, ExprResult &RHS, QualType CondTy, SourceLocation QuestionLoc)
Convert scalar operands to a vector that matches the condition in length.
static bool checkConditionalNullPointer(Sema &S, ExprResult &NullExpr, QualType PointerTy)
Return false if the NullExpr can be promoted to PointerTy, true otherwise.
static void diagnoseSubtractionOnNullPointer(Sema &S, SourceLocation Loc, Expr *Pointer, bool BothNull)
Diagnose invalid subraction on a null pointer.
static NamedDecl * getDeclFromExpr(Expr *E)
static bool checkArithmeticOnObjCPointer(Sema &S, SourceLocation opLoc, Expr *op)
Diagnose if arithmetic on the given ObjC pointer is illegal.
static bool IsInvalidCmseNSCallConversion(Sema &S, QualType FromType, QualType ToType)
static void RemoveNestedImmediateInvocation(Sema &SemaRef, Sema::ExpressionEvaluationContextRecord &Rec, SmallVector< Sema::ImmediateInvocationCandidate, 4 >::reverse_iterator It)
static void DiagnoseBitwiseOpInBitwiseOp(Sema &S, BinaryOperatorKind Opc, SourceLocation OpLoc, Expr *SubExpr)
Look for bitwise op in the left or right hand of a bitwise op with lower precedence and emit a diagno...
static void emitEmptyLookupTypoDiagnostic(const TypoCorrection &TC, Sema &SemaRef, const CXXScopeSpec &SS, DeclarationName Typo, SourceLocation TypoLoc, ArrayRef< Expr * > Args, unsigned DiagnosticID, unsigned DiagnosticSuggestID)
static QualType CheckIncrementDecrementOperand(Sema &S, Expr *Op, ExprValueKind &VK, ExprObjectKind &OK, SourceLocation OpLoc, bool IsInc, bool IsPrefix)
CheckIncrementDecrementOperand - unlike most "Check" methods, this routine doesn't need to call Usual...
static QualType OpenCLArithmeticConversions(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
Simple conversion between integer and floating point types.
static bool checkVectorResult(Sema &S, QualType CondTy, QualType VecResTy, SourceLocation QuestionLoc)
Return false if the vector condition type and the vector result type are compatible.
static void DiagnoseDivisionSizeofPointerOrArray(Sema &S, Expr *LHS, Expr *RHS, SourceLocation Loc)
static void diagnoseTautologicalComparison(Sema &S, SourceLocation Loc, Expr *LHS, Expr *RHS, BinaryOperatorKind Opc)
Diagnose some forms of syntactically-obvious tautological comparison.
static void warnOnSizeofOnArrayDecay(Sema &S, SourceLocation Loc, QualType T, const Expr *E)
Check whether E is a pointer from a decayed array type (the decayed pointer type is equal to T) and e...
static void DiagnoseBadDivideOrRemainderValues(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsDiv)
static void ConvertUTF8ToWideString(unsigned CharByteWidth, StringRef Source, SmallString< 32 > &Target)
static TypoCorrection TryTypoCorrectionForCall(Sema &S, Expr *Fn, FunctionDecl *FDecl, ArrayRef< Expr * > Args)
static bool hasAnyExplicitStorageClass(const FunctionDecl *D)
Determine whether a FunctionDecl was ever declared with an explicit storage class.
static void DiagnoseBadShiftValues(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc, QualType LHSType)
static bool CheckVecStepTraitOperandType(Sema &S, QualType T, SourceLocation Loc, SourceRange ArgRange)
static Sema::AssignConvertType checkBlockPointerTypesForAssignment(Sema &S, QualType LHSType, QualType RHSType)
checkBlockPointerTypesForAssignment - This routine determines whether two block pointer types are com...
static bool unsupportedTypeConversion(const Sema &S, QualType LHSType, QualType RHSType)
Diagnose attempts to convert between __float128, __ibm128 and long double if there is no support for ...
static void MarkVarDeclODRUsed(ValueDecl *V, SourceLocation Loc, Sema &SemaRef, const unsigned *const FunctionScopeIndexToStopAt=nullptr)
Directly mark a variable odr-used.
static void diagnoseStringPlusChar(Sema &Self, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr)
Emit a warning when adding a char literal to a string.
static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S)
CheckForModifiableLvalue - Verify that E is a modifiable lvalue.
static ValueDecl * getPrimaryDecl(Expr *E)
getPrimaryDecl - Helper function for CheckAddressOfOperand().
static void diagnoseUseOfInternalDeclInInlineFunction(Sema &S, const NamedDecl *D, SourceLocation Loc)
Check whether we're in an extern inline function and referring to a variable or function with interna...
static bool funcHasParameterSizeMangling(Sema &S, FunctionDecl *FD)
Return true if this function has a calling convention that requires mangling in the size of the param...
static bool convertPointersToCompositeType(Sema &S, SourceLocation Loc, ExprResult &LHS, ExprResult &RHS)
Returns false if the pointers are converted to a composite type, true otherwise.
static void DiagnoseBinOpPrecedence(Sema &Self, BinaryOperatorKind Opc, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr)
DiagnoseBinOpPrecedence - Emit warnings for expressions with tricky precedence.
static void diagnoseAddressOfInvalidType(Sema &S, SourceLocation Loc, Expr *E, unsigned Type)
Diagnose invalid operand for address of operations.
static QualType handleComplexIntConversion(Sema &S, ExprResult &LHS, ExprResult &RHS, QualType LHSType, QualType RHSType, bool IsCompAssign)
Handle conversions with GCC complex int extension.
static bool isMSPropertySubscriptExpr(Sema &S, Expr *Base)
static bool tryGCCVectorConvertAndSplat(Sema &S, ExprResult *Scalar, ExprResult *Vector)
Attempt to convert and splat Scalar into a vector whose types matches Vector following GCC conversion...
static bool captureInLambda(LambdaScopeInfo *LSI, ValueDecl *Var, SourceLocation Loc, const bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType, const bool RefersToCapturedVariable, const Sema::TryCaptureKind Kind, SourceLocation EllipsisLoc, const bool IsTopScope, Sema &S, bool Invalid)
Capture the given variable in the lambda.
static void DiagnoseLogicalAndInLogicalOrLHS(Sema &S, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr)
Look for '&&' in the left hand of a '||' expr.
static void CheckForNullPointerDereference(Sema &S, Expr *E)
static QualType computeConditionalNullability(QualType ResTy, bool IsBin, QualType LHSTy, QualType RHSTy, ASTContext &Ctx)
Compute the nullability of a conditional expression.
static OdrUseContext isOdrUseContext(Sema &SemaRef)
Are we within a context in which references to resolved functions or to variables result in odr-use?
static void DiagnoseConstAssignment(Sema &S, const Expr *E, SourceLocation Loc)
Emit the "read-only variable not assignable" error and print notes to give more information about why...
static Expr * BuildFloatingLiteral(Sema &S, NumericLiteralParser &Literal, QualType Ty, SourceLocation Loc)
static bool IsTypeModifiable(QualType Ty, bool IsDereference)
static bool isVariableAlreadyCapturedInScopeInfo(CapturingScopeInfo *CSI, ValueDecl *Var, bool &SubCapturesAreNested, QualType &CaptureType, QualType &DeclRefType)
static bool checkArithmeticIncompletePointerType(Sema &S, SourceLocation Loc, Expr *Operand)
Emit error if Operand is incomplete pointer type.
static bool CheckExtensionTraitOperandType(Sema &S, QualType T, SourceLocation Loc, SourceRange ArgRange, UnaryExprOrTypeTrait TraitKind)
static QualType checkSizelessVectorShift(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign)
static QualType checkArithmeticOrEnumeralThreeWayCompare(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc)
static ExprResult diagnoseUnknownAnyExpr(Sema &S, Expr *E)
static SourceLocation getUDSuffixLoc(Sema &S, SourceLocation TokLoc, unsigned Offset)
getUDSuffixLoc - Create a SourceLocation for a ud-suffix, given the location of the token and the off...
static bool checkBlockType(Sema &S, const Expr *E)
Return true if the Expr is block type.
static bool captureInBlock(BlockScopeInfo *BSI, ValueDecl *Var, SourceLocation Loc, const bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType, const bool Nested, Sema &S, bool Invalid)
static QualType handleFloatConversion(Sema &S, ExprResult &LHS, ExprResult &RHS, QualType LHSType, QualType RHSType, bool IsCompAssign)
Handle arithmethic conversion with floating point types.
static void diagnoseArithmeticOnVoidPointer(Sema &S, SourceLocation Loc, Expr *Pointer)
Diagnose invalid arithmetic on a void pointer.
static QualType checkVectorShift(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign)
Return the resulting type when a vector is shifted by a scalar or vector shift amount.
static void diagnoseUncapturableValueReferenceOrBinding(Sema &S, SourceLocation loc, ValueDecl *var)
ExprResult PerformCastFn(Sema &S, Expr *operand, QualType toType)
static void checkArithmeticNull(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompare)
static bool IsReadonlyMessage(Expr *E, Sema &S)
static void buildLambdaCaptureFixit(Sema &Sema, LambdaScopeInfo *LSI, ValueDecl *Var)
Create up to 4 fix-its for explicit reference and value capture of Var or default capture.
static void tryImplicitlyCaptureThisIfImplicitMemberFunctionAccessWithDependentArgs(Sema &S, const UnresolvedMemberExpr *const UME, SourceLocation CallLoc)
static Sema::AssignConvertType checkPointerTypesForAssignment(Sema &S, QualType LHSType, QualType RHSType, SourceLocation Loc)
static bool CheckVectorElementsTraitOperandType(Sema &S, QualType T, SourceLocation Loc, SourceRange ArgRange)
static void DiagnoseLogicalAndInLogicalOrRHS(Sema &S, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr)
Look for '&&' in the right hand of a '||' expr.
static QualType getDependentArraySubscriptType(Expr *LHS, Expr *RHS, const ASTContext &Ctx)
static void checkEnumArithmeticConversions(Sema &S, Expr *LHS, Expr *RHS, SourceLocation Loc, Sema::ArithConvKind ACK)
Check that the usual arithmetic conversions can be performed on this pair of expressions that might b...
static void diagnosePointerIncompatibility(Sema &S, SourceLocation Loc, Expr *LHSExpr, Expr *RHSExpr)
Emit error when two pointers are incompatible.
static bool enclosingClassIsRelatedToClassInWhichMembersWereFound(const UnresolvedMemberExpr *const UME, Sema &S)
static unsigned GetFixedPointRank(QualType Ty)
Return the rank of a given fixed point or integer type.
static bool CheckObjCTraitOperandConstraints(Sema &S, QualType T, SourceLocation Loc, SourceRange ArgRange, UnaryExprOrTypeTrait TraitKind)
static void diagnoseArithmeticOnTwoFunctionPointers(Sema &S, SourceLocation Loc, Expr *LHS, Expr *RHS)
Diagnose invalid arithmetic on two function pointers.
static bool checkPointerIntegerMismatch(Sema &S, ExprResult &Int, Expr *PointerExpr, SourceLocation Loc, bool IsIntFirstExpr)
Return false if the first expression is not an integer and the second expression is not a pointer,...
static ImplicitConversionKind castKindToImplicitConversionKind(CastKind CK)
static void diagnoseXorMisusedAsPow(Sema &S, const ExprResult &XorLHS, const ExprResult &XorRHS, const SourceLocation Loc)
static bool checkOpenCLConditionVector(Sema &S, Expr *Cond, SourceLocation QuestionLoc)
Return false if this is a valid OpenCL condition vector.
static bool IsArithmeticOp(BinaryOperatorKind Opc)
static bool handleComplexIntegerToFloatConversion(Sema &S, ExprResult &IntExpr, ExprResult &ComplexExpr, QualType IntTy, QualType ComplexTy, bool SkipCast)
Convert complex integers to complex floats and real integers to real floats as required for complex a...
static std::pair< ExprResult, ExprResult > CorrectDelayedTyposInBinOp(Sema &S, BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr)
static void checkObjCPointerIntrospection(Sema &S, ExprResult &L, ExprResult &R, SourceLocation OpLoc)
Check if a bitwise-& is performed on an Objective-C pointer.
static void DiagnoseDirectIsaAccess(Sema &S, const ObjCIvarRefExpr *OIRE, SourceLocation AssignLoc, const Expr *RHS)
static ExprResult rebuildUnknownAnyFunction(Sema &S, Expr *fn)
Given a function expression of unknown-any type, try to rebuild it to have a function type.
static QualType handleIntToFloatConversion(Sema &S, ExprResult &FloatExpr, ExprResult &IntExpr, QualType FloatTy, QualType IntTy, bool ConvertFloat, bool ConvertInt)
Handle arithmetic conversion from integer to float.
static bool hasIsEqualMethod(Sema &S, const Expr *LHS, const Expr *RHS)
static QualType handleComplexFloatConversion(Sema &S, ExprResult &Shorter, QualType ShorterType, QualType LongerType, bool PromotePrecision)
static FunctionDecl * rewriteBuiltinFunctionDecl(Sema *Sema, ASTContext &Context, FunctionDecl *FDecl, MultiExprArg ArgExprs)
If a builtin function has a pointer argument with no explicit address space, then it should be able t...
static void DoMarkBindingDeclReferenced(Sema &SemaRef, SourceLocation Loc, BindingDecl *BD, Expr *E)
static PredefinedIdentKind getPredefinedExprKind(tok::TokenKind Kind)
static void DiagnoseUnusedOfDecl(Sema &S, NamedDecl *D, SourceLocation Loc)
static QualType handleFixedPointConversion(Sema &S, QualType LHSTy, QualType RHSTy)
handleFixedPointConversion - Fixed point operations between fixed point types and integers or other f...
static QualType handleComplexConversion(Sema &S, ExprResult &LHS, ExprResult &RHS, QualType LHSType, QualType RHSType, bool IsCompAssign)
Handle arithmetic conversion with complex types.
static QualType CheckCommaOperands(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc)
static bool canCaptureVariableByCopy(ValueDecl *Var, const ASTContext &Context)
static void diagnoseArithmeticOnTwoVoidPointers(Sema &S, SourceLocation Loc, Expr *LHSExpr, Expr *RHSExpr)
Diagnose invalid arithmetic on two void pointers.
static void diagnoseDistinctPointerComparison(Sema &S, SourceLocation Loc, ExprResult &LHS, ExprResult &RHS, bool IsError)
Diagnose bad pointer comparisons.
static bool needsConversionOfHalfVec(bool OpRequiresConversion, ASTContext &Ctx, Expr *E0, Expr *E1=nullptr)
Returns true if conversion between vectors of halfs and vectors of floats is needed.
static bool isObjCObjectLiteral(ExprResult &E)
static NonConstCaptureKind isReferenceToNonConstCapture(Sema &S, Expr *E)
static QualType checkConditionalBlockPointerCompatibility(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc)
Return the resulting type when the operands are both block pointers.
static void DiagnoseShiftCompare(Sema &S, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr)
static void DiagnoseAdditionInShift(Sema &S, SourceLocation OpLoc, Expr *SubExpr, StringRef Shift)
static void diagnoseFunctionPointerToVoidComparison(Sema &S, SourceLocation Loc, ExprResult &LHS, ExprResult &RHS, bool IsError)
static void EmitDiagnosticForLogicalAndInLogicalOr(Sema &Self, SourceLocation OpLoc, BinaryOperator *Bop)
It accepts a '&&' expr that is inside a '||' one.
static void captureVariablyModifiedType(ASTContext &Context, QualType T, CapturingScopeInfo *CSI)
static bool canConvertIntToOtherIntTy(Sema &S, ExprResult *Int, QualType OtherIntTy)
Test if a (constant) integer Int can be casted to another integer type IntTy without losing precision...
static DeclContext * getParentOfCapturingContextOrNull(DeclContext *DC, ValueDecl *Var, SourceLocation Loc, const bool Diagnose, Sema &S)
static bool isOverflowingIntegerType(ASTContext &Ctx, QualType T)
static void CheckIdentityFieldAssignment(Expr *LHSExpr, Expr *RHSExpr, SourceLocation Loc, Sema &Sema)
static bool isLegalBoolVectorBinaryOp(BinaryOperatorKind Opc)
static ExprResult rebuildPotentialResultsAsNonOdrUsed(Sema &S, Expr *E, NonOdrUseReason NOUR)
Walk the set of potential results of an expression and mark them all as non-odr-uses if they satisfy ...
static void CheckCompleteParameterTypesForMangler(Sema &S, FunctionDecl *FD, SourceLocation Loc)
Require that all of the parameter types of function be complete.
static bool isScopedEnumerationType(QualType T)
static bool checkArithmeticBinOpPointerOperands(Sema &S, SourceLocation Loc, Expr *LHSExpr, Expr *RHSExpr)
Check the validity of a binary arithmetic operation w.r.t.
static bool breakDownVectorType(QualType type, uint64_t &len, QualType &eltType)
This file declares semantic analysis for OpenMP constructs and clauses.
static bool isInvalid(LocType Loc, bool *Invalid)
Defines the SourceManager interface.
Defines various enumerations that describe declaration and type specifiers.
Defines the clang::TypeLoc interface and its subclasses.
Defines enumerations for the type traits support.
C Language Family Type Representation.
@ Open
The standard open() call: int open(const char *path, int oflag, ...);.
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
std::string getAsString(const ASTContext &Ctx, QualType Ty) const
virtual void HandleCXXImplicitFunctionInstantiation(FunctionDecl *D)
Invoked when a function is implicitly instantiated.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
BuiltinVectorTypeInfo getBuiltinVectorTypeInfo(const BuiltinType *VecTy) const
Returns the element type, element count and number of vectors (in case of tuple) for a builtin vector...
TranslationUnitDecl * getTranslationUnitDecl() const
const ConstantArrayType * getAsConstantArrayType(QualType T) const
bool areLaxCompatibleSveTypes(QualType FirstType, QualType SecondType)
Return true if the given vector types are lax-compatible SVE vector types, false otherwise.
CanQualType ARCUnbridgedCastTy
unsigned getIntWidth(QualType T) const
QualType getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType) const
bool areCompatibleRVVTypes(QualType FirstType, QualType SecondType)
Return true if the given types are an RISC-V vector builtin type and a VectorType that is a fixed-len...
const llvm::fltSemantics & getFloatTypeSemantics(QualType T) const
Return the APFloat 'semantics' for the specified scalar floating point type.
QualType areCommonBaseCompatible(const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT)
QualType getBlockPointerType(QualType T) const
Return the uniqued reference to the type for a block of the specified type.
bool ObjCQualifiedIdTypesAreCompatible(const ObjCObjectPointerType *LHS, const ObjCObjectPointerType *RHS, bool ForCompare)
ObjCQualifiedIdTypesAreCompatible - We know that one of lhs/rhs is an ObjCQualifiedIDType.
QualType getMemberPointerType(QualType T, const Type *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
QualType getBuiltinVaListType() const
Retrieve the type of the __builtin_va_list type.
DeclarationNameTable DeclarationNames
int getIntegerTypeOrder(QualType LHS, QualType RHS) const
Return the highest ranked integer type, see C99 6.3.1.8p1.
QualType getRecordType(const RecordDecl *Decl) const
QualType getScalableVectorType(QualType EltTy, unsigned NumElts, unsigned NumFields=1) const
Return the unique reference to a scalable vector type of the specified element type and scalable numb...
QualType getBuiltinMSVaListType() const
Retrieve the type of the __builtin_ms_va_list type.
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like 'int()'.
QualType getCorrespondingSignedFixedPointType(QualType Ty) const
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
QualType getVectorType(QualType VectorType, unsigned NumElts, VectorKind VecKind) const
Return the unique reference to a vector type of the specified element type and size.
QualType getObjCSelRedefinitionType() const
Retrieve the type that 'SEL' has been defined to, which may be different from the built-in 'SEL' if '...
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
bool canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT)
canAssignObjCInterfaces - Return true if the two interface types are compatible for assignment from R...
QualType getReferenceQualifiedType(const Expr *e) const
getReferenceQualifiedType - Given an expr, will return the type for that expression,...
bool isObjCSelType(QualType T) const
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Builtin::Context & BuiltinInfo
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, const Expr *SizeExpr, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type.
const LangOptions & getLangOpts() const
bool areLaxCompatibleRVVTypes(QualType FirstType, QualType SecondType)
Return true if the given vector types are lax-compatible RISC-V vector types as defined by -flax-vect...
TypedefDecl * getBOOLDecl() const
Retrieve declaration of 'BOOL' typedef.
bool typesAreBlockPointerCompatible(QualType, QualType)
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
QualType getPointerDiffType() const
Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.
void setBOOLDecl(TypedefDecl *TD)
Save declaration of 'BOOL' typedef.
int getFloatingTypeOrder(QualType LHS, QualType RHS) const
Compare the rank of the two specified floating point types, ignoring the domain of the type (i....
QualType getIntTypeForBitwidth(unsigned DestWidth, unsigned Signed) const
getIntTypeForBitwidth - sets integer QualTy according to specified details: bitwidth,...
GVALinkage GetGVALinkageForFunction(const FunctionDecl *FD) const
CanQualType UnsignedLongTy
llvm::DenseSet< const FunctionDecl * > CUDAImplicitHostDeviceFunUsedByDevice
Keep track of CUDA/HIP implicit host device functions used on device side in device compilation.
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
TypeInfo getTypeInfo(const Type *T) const
Get the size and alignment of the specified complete type in bits.
QualType getStringLiteralArrayType(QualType EltTy, unsigned Length) const
Return a type for a constant array for a string literal of the specified element type and length.
QualType getCorrespondingSaturatedType(QualType Ty) const
QualType getBOOLType() const
type of 'BOOL' type.
CanQualType BoundMemberTy
QualType removeAddrSpaceQualType(QualType T) const
Remove any existing address space on the type and returns the type with qualifiers intact (or that's ...
llvm::DenseSet< const VarDecl * > CUDADeviceVarODRUsedByHost
Keep track of CUDA/HIP device-side variables ODR-used by host code.
CanQualType PseudoObjectTy
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
bool areComparableObjCPointerTypes(QualType LHS, QualType RHS)
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
CanQualType ObjCBuiltinBoolTy
llvm::FixedPointSemantics getFixedPointSemantics(QualType Ty) const
QualType mergeTypes(QualType, QualType, bool OfBlockPointer=false, bool Unqualified=false, bool BlockReturnType=false, bool IsConditionalOperator=false)
static bool isObjCNSObjectType(QualType Ty)
Return true if this is an NSObject object with its NSObject attribute set.
QualType getObjCIdType() const
Represents the Objective-CC id type.
llvm::DenseSet< const ValueDecl * > CUDAExternalDeviceDeclODRUsedByHost
Keep track of CUDA/HIP external kernels or device variables ODR-used by host code.
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
CanQualType UnsignedCharTy
CanQualType UnsignedIntTy
TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const
Allocate an uninitialized TypeSourceInfo.
QualType getObjCClassRedefinitionType() const
Retrieve the type that Class has been defined to, which may be different from the built-in Class if C...
CanQualType UnsignedLongLongTy
QualType getCommonSugaredType(QualType X, QualType Y, bool Unqualified=false)
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
QualType getObjCIdRedefinitionType() const
Retrieve the type that id has been defined to, which may be different from the built-in id if id has ...
QualType getPromotedIntegerType(QualType PromotableType) const
Return the type that PromotableType will promote to: C99 6.3.1.1p2, assuming that PromotableType is a...
llvm::APFixedPoint getFixedPointMax(QualType Ty) const
QualType getComplexType(QualType T) const
Return the uniqued reference to the type for a complex number with the specified element type.
bool areCompatibleSveTypes(QualType FirstType, QualType SecondType)
Return true if the given types are an SVE builtin and a VectorType that is a fixed-length representat...
bool hasDirectOwnershipQualifier(QualType Ty) const
Return true if the type has been explicitly qualified with ObjC ownership.
QualType getExtVectorType(QualType VectorType, unsigned NumElts) const
Return the unique reference to an extended vector type of the specified element type and size.
bool areCompatibleVectorTypes(QualType FirstVec, QualType SecondVec)
Return true if the given vector types are of the same unqualified type or if they are equivalent to t...
DeclarationNameInfo getNameForTemplate(TemplateName Name, SourceLocation NameLoc) const
const TargetInfo & getTargetInfo() const
CanQualType IncompleteMatrixIdxTy
std::optional< CharUnits > getTypeSizeInCharsIfKnown(QualType Ty) const
QualType getCorrespondingUnsignedType(QualType T) const
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
QualType getCorrespondingSignedType(QualType T) const
unsigned getTargetAddressSpace(LangAS AS) const
QualType getWideCharType() const
Return the type of wide characters.
bool isPromotableIntegerType(QualType T) const
More type predicates useful for type checking/promotion.
CanQualType getSignedSizeType() const
Return the unique signed counterpart of the integer type corresponding to size_t.
QualType getLogicalOperationType() const
The result type of logical operations, '<', '>', '!=', etc.
unsigned char getFixedPointScale(QualType Ty) const
QualType adjustStringLiteralBaseType(QualType StrLTy) const
bool hasCvrSimilarType(QualType T1, QualType T2)
Determine if two types are similar, ignoring only CVR qualifiers.
bool isDependenceAllowed() const
QualType getConstantMatrixType(QualType ElementType, unsigned NumRows, unsigned NumColumns) const
Return the unique reference to the matrix type of the specified element type and size.
QualType isPromotableBitField(Expr *E) const
Whether this is a promotable bitfield reference according to C99 6.3.1.1p2, bullet 2 (and GCC extensi...
bool isSentinelNullExpr(const Expr *E)
uint64_t getCharWidth() const
Return the size of the character type, in bits.
QualType getBitIntType(bool Unsigned, unsigned NumBits) const
Return a bit-precise integer type with the specified signedness and bit count.
AddrLabelExpr - The GNU address of label extension, representing &&label.
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
SourceLocation getExprLoc() const LLVM_READONLY
Wrapper for source info for arrays.
Represents an array type, per C99 6.7.5.2 - Array Declarators.
ArraySizeModifier getSizeModifier() const
QualType getElementType() const
AsTypeExpr - Clang builtin function __builtin_astype [OpenCL 6.2.4.2] This AST node provides support ...
Attr - This represents one attribute.
SourceRange getRange() const
static Kind getNullabilityAttrKind(NullabilityKind kind)
Retrieve the attribute kind corresponding to the given nullability kind.
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
One specifier in an @available expression.
StringRef getPlatform() const
VersionTuple getVersion() const
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
A builtin binary operation expression such as "x + y" or "x <= y".
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)
Retrieve the overloaded operator kind that corresponds to the given binary opcode.
static bool isComparisonOp(Opcode Opc)
bool isComparisonOp() const
StringRef getOpcodeStr() const
bool isRelationalOp() const
SourceLocation getOperatorLoc() const
bool isCompoundAssignmentOp() const
bool isMultiplicativeOp() const
static StringRef getOpcodeStr(Opcode Op)
getOpcodeStr - Turn an Opcode enum value into the punctuation char it corresponds to,...
bool isEqualityOp() const
static BinaryOperator * Create(const ASTContext &C, Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy, ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc, FPOptionsOverride FPFeatures)
bool isAdditiveOp() const
static bool isNullPointerArithmeticExtension(ASTContext &Ctx, Opcode Opc, const Expr *LHS, const Expr *RHS)
Return true if a binary operator using the specified opcode and operands would match the 'p = (i8*)nu...
bool isAssignmentOp() const
static Opcode getOverloadedOpcode(OverloadedOperatorKind OO)
Retrieve the binary opcode that corresponds to the given overloaded operator.
static bool isBitwiseOp(Opcode Opc)
A binding in a decomposition declaration.
A class which contains all the information about a particular captured value.
Represents a block literal declaration, which is like an unnamed FunctionDecl.
void setParams(ArrayRef< ParmVarDecl * > NewParamInfo)
void setSignatureAsWritten(TypeSourceInfo *Sig)
void setBlockMissingReturnType(bool val=true)
void setIsVariadic(bool value)
SourceLocation getCaretLocation() const
void setBody(CompoundStmt *B)
ArrayRef< ParmVarDecl * > parameters() const
void setCaptures(ASTContext &Context, ArrayRef< Capture > Captures, bool CapturesCXXThis)
static BlockDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L)
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
This class is used for builtin types like 'int'.
bool hasPtrArgsOrResult(unsigned ID) const
Determines whether this builtin has a result or any arguments which are pointer types.
llvm::StringRef getName(unsigned ID) const
Return the identifier name for the specified builtin, e.g.
bool hasCustomTypechecking(unsigned ID) const
Determines whether this builtin has custom typechecking.
bool isInStdNamespace(unsigned ID) const
Determines whether this builtin is a C++ standard library function that lives in (possibly-versioned)...
bool isDirectlyAddressable(unsigned ID) const
Determines whether this builtin can have its address taken with no special action required.
static CUDAKernelCallExpr * Create(const ASTContext &Ctx, Expr *Fn, CallExpr *Config, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation RP, FPOptionsOverride FPFeatures, unsigned MinNumArgs=0)
Represents a path from a specific derived class (which is not represented as part of the path) to a p...
BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases...
Represents a call to a C++ constructor.
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
Represents a C++ constructor within a class.
Represents a C++ conversion function within a class.
bool isLambdaToBlockPointerConversion() const
Determine whether this conversion function is a conversion from a lambda closure type to a block poin...
Represents a C++ base or member initializer.
A default argument (C++ [dcl.fct.default]).
static CXXDefaultArgExpr * Create(const ASTContext &C, SourceLocation Loc, ParmVarDecl *Param, Expr *RewrittenExpr, DeclContext *UsedContext)
A use of a default initializer in a constructor or in aggregate initialization.
static CXXDefaultInitExpr * Create(const ASTContext &Ctx, SourceLocation Loc, FieldDecl *Field, DeclContext *UsedContext, Expr *RewrittenInitExpr)
Field is the non-static data member whose default initializer is used by this expression.
Expr * getExpr()
Get the initialization expression that will be used.
static CXXDependentScopeMemberExpr * Create(const ASTContext &Ctx, Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs)
Represents a C++ destructor within a class.
Represents a static or instance method of a struct/union/class.
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
CXXMethodDecl * getDevirtualizedMethod(const Expr *Base, bool IsAppleKext)
If it's possible to devirtualize a call to this method, return the called function.
A call to an overloaded operator written using operator syntax.
SourceLocation getOperatorLoc() const
Returns the location of the operator symbol in the expression.
SourceRange getSourceRange() const
Represents a C++ struct/union/class.
bool isStandardLayout() const
Determine whether this class is standard-layout per C++ [class]p7.
bool hasAnyDependentBases() const
Determine whether this class has any dependent base classes which are not the current instantiation.
unsigned getNumBases() const
Retrieves the number of base classes of this class.
const CXXRecordDecl * getTemplateInstantiationPattern() const
Retrieve the record declaration from which this record could be instantiated.
bool hasDefinition() const
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
bool isDerivedFrom(const CXXRecordDecl *Base) const
Determine whether this class is derived from the class Base.
Represents a C++ nested-name-specifier or a global scope specifier.
bool isValid() const
A scope specifier is present, and it refers to a real scope.
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
SourceRange getRange() const
SourceLocation getBeginLoc() const
bool isSet() const
Deprecated.
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context.
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
bool isInvalid() const
An error occurred during parsing of the scope specifier.
bool isEmpty() const
No scope specifier.
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
Represents the this expression in C++.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
void setArg(unsigned Arg, Expr *ArgExpr)
setArg - Set the specified argument.
static CallExpr * Create(const ASTContext &Ctx, Expr *Fn, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation RParenLoc, FPOptionsOverride FPFeatures, unsigned MinNumArgs=0, ADLCallKind UsesADL=NotADL)
Create a call expression.
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return null.
void computeDependence()
Compute and set dependence bits.
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
Expr ** getArgs()
Retrieve the call arguments.
void setNumArgsUnsafe(unsigned NewNumArgs)
Bluntly set a new number of arguments without doing any checks whatsoever.
void shrinkNumArgs(unsigned NewNumArgs)
Reduce the number of arguments in this call expression.
QualType withConst() const
Retrieves a version of this type with const applied.
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
CastKind getCastKind() const
const char * getCastKindName() const
CharLiteralParser - Perform interpretation and semantic analysis of a character literal.
Represents a character-granular source range.
static CharSourceRange getCharRange(SourceRange R)
static CharSourceRange getTokenRange(SourceRange R)
CharUnits - This is an opaque type for sizes expressed in character units.
bool isZero() const
isZero - Test whether the quantity equals zero.
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
unsigned getValue() const
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
void mergeFrom(CleanupInfo Rhs)
void setExprNeedsCleanups(bool SideEffects)
bool cleanupsHaveSideEffects() const
bool exprNeedsCleanups() const
Complex values, per C99 6.2.5p11.
QualType getElementType() const
static CompoundAssignOperator * Create(const ASTContext &C, Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy, ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc, FPOptionsOverride FPFeatures, QualType CompLHSType=QualType(), QualType CompResultType=QualType())
CompoundLiteralExpr - [C99 6.5.2.5].
CompoundStmt - This represents a group of statements like { stmt stmt }.
Stmt * getStmtExprResult()
ConditionalOperator - The ?: ternary operator.
Represents the canonical version of C arrays with a specified constant size.
llvm::APInt getSize() const
Return the constant array size as an APInt.
uint64_t getZExtSize() const
Return the size zero-extended as a uint64_t.
ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluatin...
static ConstantResultStorageKind getStorageKind(const APValue &Value)
void MoveIntoResult(APValue &Value, const ASTContext &Context)
SourceLocation getBeginLoc() const LLVM_READONLY
static ConstantExpr * Create(const ASTContext &Context, Expr *E, const APValue &Result)
bool isImmediateInvocation() const
Represents a concrete matrix type with constant number of rows and columns.
unsigned getNumColumns() const
Returns the number of columns in the matrix.
unsigned getNumRows() const
Returns the number of rows in the matrix.
The result of a constraint satisfaction check, containing the necessary information to diagnose an un...
ConvertVectorExpr - Clang builtin function __builtin_convertvector This AST node provides support for...
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
void setTypoName(const IdentifierInfo *II)
void setTypoNNS(NestedNameSpecifier *NNS)
Wrapper for source info for pointers decayed from arrays and functions.
A POD class for pairing a NamedDecl* with an access specifier.
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
The results of name lookup within a DeclContext.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC.
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
const BlockDecl * getInnermostBlockDecl() const
Return this DeclContext if it is a BlockDecl.
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
void addDecl(Decl *D)
Add the declaration D into this context.
bool containsDecl(Decl *D) const
Checks whether a declaration is in this context.
RecordDecl * getOuterLexicalRecordContext()
Retrieve the outermost lexically enclosing record context.
bool isFunctionOrMethod() const
DeclContext * getLookupParent()
Find the parent context of this context that will be used for unqualified name lookup.
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
A reference to a declared variable, function, enum, etc.
NamedDecl * getFoundDecl()
Get the NamedDecl through which this reference occurred.
bool hasExplicitTemplateArgs() const
Determines whether this declaration reference was followed by an explicit template argument list.
bool refersToEnclosingVariableOrCapture() const
Does this DeclRefExpr refer to an enclosing local or a captured variable?
void setDecl(ValueDecl *NewD)
void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const
Copies the template arguments (if present) into the given structure.
SourceLocation getBeginLoc() const LLVM_READONLY
DeclarationNameInfo getNameInfo() const
SourceLocation getTemplateKeywordLoc() const
Retrieve the location of the template keyword preceding this name, if any.
static DeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, QualType T, ExprValueKind VK, NamedDecl *FoundD=nullptr, const TemplateArgumentListInfo *TemplateArgs=nullptr, NonOdrUseReason NOUR=NOUR_None)
bool hasQualifier() const
Determine whether this declaration reference was preceded by a C++ nested-name-specifier,...
NestedNameSpecifierLoc getQualifierLoc() const
If the name was qualified, retrieves the nested-name-specifier that precedes the name,...
SourceLocation getLocation() const
NestedNameSpecifier * getQualifier() const
If the name was qualified, retrieves the nested-name-specifier that precedes the name.
Decl - This represents one declaration (or definition), e.g.
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
AvailabilityResult getAvailability(std::string *Message=nullptr, VersionTuple EnclosingVersion=VersionTuple(), StringRef *RealizedPlatform=nullptr) const
Determine the availability of the given declaration.
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
void markUsed(ASTContext &C)
Mark the declaration used, in the sense of odr-use.
bool isInvalidDecl() const
SourceLocation getLocation() const
void setReferenced(bool R=true)
bool isDefinedOutsideFunctionOrMethod() const
isDefinedOutsideFunctionOrMethod - This predicate returns true if this scoped decl is defined outside...
DeclContext * getDeclContext()
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
The name of a declaration.
IdentifierInfo * getAsIdentifierInfo() const
Retrieve the IdentifierInfo * stored in this declaration name, or null if this declaration name isn't...
bool isDependentName() const
Determines whether the name itself is dependent, e.g., because it involves a C++ type that is itself ...
std::string getAsString() const
Retrieve the human-readable string for this name.
@ CXXConversionFunctionName
bool isIdentifier() const
Predicate functions for querying what type of name this is.
SourceLocation getBeginLoc() const LLVM_READONLY
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier (with source-location information) that qualifies the name of this...
TypeSourceInfo * getTypeSourceInfo() const
Information about one declarator, including the parsed type information and the identifier.
DeclaratorContext getContext() const
SourceLocation getBeginLoc() const LLVM_READONLY
bool isInvalidType() const
const IdentifierInfo * getIdentifier() const
static DependentScopeDeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
bool getSuppressSystemWarnings() const
void setElaboratedKeywordLoc(SourceLocation Loc)
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
RAII object that enters a new expression evaluation context.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
EnumDecl * getDecl() const
ExplicitCastExpr - An explicit cast written in the source code.
QualType getTypeAsWritten() const
getTypeAsWritten - Returns the type that this expression is casting to, as written in the source code...
static ExprWithCleanups * Create(const ASTContext &C, EmptyShell empty, unsigned numObjects)
This represents one expression.
bool EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer,...
Expr * IgnoreParenNoopCasts(const ASTContext &Ctx) LLVM_READONLY
Skip past any parentheses and casts which do not change the value (including ptr->int casts of the sa...
isModifiableLvalueResult isModifiableLvalue(ASTContext &Ctx, SourceLocation *Loc=nullptr) const
isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type, does not have an incomplet...
static QualType findBoundMemberType(const Expr *expr)
Given an expression of bound-member type, find the type of the member.
llvm::APSInt EvaluateKnownConstIntCheckOverflow(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
Expr * IgnoreParenCasts() LLVM_READONLY
Skip past any parentheses and casts which might surround this expression until reaching a fixed point...
LValueClassification ClassifyLValue(ASTContext &Ctx) const
Reasons why an expression might not be an l-value.
bool isValueDependent() const
Determines whether the value of this expression depends on.
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
bool containsUnexpandedParameterPack() const
Whether this expression contains an unexpanded parameter pack (for C++11 variadic templates).
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Expr * IgnoreImplicit() LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.
Expr * IgnoreConversionOperatorSingleStep() LLVM_READONLY
Skip conversion operators.
bool containsErrors() const
Whether this expression contains subexpressions which had errors, e.g.
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language.
static bool hasAnyTypeDependentArguments(ArrayRef< Expr * > Exprs)
hasAnyTypeDependentArguments - Determines if any of the expressions in Exprs is type-dependent.
@ NPC_ValueDependentIsNull
Specifies that a value-dependent expression of integral or dependent type should be considered a null...
@ NPC_NeverValueDependent
Specifies that the expression should never be value-dependent.
@ NPC_ValueDependentIsNotNull
Specifies that a value-dependent expression should be considered to never be a null pointer constant.
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...
bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const
HasSideEffects - This routine returns true for all those expressions which have any effect other than...
bool EvaluateAsConstantExpr(EvalResult &Result, const ASTContext &Ctx, ConstantExprKind Kind=ConstantExprKind::Normal) const
Evaluate an expression that is required to be a constant expression.
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on.
bool isIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
Expr * IgnoreImpCasts() LLVM_READONLY
Skip past any implicit casts which might surround this expression until reaching a fixed point.
NullPointerConstantKind
Enumeration used to describe the kind of Null pointer constant returned from isNullPointerConstant().
@ NPCK_ZeroExpression
Expression is a Null pointer constant built from a zero integer expression that is not a simple,...
@ NPCK_ZeroLiteral
Expression is a Null pointer constant built from a literal zero.
@ NPCK_CXX11_nullptr
Expression is a C++11 nullptr.
@ NPCK_NotNull
Expression is not a Null pointer constant.
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant.
QualType getEnumCoercedType(const ASTContext &Ctx) const
If this expression is an enumeration constant, return the enumeration type under which said constant ...
void setValueKind(ExprValueKind Cat)
setValueKind - Set the value kind produced by this expression.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
static bool isSameComparisonOperand(const Expr *E1, const Expr *E2)
Checks that the two Expr's will refer to the same value as a comparison operand.
void setObjectKind(ExprObjectKind Cat)
setObjectKind - Set the object kind produced by this expression.
std::optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.
bool refersToBitField() const
Returns true if this expression is a gl-value that potentially refers to a bit-field.
@ MLV_DuplicateVectorComponents
@ MLV_InvalidMessageExpression
@ MLV_ConstQualifiedField
@ MLV_SubObjCPropertySetting
bool isOrdinaryOrBitFieldObject() const
bool hasPlaceholderType() const
Returns whether this expression has a placeholder type.
static ExprValueKind getValueKindForType(QualType T)
getValueKindForType - Given a formal return or parameter type, give its value kind.
bool isKnownToHaveBooleanValue(bool Semantic=true) const
isKnownToHaveBooleanValue - Return true if this is an integer expression that is known to return 0 or...
ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the ...
ExtVectorType - Extended vector type.
Represents difference between two FPOptions values.
bool isFPConstrained() const
Represents a member of a struct/union/class.
bool isBitField() const
Determines whether this field is a bitfield.
bool hasInClassInitializer() const
Determine whether this member has a C++11 default member initializer.
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined.
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
static FixedPointLiteral * CreateFromRawInt(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l, unsigned Scale)
static FloatingLiteral * Create(const ASTContext &C, const llvm::APFloat &V, bool isexact, QualType Type, SourceLocation L)
FullExpr - Represents a "full-expression" node.
const Expr * getSubExpr() const
bool ValidateCandidate(const TypoCorrection &candidate) override
Simple predicate used by the default RankCandidate to determine whether to return an edit distance of...
Represents a function declaration or definition.
const ParmVarDecl * getParamDecl(unsigned i) const
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to call this function.
bool isImmediateFunction() const
SourceRange getReturnTypeSourceRange() const
Attempt to compute an informative source range covering the function return type.
unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const
Returns a value indicating whether this function corresponds to a builtin function.
bool hasCXXExplicitFunctionObjectParameter() const
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
QualType getReturnType() const
ArrayRef< ParmVarDecl * > parameters() const
bool hasPrototype() const
Whether this function has a prototype, either because one was explicitly written or because it was "i...
bool isExternC() const
Determines whether this function is a function with external, C linkage.
static FunctionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation NLoc, DeclarationName N, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin=false, bool isInlineSpecified=false, bool hasWrittenPrototype=true, ConstexprSpecKind ConstexprKind=ConstexprSpecKind::Unspecified, Expr *TrailingRequiresClause=nullptr)
bool isOverloadedOperator() const
Whether this function declaration represents an C++ overloaded operator, e.g., "operator+".
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any.
size_t param_size() const
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body.
SourceRange getParametersSourceRange() const
Attempt to compute an informative source range covering the function parameters, including the ellips...
QualType getCallResultType() const
Determine the type of an expression that calls this function.
Represents a reference to a function parameter pack or init-capture pack that has been substituted bu...
SourceLocation getParameterPackLocation() const
Get the location of the parameter pack.
Represents a prototype with parameter type info, e.g.
ExtParameterInfo getExtParameterInfo(unsigned I) const
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
bool isParamConsumed(unsigned I) const
unsigned getNumParams() const
QualType getParamType(unsigned i) const
bool isVariadic() const
Whether this function prototype is variadic.
ExtProtoInfo getExtProtoInfo() const
ArrayRef< QualType > getParamTypes() const
ArrayRef< QualType > param_types() const
Declaration of a template function.
unsigned getNumParams() const
ParmVarDecl * getParam(unsigned i) const
SourceLocation getLocalRangeEnd() const
TypeLoc getReturnLoc() const
SourceLocation getLocalRangeBegin() const
A class which abstracts out some details necessary for making a call.
bool getCmseNSCall() const
ExtInfo withNoReturn(bool noReturn) const
FunctionType - C99 6.7.5.3 - Function Declarators.
ExtInfo getExtInfo() const
bool getNoReturnAttr() const
Determine whether this function type includes the GNU noreturn attribute.
QualType getReturnType() const
bool getCmseNSCallAttr() const
QualType getCallResultType(const ASTContext &Context) const
Determine the type of an expression that calls a function of this type.
GNUNullExpr - Implements the GNU __null extension, which is a name for a null pointer constant that h...
static GenericSelectionExpr * Create(const ASTContext &Context, SourceLocation GenericLoc, Expr *ControllingExpr, ArrayRef< TypeSourceInfo * > AssocTypes, ArrayRef< Expr * > AssocExprs, SourceLocation DefaultLoc, SourceLocation RParenLoc, bool ContainsUnexpandedParameterPack, unsigned ResultIndex)
Create a non-result-dependent generic selection expression accepting an expression predicate.
One of these records is kept for each identifier that is lexed.
tok::TokenKind getTokenID() const
If this is a source-language token (e.g.
bool isEditorPlaceholder() const
Return true if this identifier is an editor placeholder.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
ImaginaryLiteral - We support imaginary integer and floating point literals, like "1....
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat, FPOptionsOverride FPO)
ImplicitConversionSequence - Represents an implicit conversion sequence, which may be a standard conv...
Represents a field injected from an anonymous union/struct into the parent scope.
Describes an C or C++ initializer list.
Describes the kind of initialization being performed, along with location information for tokens rela...
static InitializationKind CreateCopy(SourceLocation InitLoc, SourceLocation EqualLoc, bool AllowExplicitConvs=false)
Create a copy initialization.
static InitializationKind CreateDirectList(SourceLocation InitLoc)
static InitializationKind CreateCStyleCast(SourceLocation StartLoc, SourceRange TypeRange, bool InitList)
Create a direct initialization for a C-style cast.
Describes the sequence of initializations required to initialize a given object or reference with a s...
ExprResult Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType=nullptr)
Perform the actual initialization of the given entity based on the computed initialization sequence.
Describes an entity that is being initialized.
void setParameterCFAudited()
static InitializedEntity InitializeStmtExprResult(SourceLocation ReturnLoc, QualType Type)
static InitializedEntity InitializeTemporary(QualType Type)
Create the initialization entity for a temporary.
static InitializedEntity InitializeBlock(SourceLocation BlockVarLoc, QualType Type)
static InitializedEntity InitializeParameter(ASTContext &Context, ParmVarDecl *Parm)
Create the initialization entity for a parameter.
static InitializedEntity InitializeCompoundLiteralInit(TypeSourceInfo *TSI)
Create the entity for a compound literal initializer.
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
Represents the declaration of a label.
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
CXXMethodDecl * getCallOperator() const
Retrieve the function call operator associated with this lambda expression.
FPEvalMethodKind
Possible float expression evaluation method choices.
@ FEM_Extended
Use extended type for fp arithmetic.
@ FEM_Double
Use the type double for fp arithmetic.
@ FEM_UnsetOnCommandLine
Used only for FE option processing; this is only used to indicate that the user did not specify an ex...
@ FEM_Source
Use the declared type for fp arithmetic.
@ None
Permit no implicit vector bitcasts.
@ Integer
Permit vector bitcasts between integer vectors with different numbers of elements but the same total ...
@ All
Permit vector bitcasts between all vectors with the same total bit-width.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
clang::ObjCRuntime ObjCRuntime
bool isSubscriptPointerArithmetic() const
bool isSignedOverflowDefined() const
unsigned getOpenCLCompatibleVersion() const
Return the OpenCL version that kernel language is compatible with.
static StringRef getSourceText(CharSourceRange Range, const SourceManager &SM, const LangOptions &LangOpts, bool *Invalid=nullptr)
Returns a string for the source that the range encompasses.
static SourceLocation AdvanceToTokenCharacter(SourceLocation TokStart, unsigned Characters, const SourceManager &SM, const LangOptions &LangOpts)
AdvanceToTokenCharacter - If the current SourceLocation specifies a location at the start of a token,...
static std::string Stringify(StringRef Str, bool Charify=false)
Stringify - Convert the specified string into a C string by i) escaping '\' and " characters and ii) ...
Represents the results of name lookup.
@ NotFoundInCurrentInstantiation
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
LLVM_ATTRIBUTE_REINITIALIZES void clear()
Clears out any current state.
DeclClass * getAsSingle() const
void addDecl(NamedDecl *D)
Add a declaration to these results with its natural access.
void setLookupName(DeclarationName Name)
Sets the name to look up.
bool empty() const
Return true if no decls were found.
void resolveKind()
Resolves the result kind of the lookup, possibly hiding decls.
SourceLocation getNameLoc() const
Gets the location of the identifier.
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
CXXRecordDecl * getNamingClass() const
Returns the 'naming class' for this lookup, i.e.
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
void setNamingClass(CXXRecordDecl *Record)
Sets the 'naming class' for this lookup.
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
LookupResultKind getResultKind() const
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
DeclarationName getLookupName() const
Gets the name to look up.
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
MS property subscript expression.
Keeps track of the mangled names of lambda expressions and block literals within a particular context...
virtual unsigned getManglingNumber(const CXXMethodDecl *CallOperator)=0
Retrieve the mangling number of a new lambda expression with the given call operator within this cont...
MatrixSubscriptExpr - Matrix subscript expression for the MatrixType extension.
Represents a matrix type, as defined in the Matrix Types clang extensions.
QualType getElementType() const
Returns type of the elements being stored in the matrix.
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
SourceLocation getMemberLoc() const
getMemberLoc - Return the location of the "member", in X->F, it is the location of 'F'.
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
static MemberExpr * Create(const ASTContext &C, Expr *Base, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *MemberDecl, DeclAccessPair FoundDecl, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs, QualType T, ExprValueKind VK, ExprObjectKind OK, NonOdrUseReason NOUR)
bool performsVirtualDispatch(const LangOptions &LO) const
Returns true if virtual dispatch is performed.
SourceLocation getBeginLoc() const LLVM_READONLY
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
This represents a decl that may have a name.
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
std::string getQualifiedNameAsString() const
Linkage getFormalLinkage() const
Get the linkage from a semantic point of view.
bool isExternallyVisible() const
bool isCXXClassMember() const
Determine whether this declaration is a C++ class member.
Represent a C++ namespace.
A C++ nested-name-specifier augmented with source location information.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, const IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
NumericLiteralParser - This performs strict semantic analysis of the content of a ppnumber,...
A runtime availability query.
ObjCBoolLiteralExpr - Objective-C Boolean Literal.
Represents an ObjC class declaration.
ObjCIvarDecl * lookupInstanceVariable(IdentifierInfo *IVarName, ObjCInterfaceDecl *&ClassDeclared)
bool hasDefinition() const
Determine whether this class has been defined.
ivar_iterator ivar_begin() const
ObjCInterfaceDecl * getSuperClass() const
Interfaces are the core concept in Objective-C for object oriented design.
ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC 'id' type.
ObjCIvarDecl - Represents an ObjC instance variable.
AccessControl getAccessControl() const
QualType getUsageType(QualType objectType) const
Retrieve the type of this instance variable when viewed as a member of a specific object type.
ObjCIvarRefExpr - A reference to an ObjC instance variable.
SourceLocation getBeginLoc() const LLVM_READONLY
SourceLocation getLocation() const
SourceLocation getOpLoc() const
SourceLocation getEndLoc() const LLVM_READONLY
const Expr * getBase() const
An expression that sends a message to the given Objective-C object or class.
const ObjCMethodDecl * getMethodDecl() const
ObjCMethodDecl - Represents an instance or class method declaration.
ImplicitParamDecl * getSelfDecl() const
ArrayRef< ParmVarDecl * > parameters() const
bool isInstanceMethod() const
ObjCMethodFamily getMethodFamily() const
Determines the family of this method.
QualType getReturnType() const
bool isClassMethod() const
ObjCInterfaceDecl * getClassInterface()
Represents a pointer to an Objective C object.
bool isObjCQualifiedIdType() const
True if this is equivalent to 'id.
bool isObjCIdType() const
True if this is equivalent to the 'id' type, i.e.
ObjCInterfaceDecl * getInterfaceDecl() const
If this pointer points to an Objective @interface type, gets the declaration for that interface.
const ObjCInterfaceType * getInterfaceType() const
If this pointer points to an Objective C @interface type, gets the type for that interface.
Represents a class type in Objective C.
Represents one property declaration in an Objective-C interface.
static ObjCPropertyDecl * findPropertyDecl(const DeclContext *DC, const IdentifierInfo *propertyID, ObjCPropertyQueryKind queryKind)
Lookup a property by name in the specified DeclContext.
Represents an Objective-C protocol declaration.
bool allowsSizeofAlignof() const
Does this runtime allow sizeof or alignof on object types?
bool allowsPointerArithmetic() const
Does this runtime allow pointer arithmetic on objects?
static OffsetOfExpr * Create(const ASTContext &C, QualType type, SourceLocation OperatorLoc, TypeSourceInfo *tsi, ArrayRef< OffsetOfNode > comps, ArrayRef< Expr * > exprs, SourceLocation RParenLoc)
Helper class for OffsetOfExpr.
void * getAsOpaquePtr() const
static OpaquePtr getFromOpaquePtr(void *P)
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
bool isAvailableOption(llvm::StringRef Ext, const LangOptions &LO) const
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13....
@ CSK_Normal
Normal lookup.
SmallVectorImpl< OverloadCandidate >::iterator iterator
OverloadingResult BestViableFunction(Sema &S, SourceLocation Loc, OverloadCandidateSet::iterator &Best)
Find the best viable function on this overload set, if it exists.
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr.
static FindResult find(Expr *E)
Finds the overloaded expression in the given expression E of OverloadTy.
ParenExpr - This represents a parethesized expression, e.g.
SourceLocation getBeginLoc() const LLVM_READONLY
const Expr * getSubExpr() const
Expr * getExpr(unsigned Init)
static ParenListExpr * Create(const ASTContext &Ctx, SourceLocation LParenLoc, ArrayRef< Expr * > Exprs, SourceLocation RParenLoc)
Create a paren list.
unsigned getNumExprs() const
Return the number of expressions in this paren list.
SourceLocation getLParenLoc() const
SourceLocation getRParenLoc() const
Represents a parameter to a function.
bool hasUnparsedDefaultArg() const
Determines whether this parameter has a default argument that has not yet been parsed.
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
bool hasUninstantiatedDefaultArg() const
QualType getOriginalType() const
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
bool hasDefaultArg() const
Determines whether this parameter has a default argument, either parsed or not.
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
static PredefinedExpr * Create(const ASTContext &Ctx, SourceLocation L, QualType FNTy, PredefinedIdentKind IK, bool IsTransparent, StringLiteral *SL)
Create a PredefinedExpr.
static std::string ComputeName(PredefinedIdentKind IK, const Decl *CurrentDecl, bool ForceElaboratedPrinting=false)
SourceLocation getLastFPEvalPragmaLocation() const
void CreateString(StringRef Str, Token &Tok, SourceLocation ExpansionLocStart=SourceLocation(), SourceLocation ExpansionLocEnd=SourceLocation())
Plop the specified string into a scratch buffer and set the specified token's location and length to ...
LangOptions::FPEvalMethodKind getCurrentFPEvalMethod() const
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
SourceManager & getSourceManager() const
bool isMacroDefined(StringRef Id)
const TargetInfo & getTargetInfo() const
char getSpellingOfSingleCharacterNumericConstant(const Token &Tok, bool *Invalid=nullptr) const
Given a Token Tok that is a numeric constant with length 1, return the character.
StringRef getSpelling(SourceLocation loc, SmallVectorImpl< char > &buffer, bool *invalid=nullptr) const
Return the 'spelling' of the token at the given location; does not go up to the spelling location or ...
bool isCodeCompletionEnabled() const
Determine if we are performing code completion.
IdentifierTable & getIdentifierTable()
const LangOptions & getLangOpts() const
DiagnosticsEngine & getDiagnostics() const
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Computes the source location just past the end of the token at this source location.
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const
Forwarding function for diagnostics.
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
bool hasQualifiers() const
Determine whether this type has any qualifiers.
bool hasNonTrivialToPrimitiveCopyCUnion() const
Check if this is or contains a C union that is non-trivial to copy, which is a union that has a membe...
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type.
bool isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const
QualType withConst() const
void addConst()
Add the const type qualifier to this QualType.
bool isAtLeastAsQualifiedAs(QualType Other) const
Determine whether this type is at least as qualified as the other given type, requiring exact equalit...
bool isNull() const
Return true if this QualType doesn't point to a type yet.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
LangAS getAddressSpace() const
Return the address space of this type.
bool hasNonTrivialToPrimitiveDestructCUnion() const
Check if this is or contains a C union that is non-trivial to destruct, which is a union that has a m...
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
bool isAddressSpaceOverlapping(QualType T) const
Returns true if address space qualifiers overlap with T address space qualifiers.
bool isCXX98PODType(const ASTContext &Context) const
Return true if this is a POD type according to the rules of the C++98 standard, regardless of the cur...
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
QualType getCanonicalType() const
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
bool isWebAssemblyReferenceType() const
Returns true if it is a WebAssembly Reference Type.
QualType withCVRQualifiers(unsigned CVR) const
bool isCForbiddenLValueType() const
Determine whether expressions of the given type are forbidden from being lvalues in C.
bool isConstQualified() const
Determine whether this type is const-qualified.
bool hasAddressSpace() const
Check if this type has any address space qualifier.
QualType getAtomicUnqualifiedType() const
Remove all qualifiers including _Atomic.
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after.
QualType getSingleStepDesugaredType(const ASTContext &Context) const
Return the specified type with one level of "sugar" removed from the type.
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
Qualifiers getLocalQualifiers() const
Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...
bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const
Check if this is or contains a C union that is non-trivial to default-initialize, which is a union th...
The collection of all-type qualifiers we support.
unsigned getCVRQualifiers() const
void removeCVRQualifiers(unsigned mask)
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
@ OCL_Weak
Reading or writing from this object requires a barrier call.
@ OCL_Autoreleasing
Assigning into this object requires a lifetime extension.
void removeObjCLifetime()
void removeAddressSpace()
void setAddressSpace(LangAS space)
static bool isAddressSpaceSupersetOf(LangAS A, LangAS B)
Returns true if address space A is equal to or a superset of B.
ObjCLifetime getObjCLifetime() const
Qualifiers withoutObjCLifetime() const
Qualifiers withoutObjCGCAttr() const
bool compatiblyIncludes(Qualifiers other) const
Determines if these qualifiers compatibly include another set.
LangAS getAddressSpace() const
bool compatiblyIncludesObjCLifetime(Qualifiers other) const
Determines if these qualifiers compatibly include another set of qualifiers from the narrow perspecti...
Represents a struct/union/class.
field_range fields() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
RecordDecl * getDecl() const
static RecoveryExpr * Create(ASTContext &Ctx, QualType T, SourceLocation BeginLoc, SourceLocation EndLoc, ArrayRef< Expr * > SubExprs)
A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Base for LValueReferenceType and RValueReferenceType.
Scope - A scope is a transient data structure that is used while parsing the program.
unsigned getFlags() const
getFlags - Return the flags for this scope.
@ ContinueScope
This is a while, do, for, which can have continue statements embedded into it.
@ ControlScope
The controlling scope in a if/switch/while/for statement.
@ BreakScope
This is a while, do, switch, for, etc that can have break statements embedded into it.
@ DeclScope
This is a scope that can contain a declaration.
Smart pointer class that efficiently represents Objective-C method names.
StringRef getNameForSlot(unsigned argIndex) const
Retrieve the name at a given position in the selector.
bool isUnarySelector() const
A generic diagnostic builder for errors which may or may not be deferred.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
void RecordImplicitHostDeviceFuncUsedByDevice(const FunctionDecl *FD)
Record FD if it is a CUDA/HIP implicit host device function used on device side in device compilation...
CUDAFunctionTarget IdentifyTarget(const FunctionDecl *D, bool IgnoreImplicitHDAttr=false)
Determines whether the given function is a CUDA device/host/kernel/etc.
bool CheckCall(SourceLocation Loc, FunctionDecl *Callee)
Check whether we're allowed to call Callee from the current context.
@ CVT_Host
Emitted on device side with a shadow variable on host side.
ExprResult ActOnArraySectionExpr(Expr *Base, SourceLocation LBLoc, Expr *LowerBound, SourceLocation ColonLocFirst, Expr *Length, SourceLocation RBLoc)
Checks and creates an Array Section used in an OpenACC construct/clause.
ExprResult ActOnOpenMPCall(ExprResult Call, Scope *Scope, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig)
Given the potential call expression Call, determine if there is a specialization via the OpenMP decla...
void tryCaptureOpenMPLambdas(ValueDecl *V)
Function tries to capture lambda's captured variables in the OpenMP region before the original lambda...
OpenMPClauseKind isOpenMPPrivateDecl(ValueDecl *D, unsigned Level, unsigned CapLevel) const
Check if the specified variable is used in 'private' clause.
VarDecl * isOpenMPCapturedDecl(ValueDecl *D, bool CheckScopeInfo=false, unsigned StopAt=0)
Check if the specified variable is used in one of the private clauses (private, firstprivate,...
ExprResult ActOnOMPArraySectionExpr(Expr *Base, SourceLocation LBLoc, Expr *LowerBound, SourceLocation ColonLocFirst, SourceLocation ColonLocSecond, Expr *Length, Expr *Stride, SourceLocation RBLoc)
bool isOpenMPCapturedByRef(const ValueDecl *D, unsigned Level, unsigned OpenMPCaptureLevel) const
Return true if the provided declaration VD should be captured by reference.
bool isOpenMPTargetCapturedDecl(const ValueDecl *D, unsigned Level, unsigned CaptureLevel) const
Check if the specified variable is captured by 'target' directive.
bool isOpenMPGlobalCapturedDecl(ValueDecl *D, unsigned Level, unsigned CaptureLevel) const
Check if the specified global variable must be captured by outer capture regions.
bool isInOpenMPDeclareTargetContext() const
Return true inside OpenMP declare target region.
void checkDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D, SourceLocation IdLoc=SourceLocation())
Check declaration inside target region.
const ValueDecl * getOpenMPDeclareMapperVarName() const
RAII object used to temporarily allow the C++ 'this' expression to be used, with the given qualifiers...
RAII class used to indicate that we are performing provisional semantic analysis to determine the val...
Abstract base class used for diagnosing integer constant expression violations.
virtual SemaDiagnosticBuilder diagnoseNotICE(Sema &S, SourceLocation Loc)=0
virtual SemaDiagnosticBuilder diagnoseNotICEType(Sema &S, SourceLocation Loc, QualType T)
virtual SemaDiagnosticBuilder diagnoseFold(Sema &S, SourceLocation Loc)
Sema - This implements semantic analysis and AST building for C.
const FieldDecl * getSelfAssignmentClassMemberCandidate(const ValueDecl *SelfAssigned)
Returns a field in a CXXRecordDecl that has the same name as the decl SelfAssigned when inside a CXXM...
void DefineImplicitLambdaToFunctionPointerConversion(SourceLocation CurrentLoc, CXXConversionDecl *Conv)
Define the "body" of the conversion from a lambda object to a function pointer.
ObjCMethodDecl * LookupMethodInObjectType(Selector Sel, QualType Ty, bool IsInstance)
LookupMethodInType - Look up a method in an ObjCObjectType.
ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo)
Package the given type and TSI into a ParsedType.
QualType getCurrentThisType()
Try to retrieve the type of the 'this' pointer.
std::optional< ExpressionEvaluationContextRecord::InitializationContext > InnermostDeclarationWithDelayedImmediateInvocations() const
SmallVector< CodeSynthesisContext, 16 > CodeSynthesisContexts
List of active code synthesis contexts.
void CheckFloatComparison(SourceLocation Loc, Expr *LHS, Expr *RHS, BinaryOperatorKind Opcode)
Check for comparisons of floating-point values using == and !=.
Scope * getCurScope() const
Retrieve the parser's current scope.
bool DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R, CorrectionCandidateCallback &CCC, TemplateArgumentListInfo *ExplicitTemplateArgs=nullptr, ArrayRef< Expr * > Args=std::nullopt, DeclContext *LookupCtx=nullptr, TypoExpr **Out=nullptr)
Diagnose an empty lookup.
QualType FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
FindCompositeObjCPointerType - Helper method to find composite type of two objective-c pointer types ...
void CheckObjCBridgeRelatedCast(QualType castType, Expr *castExpr)
ExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc, tok::TokenKind Op, Expr *Input, bool IsAfterAmp=false)
bool RequireCompleteSizedExprType(Expr *E, unsigned DiagID, const Ts &...Args)
ExprResult ActOnIntegerConstant(SourceLocation Loc, uint64_t Val)
ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *InputExpr, bool IsAfterAmp=false)
bool isValidRVVBitcast(QualType srcType, QualType destType)
Are the two types RVV-bitcast-compatible types? I.e.
bool isAlwaysConstantEvaluatedContext() const
bool isExternalWithNoLinkageType(const ValueDecl *VD) const
Determine if VD, which must be a variable or function, is an external symbol that nonetheless can't b...
void DiagnoseUnusedParameters(ArrayRef< ParmVarDecl * > Parameters)
Diagnose any unused parameters in the given sequence of ParmVarDecl pointers.
ExprResult IgnoredValueConversions(Expr *E)
IgnoredValueConversions - Given that an expression's result is syntactically ignored,...
bool RequireCompleteSizedType(SourceLocation Loc, QualType T, unsigned DiagID, const Ts &...Args)
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
@ LookupObjCImplicitSelfParam
Look up implicit 'self' parameter of an objective-c method.
@ LookupMemberName
Member name lookup, which finds the names of class/struct/union members.
void DiagnoseSentinelCalls(const NamedDecl *D, SourceLocation Loc, ArrayRef< Expr * > Args)
DiagnoseSentinelCalls - This routine checks whether a call or message-send is to a declaration with t...
ExprResult ActOnConstantExpression(ExprResult Res)
QualType CheckLogicalOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc)
ExprResult ActOnCompoundLiteral(SourceLocation LParenLoc, ParsedType Ty, SourceLocation RParenLoc, Expr *InitExpr)
bool CheckObjCBridgeRelatedConversions(SourceLocation Loc, QualType DestType, QualType SrcType, Expr *&SrcExpr, bool Diagnose=true)
@ NTCUC_LValueToRValueVolatile
ImplicitConversionSequence TryImplicitConversion(Expr *From, QualType ToType, bool SuppressUserConversions, AllowedExplicit AllowExplicit, bool InOverloadResolution, bool CStyle, bool AllowObjCWritebackConversion)
ExprResult BuildLiteralOperatorCall(LookupResult &R, DeclarationNameInfo &SuffixInfo, ArrayRef< Expr * > Args, SourceLocation LitEndLoc, TemplateArgumentListInfo *ExplicitTemplateArgs=nullptr)
BuildLiteralOperatorCall - Build a UserDefinedLiteral by creating a call to a literal operator descri...
bool areVectorTypesSameSize(QualType srcType, QualType destType)
bool isSelfExpr(Expr *RExpr)
Private Helper predicate to check for 'self'.
ExprResult BuildIvarRefExpr(Scope *S, SourceLocation Loc, ObjCIvarDecl *IV)
void DiagnoseAlwaysNonNullPointer(Expr *E, Expr::NullPointerConstantKind NullType, bool IsEqual, SourceRange Range)
Diagnose pointers that are always non-null.
void DefineImplicitMoveAssignment(SourceLocation CurrentLocation, CXXMethodDecl *MethodDecl)
Defines an implicitly-declared move assignment operator.
void DecomposeUnqualifiedId(const UnqualifiedId &Id, TemplateArgumentListInfo &Buffer, DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *&TemplateArgs)
Decomposes the given name into a DeclarationNameInfo, its location, and possibly a list of template a...
bool InstantiateDefaultArgument(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param)
void ActOnStartStmtExpr()
ExprResult CreateOverloadedArraySubscriptExpr(SourceLocation LLoc, SourceLocation RLoc, Expr *Base, MultiExprArg Args)
void WarnOnPendingNoDerefs(ExpressionEvaluationContextRecord &Rec)
Emit a warning for all pending noderef expressions that we recorded.
void ActOnStmtExprError()
DeclResult LookupIvarInObjCMethod(LookupResult &Lookup, Scope *S, IdentifierInfo *II)
The parser has read a name in, and Sema has detected that we're currently inside an ObjC method.
QualType UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, ArithConvKind ACK)
UsualArithmeticConversions - Performs various conversions that are common to binary operators (C99 6....
void CheckPtrComparisonWithNullChar(ExprResult &E, ExprResult &NullE)
NamedDecl * ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II, Scope *S)
ImplicitlyDefineFunction - An undeclared identifier was used in a function call, forming a call to an...
std::unique_ptr< NSAPI > NSAPIObj
Caches identifiers/selectors for NSFoundation APIs.
unsigned CapturingFunctionScopes
Track the number of currently active capturing scopes.
void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl=nullptr, ExpressionEvaluationContextRecord::ExpressionKind Type=ExpressionEvaluationContextRecord::EK_Other)
ObjCMethodDecl * LookupInstanceMethodInGlobalPool(Selector Sel, SourceRange R, bool receiverIdOrClass=false)
LookupInstanceMethodInGlobalPool - Returns the method and warns if there are multiple signatures.
ExprResult CheckBooleanCondition(SourceLocation Loc, Expr *E, bool IsConstexpr=false)
CheckBooleanCondition - Diagnose problems involving the use of the given expression as a boolean cond...
@ Boolean
A boolean condition, from 'if', 'while', 'for', or 'do'.
@ Switch
An integral condition for a 'switch' statement.
@ ConstexprIf
A constant boolean condition from 'if constexpr'.
bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC)
Require that the context specified by SS be complete.
ExprResult ActOnIdExpression(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, UnqualifiedId &Id, bool HasTrailingLParen, bool IsAddressOfOperand, CorrectionCandidateCallback *CCC=nullptr, bool IsInlineAsmIdentifier=false, Token *KeywordReplacement=nullptr)
SmallVector< sema::FunctionScopeInfo *, 4 > FunctionScopes
Stack containing information about each of the nested function, block, and method scopes that are cur...
bool CheckObjCARCUnavailableWeakConversion(QualType castType, QualType ExprType)
PoppedFunctionScopePtr PopFunctionScopeInfo(const sema::AnalysisBasedWarnings::Policy *WP=nullptr, const Decl *D=nullptr, QualType BlockType=QualType())
Pop a function (or block or lambda or captured region) scope from the stack.
Preprocessor & getPreprocessor() const
Scope * getScopeForContext(DeclContext *Ctx)
Determines the active Scope associated with the given declaration context.
QualType GetSignedSizelessVectorType(QualType V)
bool CheckCXXThisCapture(SourceLocation Loc, bool Explicit=false, bool BuildAndDiagnose=true, const unsigned *const FunctionScopeIndexToStopAt=nullptr, bool ByCopy=false)
Make sure the value of 'this' is actually available in the current context, if it is a potentially ev...
llvm::SmallPtrSet< ConstantExpr *, 4 > FailedImmediateInvocations
ExprResult ActOnCharacterConstant(const Token &Tok, Scope *UDLScope=nullptr)
DefaultedComparisonKind getDefaultedComparisonKind(const FunctionDecl *FD)
ExprResult MaybeBindToTemporary(Expr *E)
MaybeBindToTemporary - If the passed in expression has a record type with a non-trivial destructor,...
void CheckCompleteDestructorVariant(SourceLocation CurrentLocation, CXXDestructorDecl *Dtor)
Do semantic checks to allow the complete destructor variant to be emitted when the destructor is defi...
void MarkCaptureUsedInEnclosingContext(ValueDecl *Capture, SourceLocation Loc, unsigned CapturingScopeIndex)
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, AllowFoldKind CanFold=NoFold)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
Expr * BuildBuiltinCallExpr(SourceLocation Loc, Builtin::ID Id, MultiExprArg CallArgs)
BuildBuiltinCallExpr - Create a call to a builtin function specified by Id.
QualType CheckVectorOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign, bool AllowBothBool, bool AllowBoolConversion, bool AllowBoolOperation, bool ReportInvalid)
type checking for vector binary operators.
LiteralOperatorLookupResult LookupLiteralOperator(Scope *S, LookupResult &R, ArrayRef< QualType > ArgTys, bool AllowRaw, bool AllowTemplate, bool AllowStringTemplate, bool DiagnoseMissing, StringLiteral *StringLit=nullptr)
LookupLiteralOperator - Determine which literal operator should be used for a user-defined literal,...
FPOptionsOverride CurFPFeatureOverrides()
bool isValidSveBitcast(QualType srcType, QualType destType)
Are the two types SVE-bitcast-compatible types? I.e.
ExprResult ActOnDependentIdExpression(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, bool isAddressOfOperand, const TemplateArgumentListInfo *TemplateArgs)
ActOnDependentIdExpression - Handle a dependent id-expression that was just parsed.
ObjCLiteralKind CheckLiteralKind(Expr *FromE)
void MarkDeclarationsReferencedInExpr(Expr *E, bool SkipLocalVariables=false, ArrayRef< const Expr * > StopAt=std::nullopt)
Mark any declarations that appear within this expression or any potentially-evaluated subexpressions ...
ObjCMethodDecl * LookupMethodInQualifiedType(Selector Sel, const ObjCObjectPointerType *OPT, bool IsInstance)
LookupMethodInQualifiedType - Lookups up a method in protocol qualifier list of a qualified objective...
ExprResult BuildStmtExpr(SourceLocation LPLoc, Stmt *SubStmt, SourceLocation RPLoc, unsigned TemplateDepth)
ExprResult BuildCallToMemberFunction(Scope *S, Expr *MemExpr, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false, bool AllowRecovery=false)
BuildCallToMemberFunction - Build a call to a member function.
NamedDecl * LookupSingleName(Scope *S, DeclarationName Name, SourceLocation Loc, LookupNameKind NameKind, RedeclarationKind Redecl=RedeclarationKind::NotForRedeclaration)
Look up a name, looking for a single declaration.
ExprResult BuildVAArgExpr(SourceLocation BuiltinLoc, Expr *E, TypeSourceInfo *TInfo, SourceLocation RPLoc)
FunctionDecl * getCurFunctionDecl(bool AllowLambda=false) const
Returns a pointer to the innermost enclosing function, or nullptr if the current context is not insid...
ExprResult PerformContextualImplicitConversion(SourceLocation Loc, Expr *FromE, ContextualImplicitConverter &Converter)
Perform a contextual implicit conversion.
ExprResult UsualUnaryConversions(Expr *E)
UsualUnaryConversions - Performs various conversions that are common to most operators (C99 6....
ExprResult CheckUnevaluatedOperand(Expr *E)
ExprResult DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT, FunctionDecl *FDecl)
DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but will create a trap if the resul...
void DiagnoseCommaOperator(const Expr *LHS, SourceLocation Loc)
ExprResult tryConvertExprToType(Expr *E, QualType Ty)
Try to convert an expression E to type Ty.
bool DeduceReturnType(FunctionDecl *FD, SourceLocation Loc, bool Diagnose=true)
std::vector< Token > ExpandFunctionLocalPredefinedMacros(ArrayRef< Token > Toks)
bool CheckMatrixCast(SourceRange R, QualType DestTy, QualType SrcTy, CastKind &Kind)
QualType CheckAddressOfOperand(ExprResult &Operand, SourceLocation OpLoc)
CheckAddressOfOperand - The operand of & must be either a function designator or an lvalue designatin...
ParmVarDecl * BuildParmVarDeclForTypedef(DeclContext *DC, SourceLocation Loc, QualType T)
Synthesizes a variable for a parameter arising from a typedef.
ExprResult CheckSwitchCondition(SourceLocation SwitchLoc, Expr *Cond)
static bool TooManyArguments(size_t NumParams, size_t NumArgs, bool PartialOverloading=false)
To be used for checking whether the arguments being passed to function exceeds the number of paramete...
bool ShouldSplatAltivecScalarInCast(const VectorType *VecTy)
QualType InvalidOperands(SourceLocation Loc, ExprResult &LHS, ExprResult &RHS)
the following "Check" methods will return a valid/converted QualType or a null QualType (indicating a...
bool DiagIfReachable(SourceLocation Loc, ArrayRef< const Stmt * > Stmts, const PartialDiagnostic &PD)
Conditionally issue a diagnostic based on the statements's reachability analysis.
QualType CheckShiftOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc, bool IsCompAssign=false)
ExprResult BuildQualifiedDeclarationNameExpr(CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, bool IsAddressOfOperand, const Scope *S, TypeSourceInfo **RecoveryTSI=nullptr)
BuildQualifiedDeclarationNameExpr - Build a C++ qualified declaration name, generally during template...
DiagnosticsEngine & getDiagnostics() const
ExprResult MaybeConvertParenListExprToParenExpr(Scope *S, Expr *ME)
This is not an AltiVec-style cast or or C++ direct-initialization, so turn the ParenListExpr into a s...
bool checkAddressOfFunctionIsAvailable(const FunctionDecl *Function, bool Complain=false, SourceLocation Loc=SourceLocation())
Returns whether the given function's address can be taken or not, optionally emitting a diagnostic if...
ExprResult checkPseudoObjectAssignment(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opcode, Expr *LHS, Expr *RHS)
bool CheckCaseExpression(Expr *E)
bool LookupBuiltin(LookupResult &R)
Lookup a builtin function, when name lookup would otherwise fail.
QualType CheckMatrixElementwiseOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign)
Type checking for matrix binary operators.
bool tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD, bool ForceComplain=false, bool(*IsPlausibleResult)(QualType)=nullptr)
Try to recover by turning the given expression into a call.
FunctionDecl * ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr, QualType TargetType, bool Complain, DeclAccessPair &Found, bool *pHadMultipleCandidates=nullptr)
ResolveAddressOfOverloadedFunction - Try to resolve the address of an overloaded function (C++ [over....
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
void LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S, UnresolvedSetImpl &Functions)
void checkSpecializationReachability(SourceLocation Loc, NamedDecl *Spec)
void CleanupVarDeclMarking()
ExprResult DefaultFunctionArrayLvalueConversion(Expr *E, bool Diagnose=true)
bool isImmediateFunctionContext() const
ASTContext & getASTContext() const
ExprResult CallExprUnaryConversions(Expr *E)
CallExprUnaryConversions - a special case of an unary conversion performed on a function designator o...
void translateTemplateArguments(const ASTTemplateArgsPtr &In, TemplateArgumentListInfo &Out)
Translates template arguments as provided by the parser into template arguments used by semantic anal...
ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *Input, bool IsAfterAmp=false)
bool tryCaptureVariable(ValueDecl *Var, SourceLocation Loc, TryCaptureKind Kind, SourceLocation EllipsisLoc, bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType, const unsigned *const FunctionScopeIndexToStopAt)
Try to capture the given variable.
void MarkVariableReferenced(SourceLocation Loc, VarDecl *Var)
Mark a variable referenced, and check whether it is odr-used (C++ [basic.def.odr]p2,...
void LookupBinOp(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opc, UnresolvedSetImpl &Functions)
ExprResult BuildTemplateIdExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, bool RequiresADL, const TemplateArgumentListInfo *TemplateArgs)
void DiagnoseUnguardedAvailabilityViolations(Decl *FD)
Issue any -Wunguarded-availability warnings in FD.
void PopExpressionEvaluationContext()
AssignConvertType CheckTransparentUnionArgumentConstraints(QualType ArgType, ExprResult &RHS)
ExprResult CreateOverloadedBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *LHS, Expr *RHS, bool RequiresADL=true, bool AllowRewrittenCandidates=true, FunctionDecl *DefaultedFn=nullptr)
Create a binary operation that may resolve to an overloaded operator.
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
ExprResult DefaultArgumentPromotion(Expr *E)
DefaultArgumentPromotion (C99 6.5.2.2p6).
ExprResult BuildPredefinedExpr(SourceLocation Loc, PredefinedIdentKind IK)
bool CheckArgsForPlaceholders(MultiExprArg args)
Check an argument list for placeholders that we won't try to handle later.
bool UseArgumentDependentLookup(const CXXScopeSpec &SS, const LookupResult &R, bool HasTrailingLParen)
bool isBoundsAttrContext() const
void InstantiateVariableDefinition(SourceLocation PointOfInstantiation, VarDecl *Var, bool Recursive=false, bool DefinitionRequired=false, bool AtEndOfTU=false)
Instantiate the definition of the given variable from its template.
ExprResult BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo, SourceLocation RParenLoc, Expr *LiteralExpr)
ExprResult ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc, LabelDecl *TheDecl)
ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
DefaultedComparisonKind
Kinds of defaulted comparison operator functions.
@ None
This is not a defaultable comparison operator.
ExprResult ActOnParenListExpr(SourceLocation L, SourceLocation R, MultiExprArg Val)
FunctionDecl * ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl, bool Complain=false, DeclAccessPair *Found=nullptr, TemplateSpecCandidateSet *FailedTSC=nullptr)
Given an expression that refers to an overloaded function, try to resolve that overloaded function ex...
QualType CheckMatrixMultiplyOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign)
ObjCMethodDecl * getCurMethodDecl()
getCurMethodDecl - If inside of a method body, this returns a pointer to the method decl for the meth...
DeclRefExpr * BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, SourceLocation Loc, const CXXScopeSpec *SS=nullptr)
void DefineImplicitMoveConstructor(SourceLocation CurrentLocation, CXXConstructorDecl *Constructor)
DefineImplicitMoveConstructor - Checks for feasibility of defining this constructor as the move const...
ExprResult ActOnChooseExpr(SourceLocation BuiltinLoc, Expr *CondExpr, Expr *LHSExpr, Expr *RHSExpr, SourceLocation RPLoc)
ExprResult CreateGenericSelectionExpr(SourceLocation KeyLoc, SourceLocation DefaultLoc, SourceLocation RParenLoc, bool PredicateIsExpr, void *ControllingExprOrType, ArrayRef< TypeSourceInfo * > Types, ArrayRef< Expr * > Exprs)
ControllingExprOrType is either a TypeSourceInfo * or an Expr *.
CastKind PrepareCastToObjCObjectPointer(ExprResult &E)
Prepare a conversion of the given expression to an ObjC object pointer type.
ExprResult ActOnUnevaluatedStringLiteral(ArrayRef< Token > StringToks)
void DiagnoseSelfMove(const Expr *LHSExpr, const Expr *RHSExpr, SourceLocation OpLoc)
Warn if a value is moved to itself.
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()
void CheckTollFreeBridgeCast(QualType castType, Expr *castExpr)
@ UPPC_Block
Block expression.
const LangOptions & getLangOpts() const
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, CorrectionCandidateCallback &CCC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr, bool RecordFailure=true)
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
QualType CheckComparisonCategoryType(ComparisonCategoryType Kind, SourceLocation Loc, ComparisonCategoryUsage Usage)
Lookup the specified comparison category types in the standard library, an check the VarDecls possibl...
void DiagnoseInvalidJumps(Stmt *Body)
TypoExpr * CorrectTypoDelayed(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, CorrectionCandidateCallback &CCC, TypoDiagnosticGenerator TDG, TypoRecoveryCallback TRC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr)
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
QualType CheckCompareOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc)
CastKind PrepareScalarCast(ExprResult &src, QualType destType)
Prepares for a scalar cast, performing all the necessary stages except the final cast and returning t...
QualType CheckVectorLogicalOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc)
bool tryToFixVariablyModifiedVarType(TypeSourceInfo *&TInfo, QualType &T, SourceLocation Loc, unsigned FailedFoldDiagID)
Attempt to fold a variable-sized type to a constant-sized type, returning true if we were successful.
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
void MarkExpressionAsImmediateEscalating(Expr *E)
NonOdrUseReason getNonOdrUseReasonInCurrentContext(ValueDecl *D)
If D cannot be odr-used in the current expression evaluation context, return a reason explaining why.
void DefineDefaultedComparison(SourceLocation Loc, FunctionDecl *FD, DefaultedComparisonKind DCK)
void diagnoseUnavailableAlignedAllocation(const FunctionDecl &FD, SourceLocation Loc)
Produce diagnostics if FD is an aligned allocation or deallocation function that is unavailable.
void MarkFunctionParmPackReferenced(FunctionParmPackExpr *E)
Perform reference-marking and odr-use handling for a FunctionParmPackExpr.
QualType CheckAdditionOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc, QualType *CompLHSTy=nullptr)
VariadicCallType getVariadicCallType(FunctionDecl *FDecl, const FunctionProtoType *Proto, Expr *Fn)
bool isPotentialImplicitMemberAccess(const CXXScopeSpec &SS, LookupResult &R, bool IsAddressOfOperand)
Check whether an expression might be an implicit class member access.
ExprResult BuildCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false, bool AllowRecovery=false)
BuildCallExpr - Handle a call to Fn with the specified array of arguments.
bool CheckUseOfCXXMethodAsAddressOfOperand(SourceLocation OpLoc, const Expr *Op, const CXXMethodDecl *MD)
ExprResult BuildSourceLocExpr(SourceLocIdentKind Kind, QualType ResultTy, SourceLocation BuiltinLoc, SourceLocation RPLoc, DeclContext *ParentContext)
bool ActOnAlignasTypeArgument(StringRef KWName, ParsedType Ty, SourceLocation OpLoc, SourceRange R)
ActOnAlignasTypeArgument - Handle alignas(type-id) and _Alignas(type-name) .
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
ExprResult checkPseudoObjectIncDec(Scope *S, SourceLocation OpLoc, UnaryOperatorKind Opcode, Expr *Op)
Check an increment or decrement of a pseudo-object expression.
void checkTypeSupport(QualType Ty, SourceLocation Loc, ValueDecl *D=nullptr)
Check if the type is allowed to be used for the current target.
bool areMatrixTypesOfTheSameDimension(QualType srcTy, QualType destTy)
Are the two types matrix types and do they have the same dimensions i.e.
void CheckExtraCXXDefaultArguments(Declarator &D)
CheckExtraCXXDefaultArguments - Check for any extra default arguments in the declarator,...
bool hasCStrMethod(const Expr *E)
Check to see if a given expression could have '.c_str()' called on it.
const LangOptions & LangOpts
void EmitRelatedResultTypeNoteForReturn(QualType destType)
Given that we had incompatible pointer types in a return statement, check whether we're in a method w...
ExprResult BuildBuiltinOffsetOf(SourceLocation BuiltinLoc, TypeSourceInfo *TInfo, ArrayRef< OffsetOfComponent > Components, SourceLocation RParenLoc)
__builtin_offsetof(type, a.b[123][456].c)
sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)
Retrieve the current lambda scope info, if any.
ExprResult BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, SourceLocation LParenLoc, ArrayRef< Expr * > Arg, SourceLocation RParenLoc, Expr *Config=nullptr, bool IsExecConfig=false, ADLCallKind UsesADL=ADLCallKind::NotADL)
BuildResolvedCallExpr - Build a call to a resolved expression, i.e.
ExprResult CheckForImmediateInvocation(ExprResult E, FunctionDecl *Decl)
Wrap the expression in a ConstantExpr if it is a potential immediate invocation.
ExprResult TemporaryMaterializationConversion(Expr *E)
If E is a prvalue denoting an unmaterialized temporary, materialize it as an xvalue.
NamedDeclSetType UnusedPrivateFields
Set containing all declared private fields that are not used.
Expr * stripARCUnbridgedCast(Expr *e)
stripARCUnbridgedCast - Given an expression of ARCUnbridgedCast type, remove the placeholder cast.
void DefineInheritingConstructor(SourceLocation UseLoc, CXXConstructorDecl *Constructor)
Define the specified inheriting constructor.
void CheckUnusedVolatileAssignment(Expr *E)
Check whether E, which is either a discarded-value expression or an unevaluated operand,...
void MaybeSuggestAddingStaticToDecl(const FunctionDecl *D)
@ OperatorInExpression
The '<=>' operator was used in an expression and a builtin operator was selected.
bool CanUseDecl(NamedDecl *D, bool TreatUnavailableAsInvalid)
Determine whether the use of this declaration is valid, without emitting diagnostics.
void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse)
Perform marking for a reference to an arbitrary declaration.
void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class, bool DefinitionRequired=false)
Note that the vtable for the given class was used at the given location.
QualType InvalidLogicalVectorOperands(SourceLocation Loc, ExprResult &LHS, ExprResult &RHS)
bool diagnoseArgIndependentDiagnoseIfAttrs(const NamedDecl *ND, SourceLocation Loc)
Emit diagnostics for the diagnose_if attributes on Function, ignoring any ArgDependent DiagnoseIfAttr...
CleanupInfo Cleanup
Used to control the generation of ExprWithCleanups.
llvm::DenseMap< ParmVarDecl *, SourceLocation > UnparsedDefaultArgLocs
NamedDecl * getCurFunctionOrMethodDecl() const
getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method or C function we're in,...
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, const CXXScopeSpec &SS, QualType T, TagDecl *OwnedTagDecl=nullptr)
Retrieve a version of the type 'T' that is elaborated by Keyword, qualified by the nested-name-specif...
QualType FindCompositePointerType(SourceLocation Loc, Expr *&E1, Expr *&E2, bool ConvertArgs=true)
Find a merged pointer type and convert the two expressions to it.
SmallVector< std::deque< PendingImplicitInstantiation >, 8 > SavedPendingInstantiations
VarArgKind isValidVarArgType(const QualType &Ty)
Determine the degree of POD-ness for an expression.
bool isQualifiedMemberAccess(Expr *E)
Determine whether the given expression is a qualified member access expression, of a form that could ...
bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS, bool AllowBuiltinCreation=false, bool EnteringContext=false)
Performs name lookup for a name that was parsed in the source code, and may contain a C++ scope speci...
static CastKind ScalarTypeToBooleanCastKind(QualType ScalarTy)
ScalarTypeToBooleanCastKind - Returns the cast kind corresponding to the conversion from scalar type ...
void DefineImplicitLambdaToBlockPointerConversion(SourceLocation CurrentLoc, CXXConversionDecl *Conv)
Define the "body" of the conversion from a lambda object to a block pointer.
void DefineImplicitDestructor(SourceLocation CurrentLocation, CXXDestructorDecl *Destructor)
DefineImplicitDestructor - Checks for feasibility of defining this destructor as the default destruct...
ExprResult BuildCStyleCastExpr(SourceLocation LParenLoc, TypeSourceInfo *Ty, SourceLocation RParenLoc, Expr *Op)
sema::FunctionScopeInfo * getCurFunction() const
void checkUnsafeExprAssigns(SourceLocation Loc, Expr *LHS, Expr *RHS)
checkUnsafeExprAssigns - Check whether +1 expr is being assigned to weak/__unsafe_unretained expressi...
ExprResult LookupInObjCMethod(LookupResult &LookUp, Scope *S, IdentifierInfo *II, bool AllowBuiltinCreation=false)
The parser has read a name in, and Sema has detected that we're currently inside an ObjC method.
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)
ExprResult BuildObjCStringLiteral(SourceLocation AtLoc, StringLiteral *S)
bool CheckDerivedToBaseConversion(QualType Derived, QualType Base, SourceLocation Loc, SourceRange Range, CXXCastPath *BasePath=nullptr, bool IgnoreAccess=false)
bool isInLifetimeExtendingContext() const
void maybeExtendBlockObject(ExprResult &E)
Do an explicit extend of the given block pointer if we're in ARC.
ExprResult ActOnGenericSelectionExpr(SourceLocation KeyLoc, SourceLocation DefaultLoc, SourceLocation RParenLoc, bool PredicateIsExpr, void *ControllingExprOrType, ArrayRef< ParsedType > ArgTypes, ArrayRef< Expr * > ArgExprs)
ControllingExprOrType is either an opaque pointer coming out of a ParsedType or an Expr *.
void ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope)
ActOnBlockError - If there is an error parsing a block, this callback is invoked to pop the informati...
ExprResult prepareVectorSplat(QualType VectorTy, Expr *SplattedExpr)
Prepare SplattedExpr for a vector splat operation, adding implicit casts if necessary.
sema::BlockScopeInfo * getCurBlock()
Retrieve the current block, if any.
bool IvarBacksCurrentMethodAccessor(ObjCInterfaceDecl *IFace, ObjCMethodDecl *Method, ObjCIvarDecl *IV)
IvarBacksCurrentMethodAccessor - This routine returns 'true' if 'IV' is an ivar synthesized for 'Meth...
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
MaterializeTemporaryExpr * CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary, bool BoundToLvalueReference)
ExprResult checkUnknownAnyCast(SourceRange TypeRange, QualType CastType, Expr *CastExpr, CastKind &CastKind, ExprValueKind &VK, CXXCastPath &Path)
Check a cast of an unknown-any type.
SuppressedDiagnosticsMap SuppressedDiagnostics
DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name)
Retrieves the declaration name from a parsed unqualified-id.
std::deque< PendingImplicitInstantiation > PendingLocalImplicitInstantiations
The queue of implicit template instantiations that are required and must be performed within the curr...
ExprResult ActOnGNUNullExpr(SourceLocation TokenLoc)
ExprResult PerformContextuallyConvertToBool(Expr *From)
PerformContextuallyConvertToBool - Perform a contextual conversion of the expression From to bool (C+...
void DefineImplicitCopyAssignment(SourceLocation CurrentLocation, CXXMethodDecl *MethodDecl)
Defines an implicitly-declared copy assignment operator.
bool DiagnoseConditionalForNull(const Expr *LHSExpr, const Expr *RHSExpr, SourceLocation QuestionLoc)
Emit a specialized diagnostic when one expression is a null pointer constant and the other is not a p...
bool CheckFunctionConstraints(const FunctionDecl *FD, ConstraintSatisfaction &Satisfaction, SourceLocation UsageLoc=SourceLocation(), bool ForOverloadResolution=false)
Check whether the given function decl's trailing requires clause is satisfied, if any.
void MarkDeclarationsReferencedInType(SourceLocation Loc, QualType T)
Mark all of the declarations referenced within a particular AST node as referenced.
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5.
DeclContext * getFunctionLevelDeclContext(bool AllowLambda=false) const
If AllowLambda is true, treat lambda as function.
AssignConvertType
AssignConvertType - All of the 'assignment' semantic checks return this enum to indicate whether the ...
@ IncompatiblePointerDiscardsQualifiers
IncompatiblePointerDiscardsQualifiers - The assignment discards qualifiers that we don't permit to be...
@ IntToPointer
IntToPointer - The assignment converts an int to a pointer, which we accept as an extension.
@ IncompatibleBlockPointer
IncompatibleBlockPointer - The assignment is between two block pointers types that are not compatible...
@ IncompatibleObjCQualifiedId
IncompatibleObjCQualifiedId - The assignment is between a qualified id type and something else (that ...
@ IncompatibleVectors
IncompatibleVectors - The assignment is between two vector types that have the same size,...
@ CompatiblePointerDiscardsQualifiers
CompatiblePointerDiscardsQualifiers - The assignment discards c/v/r qualifiers, which we accept as an...
@ IncompatiblePointer
IncompatiblePointer - The assignment is between two pointers types that are not compatible,...
@ IncompatibleObjCWeakRef
IncompatibleObjCWeakRef - Assigning a weak-unavailable object to an object with __weak qualifier.
@ Compatible
Compatible - the types are compatible according to the standard.
@ IncompatibleFunctionPointerStrict
IncompatibleFunctionPointerStrict - The assignment is between two function pointer types that are not...
@ Incompatible
Incompatible - We reject this conversion outright, it is invalid to represent it in the AST.
@ FunctionVoidPointer
FunctionVoidPointer - The assignment is between a function pointer and void*, which the standard does...
@ IncompatibleFunctionPointer
IncompatibleFunctionPointer - The assignment is between two function pointers types that are not comp...
@ IncompatiblePointerSign
IncompatiblePointerSign - The assignment is between two pointers types which point to integers which ...
@ IncompatibleNestedPointerQualifiers
IncompatibleNestedPointerQualifiers - The assignment is between two nested pointer types,...
@ IncompatibleNestedPointerAddressSpaceMismatch
IncompatibleNestedPointerAddressSpaceMismatch - The assignment changes address spaces in nested point...
@ PointerToInt
PointerToInt - The assignment converts a pointer to an int, which we accept as an extension.
@ IntToBlockPointer
IntToBlockPointer - The assignment converts an int to a block pointer.
void CheckShadowingDeclModification(Expr *E, SourceLocation Loc)
Warn if 'E', which is an expression that is about to be modified, refers to a shadowing declaration.
ArithConvKind
Context in which we're performing a usual arithmetic conversion.
@ ACK_Arithmetic
An arithmetic operation.
@ ACK_CompAssign
A compound assignment expression.
@ ACK_BitwiseOp
A bitwise operation.
@ ACK_Conditional
A conditional (?:) operator.
@ ACK_Comparison
A comparison.
void MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base=nullptr)
Perform reference-marking and odr-use handling for a DeclRefExpr.
ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E)
ExprResult ActOnSourceLocExpr(SourceLocIdentKind Kind, SourceLocation BuiltinLoc, SourceLocation RPLoc)
llvm::PointerIntPair< ConstantExpr *, 1 > ImmediateInvocationCandidate
ExprResult CheckPlaceholderExpr(Expr *E)
Check for operands with placeholder types and complain if found.
ExprResult TransformToPotentiallyEvaluated(Expr *E)
EnableIfAttr * CheckEnableIf(FunctionDecl *Function, SourceLocation CallLoc, ArrayRef< Expr * > Args, bool MissingImplicitThis=false)
Check the enable_if expressions on the given function.
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
SourceManager & getSourceManager() const
@ TryCapture_ExplicitByRef
ExprResult BuildAsTypeExpr(Expr *E, QualType DestTy, SourceLocation BuiltinLoc, SourceLocation RParenLoc)
Create a new AsTypeExpr node (bitcast) from the arguments.
ExprResult checkPseudoObjectRValue(Expr *E)
bool CheckVecStepExpr(Expr *E)
void diagnoseARCUnbridgedCast(Expr *e)
Given that we saw an expression with the ARCUnbridgedCastTy placeholder type, complain bitterly.
ExprResult FixOverloadedFunctionReference(Expr *E, DeclAccessPair FoundDecl, FunctionDecl *Fn)
FixOverloadedFunctionReference - E is an expression that refers to a C++ overloaded function (possibl...
ExprResult ActOnConditionalOp(SourceLocation QuestionLoc, SourceLocation ColonLoc, Expr *CondExpr, Expr *LHSExpr, Expr *RHSExpr)
ActOnConditionalOp - Parse a ?: operation.
QualType CheckVectorCompareOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc)
CheckVectorCompareOperands - vector comparisons are a clang extension that operates on extended vecto...
QualType CheckMultiplyDivideOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign, bool IsDivide)
ExprResult CheckCXXBooleanCondition(Expr *CondExpr, bool IsConstexpr=false)
CheckCXXBooleanCondition - Returns true if conversion to bool is invalid.
ExprResult CheckLValueToRValueConversionOperand(Expr *E)
QualType CheckAssignmentOperands(Expr *LHSExpr, ExprResult &RHS, SourceLocation Loc, QualType CompoundType, BinaryOperatorKind Opc)
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.
ExprResult ActOnObjCBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind)
ActOnObjCBoolLiteral - Parse {__objc_yes,__objc_no} literals.
bool resolveAndFixAddressOfSingleOverloadCandidate(ExprResult &SrcExpr, bool DoFunctionPointerConversion=false)
Given an overloaded function, tries to turn it into a non-overloaded function reference using resolve...
ARCConversionResult CheckObjCConversion(SourceRange castRange, QualType castType, Expr *&op, CheckedConversionKind CCK, bool Diagnose=true, bool DiagnoseCFAudited=false, BinaryOperatorKind Opc=BO_PtrMemD)
Checks for invalid conversions and casts between retainable pointers and other pointer kinds for ARC ...
QualType CheckPointerToMemberOperands(ExprResult &LHS, ExprResult &RHS, ExprValueKind &VK, SourceLocation OpLoc, bool isIndirect)
bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement, const PartialDiagnostic &PD)
Conditionally issue a diagnostic based on the current evaluation context.
ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param, Expr *Init=nullptr)
BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating the default expr if needed.
void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=true, bool AllowExplicitConversion=false, ADLCallKind IsADLCandidate=ADLCallKind::NotADL, ConversionSequenceList EarlyConversions=std::nullopt, OverloadCandidateParamOrder PO={}, bool AggregateCandidateDeduction=false)
AddOverloadCandidate - Adds the given function to the set of candidate functions, using the given fun...
bool anyAltivecTypes(QualType srcType, QualType destType)
bool isLaxVectorConversion(QualType srcType, QualType destType)
Is this a legal conversion between two types, one of which is known to be a vector type?
void keepInLifetimeExtendingContext()
keepInLifetimeExtendingContext - Pull down InLifetimeExtendingContext flag from previous context.
void PushBlockScope(Scope *BlockScope, BlockDecl *Block)
sema::FunctionScopeInfo * getCurFunctionAvailabilityContext()
Retrieve the current function, if any, that should be analyzed for potential availability violations.
ExprResult BuildOverloadedCallExpr(Scope *S, Expr *Fn, UnresolvedLookupExpr *ULE, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc, Expr *ExecConfig, bool AllowTypoCorrection=true, bool CalleesAddressIsTaken=false)
BuildOverloadedCallExpr - Given the call expression that calls Fn (which eventually refers to the dec...
QualType CXXCheckConditionalOperands(ExprResult &cond, ExprResult &lhs, ExprResult &rhs, ExprValueKind &VK, ExprObjectKind &OK, SourceLocation questionLoc)
Check the operands of ?: under C++ semantics.
ExprResult BuildAnonymousStructUnionMemberReference(const CXXScopeSpec &SS, SourceLocation nameLoc, IndirectFieldDecl *indirectField, DeclAccessPair FoundDecl=DeclAccessPair::make(nullptr, AS_none), Expr *baseObjectExpr=nullptr, SourceLocation opLoc=SourceLocation())
MaybeODRUseExprSet MaybeODRUseExprs
ExprResult PerformImplicitConversion(Expr *From, QualType ToType, const ImplicitConversionSequence &ICS, AssignmentAction Action, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
PerformImplicitConversion - Perform an implicit conversion of the expression From to the type ToType ...
bool InstantiateInClassInitializer(SourceLocation PointOfInstantiation, FieldDecl *Instantiation, FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs)
Instantiate the definition of a field from the given pattern.
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReciever=nullptr, bool SkipTrailingRequiresClause=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics.
bool CheckParmsForFunctionDef(ArrayRef< ParmVarDecl * > Parameters, bool CheckParameterNames)
CheckParmsForFunctionDef - Check that the parameters of the given function are appropriate for the de...
void CheckShadow(NamedDecl *D, NamedDecl *ShadowedDecl, const LookupResult &R)
Diagnose variable or built-in function shadowing.
ExprResult BuildCallToObjectOfClassType(Scope *S, Expr *Object, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc)
BuildCallToObjectOfClassType - Build a call to an object of class type (C++ [over....
ExprResult ActOnStringLiteral(ArrayRef< Token > StringToks, Scope *UDLScope=nullptr)
ActOnStringLiteral - The specified tokens were lexed as pasted string fragments (e....
bool isCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind=CompleteTypeKind::Default)
ExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc, tok::TokenKind Kind, Expr *LHSExpr, Expr *RHSExpr)
void checkUnusedDeclAttributes(Declarator &D)
checkUnusedDeclAttributes - Given a declarator which is not being used to build a declaration,...
ExprResult CheckExtVectorCast(SourceRange R, QualType DestTy, Expr *CastExpr, CastKind &Kind)
void setFunctionHasBranchProtectedScope()
bool isConstantEvaluatedContext() const
void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation, FunctionDecl *Function, bool Recursive=false, bool DefinitionRequired=false, bool AtEndOfTU=false)
Instantiate the definition of the given function from its template.
void mergeDeclAttributes(NamedDecl *New, Decl *Old, AvailabilityMergeKind AMK=AMK_Redeclaration)
mergeDeclAttributes - Copy attributes from the Old decl to the New one.
bool CheckForConstantInitializer(Expr *Init, unsigned DiagID=diag::err_init_element_not_constant)
type checking declaration initializers (C99 6.7.8)
llvm::SmallPtrSet< const Decl *, 4 > ParsingInitForAutoVars
ParsingInitForAutoVars - a set of declarations with auto types for which we are currently parsing the...
const DeclContext * getCurObjCLexicalContext() const
bool CheckPointerConversion(Expr *From, QualType ToType, CastKind &Kind, CXXCastPath &BasePath, bool IgnoreBaseAccess, bool Diagnose=true)
CheckPointerConversion - Check the pointer conversion from the expression From to the type ToType.
SmallVector< ExprWithCleanups::CleanupObject, 8 > ExprCleanupObjects
ExprCleanupObjects - This is the stack of objects requiring cleanup that are created by the current f...
void NoteDeletedFunction(FunctionDecl *FD)
Emit a note explaining that this function is deleted.
sema::AnalysisBasedWarnings AnalysisWarnings
Worker object for performing CFG-based warnings.
std::deque< PendingImplicitInstantiation > PendingInstantiations
The queue of implicit template instantiations that are required but have not yet been performed.
ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc, Expr *Idx, SourceLocation RLoc)
void NoteAllOverloadCandidates(Expr *E, QualType DestType=QualType(), bool TakingAddress=false)
ExprResult ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind)
QualType GetSignedVectorType(QualType V)
QualType CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS, ExprResult &RHS, ExprValueKind &VK, ExprObjectKind &OK, SourceLocation QuestionLoc)
Note that LHS is not null here, even if this is the gnu "x ?: y" extension.
ExpressionEvaluationContext
Describes how the expressions currently being parsed are evaluated at run-time, if at all.
@ UnevaluatedAbstract
The current expression occurs within an unevaluated operand that unconditionally permits abstract ref...
@ UnevaluatedList
The current expression occurs within a braced-init-list within an unevaluated operand.
@ ConstantEvaluated
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
@ DiscardedStatement
The current expression occurs within a discarded statement.
@ PotentiallyEvaluated
The current expression is potentially evaluated at run time, which means that code may be generated t...
@ Unevaluated
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7),...
@ ImmediateFunctionContext
In addition of being constant evaluated, the current expression occurs in an immediate function conte...
@ PotentiallyEvaluatedIfUsed
The current expression is potentially evaluated, but any declarations referenced inside that expressi...
void CheckCompatibleReinterpretCast(QualType SrcType, QualType DestType, bool IsDereference, SourceRange Range)
ExprResult BuildDependentDeclRefExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)
ExprResult ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy, SourceLocation BuiltinLoc, SourceLocation RParenLoc)
__builtin_astype(...)
ExprResult CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo, SourceLocation OpLoc, UnaryExprOrTypeTrait ExprKind, SourceRange R)
Build a sizeof or alignof expression given a type operand.
TypeSourceInfo * GetTypeForDeclarator(Declarator &D)
GetTypeForDeclarator - Convert the type for the specified declarator to Type instances.
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
bool CheckCallReturnType(QualType ReturnType, SourceLocation Loc, CallExpr *CE, FunctionDecl *FD)
CheckCallReturnType - Checks that a call expression's return type is complete.
bool CheckUnaryExprOrTypeTraitOperand(Expr *E, UnaryExprOrTypeTrait ExprKind)
Check the constraints on expression operands to unary type expression and type traits.
ExprResult ActOnVAArg(SourceLocation BuiltinLoc, Expr *E, ParsedType Ty, SourceLocation RPLoc)
TypeSourceInfo * GetTypeForDeclaratorCast(Declarator &D, QualType FromTy)
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
ExprResult forceUnknownAnyToType(Expr *E, QualType ToType)
Force an expression with unknown-type to an expression of the given type.
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
void NoteDeletedInheritingConstructor(CXXConstructorDecl *CD)
QualType getCapturedDeclRefType(ValueDecl *Var, SourceLocation Loc)
Given a variable, determine the type that a reference to that variable will have in the given scope.
ExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc, Declarator &D, ParsedType &Ty, SourceLocation RParenLoc, Expr *CastExpr)
Expr * MaybeCreateExprWithCleanups(Expr *SubExpr)
MaybeCreateExprWithCleanups - If the current full-expression requires any cleanups,...
ExprResult BuildObjCSubscriptExpression(SourceLocation RB, Expr *BaseExpr, Expr *IndexExpr, ObjCMethodDecl *getterMethod, ObjCMethodDecl *setterMethod)
Build an ObjC subscript pseudo-object expression, given that that's supported by the runtime.
bool RebuildingImmediateInvocation
Whether the AST is currently being rebuilt to correct immediate invocations.
void DiagnoseAvailabilityOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass, bool ObjCPropertyAccess, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReceiver=nullptr)
void DiscardCleanupsInEvaluationContext()
bool NeedToCaptureVariable(ValueDecl *Var, SourceLocation Loc)
Checks if the variable must be captured.
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
void PushDeclContext(Scope *S, DeclContext *DC)
Set the current declaration context until it gets popped.
bool CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty, CastKind &Kind)
bool LookupTemplateName(LookupResult &R, Scope *S, CXXScopeSpec &SS, QualType ObjectType, bool EnteringContext, bool &MemberOfUnknownSpecialization, RequiredTemplateKind RequiredTemplate=SourceLocation(), AssumedTemplateKind *ATK=nullptr, bool AllowTypoCorrection=true)
SourceManager & SourceMgr
bool CheckAlignasTypeArgument(StringRef KWName, TypeSourceInfo *TInfo, SourceLocation OpLoc, SourceRange R)
ExprResult BuildVectorLiteral(SourceLocation LParenLoc, SourceLocation RParenLoc, Expr *E, TypeSourceInfo *TInfo)
Build an altivec or OpenCL literal.
void checkRetainCycles(ObjCMessageExpr *msg)
checkRetainCycles - Check whether an Objective-C message send might create an obvious retain cycle.
bool isUnavailableAlignedAllocationFunction(const FunctionDecl &FD) const
Determine whether FD is an aligned allocation or deallocation function that is unavailable.
bool DiagnoseDependentMemberLookup(const LookupResult &R)
Diagnose a lookup that found results in an enclosing class during error recovery.
DiagnosticsEngine & Diags
OpenCLOptions & getOpenCLOptions()
NamespaceDecl * getStdNamespace() const
ExprResult DefaultFunctionArrayConversion(Expr *E, bool Diagnose=true)
DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).
void deduceClosureReturnType(sema::CapturingScopeInfo &CSI)
Deduce a block or lambda's return type based on the return statements present in the body.
bool areLaxCompatibleVectorTypes(QualType srcType, QualType destType)
Are the two types lax-compatible vector types? That is, given that one of them is a vector,...
ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)
void diagnoseMissingTemplateArguments(TemplateName Name, SourceLocation Loc)
ExprResult BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field)
void DiagnoseAssignmentAsCondition(Expr *E)
DiagnoseAssignmentAsCondition - Given that an expression is being used as a boolean condition,...
void checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec)
We've found a use of a templated declaration that would trigger an implicit instantiation.
void EmitRelatedResultTypeNote(const Expr *E)
If the given expression involves a message send to a method with a related result type,...
QualType CheckBitwiseOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc)
llvm::MapVector< NamedDecl *, SourceLocation > UndefinedButUsed
UndefinedInternals - all the used, undefined objects which require a definition in this translation u...
ExprResult ActOnStmtExpr(Scope *S, SourceLocation LPLoc, Stmt *SubStmt, SourceLocation RPLoc)
bool ResolveAndFixSingleFunctionTemplateSpecialization(ExprResult &SrcExpr, bool DoFunctionPointerConversion=false, bool Complain=false, SourceRange OpRangeForComplaining=SourceRange(), QualType DestTypeForComplaining=QualType(), unsigned DiagIDForComplaining=0)
ExprResult ConvertParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg, SourceLocation EqualLoc)
void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD)
ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in it, apply them to D.
void checkVariadicArgument(const Expr *E, VariadicCallType CT)
Check to see if the given expression is a valid argument to a variadic function, issuing a diagnostic...
void CheckStaticArrayArgument(SourceLocation CallLoc, ParmVarDecl *Param, const Expr *ArgExpr)
CheckStaticArrayArgument - If the given argument corresponds to a static array parameter,...
QualType CheckSizelessVectorCompareOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc)
ExprResult ConvertMemberDefaultInitExpression(FieldDecl *FD, Expr *InitExpr, SourceLocation InitLoc)
ExprResult BuildObjCNumericLiteral(SourceLocation AtLoc, Expr *Number)
BuildObjCNumericLiteral - builds an ObjCBoxedExpr AST node for the numeric literal expression.
bool IsInvalidSMECallConversion(QualType FromType, QualType ToType)
void checkNonTrivialCUnionInInitializer(const Expr *Init, SourceLocation Loc)
Emit diagnostics if the initializer or any of its explicit or implicitly-generated subexpressions req...
ExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc, Stmt *Body, Scope *CurScope)
ActOnBlockStmtExpr - This is called when the body of a block statement literal was successfully compl...
void DiagnoseDeletedDefaultedFunction(FunctionDecl *FD)
Produce notes explaining why a defaulted function was defined as deleted.
void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)
Run some code with "sufficient" stack space.
void MarkMemberReferenced(MemberExpr *E)
Perform reference-marking and odr-use handling for a MemberExpr.
bool DiagnoseAssignmentResult(AssignConvertType ConvTy, SourceLocation Loc, QualType DstType, QualType SrcType, Expr *SrcExpr, AssignmentAction Action, bool *Complained=nullptr)
DiagnoseAssignmentResult - Emit a diagnostic, if required, for the assignment conversion type specifi...
void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, bool MightBeOdrUse=true)
Mark a function referenced, and check whether it is odr-used (C++ [basic.def.odr]p2,...
ExprResult ActOnStmtExprResult(ExprResult E)
ExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc, tok::TokenKind Kind, Expr *Input)
bool GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl, const FunctionProtoType *Proto, unsigned FirstParam, ArrayRef< Expr * > Args, SmallVectorImpl< Expr * > &AllArgs, VariadicCallType CallType=VariadicDoesNotApply, bool AllowExplicit=false, bool IsListInitialization=false)
GatherArgumentsForCall - Collector argument expressions for various form of call prototypes.
std::tuple< MangleNumberingContext *, Decl * > getCurrentMangleNumberContext(const DeclContext *DC)
Compute the mangling number context for a lambda expression or block literal.
bool CheckConversionToObjCLiteral(QualType DstType, Expr *&SrcExpr, bool Diagnose=true)
void DiagnoseEqualityWithExtraParens(ParenExpr *ParenE)
Redundant parentheses over an equality comparison can indicate that the user intended an assignment u...
SemaDiagnosticBuilder targetDiag(SourceLocation Loc, unsigned DiagID, const FunctionDecl *FD=nullptr)
ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End, ArrayRef< Expr * > SubExprs, QualType T=QualType())
Attempts to produce a RecoveryExpr after some AST node cannot be created.
ExprResult BuildBinOp(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr)
ExprResult ActOnNumericConstant(const Token &Tok, Scope *UDLScope=nullptr)
ExprResult PerformObjectMemberConversion(Expr *From, NestedNameSpecifier *Qualifier, NamedDecl *FoundDecl, NamedDecl *Member)
Cast a base object to a member's actual type.
ExprResult BuildInitList(SourceLocation LBraceLoc, MultiExprArg InitArgList, SourceLocation RBraceLoc)
void ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope)
ActOnBlockStart - This callback is invoked when a block literal is started.
ExprResult ActOnArraySubscriptExpr(Scope *S, Expr *Base, SourceLocation LLoc, MultiExprArg ArgExprs, SourceLocation RLoc)
ExprResult CreateBuiltinBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr)
CreateBuiltinBinOp - Creates a new built-in binary operation with operator Opc at location TokLoc.
AssignConvertType CheckAssignmentConstraints(SourceLocation Loc, QualType LHSType, QualType RHSType)
CheckAssignmentConstraints - Perform type checking for assignment, argument passing,...
void DiagnoseUnsatisfiedConstraint(const ConstraintSatisfaction &Satisfaction, bool First=true)
Emit diagnostics explaining why a constraint expression was deemed unsatisfied.
bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base)
Determine whether the type Derived is a C++ class that is derived from the type Base.
ExprResult ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig=nullptr)
ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
ExprResult ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc, UnaryExprOrTypeTrait ExprKind, bool IsType, void *TyOrEx, SourceRange ArgRange)
ActOnUnaryExprOrTypeTraitExpr - Handle sizeof(type) and sizeof expr and the same for alignof and __al...
QualType PreferredConditionType(ConditionKind K) const
void clearDelayedTypo(TypoExpr *TE)
Clears the state of the given TypoExpr.
@ LOLR_ErrorNoDiagnostic
The lookup found no match but no diagnostic was issued.
@ LOLR_Raw
The lookup found a single 'raw' literal operator, which expects a string literal containing the spell...
@ LOLR_Error
The lookup resulted in an error.
@ LOLR_Cooked
The lookup found a single 'cooked' literal operator, which expects a normal literal to be built and p...
@ LOLR_StringTemplatePack
The lookup found an overload set of literal operator templates, which expect the character type and c...
@ LOLR_Template
The lookup found an overload set of literal operator templates, which expect the characters of the sp...
void ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo, Scope *CurScope)
ActOnBlockArguments - This callback allows processing of block arguments.
QualType CheckRemainderOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign=false)
@ Diagnose
Diagnose issues that are non-constant or that are extensions.
std::pair< ValueDecl *, SourceLocation > PendingImplicitInstantiation
An entity for which implicit template instantiation is required.
unsigned getTemplateDepth(Scope *S) const
Determine the number of levels of enclosing template parameters.
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false, bool ForceNoCPlusPlus=false)
Perform unqualified name lookup starting from a given scope.
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
ExprResult ActOnObjCAvailabilityCheckExpr(llvm::ArrayRef< AvailabilitySpec > AvailSpecs, SourceLocation AtLoc, SourceLocation RParen)
bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType)
Helper function to determine whether this is the (deprecated) C++ conversion from a string literal to...
void computeNRVO(Stmt *Body, sema::FunctionScopeInfo *Scope)
Given the set of return statements within a function body, compute the variables that are subject to ...
void checkNonTrivialCUnion(QualType QT, SourceLocation Loc, NonTrivialCUnionContext UseContext, unsigned NonTrivialKind)
Emit diagnostics if a non-trivial C union type or a struct that contains a non-trivial C union is use...
QualType CheckSubtractionOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, QualType *CompLHSTy=nullptr)
static ConditionResult ConditionError()
ExprResult ActOnConvertVectorExpr(Expr *E, ParsedType ParsedDestTy, SourceLocation BuiltinLoc, SourceLocation RParenLoc)
__builtin_convertvector(...)
void HandleFunctionTypeMismatch(PartialDiagnostic &PDiag, QualType FromType, QualType ToType)
HandleFunctionTypeMismatch - Gives diagnostic information for differeing function types.
const TypoExprState & getTypoExprState(TypoExpr *TE) const
ExprResult checkUnknownAnyArg(SourceLocation callLoc, Expr *result, QualType ¶mType)
Type-check an expression that's being passed to an __unknown_anytype parameter.
bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn, FunctionDecl *FDecl, const FunctionProtoType *Proto, ArrayRef< Expr * > Args, SourceLocation RParenLoc, bool ExecConfig=false)
ConvertArgumentsForCall - Converts the arguments specified in Args/NumArgs to the parameter types of ...
ExprResult ActOnBuiltinOffsetOf(Scope *S, SourceLocation BuiltinLoc, SourceLocation TypeLoc, ParsedType ParsedArgTy, ArrayRef< OffsetOfComponent > Components, SourceLocation RParenLoc)
bool hasAnyUnrecoverableErrorsInThisFunction() const
Determine whether any errors occurred within this function/method/ block.
FullExprArg MakeFullExpr(Expr *Arg)
bool IsFunctionConversion(QualType FromType, QualType ToType, QualType &ResultTy)
Determine whether the conversion from FromType to ToType is a valid conversion that strips "noexcept"...
llvm::SmallVector< std::pair< SourceLocation, const BlockDecl * >, 1 > ImplicitlyRetainedSelfLocs
List of SourceLocations where 'self' is implicitly retained inside a block.
MultiLevelTemplateArgumentList getTemplateInstantiationArgs(const NamedDecl *D, const DeclContext *DC=nullptr, bool Final=false, std::optional< ArrayRef< TemplateArgument > > Innermost=std::nullopt, bool RelativeToPrimary=false, const FunctionDecl *Pattern=nullptr, bool ForConstraintInstantiation=false, bool SkipForSpecialization=false)
Retrieve the template argument list(s) that should be used to instantiate the definition of the given...
bool 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.
StringRef getPlatformName() const
Retrieve the name of the platform as it is used in the availability attribute.
@ CharPtrBuiltinVaList
typedef char* __builtin_va_list;
virtual size_t getMaxBitIntWidth() const
virtual bool useFP16ConversionIntrinsics() const
Check whether llvm intrinsics such as llvm.convert.to.fp16 should be used to convert to and from __fp...
unsigned getTypeWidth(IntType T) const
Return the width (in bits) of the specified integer type enum.
uint64_t getPointerWidth(LangAS AddrSpace) const
Return the width of pointers on this target, for the specified address space.
unsigned getIntWidth() const
getIntWidth/Align - Return the size of 'signed int' and 'unsigned int' for this target,...
IntType getSizeType() const
unsigned getLongLongWidth() const
getLongLongWidth/Align - Return the size of 'signed long long' and 'unsigned long long' for this targ...
bool isTLSSupported() const
Whether the target supports thread-local storage.
virtual bool supportsExtendIntArgs() const
Whether the option -fextend-arguments={32,64} is supported on the target.
virtual BuiltinVaListKind getBuiltinVaListKind() const =0
Returns the kind of __builtin_va_list type that should be used with this target.
bool hasBuiltinMSVaList() const
Returns whether or not type __builtin_ms_va_list type is available on this target.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
unsigned getIntMaxTWidth() const
Return the size of intmax_t and uintmax_t for this target, in bits.
unsigned getLongWidth() const
getLongWidth/Align - Return the size of 'signed long' and 'unsigned long' for this target,...
virtual bool hasFeature(StringRef Feature) const
Determine whether the given target has the given feature.
A convenient class for passing around template argument information.
void setLAngleLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
void addArgument(const TemplateArgumentLoc &Loc)
Location wrapper for a TemplateArgument.
Represents a template argument.
Expr * getAsExpr() const
Retrieve the template argument as an expression.
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
@ Declaration
The template argument is a declaration that was provided for a pointer, reference,...
@ Expression
The template argument is an expression, and we've not resolved it to one of the other forms yet,...
ArgKind getKind() const
Return the kind of stored template argument.
The base class of all kinds of template declarations (e.g., class, function, etc.).
Represents a C++ template name within the type system.
Token - This structure provides full information about a lexed token.
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file.
unsigned getLength() const
void setKind(tok::TokenKind K)
tok::TokenKind getKind() const
void setLocation(SourceLocation L)
void startToken()
Reset all flags to cleared.
void setIdentifierInfo(IdentifierInfo *II)
Represents a declaration of a type.
const Type * getTypeForDecl() const
SourceLocation getBeginLoc() const LLVM_READONLY
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
TypeSpecTypeLoc pushTypeSpec(QualType T)
Pushes space for a typespec TypeLoc.
TypeSourceInfo * getTypeSourceInfo(ASTContext &Context, QualType T)
Creates a TypeSourceInfo for the given type.
Base wrapper for a particular "section" of type source info.
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
void initializeFullCopy(TypeLoc Other)
Initializes this by copying its information from another TypeLoc of the same type.
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
SourceRange getLocalSourceRange() const
Get the local source range.
T getAsAdjusted() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
SourceLocation getBeginLoc() const
Get the begin source location.
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
void setNameLoc(SourceLocation Loc)
The base class of the type hierarchy.
bool isIncompleteOrObjectType() const
Return true if this is an incomplete or object type, in other words, not a function type.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isFixedPointOrIntegerType() const
Return true if this is a fixed point or integer type.
bool isBlockPointerType() const
bool isBooleanType() const
bool isObjCBuiltinType() const
bool hasAttr(attr::Kind AK) const
Determine whether this type had the specified attribute applied to it (looking through top-level type...
const Type * getPointeeOrArrayElementType() const
If this is a pointer type, return the pointee type.
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
bool isPlaceholderType() const
Test for a type which does not represent an actual type-system type but is instead used as a placehol...
bool isComplexType() const
isComplexType() does not include complex integers (a GCC extension).
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
bool canDecayToPointerType() const
Determines whether this type can decay to a pointer type.
bool hasIntegerRepresentation() const
Determine whether this type has an integer representation of some sort, e.g., it is an integer type o...
bool isVoidPointerType() const
const ComplexType * getAsComplexIntegerType() const
bool isFunctionPointerType() const
bool isArithmeticType() const
bool isConstantMatrixType() const
bool isPointerType() const
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
bool isSVESizelessBuiltinType() const
Returns true for SVE scalable vector types.
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
bool isSignedFixedPointType() const
Return true if this is a fixed point type that is signed according to ISO/IEC JTC1 SC22 WG14 N1169.
bool isEnumeralType() const
bool isScalarType() const
bool isVariableArrayType() const
bool isSizelessBuiltinType() const
bool isSveVLSBuiltinType() const
Determines if this is a sizeless type supported by the 'arm_sve_vector_bits' type attribute,...
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
bool isObjCQualifiedIdType() const
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
bool hasUnsignedIntegerRepresentation() const
Determine whether this type has an unsigned integer representation of some sort, e....
bool isExtVectorType() const
bool isAnyCharacterType() const
Determine whether this type is any of the built-in character types.
bool isExtVectorBoolType() const
QualType getSveEltType(const ASTContext &Ctx) const
Returns the representative type for the element of an SVE builtin type.
bool isNonOverloadPlaceholderType() const
Test for a placeholder type other than Overload; see BuiltinType::isNonOverloadPlaceholderType.
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
bool isBitIntType() const
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
bool isBuiltinType() const
Helper methods to distinguish type categories.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool isAnyComplexType() const
bool isFixedPointType() const
Return true if this is a fixed point type according to ISO/IEC JTC1 SC22 WG14 N1169.
bool isSaturatedFixedPointType() const
Return true if this is a saturated fixed point type according to ISO/IEC JTC1 SC22 WG14 N1169.
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
ScalarTypeKind getScalarTypeKind() const
Given that this is a scalar type, classify it.
const BuiltinType * getAsPlaceholderType() const
bool hasSignedIntegerRepresentation() const
Determine whether this type has an signed integer representation of some sort, e.g....
bool isWebAssemblyTableType() const
Returns true if this is a WebAssembly table type: either an array of reference types,...
bool isMemberPointerType() const
bool isAtomicType() const
bool isOverloadableType() const
Determines whether this is a type for which one can define an overloaded operator.
bool isObjCIdType() const
bool isMatrixType() const
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isComplexIntegerType() const
bool isUnscopedEnumerationType() const
bool isObjCObjectType() const
bool isBlockCompatibleObjCPointerType(ASTContext &ctx) const
const ArrayType * getAsArrayTypeUnsafe() const
A variant of getAs<> for array types which silently discards qualifiers from the outermost type.
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isFunctionType() const
bool isObjCObjectPointerType() const
bool hasFloatingRepresentation() const
Determine whether this type has a floating-point representation of some sort, e.g....
bool isUnsignedFixedPointType() const
Return true if this is a fixed point type that is unsigned according to ISO/IEC JTC1 SC22 WG14 N1169.
bool isVectorType() const
bool isObjCQualifiedClassType() const
bool isObjCClassType() const
bool isRealFloatingType() const
Floating point categories.
bool isRVVSizelessBuiltinType() const
Returns true for RVV scalable vector types.
bool isFloatingType() const
bool isUnsignedIntegerType() const
Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...
bool isAnyPointerType() const
TypeClass getTypeClass() const
const T * getAs() const
Member-template getAs<specific type>'.
bool isNullPtrType() const
bool isRecordType() const
std::optional< NullabilityKind > getNullability() const
Determine the nullability of the given type.
bool isSizelessVectorType() const
Returns true for all scalable vector types.
Represents the declaration of a typedef-name via the 'typedef' type specifier.
Simple class containing the result of Sema::CorrectTypo.
IdentifierInfo * getCorrectionAsIdentifierInfo() const
std::string getAsString(const LangOptions &LO) const
SourceRange getCorrectionRange() const
void WillReplaceSpecifier(bool ForceReplacement)
DeclClass * getCorrectionDeclAs() const
DeclarationName getCorrection() const
Gets the DeclarationName of the typo correction.
NestedNameSpecifier * getCorrectionSpecifier() const
Gets the NestedNameSpecifier needed to use the typo correction.
bool isOverloaded() const
NamedDecl * getFoundDecl() const
Get the correction declaration found by name lookup (before we looked through using shadow declaratio...
TypoExpr - Internal placeholder for expressions where typo correction still needs to be performed and...
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand.
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
SourceLocation getOperatorLoc() const
getOperatorLoc - Return the location of the operator.
Expr * getSubExpr() const
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)
Retrieve the overloaded operator kind that corresponds to the given unary opcode.
static UnaryOperator * Create(const ASTContext &C, Expr *input, Opcode opc, QualType type, ExprValueKind VK, ExprObjectKind OK, SourceLocation l, bool CanOverflow, FPOptionsOverride FPFeatures)
bool isIncrementDecrementOp() const
An artificial decl, representing a global anonymous constant value which is uniquified by value withi...
Represents a C++ unqualified-id that has been parsed.
void setImplicitSelfParam(const IdentifierInfo *Id)
Specify that this unqualified-id is an implicit 'self' parameter.
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
static UnresolvedLookupExpr * Create(const ASTContext &Context, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool RequiresADL, UnresolvedSetIterator Begin, UnresolvedSetIterator End, bool KnownDependent)
Represents a C++ member access expression for which lookup produced a set of overloaded functions.
CXXRecordDecl * getNamingClass()
Retrieve the naming class of this lookup.
bool isImplicitAccess() const
True if this is an implicit access, i.e., one in which the member being accessed was not written in t...
A set of unresolved declarations.
A set of unresolved declarations.
A call to a literal operator (C++11 [over.literal]) written as a user-defined literal (C++11 [lit....
Represents a call to the builtin function __builtin_va_arg.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
void setType(QualType newType)
bool isWeak() const
Determine whether this symbol is weakly-imported, or declared with the weak or weak-ref attr.
VarDecl * getPotentiallyDecomposedVarDecl()
Represents a variable declaration or definition.
VarDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
bool isStaticDataMember() const
Determines whether this is a static data member.
bool hasGlobalStorage() const
Returns true for all variables that do not have local storage.
bool mightBeUsableInConstantExpressions(const ASTContext &C) const
Determine whether this variable's value might be usable in a constant expression, according to the re...
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
For a static data member that was instantiated from a static data member of a class template,...
bool isInline() const
Whether this variable is (C++1z) inline.
const Expr * getInit() const
bool hasExternalStorage() const
Returns true if a variable has extern or private_extern storage.
bool isARCPseudoStrong() const
Determine whether this variable is an ARC pseudo-__strong variable.
bool hasLocalStorage() const
Returns true if a variable with function scope is a non-static local variable.
@ TLS_None
Not a TLS variable.
@ DeclarationOnly
This declaration is only a declaration.
DefinitionKind hasDefinition(ASTContext &) const
Check whether this variable is defined in this translation unit.
bool isUsableInConstantExpressions(const ASTContext &C) const
Determine whether this variable's value can be used in a constant expression, according to the releva...
SourceLocation getPointOfInstantiation() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
bool isLocalVarDeclOrParm() const
Similar to isLocalVarDecl but also includes parameters.
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this variable is an instantiation of a static data member of a class template specialization,...
Declaration of a variable template.
Represents a C array with a specified size that is not an integer-constant-expression.
Expr * getSizeExpr() const
Represents a GCC generic vector type.
unsigned getNumElements() const
VectorKind getVectorKind() const
QualType getElementType() const
Policy getDefaultPolicy()
Retains information about a block that is currently being parsed.
Scope * TheScope
TheScope - This is the scope for the block itself, which contains arguments etc.
QualType FunctionType
BlockType - The function type of the block, if one was given.
ValueDecl * getVariable() const
bool isBlockCapture() const
SourceLocation getLocation() const
Retrieve the location at which this variable was captured.
void markUsed(bool IsODRUse)
bool isThisCapture() const
QualType getCaptureType() const
Retrieve the capture type for this capture, which is effectively the type of the non-static data memb...
bool isCopyCapture() const
Retains information about a captured region.
unsigned short OpenMPLevel
unsigned short CapRegionKind
The kind of captured region.
unsigned short OpenMPCaptureLevel
void addVLATypeCapture(SourceLocation Loc, const VariableArrayType *VLAType, QualType CaptureType)
QualType ReturnType
ReturnType - The target type of return statements in this context, or null if unknown.
SmallVector< Capture, 4 > Captures
Captures - The captures.
ImplicitCaptureStyle ImpCaptureStyle
unsigned CXXThisCaptureIndex
CXXThisCaptureIndex - The (index+1) of the capture of 'this'; zero if 'this' is not captured.
bool HasImplicitReturnType
Capture & getCXXThisCapture()
Retrieve the capture of C++ 'this', if it has been captured.
llvm::DenseMap< ValueDecl *, unsigned > CaptureMap
CaptureMap - A map of captured variables to (index+1) into Captures.
bool isCXXThisCaptured() const
Determine whether the C++ 'this' is captured.
bool isVLATypeCaptured(const VariableArrayType *VAT) const
Determine whether the given variable-array type has been captured.
void addCapture(ValueDecl *Var, bool isBlock, bool isByref, bool isNested, SourceLocation Loc, SourceLocation EllipsisLoc, QualType CaptureType, bool Invalid)
Capture & getCapture(ValueDecl *Var)
Retrieve the capture of the given variable, if it has been captured already.
Retains information about a function, method, or block that is currently being parsed.
void recordUseOfWeak(const ExprT *E, bool IsRead=true)
Record that a weak object was accessed.
void markSafeWeakUse(const Expr *E)
Record that a given expression is a "safe" access of a weak object (e.g.
void addBlock(const BlockDecl *BD)
void setHasBranchProtectedScope()
llvm::SmallVector< AddrLabelExpr *, 4 > AddrLabels
The set of GNU address of label extension "&&label".
bool HasOMPDeclareReductionCombiner
True if current scope is for OpenMP declare reduction combiner.
SourceRange IntroducerRange
Source range covering the lambda introducer [...].
bool lambdaCaptureShouldBeConst() const
void addPotentialCapture(Expr *VarExpr)
Add a variable that might potentially be captured by the lambda and therefore the enclosing lambdas.
void addPotentialThisCapture(SourceLocation Loc)
CXXRecordDecl * Lambda
The class that describes the lambda.
unsigned NumExplicitCaptures
The number of captures in the Captures list that are explicit captures.
bool AfterParameterList
Indicate that we parsed the parameter list at which point the mutability of the lambda is known.
CXXMethodDecl * CallOperator
The lambda's compiler-generated operator().
Defines the clang::TargetInfo interface.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
bool isStringLiteral(TokenKind K)
Return true if this is a C or C++ string-literal (or C++11 user-defined-string-literal) token.
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
The JSON file list parser is used to communicate input to InstallAPI.
@ Vector
'vector' clause, allowed on 'loop', Combined, and 'routine' directives.
@ Self
'self' clause, allowed on Compute and Combined Constructs, plus 'update'.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
@ OO_None
Not an overloaded operator.
bool isa(CodeGen::Address addr)
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))
@ OR_Success
Overload resolution succeeded.
bool isTargetAddressSpace(LangAS AS)
DeclContext * getLambdaAwareParentOfDeclContext(DeclContext *DC)
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
NullabilityKind
Describes the nullability of a particular type.
@ Nullable
Values of this type can be null.
@ Unspecified
Whether values of this type can be null is (explicitly) unspecified.
@ NonNull
Values of this type can never be null.
ExprObjectKind
A further classification of the kind of object referenced by an l-value or x-value.
@ OK_VectorComponent
A vector component is an element or range of elements on a vector.
@ OK_ObjCProperty
An Objective-C property is a logical field of an Objective-C object which is read and written via Obj...
@ OK_Ordinary
An ordinary object is located at an address in memory.
@ OK_BitField
A bitfield object is a bitfield on a C or C++ record.
@ OK_MatrixComponent
A matrix component is a single element of a matrix.
@ IK_ImplicitSelfParam
An implicit 'self' parameter.
@ IK_TemplateId
A template-id, e.g., f<int>.
llvm::omp::Clause OpenMPClauseKind
OpenMP clauses.
std::optional< ComparisonCategoryType > getComparisonCategoryForBuiltinCmp(QualType T)
Get the comparison category that should be used when comparing values of type T.
UnaryExprOrTypeTrait
Names for the "expression or type" traits.
ObjCMethodFamily
A family of Objective-C methods.
unsigned toTargetAddressSpace(LangAS AS)
@ Internal
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
TemplateDecl * getAsTypeTemplateDecl(Decl *D)
bool isLambdaCallOperator(const CXXMethodDecl *MD)
@ Result
The result type of a method or function.
ImplicitConversionKind
ImplicitConversionKind - The kind of implicit conversion used to convert an argument to a parameter's...
@ ICK_Complex_Conversion
Complex conversions (C99 6.3.1.6)
@ ICK_Integral_Conversion
Integral conversions (C++ [conv.integral])
@ ICK_Floating_Integral
Floating-integral conversions (C++ [conv.fpint])
@ ICK_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.
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
ActionResult< Decl * > DeclResult
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
@ TSK_ExplicitInstantiationDeclaration
This template specialization was instantiated from a template due to an explicit instantiation declar...
@ TSK_ImplicitInstantiation
This template specialization was implicitly instantiated from a template.
@ TSK_Undeclared
This template specialization was formed from a template-id but has not yet been declared,...
CallingConv
CallingConv - Specifies the calling convention that a function uses.
@ AltiVecBool
is AltiVec 'vector bool ...'
@ SveFixedLengthData
is AArch64 SVE fixed-length data vector
@ AltiVecVector
is AltiVec vector
@ AltiVecPixel
is AltiVec 'vector Pixel'
@ Generic
not a target-specific vector type
@ RVVFixedLengthData
is RISC-V RVV fixed-length data vector
@ RVVFixedLengthMask
is RISC-V RVV fixed-length mask vector
@ SveFixedLengthPredicate
is AArch64 SVE fixed-length predicate vector
@ None
No keyword precedes the qualified type name.
@ Other
Other implicit parameter.
@ Implicit
An implicit conversion.
bool isGenericLambdaCallOperatorSpecialization(const CXXMethodDecl *MD)
NonOdrUseReason
The reason why a DeclRefExpr does not constitute an odr-use.
@ NOUR_Discarded
This name appears as a potential result of a discarded value expression.
@ NOUR_Unevaluated
This name appears in an unevaluated operand.
@ NOUR_None
This is an odr-use.
@ NOUR_Constant
This name appears as a potential result of an lvalue-to-rvalue conversion that is a constant expressi...
Represents an element in a path from a derived class to a base class.
The class facilities generation and storage of conversion FixIts.
OverloadFixItKind Kind
The type of fix applied.
bool tryToFixConversion(const Expr *FromExpr, const QualType FromQTy, const QualType ToQTy, Sema &S)
If possible, generates and stores a fix for the given conversion.
std::vector< FixItHint > Hints
The list of Hints generated so far.
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
DeclarationName getName() const
getName - Returns the embedded declaration name.
void setCXXLiteralOperatorNameLoc(SourceLocation Loc)
setCXXLiteralOperatorNameLoc - Sets the location of the literal operator name (not the operator keywo...
SourceLocation getBeginLoc() const
getBeginLoc - Retrieve the location of the first token.
SourceLocation getEndLoc() const LLVM_READONLY
EvalResult is a struct with detailed info about an evaluated expression.
APValue Val
Val - This is the value the expression can be folded to.
SmallVectorImpl< PartialDiagnosticAt > * Diag
Diag - If this is non-null, it will be filled in with a stack of notes indicating why evaluation fail...
bool HasSideEffects
Whether the evaluated expression has side effects.
Extra information about a function prototype.
unsigned HasTrailingReturn
FunctionType::ExtInfo ExtInfo
bool HasFormOfMemberPointer
OverloadExpr * Expression
@ DefaultFunctionArgumentInstantiation
We are instantiating a default argument for a function.
Data structure used to record current or nested expression evaluation contexts.
llvm::SmallPtrSet< const Expr *, 8 > PossibleDerefs
bool InLifetimeExtendingContext
Whether we are currently in a context in which all temporaries must be lifetime-extended,...
SmallVector< Expr *, 2 > VolatileAssignmentLHSs
Expressions appearing as the LHS of a volatile assignment in this context.
bool isUnevaluated() const
llvm::SmallPtrSet< DeclRefExpr *, 4 > ReferenceToConsteval
Set of DeclRefExprs referencing a consteval function when used in a context not already known to be i...
llvm::SmallVector< ImmediateInvocationCandidate, 4 > ImmediateInvocationCandidates
Set of candidates for starting an immediate invocation.
SmallVector< MaterializeTemporaryExpr *, 8 > ForRangeLifetimeExtendTemps
P2718R0 - Lifetime extension in range-based for loops.
enum clang::Sema::ExpressionEvaluationContextRecord::ExpressionKind ExprContext
SmallVector< LambdaExpr *, 2 > Lambdas
The lambdas that are present within this context, if it is indeed an unevaluated context.
ExpressionKind
Describes whether we are in an expression constext which we have to handle differently.
MaybeODRUseExprSet SavedMaybeODRUseExprs
CleanupInfo ParentCleanup
Whether the enclosing context needed a cleanup.
unsigned NumTypos
The number of typos encountered during this expression evaluation context (i.e.
bool isConstantEvaluated() const
ExpressionEvaluationContext Context
The expression evaluation context.
bool InImmediateEscalatingFunctionContext
unsigned NumCleanupObjects
The number of active cleanup objects when we entered this expression evaluation context.
Abstract class used to diagnose incomplete types.
Location information for a TemplateArgument.