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();
5079 if (isa<ParenListExpr>(base)) {
5083 base = result.
get();
5090 auto CheckAndReportCommaError = [
this, base, rbLoc](
Expr *E) {
5091 if (isa<BinaryOperator>(E) && cast<BinaryOperator>(E)->isCommaOp()) {
5092 Diag(E->getExprLoc(), diag::err_matrix_subscript_comma)
5102 !isa<MatrixSubscriptExpr>(base)) {
5103 Diag(base->
getExprLoc(), diag::err_matrix_separate_incomplete_index)
5109 auto *matSubscriptE = dyn_cast<MatrixSubscriptExpr>(base);
5110 if (matSubscriptE) {
5111 assert(ArgExprs.size() == 1);
5112 if (CheckAndReportCommaError(ArgExprs.front()))
5115 assert(matSubscriptE->isIncomplete() &&
5116 "base has to be an incomplete matrix subscript");
5118 matSubscriptE->getRowIdx(),
5119 ArgExprs.front(), rbLoc);
5132 bool IsMSPropertySubscript =
false;
5135 if (!IsMSPropertySubscript) {
5139 base = result.
get();
5145 assert(ArgExprs.size() == 1);
5146 if (CheckAndReportCommaError(ArgExprs.front()))
5154 Expr *idx = ArgExprs[0];
5155 if ((isa<BinaryOperator>(idx) && cast<BinaryOperator>(idx)->isCommaOp()) ||
5156 (isa<CXXOperatorCallExpr>(idx) &&
5157 cast<CXXOperatorCallExpr>(idx)->getOperator() == OO_Comma)) {
5163 if (ArgExprs.size() == 1 &&
5164 ArgExprs[0]->getType()->isNonOverloadPlaceholderType()) {
5168 ArgExprs[0] = result.
get();
5178 !isa<PackExpansionExpr>(ArgExprs[0])) {
5180 base, ArgExprs.front(),
5193 if (IsMSPropertySubscript) {
5194 assert(ArgExprs.size() == 1);
5212 (ArgExprs.size() != 1 || isa<PackExpansionExpr>(ArgExprs[0]) ||
5213 ArgExprs[0]->getType()->isRecordType())))) {
5220 if (!Res.
isInvalid() && isa<ArraySubscriptExpr>(Res.
get()))
5221 CheckSubscriptAccessOfNoDeref(cast<ArraySubscriptExpr>(Res.
get()));
5231 return InitSeq.
Perform(*
this, Entity, Kind, E);
5245 RowIdx = RowR.
get();
5260 ColumnIdx = ColumnR.
get();
5265 auto IsIndexValid = [&](
Expr *IndexExpr,
unsigned Dim,
5266 bool IsColumnIdx) ->
Expr * {
5274 if (std::optional<llvm::APSInt> Idx =
5276 if ((*Idx < 0 || *Idx >= Dim)) {
5278 << IsColumnIdx << Dim;
5286 "should be able to convert any integer type to size type");
5287 return ConvExpr.
get();
5291 RowIdx = IsIndexValid(RowIdx, MTy->getNumRows(),
false);
5292 ColumnIdx = IsIndexValid(ColumnIdx, MTy->getNumColumns(),
true);
5293 if (!RowIdx || !ColumnIdx)
5297 MTy->getElementType(), RBLoc);
5300void Sema::CheckAddressOfNoDeref(
const Expr *E) {
5307 while ((
Member = dyn_cast<MemberExpr>(StrippedExpr)) && !
Member->isArrow())
5308 StrippedExpr =
Member->getBase()->IgnoreParenImpCasts();
5310 LastRecord.PossibleDerefs.erase(StrippedExpr);
5321 if (isa<ArrayType>(ResultTy))
5324 if (ResultTy->
hasAttr(attr::NoDeref)) {
5325 LastRecord.PossibleDerefs.insert(E);
5333 if (!(isa<ArrayType>(BaseTy) || isa<PointerType>(BaseTy)))
5338 while ((
Member = dyn_cast<MemberExpr>(
Base->IgnoreParenCasts())) &&
5342 if (
const auto *Ptr = dyn_cast<PointerType>(
Base->getType())) {
5343 if (Ptr->getPointeeType()->hasAttr(attr::NoDeref))
5344 LastRecord.PossibleDerefs.insert(E);
5360 for (
auto *Op : {LHSExp, RHSExp}) {
5361 Op = Op->IgnoreImplicit();
5362 if (Op->getType()->isArrayType() && !Op->isLValue())
5385 Expr *BaseExpr, *IndexExpr;
5420 Diag(LLoc, diag::err_subscript_nonfragile_interface)
5432 LHSExp = Materialized.
get();
5438 ResultType = VTy->getElementType();
5442 Qualifiers Combined = BaseQuals + MemberQuals;
5443 if (Combined != MemberQuals)
5458 LHSExp = Materialized.
get();
5469 Qualifiers Combined = BaseQuals + MemberQuals;
5470 if (Combined != MemberQuals)
5481 CK_ArrayToPointerDecay).
get();
5487 }
else if (RHSTy->isArrayType()) {
5492 CK_ArrayToPointerDecay).
get();
5499 return ExprError(
Diag(LLoc, diag::err_typecheck_subscript_value)
5504 return ExprError(
Diag(LLoc, diag::err_typecheck_subscript_not_integer)
5510 std::optional<llvm::APSInt> IntegerContantExpr =
5512 if (!IntegerContantExpr.has_value() ||
5513 IntegerContantExpr.value().isNegative())
5529 Diag(LLoc, diag::ext_gnu_subscript_void_type)
5540 diag::err_subscript_incomplete_or_sizeless_type, BaseExpr))
5553 auto *CSI = dyn_cast<CapturingScopeInfo>(*I);
5557 if (
auto *LSI = dyn_cast<LambdaScopeInfo>(CSI))
5558 DC = LSI->CallOperator;
5559 else if (
auto *CRSI = dyn_cast<CapturedRegionScopeInfo>(CSI))
5560 DC = CRSI->TheCapturedDecl;
5561 else if (
auto *BSI = dyn_cast<BlockScopeInfo>(CSI))
5579 bool SkipImmediateInvocations) {
5581 assert(!RewrittenInit &&
"Should not have a rewritten init expression yet");
5585 Diag(Param->
getBeginLoc(), diag::err_recursive_default_argument) << FD;
5586 Diag(CallLoc, diag::note_recursive_default_argument_used_here);
5591 Diag(CallLoc, diag::err_use_of_default_argument_to_function_declared_later)
5594 diag::note_default_argument_declared_here);
5599 assert(!RewrittenInit &&
"Should not have a rewitten init expression yet");
5605 assert(
Init &&
"default argument but no initializer?");
5614 if (
auto *InitWithCleanup = dyn_cast<ExprWithCleanups>(
Init)) {
5621 assert(!InitWithCleanup->getNumObjects() &&
5622 "default argument expression has capturing blocks?");
5635 SkipImmediateInvocations;
5646 bool HasImmediateCalls =
false;
5651 HasImmediateCalls |= FD->isImmediateFunction();
5657 HasImmediateCalls |= FD->isImmediateFunction();
5666 HasImmediateCalls =
true;
5681 return TraverseStmt(E->
getExpr());
5685 return TraverseStmt(E->
getExpr());
5710 assert(Param->
hasDefaultArg() &&
"can't build nonexistent default arg");
5714 std::optional<ExpressionEvaluationContextRecord::InitializationContext>
5715 InitializationContext =
5717 if (!InitializationContext.has_value())
5718 InitializationContext.emplace(CallLoc, Param,
CurContext);
5744 if (!NestedDefaultChecking)
5745 V.TraverseDecl(Param);
5749 if (
V.HasImmediateCalls || InLifetimeExtendingContext) {
5750 if (
V.HasImmediateCalls)
5759 Res = Immediate.TransformInitializer(Param->
getInit(),
5773 CallLoc, FD, Param,
Init,
5774 NestedDefaultChecking))
5778 Init, InitializationContext->Context);
5782 assert(Field->hasInClassInitializer());
5785 if (Field->isInvalidDecl())
5790 auto *ParentRD = cast<CXXRecordDecl>(Field->getParent());
5792 std::optional<ExpressionEvaluationContextRecord::InitializationContext>
5793 InitializationContext =
5795 if (!InitializationContext.has_value())
5796 InitializationContext.emplace(Loc, Field,
CurContext);
5805 if (!Field->getInClassInitializer()) {
5811 ClassPattern->
lookup(Field->getDeclName());
5814 for (
auto *L : Lookup) {
5815 if ((Pattern = dyn_cast<FieldDecl>(L)))
5818 assert(Pattern &&
"We must have set the Pattern!");
5822 Field->setInvalidDecl();
5834 if (!NestedDefaultChecking)
5835 V.TraverseDecl(Field);
5836 if (
V.HasImmediateCalls) {
5840 NestedDefaultChecking;
5845 Res = Immediate.TransformInitializer(Field->getInClassInitializer(),
5851 Field->setInvalidDecl();
5857 if (Field->getInClassInitializer()) {
5858 Expr *E =
Init ?
Init : Field->getInClassInitializer();
5859 if (!NestedDefaultChecking)
5867 if (Res.isInvalid()) {
5868 Field->setInvalidDecl();
5874 Field, InitializationContext->Context,
5893 Diag(Loc, diag::err_default_member_initializer_not_yet_parsed)
5894 << OutermostClass << Field;
5895 Diag(Field->getEndLoc(),
5896 diag::note_default_member_initializer_not_yet_parsed);
5899 Field->setInvalidDecl();
5907 if (isa_and_nonnull<CXXConstructorDecl>(FDecl))
5912 if (
CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl))
5913 if (Method->isInstance())
5928 FunctionName(FuncName) {}
5930 bool ValidateCandidate(
const TypoCorrection &candidate)
override {
5939 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
5940 return std::make_unique<FunctionCallCCC>(*
this);
5960 if (
NamedDecl *ND = Corrected.getFoundDecl()) {
5961 if (Corrected.isOverloaded()) {
5971 ND = Best->FoundDecl;
5972 Corrected.setCorrectionDecl(ND);
5978 ND = ND->getUnderlyingDecl();
5979 if (isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND))
5998 bool IsExecConfig) {
6007 bool HasExplicitObjectParameter =
6009 unsigned ExplicitObjectParameterOffset = HasExplicitObjectParameter ? 1 : 0;
6020 if (Args.size() < NumParams) {
6021 if (Args.size() < MinArgs) {
6026 ? diag::err_typecheck_call_too_few_args_suggest
6027 : diag::err_typecheck_call_too_few_args_at_least_suggest;
6030 << FnKind << MinArgs - ExplicitObjectParameterOffset
6031 <<
static_cast<unsigned>(Args.size()) -
6032 ExplicitObjectParameterOffset
6034 }
else if (MinArgs - ExplicitObjectParameterOffset == 1 && FDecl &&
6039 ? diag::err_typecheck_call_too_few_args_one
6040 : diag::err_typecheck_call_too_few_args_at_least_one)
6041 << FnKind << FDecl->
getParamDecl(ExplicitObjectParameterOffset)
6045 ? diag::err_typecheck_call_too_few_args
6046 : diag::err_typecheck_call_too_few_args_at_least)
6047 << FnKind << MinArgs - ExplicitObjectParameterOffset
6048 <<
static_cast<unsigned>(Args.size()) -
6049 ExplicitObjectParameterOffset
6053 if (!TC && FDecl && !FDecl->
getBuiltinID() && !IsExecConfig)
6061 assert((
Call->getNumArgs() == NumParams) &&
6062 "We should have reserved space for the default arguments before!");
6067 if (Args.size() > NumParams) {
6073 ? diag::err_typecheck_call_too_many_args_suggest
6074 : diag::err_typecheck_call_too_many_args_at_most_suggest;
6077 << FnKind << NumParams - ExplicitObjectParameterOffset
6078 <<
static_cast<unsigned>(Args.size()) -
6079 ExplicitObjectParameterOffset
6081 }
else if (NumParams - ExplicitObjectParameterOffset == 1 && FDecl &&
6084 Diag(Args[NumParams]->getBeginLoc(),
6085 MinArgs == NumParams
6086 ? diag::err_typecheck_call_too_many_args_one
6087 : diag::err_typecheck_call_too_many_args_at_most_one)
6088 << FnKind << FDecl->
getParamDecl(ExplicitObjectParameterOffset)
6089 <<
static_cast<unsigned>(Args.size()) -
6090 ExplicitObjectParameterOffset
6093 Args.back()->getEndLoc());
6095 Diag(Args[NumParams]->getBeginLoc(),
6096 MinArgs == NumParams
6097 ? diag::err_typecheck_call_too_many_args
6098 : diag::err_typecheck_call_too_many_args_at_most)
6099 << FnKind << NumParams - ExplicitObjectParameterOffset
6100 <<
static_cast<unsigned>(Args.size()) -
6101 ExplicitObjectParameterOffset
6104 Args.back()->getEndLoc());
6107 if (!TC && FDecl && !FDecl->
getBuiltinID() && !IsExecConfig)
6112 Call->shrinkNumArgs(NumParams);
6123 unsigned TotalNumArgs = AllArgs.size();
6124 for (
unsigned i = 0; i < TotalNumArgs; ++i)
6125 Call->setArg(i, AllArgs[i]);
6127 Call->computeDependence();
6136 bool IsListInitialization) {
6141 for (
unsigned i = FirstParam; i < NumParams; i++) {
6146 if (ArgIx < Args.size()) {
6147 Arg = Args[ArgIx++];
6150 diag::err_call_incomplete_argument, Arg))
6154 bool CFAudited =
false;
6156 FDecl && FDecl->
hasAttr<CFAuditedTransferAttr>() &&
6157 (!Param || !Param->
hasAttr<CFConsumedAttr>()))
6160 FDecl && FDecl->
hasAttr<CFAuditedTransferAttr>() &&
6161 (!Param || !Param->
hasAttr<CFConsumedAttr>()))
6167 BE->getBlockDecl()->setDoesNotEscape();
6180 Entity,
SourceLocation(), Arg, IsListInitialization, AllowExplicit);
6186 assert(Param &&
"can't use default arguments without a known callee");
6198 CheckArrayAccess(Arg);
6203 AllArgs.push_back(Arg);
6212 for (
Expr *A : Args.slice(ArgIx)) {
6216 AllArgs.push_back(arg.get());
6221 for (
Expr *A : Args.slice(ArgIx)) {
6224 AllArgs.push_back(Arg.
get());
6229 for (
Expr *A : Args.slice(ArgIx))
6230 CheckArrayAccess(A);
6238 TL = DTL.getOriginalLoc();
6241 << ATL.getLocalSourceRange();
6255 const Expr *ArgExpr) {
6285 Diag(CallLoc, diag::warn_static_array_too_small)
6293 std::optional<CharUnits> ArgSize =
6295 std::optional<CharUnits> ParmSize =
6297 if (ArgSize && ParmSize && *ArgSize < *ParmSize) {
6298 Diag(CallLoc, diag::warn_static_array_too_small)
6300 << (
unsigned)ParmSize->getQuantity() << 1;
6314 if (!placeholder)
return false;
6316 switch (placeholder->
getKind()) {
6318#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
6319 case BuiltinType::Id:
6320#include "clang/Basic/OpenCLImageTypes.def"
6321#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
6322 case BuiltinType::Id:
6323#include "clang/Basic/OpenCLExtensionTypes.def"
6326#define SVE_TYPE(Name, Id, SingletonId) \
6327 case BuiltinType::Id:
6328#include "clang/Basic/AArch64SVEACLETypes.def"
6329#define PPC_VECTOR_TYPE(Name, Id, Size) \
6330 case BuiltinType::Id:
6331#include "clang/Basic/PPCTypes.def"
6332#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
6333#include "clang/Basic/RISCVVTypes.def"
6334#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
6335#include "clang/Basic/WebAssemblyReferenceTypes.def"
6336#define PLACEHOLDER_TYPE(ID, SINGLETON_ID)
6337#define BUILTIN_TYPE(ID, SINGLETON_ID) case BuiltinType::ID:
6338#include "clang/AST/BuiltinTypes.def"
6343 case BuiltinType::Overload:
6348 case BuiltinType::ARCUnbridgedCast:
6352 case BuiltinType::PseudoObject:
6357 case BuiltinType::UnknownAny:
6361 case BuiltinType::BoundMember:
6362 case BuiltinType::BuiltinFn:
6363 case BuiltinType::IncompleteMatrixIdx:
6364 case BuiltinType::OMPArraySection:
6365 case BuiltinType::OMPArrayShaping:
6366 case BuiltinType::OMPIterator:
6370 llvm_unreachable(
"bad builtin type kind");
6376 bool hasInvalid =
false;
6377 for (
size_t i = 0, e = args.size(); i != e; i++) {
6380 if (result.
isInvalid()) hasInvalid =
true;
6381 else args[i] = result.
get();
6409 bool NeedsNewDecl =
false;
6422 if (!ParamType->isPointerType() || ParamType.hasAddressSpace() ||
6426 OverloadParams.push_back(ParamType);
6434 NeedsNewDecl =
true;
6447 OverloadParams, EPI);
6456 FT = cast<FunctionProtoType>(OverloadTy);
6457 for (
unsigned i = 0, e = FT->
getNumParams(); i != e; ++i) {
6464 Params.push_back(Parm);
6466 OverloadDecl->setParams(Params);
6468 return OverloadDecl;
6479 !Callee->isVariadic())
6481 if (Callee->getMinRequiredArguments() > ArgExprs.size())
6484 if (
const EnableIfAttr *
Attr =
6487 isa<CXXMethodDecl>(Callee)
6488 ? diag::err_ovl_no_viable_member_function_in_call
6489 : diag::err_ovl_no_viable_function_in_call)
6490 << Callee << Callee->getSourceRange();
6491 S.
Diag(Callee->getLocation(),
6492 diag::note_ovl_candidate_disabled_by_function_cond_attr)
6493 <<
Attr->getCond()->getSourceRange() <<
Attr->getMessage();
6501 const auto GetFunctionLevelDCIfCXXClass =
6509 if (
const auto *MD = dyn_cast<CXXMethodDecl>(DC))
6510 return MD->
getParent()->getCanonicalDecl();
6513 if (
const auto *RD = dyn_cast<CXXRecordDecl>(DC))
6514 return RD->getCanonicalDecl();
6521 const CXXRecordDecl *
const CurParentClass = GetFunctionLevelDCIfCXXClass(S);
6522 if (!CurParentClass)
6529 assert(NamingClass &&
"Must have naming class even for implicit access");
6535 return CurParentClass == NamingClass ||
6584 if (
Call->getNumArgs() != 1)
6587 const Expr *E =
Call->getCallee()->IgnoreParenImpCasts();
6588 if (!E || isa<UnresolvedLookupExpr>(E))
6590 const DeclRefExpr *DRE = dyn_cast_if_present<DeclRefExpr>(E);
6603 if (BuiltinID != Builtin::BImove && BuiltinID != Builtin::BIforward)
6606 S.
Diag(DRE->
getLocation(), diag::warn_unqualified_call_to_std_cast_function)
6617 if (
Call.isInvalid())
6622 if (
const auto *ULE = dyn_cast<UnresolvedLookupExpr>(Fn);
6623 ULE && ULE->hasExplicitTemplateArgs() &&
6624 ULE->decls_begin() == ULE->decls_end()) {
6626 ? diag::warn_cxx17_compat_adl_only_template_id
6627 : diag::ext_adl_only_template_id)
6635 if (
const auto *CE = dyn_cast<CallExpr>(
Call.get()))
6646 Expr *ExecConfig,
bool IsExecConfig,
6647 bool AllowRecovery) {
6658 if (isa<CXXPseudoDestructorExpr>(Fn)) {
6659 if (!ArgExprs.empty()) {
6664 ArgExprs.back()->getEndLoc()));
6681 cast<CallExpr>(ExecConfig), ArgExprs,
6687 *
this, dyn_cast<UnresolvedMemberExpr>(Fn->
IgnoreParens()),
6708 RParenLoc, ExecConfig, IsExecConfig,
6725 Scope, Fn, ULE, LParenLoc, ArgExprs, RParenLoc, ExecConfig,
6728 RParenLoc, ExecConfig, IsExecConfig,
6742 bool CallingNDeclIndirectly =
false;
6744 if (
UnaryOperator *UnOp = dyn_cast<UnaryOperator>(NakedFn)) {
6745 if (UnOp->getOpcode() == UO_AddrOf) {
6746 CallingNDeclIndirectly =
true;
6751 if (
auto *DRE = dyn_cast<DeclRefExpr>(NakedFn)) {
6752 NDecl = DRE->getDecl();
6765 nullptr, DRE->isNonOdrUse());
6768 }
else if (
auto *ME = dyn_cast<MemberExpr>(NakedFn))
6769 NDecl = ME->getMemberDecl();
6771 if (
FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(NDecl)) {
6785 FD->getBuiltinID()) {
6786 for (
unsigned Idx = 0; Idx < FD->param_size(); ++Idx) {
6789 !ArgExprs[Idx]->getType()->isPointerType())
6793 auto ArgTy = ArgExprs[Idx]->getType();
6794 auto ArgPtTy = ArgTy->getPointeeType();
6795 auto ArgAS = ArgPtTy.getAddressSpace();
6798 bool NeedImplicitASC =
6803 if (!NeedImplicitASC)
6807 if (ArgExprs[Idx]->isGLValue()) {
6809 Context, ArgExprs[Idx]->getType(), CK_NoOp, ArgExprs[Idx],
6814 Qualifiers ArgPtQuals = ArgPtTy.getQualifiers();
6824 CK_AddressSpaceConversion)
6834 llvm::any_of(ArgExprs,
6835 [](
clang::Expr *E) { return E->containsErrors(); })) &&
6836 "should only occur in error-recovery path.");
6841 ExecConfig, IsExecConfig);
6854 assert(BuiltInDecl &&
"failed to find builtin declaration");
6858 assert(DeclRef.
isUsable() &&
"Builtin reference cannot fail");
6863 assert(!
Call.isInvalid() &&
"Call to builtin cannot fail!");
6888 Diag(BuiltinLoc, diag::err_invalid_astype_of_different_size)
6917 FunctionDecl *FDecl = dyn_cast_or_null<FunctionDecl>(NDecl);
6918 unsigned BuiltinID = (FDecl ? FDecl->
getBuiltinID() : 0);
6921 if (FDecl && FDecl->
hasAttr<AnyX86InterruptAttr>()) {
6934 if (Caller->hasAttr<ARMInterruptAttr>()) {
6936 if (VFP && (!FDecl || !FDecl->
hasAttr<ARMInterruptAttr>())) {
6937 Diag(Fn->
getExprLoc(), diag::warn_arm_interrupt_calling_convention);
6942 if (Caller->hasAttr<AnyX86InterruptAttr>() ||
6943 Caller->hasAttr<AnyX86NoCallerSavedRegistersAttr>()) {
6945 bool HasNonGPRRegisters =
6947 if (HasNonGPRRegisters &&
6948 (!FDecl || !FDecl->
hasAttr<AnyX86NoCallerSavedRegistersAttr>())) {
6950 << (Caller->hasAttr<AnyX86InterruptAttr>() ? 0 : 1);
6990 return ExprError(
Diag(LParenLoc, diag::err_typecheck_call_not_function)
7005 return ExprError(
Diag(LParenLoc, diag::err_typecheck_call_not_function)
7013 const auto *Proto = dyn_cast_or_null<FunctionProtoType>(FuncT);
7014 unsigned NumParams = Proto ? Proto->getNumParams() : 0;
7018 assert(UsesADL == ADLCallKind::NotADL &&
7019 "CUDAKernelCallExpr should not use ADL");
7040 TheCall = dyn_cast<CallExpr>(
Result.get());
7041 bool CorrectedTypos = TheCall != TheOldCall;
7042 if (!TheCall)
return Result;
7049 if (CorrectedTypos && Args.size() < NumParams) {
7065 return CheckBuiltinFunctionCall(FDecl, BuiltinID, TheCall);
7070 if (FDecl && !FDecl->
hasAttr<CUDAGlobalAttr>())
7071 return ExprError(
Diag(LParenLoc,diag::err_kern_call_not_global_function)
7078 return ExprError(
Diag(LParenLoc, diag::err_kern_type_not_void_return)
7082 if (FDecl && FDecl->
hasAttr<CUDAGlobalAttr>())
7083 return ExprError(
Diag(LParenLoc, diag::err_global_call_not_config)
7099 for (
const Expr *Arg : Args) {
7100 if (Arg && Arg->getType()->isWebAssemblyTableType()) {
7102 diag::err_wasm_table_as_function_parameter));
7112 assert(isa<FunctionNoProtoType>(FuncT) &&
"Unknown FunctionType!");
7120 if (!Proto || !(Proto->isVariadic() && Args.size() >= Def->
param_size()))
7121 Diag(RParenLoc, diag::warn_call_wrong_number_of_arguments)
7141 if (!Proto && !Args.empty() &&
7145 Diag(LParenLoc, diag::warn_strict_uses_without_prototype)
7146 << (FDecl !=
nullptr) << FDecl;
7149 for (
unsigned i = 0, e = Args.size(); i != e; i++) {
7150 Expr *Arg = Args[i];
7152 if (Proto && i < Proto->getNumParams()) {
7154 Context, Proto->getParamType(i), Proto->isParamConsumed(i));
7172 diag::err_call_incomplete_argument, Arg))
7180 if (
CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl))
7181 if (!isa<RequiresExprBodyDecl>(
CurContext) &&
7182 Method->isImplicitObjectMemberFunction())
7183 return ExprError(
Diag(LParenLoc, diag::err_member_call_without_object)
7192 for (
unsigned i = 0, e = Args.size(); i != e; i++) {
7193 if (
const auto *RT =
7194 dyn_cast<RecordType>(Args[i]->getType().getCanonicalType())) {
7195 if (RT->getDecl()->isOrContainsUnion())
7196 Diag(Args[i]->getBeginLoc(), diag::warn_cmse_nonsecure_union)
7207 checkFortifiedBuiltinMemoryFunction(FDecl, TheCall);
7210 return CheckBuiltinFunctionCall(FDecl, BuiltinID, TheCall);
7212 if (CheckPointerCall(NDecl, TheCall, Proto))
7215 if (CheckOtherCall(TheCall, Proto))
7225 assert(Ty &&
"ActOnCompoundLiteral(): missing type");
7226 assert(InitExpr &&
"ActOnCompoundLiteral(): missing expression");
7244 diag::err_array_incomplete_or_sizeless_type,
7258 std::optional<unsigned> NumInits;
7259 if (
const auto *ILE = dyn_cast<InitListExpr>(LiteralExpr))
7260 NumInits = ILE->getNumInits();
7261 if ((
LangOpts.CPlusPlus || NumInits.value_or(0)) &&
7263 diag::err_variable_object_no_init))
7268 diag::err_typecheck_decl_incomplete_type,
7283 LiteralExpr =
Result.get();
7311 if (
auto ILE = dyn_cast<InitListExpr>(LiteralExpr))
7312 for (
unsigned i = 0, j = ILE->getNumInits(); i != j; i++) {
7318 VK, LiteralExpr, isFileScope);
7330 Diag(LParenLoc, diag::err_compound_literal_with_address_space)
7366 bool DiagnosedArrayDesignator =
false;
7367 bool DiagnosedNestedDesignator =
false;
7368 bool DiagnosedMixedDesignator =
false;
7372 for (
unsigned I = 0, E = InitArgList.size(); I != E; ++I) {
7373 if (
auto *DIE = dyn_cast<DesignatedInitExpr>(InitArgList[I])) {
7375 FirstDesignator = DIE->getBeginLoc();
7380 if (!DiagnosedNestedDesignator && DIE->size() > 1) {
7381 DiagnosedNestedDesignator =
true;
7382 Diag(DIE->getBeginLoc(), diag::ext_designated_init_nested)
7383 << DIE->getDesignatorsSourceRange();
7386 for (
auto &Desig : DIE->designators()) {
7387 if (!Desig.isFieldDesignator() && !DiagnosedArrayDesignator) {
7388 DiagnosedArrayDesignator =
true;
7389 Diag(Desig.getBeginLoc(), diag::ext_designated_init_array)
7390 << Desig.getSourceRange();
7394 if (!DiagnosedMixedDesignator &&
7395 !isa<DesignatedInitExpr>(InitArgList[0])) {
7396 DiagnosedMixedDesignator =
true;
7397 Diag(DIE->getBeginLoc(), diag::ext_designated_init_mixed)
7398 << DIE->getSourceRange();
7399 Diag(InitArgList[0]->getBeginLoc(), diag::note_designated_init_mixed)
7400 << InitArgList[0]->getSourceRange();
7403 isa<DesignatedInitExpr>(InitArgList[0])) {
7404 DiagnosedMixedDesignator =
true;
7405 auto *DIE = cast<DesignatedInitExpr>(InitArgList[0]);
7406 Diag(DIE->getBeginLoc(), diag::ext_designated_init_mixed)
7407 << DIE->getSourceRange();
7408 Diag(InitArgList[I]->getBeginLoc(), diag::note_designated_init_mixed)
7409 << InitArgList[I]->getSourceRange();
7413 if (FirstDesignator.
isValid()) {
7417 !DiagnosedNestedDesignator && !DiagnosedMixedDesignator) {
7419 ? diag::warn_cxx17_compat_designated_init
7420 : diag::ext_cxx_designated_init);
7422 Diag(FirstDesignator, diag::ext_designated_init);
7437 for (
unsigned I = 0, E = InitArgList.size(); I != E; ++I) {
7438 if (InitArgList[I]->getType()->isNonOverloadPlaceholderType()) {
7445 InitArgList[I] = result.
get();
7473 if (
type->isObjCObjectPointerType()) {
7475 }
else if (
type->isBlockPointerType()) {
7477 return CK_BlockPointerToObjCPointerCast;
7479 assert(
type->isPointerType());
7480 return CK_CPointerToObjCPointerCast;
7497 llvm_unreachable(
"member pointer type in C");
7506 if (SrcAS != DestAS)
7507 return CK_AddressSpaceConversion;
7514 ? CK_BitCast : CK_AnyPointerToBlockPointerCast);
7519 return CK_CPointerToObjCPointerCast;
7521 return CK_BlockPointerToObjCPointerCast;
7523 return CK_PointerToBoolean;
7525 return CK_PointerToIntegral;
7531 llvm_unreachable(
"illegal cast from pointer");
7533 llvm_unreachable(
"Should have returned before this");
7538 return CK_FixedPointCast;
7540 return CK_FixedPointToBoolean;
7542 return CK_FixedPointToIntegral;
7544 return CK_FixedPointToFloating;
7548 diag::err_unimplemented_conversion_with_fixed_point_type)
7550 return CK_IntegralCast;
7555 llvm_unreachable(
"illegal cast to pointer type");
7557 llvm_unreachable(
"Should have returned before this");
7567 return CK_NullToPointer;
7568 return CK_IntegralToPointer;
7570 return CK_IntegralToBoolean;
7572 return CK_IntegralCast;
7574 return CK_IntegralToFloating;
7579 return CK_IntegralRealToComplex;
7583 CK_IntegralToFloating);
7584 return CK_FloatingRealToComplex;
7586 llvm_unreachable(
"member pointer type in C");
7588 return CK_IntegralToFixedPoint;
7590 llvm_unreachable(
"Should have returned before this");
7595 return CK_FloatingCast;
7597 return CK_FloatingToBoolean;
7599 return CK_FloatingToIntegral;
7604 return CK_FloatingRealToComplex;
7608 CK_FloatingToIntegral);
7609 return CK_IntegralRealToComplex;
7613 llvm_unreachable(
"valid float->pointer cast?");
7615 llvm_unreachable(
"member pointer type in C");
7617 return CK_FloatingToFixedPoint;
7619 llvm_unreachable(
"Should have returned before this");
7624 return CK_FloatingComplexCast;
7626 return CK_FloatingComplexToIntegralComplex;
7630 return CK_FloatingComplexToReal;
7632 return CK_FloatingCast;
7635 return CK_FloatingComplexToBoolean;
7639 CK_FloatingComplexToReal);
7640 return CK_FloatingToIntegral;
7644 llvm_unreachable(
"valid complex float->pointer cast?");
7646 llvm_unreachable(
"member pointer type in C");
7649 diag::err_unimplemented_conversion_with_fixed_point_type)
7651 return CK_IntegralCast;
7653 llvm_unreachable(
"Should have returned before this");
7658 return CK_IntegralComplexToFloatingComplex;
7660 return CK_IntegralComplexCast;
7664 return CK_IntegralComplexToReal;
7666 return CK_IntegralCast;
7669 return CK_IntegralComplexToBoolean;
7673 CK_IntegralComplexToReal);
7674 return CK_IntegralToFloating;
7678 llvm_unreachable(
"valid complex int->pointer cast?");
7680 llvm_unreachable(
"member pointer type in C");
7683 diag::err_unimplemented_conversion_with_fixed_point_type)
7685 return CK_IntegralCast;
7687 llvm_unreachable(
"Should have returned before this");
7690 llvm_unreachable(
"Unhandled scalar cast");
7697 len = vecType->getNumElements();
7698 eltType = vecType->getElementType();
7705 if (!
type->isRealType())
return false;
7721 auto ValidScalableConversion = [](
QualType FirstType,
QualType SecondType) {
7725 const auto *VecTy = SecondType->getAs<
VectorType>();
7729 return ValidScalableConversion(srcTy, destTy) ||
7730 ValidScalableConversion(destTy, srcTy);
7742 auto ValidScalableConversion = [](
QualType FirstType,
QualType SecondType) {
7746 const auto *VecTy = SecondType->getAs<
VectorType>();
7750 return ValidScalableConversion(srcTy, destTy) ||
7751 ValidScalableConversion(destTy, srcTy);
7763 return matSrcType->
getNumRows() == matDestType->getNumRows() &&
7764 matSrcType->
getNumColumns() == matDestType->getNumColumns();
7770 uint64_t SrcLen, DestLen;
7783 return (SrcLen * SrcEltSize == DestLen * DestEltSize);
7789 "expected at least one type to be a vector here");
7791 bool IsSrcTyAltivec =
7807 return (IsSrcTyAltivec || IsDestTyAltivec);
7843 if (!Vec || !Vec->getElementType()->isIntegralOrEnumerationType())
7848 if (!Vec || !Vec->getElementType()->isIntegralOrEnumerationType())
7865 return Diag(R.
getBegin(), diag::err_invalid_conversion_between_matrixes)
7866 << DestTy << SrcTy << R;
7870 diag::err_invalid_conversion_between_matrix_and_type)
7871 << SrcTy << DestTy << R;
7874 diag::err_invalid_conversion_between_matrix_and_type)
7875 << DestTy << SrcTy << R;
7878 Kind = CK_MatrixCast;
7884 assert(VectorTy->
isVectorType() &&
"Not a vector type!");
7890 diag::err_invalid_conversion_between_vectors :
7891 diag::err_invalid_conversion_between_vector_and_integer)
7892 << VectorTy << Ty << R;
7895 diag::err_invalid_conversion_between_vector_and_scalar)
7896 << VectorTy << Ty << R;
7905 if (DestElemTy == SplattedExpr->
getType())
7906 return SplattedExpr;
7919 CK_BooleanToSignedIntegral);
7920 SplattedExpr = CastExprRes.
get();
7921 CK = CK_IntegralToFloating;
7923 CK = CK_BooleanToSignedIntegral;
7930 SplattedExpr = CastExprRes.
get();
7949 Diag(R.
getBegin(),diag::err_invalid_conversion_between_ext_vectors)
7950 << DestTy << SrcTy << R;
7962 diag::err_invalid_conversion_between_vector_and_scalar)
7963 << DestTy << SrcTy << R;
7965 Kind = CK_VectorSplat;
7974 "ActOnCastExpr(): missing type or expr");
7996 bool isVectorLiteral =
false;
8011 isVectorLiteral =
true;
8014 isVectorLiteral =
true;
8019 if (isVectorLiteral)
8025 if (isa<ParenListExpr>(
CastExpr)) {
8046 assert((isa<ParenListExpr>(E) || isa<ParenExpr>(E)) &&
8047 "Expected paren or paren list expression");
8054 LiteralLParenLoc = PE->getLParenLoc();
8055 LiteralRParenLoc = PE->getRParenLoc();
8056 exprs = PE->getExprs();
8057 numExprs = PE->getNumExprs();
8059 LiteralLParenLoc = cast<ParenExpr>(E)->getLParen();
8060 LiteralRParenLoc = cast<ParenExpr>(E)->getRParen();
8061 subExpr = cast<ParenExpr>(E)->getSubExpr();
8084 if (numExprs == 1) {
8087 if (Literal.isInvalid())
8093 else if (numExprs < numElems) {
8095 diag::err_incorrect_number_of_vector_initializers);
8099 initExprs.append(exprs, exprs + numExprs);
8108 if (Literal.isInvalid())
8115 initExprs.append(exprs, exprs + numExprs);
8120 initExprs, LiteralRParenLoc);
8155 const Expr *NullExpr = LHSExpr;
8156 const Expr *NonPointerExpr = RHSExpr;
8163 NonPointerExpr = LHSExpr;
8185 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands_null)
8186 << NonPointerExpr->
getType() << DiagType
8198 S.
Diag(QuestionLoc, diag::err_typecheck_cond_expect_nonfloat)
8206 S.
Diag(QuestionLoc, diag::err_typecheck_cond_expect_scalar)
8240 bool IsBlockPointer =
false;
8244 IsBlockPointer =
true;
8269 ResultAddrSpace = LAddrSpace;
8271 ResultAddrSpace = RAddrSpace;
8273 S.
Diag(Loc, diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
8280 auto LHSCastKind = CK_BitCast, RHSCastKind = CK_BitCast;
8295 LAddrSpace == ResultAddrSpace ? CK_BitCast : CK_AddressSpaceConversion;
8297 RAddrSpace == ResultAddrSpace ? CK_BitCast : CK_AddressSpaceConversion;
8305 lhptee, rhptee,
false,
false,
8308 if (CompositeTy.
isNull()) {
8325 S.
Diag(Loc, diag::ext_typecheck_cond_incompatible_pointers)
8336 QualType ResultTy = [&, ResultAddrSpace]() {
8342 .withCVRQualifiers(MergedCVRQual);
8371 S.
Diag(Loc, diag::err_typecheck_cond_incompatible_operands)
8424 bool IsIntFirstExpr) {
8426 !Int.get()->getType()->isIntegerType())
8429 Expr *Expr1 = IsIntFirstExpr ? Int.get() : PointerExpr;
8430 Expr *Expr2 = IsIntFirstExpr ? PointerExpr : Int.get();
8432 S.
Diag(Loc, diag::ext_typecheck_cond_pointer_integer_mismatch)
8436 CK_IntegralToPointer);
8470 S.
Diag(QuestionLoc, diag::err_typecheck_cond_expect_int_float)
8476 S.
Diag(QuestionLoc, diag::err_typecheck_cond_expect_int_float)
8482 if (LHSType == RHSType)
8491 return handleIntegerConversion<doIntegralCast, doIntegralCast>
8492 (S, LHS, RHS, LHSType, RHSType,
false);
8526 llvm::raw_svector_ostream OS(Str);
8527 OS <<
"(vector of " << NumElements <<
" '" << EleTyName <<
"' values)";
8528 S.
Diag(QuestionLoc, diag::err_conditional_vector_element_size)
8529 << CondTy << OS.str();
8550 S.
Diag(QuestionLoc, diag::err_typecheck_cond_expect_nonfloat)
8568 S.
Diag(QuestionLoc, diag::err_conditional_vector_size)
8569 << CondTy << VecResTy;
8574 QualType RVE = RV->getElementType();
8577 S.
Diag(QuestionLoc, diag::err_conditional_vector_element_size)
8578 << CondTy << VecResTy;
8604 bool IsBoolVecLang =
8628 if (
const CallExpr *CE = dyn_cast<CallExpr>(E)) {
8629 QualType Ty = CE->getCallee()->getType();
8667 "should only occur in error-recovery path.");
8702 Diag(QuestionLoc, diag::err_wasm_table_conditional_expression)
8711 diag::err_typecheck_cond_incompatible_operands) << LHSTy << RHSTy
8730 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
8746 if (LHSRT->getDecl() == RHSRT->getDecl())
8790 if (!compositeType.
isNull())
8791 return compositeType;
8825 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
8897 if (!(compositeType =
8905 RHSOPT->isObjCQualifiedIdType()) &&
8916 Diag(QuestionLoc, diag::ext_typecheck_cond_incompatible_operands)
8927 return compositeType;
8934 Diag(QuestionLoc, diag::err_cond_voidptr_arc) << LHSTy << RHSTy
8954 Diag(QuestionLoc, diag::err_cond_voidptr_arc) << LHSTy << RHSTy
8986 Self.Diag(Loc,
Note) << ParenRange;
9006 const Expr **RHSExprs) {
9011 if (
const auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E)) {
9012 E = MTE->getSubExpr();
9017 if (
const auto *OP = dyn_cast<BinaryOperator>(E);
9019 *Opcode = OP->getOpcode();
9020 *RHSExprs = OP->getRHS();
9025 if (
const auto *
Call = dyn_cast<CXXOperatorCallExpr>(E)) {
9026 if (
Call->getNumArgs() != 2)
9032 if (OO < OO_Plus || OO > OO_Arrow ||
9033 OO == OO_PlusPlus || OO == OO_MinusMinus)
9039 *RHSExprs =
Call->getArg(1);
9055 if (
const auto *OP = dyn_cast<BinaryOperator>(E))
9056 return OP->isComparisonOp() || OP->isLogicalOp();
9057 if (
const auto *OP = dyn_cast<UnaryOperator>(E))
9058 return OP->getOpcode() == UO_LNot;
9073 const Expr *RHSExpr) {
9075 const Expr *CondRHS;
9086 ? diag::warn_precedence_bitwise_conditional
9087 : diag::warn_precedence_conditional;
9089 Self.Diag(OpLoc, DiagID)
9095 Self.PDiag(diag::note_precedence_silence)
9100 Self.PDiag(diag::note_precedence_conditional_first),
9111 auto GetNullability = [](
QualType Ty) {
9112 std::optional<NullabilityKind> Kind = Ty->getNullability();
9122 auto LHSKind = GetNullability(LHSTy), RHSKind = GetNullability(RHSTy);
9130 MergedKind = RHSKind;
9137 MergedKind = RHSKind;
9139 MergedKind = LHSKind;
9145 if (GetNullability(ResTy) == MergedKind)
9182 CondExpr = CondResult.
get();
9183 LHSExpr = LHSResult.
get();
9184 RHSExpr = RHSResult.
get();
9190 Expr *commonExpr =
nullptr;
9192 commonExpr = CondExpr;
9199 commonExpr = result.
get();
9213 commonExpr = commonRes.
get();
9223 commonExpr = MatExpr.
get();
9231 LHSExpr = CondExpr = opaqueValue;
9237 ExprResult Cond = CondExpr, LHS = LHSExpr, RHS = RHSExpr;
9239 VK, OK, QuestionLoc);
9247 CheckBoolLikeConversion(Cond.
get(), QuestionLoc);
9255 RHS.get(), result, VK, OK);
9258 commonExpr, opaqueValue, Cond.
get(), LHS.get(), RHS.get(), QuestionLoc,
9259 ColonLoc, result, VK, OK);
9264 unsigned FromAttributes = 0, ToAttributes = 0;
9265 if (
const auto *FromFn =
9269 if (
const auto *ToFn =
9274 return FromAttributes != ToAttributes;
9282 if (
const auto *ToFn =
9284 if (
const auto *FromFn =
9303 assert(LHSType.
isCanonical() &&
"LHS not canonicalized!");
9304 assert(RHSType.
isCanonical() &&
"RHS not canonicalized!");
9307 const Type *lhptee, *rhptee;
9309 std::tie(lhptee, lhq) =
9310 cast<PointerType>(LHSType)->getPointeeType().split().asPair();
9311 std::tie(rhptee, rhq) =
9312 cast<PointerType>(RHSType)->getPointeeType().split().asPair();
9372 diag::warn_typecheck_convert_incompatible_function_pointer_strict,
9395 if (ltrans == rtrans) {
9409 if (isa<PointerType>(lhptee) && isa<PointerType>(rhptee)) {
9411 std::tie(lhptee, lhq) =
9412 cast<PointerType>(lhptee)->getPointeeType().split().asPair();
9413 std::tie(rhptee, rhq) =
9414 cast<PointerType>(rhptee)->getPointeeType().split().asPair();
9427 }
while (isa<PointerType>(lhptee) && isa<PointerType>(rhptee));
9429 if (lhptee == rhptee)
9455 assert(LHSType.
isCanonical() &&
"LHS not canonicalized!");
9456 assert(RHSType.
isCanonical() &&
"RHS not canonicalized!");
9477 if (LQuals != RQuals)
9506 assert(LHSType.
isCanonical() &&
"LHS was not canonicalized!");
9507 assert(RHSType.
isCanonical() &&
"RHS was not canonicalized!");
9555 return VT->getElementType().getCanonicalType() == ElementType;
9588 if (LHSType == RHSType) {
9595 if (
const auto *AT = dyn_cast<AutoType>(LHSType)) {
9596 if (AT->isGNUAutoType()) {
9604 if (
const AtomicType *AtomicTy = dyn_cast<AtomicType>(LHSType)) {
9609 if (Kind != CK_NoOp && ConvertRHS)
9611 Kind = CK_NonAtomicToAtomic;
9624 Kind = CK_LValueBitCast;
9639 Kind = CK_VectorSplat;
9665 << RHSType << LHSType;
9684 << RHSType << LHSType;
9734 if (
const PointerType *LHSPointer = dyn_cast<PointerType>(LHSType)) {
9736 if (isa<PointerType>(RHSType)) {
9737 LangAS AddrSpaceL = LHSPointer->getPointeeType().getAddressSpace();
9739 if (AddrSpaceL != AddrSpaceR)
9740 Kind = CK_AddressSpaceConversion;
9751 Kind = CK_IntegralToPointer;
9757 if (isa<ObjCObjectPointerType>(RHSType)) {
9759 if (LHSPointer->getPointeeType()->isVoidType()) {
9778 if (LHSPointer->getPointeeType()->isVoidType()) {
9779 LangAS AddrSpaceL = LHSPointer->getPointeeType().getAddressSpace();
9784 AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion : CK_BitCast;
9793 if (isa<BlockPointerType>(LHSType)) {
9802 Kind = AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion : CK_BitCast;
9808 Kind = CK_IntegralToPointer;
9814 Kind = CK_AnyPointerToBlockPointerCast;
9820 if (RHSPT->getPointeeType()->isVoidType()) {
9821 Kind = CK_AnyPointerToBlockPointerCast;
9829 if (isa<ObjCObjectPointerType>(LHSType)) {
9835 if (
getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
9844 Kind = CK_IntegralToPointer;
9850 if (isa<PointerType>(RHSType)) {
9851 Kind = CK_CPointerToObjCPointerCast;
9873 Kind = CK_BlockPointerToObjCPointerCast;
9885 Kind = CK_NullToPointer;
9890 if (isa<PointerType>(RHSType)) {
9893 Kind = CK_PointerToBoolean;
9899 Kind = CK_PointerToIntegral;
9907 if (isa<ObjCObjectPointerType>(RHSType)) {
9910 Kind = CK_PointerToBoolean;
9916 Kind = CK_PointerToIntegral;
9924 if (isa<TagType>(LHSType) && isa<TagType>(RHSType)) {
9932 Kind = CK_IntToOCLSampler;
9974 for (
auto *it : UD->
fields()) {
9975 if (it->getType()->isPointerType()) {
10014 bool DiagnoseCFAudited,
10018 assert((ConvertRHS || !
Diagnose) &&
"can't indicate whether we diagnosed");
10024 ExprResult &RHS = ConvertRHS ? CallerRHS : LocalRHS;
10028 if (RHSPtrType->getPointeeType()->hasAttr(attr::NoDeref) &&
10029 !LHSPtrType->getPointeeType()->hasAttr(attr::NoDeref)) {
10031 diag::warn_noderef_to_dereferenceable_pointer)
10050 AllowedExplicit::None,
10062 if (
getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
10077 RHS.
get(), LHSType,
false, DAP))
10168 if (
getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
10198struct OriginalOperand {
10199 explicit OriginalOperand(
Expr *Op) : Orig(Op), Conversion(nullptr) {
10200 if (
auto *MTE = dyn_cast<MaterializeTemporaryExpr>(Op))
10201 Op = MTE->getSubExpr();
10202 if (
auto *BTE = dyn_cast<CXXBindTemporaryExpr>(Op))
10203 Op = BTE->getSubExpr();
10204 if (
auto *ICE = dyn_cast<ImplicitCastExpr>(Op)) {
10205 Orig = ICE->getSubExprAsWritten();
10206 Conversion = ICE->getConversionFunction();
10210 QualType getType()
const {
return Orig->getType(); }
10219 OriginalOperand OrigLHS(LHS.
get()), OrigRHS(RHS.
get());
10221 Diag(Loc, diag::err_typecheck_invalid_operands)
10222 << OrigLHS.getType() << OrigRHS.getType()
10227 if (OrigLHS.Conversion) {
10228 Diag(OrigLHS.Conversion->getLocation(),
10229 diag::note_typecheck_invalid_operands_converted)
10232 if (OrigRHS.Conversion) {
10233 Diag(OrigRHS.Conversion->getLocation(),
10234 diag::note_typecheck_invalid_operands_converted)
10252 if (!(LHSNatVec && RHSNatVec)) {
10254 Expr *NonVector = !LHSNatVec ? LHS.
get() : RHS.
get();
10255 Diag(Loc, diag::err_typecheck_logical_vector_expr_gnu_cpp_restrict)
10257 <<
Vector->getSourceRange();
10261 Diag(Loc, diag::err_typecheck_logical_vector_expr_gnu_cpp_restrict)
10284 unsigned &DiagID) {
10293 DiagID = diag::err_opencl_scalar_type_rank_greater_than_vector_type;
10298 scalarCast = CK_IntegralCast;
10303 DiagID = diag::err_opencl_scalar_type_rank_greater_than_vector_type;
10306 scalarCast = CK_FloatingCast;
10309 scalarCast = CK_IntegralToFloating;
10318 if (scalarCast != CK_NoOp)
10329 assert(VecTy &&
"Expression E must be a vector");
10334 VecTy->getVectorKind());
10338 if (
auto *ICE = dyn_cast<ImplicitCastExpr>(E))
10339 if (ICE->getSubExpr()->getType() == NewVecTy)
10340 return ICE->getSubExpr();
10342 auto Cast = ElementType->
isIntegerType() ? CK_IntegralCast : CK_FloatingCast;
10350 QualType IntTy = Int->get()->getType().getUnqualifiedType();
10356 bool CstInt = Int->get()->EvaluateAsInt(EVResult, S.
Context);
10365 unsigned NumBits = IntSigned
10367 :
Result.getActiveBits())
10368 :
Result.getActiveBits();
10375 return (IntSigned != OtherIntSigned &&
10381 return (Order < 0);
10388 QualType IntTy = Int->get()->getType().getUnqualifiedType();
10393 bool CstInt = Int->get()->EvaluateAsInt(EVResult, S.
Context);
10405 llvm::APFloat::rmTowardZero);
10408 bool Ignored =
false;
10409 Float.convertToInteger(ConvertBack, llvm::APFloat::rmNearestTiesToEven,
10411 if (
Result != ConvertBack)
10417 unsigned FloatPrec = llvm::APFloat::semanticsPrecision(
10419 if (Bits > FloatPrec)
10432 QualType ScalarTy = Scalar->get()->getType().getUnqualifiedType();
10433 QualType VectorTy =
Vector->get()->getType().getUnqualifiedType();
10437 assert(!isa<ExtVectorType>(VT) &&
10438 "ExtVectorTypes should not be handled here!");
10439 VectorEltTy = VT->getElementType();
10444 llvm_unreachable(
"Only Fixed-Length and SVE Vector types are handled here");
10470 ScalarCast = CK_IntegralCast;
10474 ScalarCast = CK_FloatingToIntegral;
10482 llvm::APFloat
Result(0.0);
10488 bool CstScalar = Scalar->get()->isValueDependent() ||
10491 if (!CstScalar && Order < 0)
10497 bool Truncated =
false;
10499 llvm::APFloat::rmNearestTiesToEven, &Truncated);
10504 ScalarCast = CK_FloatingCast;
10509 ScalarCast = CK_IntegralToFloating;
10516 if (ScalarCast != CK_NoOp)
10524 bool AllowBothBool,
10525 bool AllowBoolConversions,
10526 bool AllowBoolOperation,
10527 bool ReportInvalid) {
10528 if (!IsCompAssign) {
10544 assert(LHSVecType || RHSVecType);
10548 if (!AllowBothBool && LHSVecType &&
10554 if (!AllowBoolOperation &&
10563 if (LHSVecType && RHSVecType &&
10565 if (isa<ExtVectorType>(LHSVecType)) {
10578 if (AllowBoolConversions && LHSVecType && RHSVecType &&
10588 if (!IsCompAssign &&
10591 RHSVecType->getElementType()->isIntegerType()) {
10600 unsigned &SVEorRVV) {
10618 if (IsSveRVVConversion(LHSType, RHSType, SVEorRVV) ||
10619 IsSveRVVConversion(RHSType, LHSType, SVEorRVV)) {
10620 Diag(Loc, diag::err_typecheck_sve_rvv_ambiguous)
10621 << SVEorRVV << LHSType << RHSType;
10628 unsigned &SVEorRVV) {
10633 if (FirstVecType && SecondVecType) {
10636 SecondVecType->getVectorKind() ==
10648 if (SecondVecType &&
10661 if (IsSveRVVGnuConversion(LHSType, RHSType, SVEorRVV) ||
10662 IsSveRVVGnuConversion(RHSType, LHSType, SVEorRVV)) {
10663 Diag(Loc, diag::err_typecheck_sve_rvv_gnu_ambiguous)
10664 << SVEorRVV << LHSType << RHSType;
10670 unsigned DiagID = diag::err_typecheck_vector_not_convertable;
10672 if (isa<ExtVectorType>(LHSVecType)) {
10683 if (isa<ExtVectorType>(RHSVecType)) {
10685 LHSType, RHSVecType->getElementType(),
10698 QualType VecType = LHSVecType ? LHSType : RHSType;
10699 const VectorType *VT = LHSVecType ? LHSVecType : RHSVecType;
10700 QualType OtherType = LHSVecType ? RHSType : LHSType;
10701 ExprResult *OtherExpr = LHSVecType ? &RHS : &LHS;
10706 Diag(Loc, diag::warn_deprecated_lax_vec_conv_all) << RHSType << LHSType;
10710 if (!IsCompAssign) {
10729 if ((!RHSVecType && !RHSType->
isRealType()) ||
10731 Diag(Loc, diag::err_typecheck_vector_not_convertable_non_scalar)
10732 << LHSType << RHSType
10742 RHSVecType && isa<ExtVectorType>(RHSVecType) &&
10743 LHSVecType && isa<ExtVectorType>(LHSVecType)) {
10744 Diag(Loc, diag::err_opencl_implicit_vector_conversion) << LHSType
10753 if ((RHSVecType && !isa<ExtVectorType>(RHSVecType)) ||
10754 (LHSVecType && !isa<ExtVectorType>(LHSVecType))) {
10755 QualType Scalar = LHSVecType ? RHSType : LHSType;
10757 unsigned ScalarOrVector = LHSVecType && RHSVecType ? 1 : 0;
10759 diag::err_typecheck_vector_not_convertable_implict_truncation)
10760 << ScalarOrVector << Scalar <<
Vector;
10767 << LHSType << RHSType
10776 if (!IsCompAssign) {
10791 unsigned DiagID = diag::err_typecheck_invalid_operands;
10793 ((LHSBuiltinTy && LHSBuiltinTy->
isSVEBool()) ||
10794 (RHSBuiltinTy && RHSBuiltinTy->isSVEBool()))) {
10815 Diag(Loc, diag::err_typecheck_vector_not_convertable_non_scalar)
10824 Diag(Loc, diag::err_typecheck_vector_lengths_not_equal)
10833 bool ScalarOrVector =
10836 Diag(Loc, diag::err_typecheck_vector_not_convertable_implict_truncation)
10837 << ScalarOrVector << Scalar <<
Vector;
10869 S.
Diag(Loc, diag::warn_null_in_arithmetic_operation)
10881 S.
Diag(Loc, diag::warn_null_in_comparison_operation)
10882 << LHSNull << NonNullType
10888 const auto *LUE = dyn_cast<UnaryExprOrTypeTraitExpr>(LHS);
10889 const auto *RUE = dyn_cast<UnaryExprOrTypeTraitExpr>(RHS);
10892 if (LUE->getKind() != UETT_SizeOf || LUE->isArgumentType() ||
10893 RUE->getKind() != UETT_SizeOf)
10900 if (RUE->isArgumentType())
10901 RHSTy = RUE->getArgumentType().getNonReferenceType();
10903 RHSTy = RUE->getArgumentExpr()->IgnoreParens()->getType();
10910 if (
const auto *DRE = dyn_cast<DeclRefExpr>(LHSArg)) {
10911 if (
const ValueDecl *LHSArgDecl = DRE->getDecl())
10912 S.
Diag(LHSArgDecl->getLocation(), diag::note_pointer_declared_here)
10916 QualType ArrayElemTy = ArrayTy->getElementType();
10922 S.
Diag(Loc, diag::warn_division_sizeof_array)
10924 if (
const auto *DRE = dyn_cast<DeclRefExpr>(LHSArg)) {
10925 if (
const ValueDecl *LHSArgDecl = DRE->getDecl())
10926 S.
Diag(LHSArgDecl->getLocation(), diag::note_array_declared_here)
10930 S.
Diag(Loc, diag::note_precedence_silence) << RHS;
10943 S.
PDiag(diag::warn_remainder_division_by_zero)
10949 bool IsCompAssign,
bool IsDiv) {
11027 ? diag::err_typecheck_pointer_arith_void_type
11028 : diag::ext_gnu_void_ptr)
11037 ? diag::err_typecheck_pointer_arith_void_type
11038 : diag::ext_gnu_void_ptr)
11039 << 0 <<
Pointer->getSourceRange();
11050 S.
Diag(Loc, diag::warn_gnu_null_ptr_arith)
11051 <<
Pointer->getSourceRange();
11053 S.
Diag(Loc, diag::warn_pointer_arith_null_ptr)
11070 S.
PDiag(diag::warn_pointer_sub_null_ptr)
11072 <<
Pointer->getSourceRange());
11081 ? diag::err_typecheck_pointer_arith_function_type
11082 : diag::ext_gnu_ptr_func_arith)
11094 assert(
Pointer->getType()->isAnyPointerType());
11096 ? diag::err_typecheck_pointer_arith_function_type
11097 : diag::ext_gnu_ptr_func_arith)
11098 << 0 <<
Pointer->getType()->getPointeeType()
11100 <<
Pointer->getSourceRange();
11108 QualType ResType = Operand->getType();
11110 ResType = ResAtomicType->getValueType();
11116 diag::err_typecheck_arithmetic_incomplete_or_sizeless_type,
11117 Operand->getSourceRange());
11130 QualType ResType = Operand->getType();
11132 ResType = ResAtomicType->getValueType();
11164 if (!isLHSPointer && !isRHSPointer)
return true;
11166 QualType LHSPointeeTy, RHSPointeeTy;
11171 if (isLHSPointer && isRHSPointer) {
11174 diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
11182 bool isLHSVoidPtr = isLHSPointer && LHSPointeeTy->
isVoidType();
11183 bool isRHSVoidPtr = isRHSPointer && RHSPointeeTy->
isVoidType();
11184 if (isLHSVoidPtr || isRHSVoidPtr) {
11192 bool isLHSFuncPtr = isLHSPointer && LHSPointeeTy->
isFunctionType();
11193 bool isRHSFuncPtr = isRHSPointer && RHSPointeeTy->
isFunctionType();
11194 if (isLHSFuncPtr || isRHSFuncPtr) {
11216 Expr* IndexExpr = RHSExpr;
11219 IndexExpr = LHSExpr;
11222 bool IsStringPlusInt = StrExpr &&
11228 Self.Diag(OpLoc, diag::warn_string_plus_int)
11232 if (IndexExpr == RHSExpr) {
11234 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence)
11239 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence);
11245 const Expr *StringRefExpr = LHSExpr;
11250 CharExpr = dyn_cast<CharacterLiteral>(LHSExpr->
IgnoreImpCasts());
11251 StringRefExpr = RHSExpr;
11254 if (!CharExpr || !StringRefExpr)
11274 Self.Diag(OpLoc, diag::warn_string_plus_char)
11275 << DiagRange << Ctx.
CharTy;
11277 Self.Diag(OpLoc, diag::warn_string_plus_char)
11278 << DiagRange << CharExpr->
getType();
11284 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence)
11289 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence);
11298 S.
Diag(Loc, diag::err_typecheck_sub_ptr_compatible)
11317 if (CompLHSTy) *CompLHSTy = compType;
11326 *CompLHSTy = compType;
11335 *CompLHSTy = compType;
11345 if (Opc == BO_Add) {
11352 if (CompLHSTy) *CompLHSTy = compType;
11366 std::swap(PExp, IExp);
11377 if (!IExp->getType()->isIntegerType())
11386 (!IExp->isValueDependent() &&
11387 (!IExp->EvaluateAsInt(KnownVal,
Context) ||
11391 Context, BO_Add, PExp, IExp);
11403 CheckArrayAccess(PExp, IExp);
11412 *CompLHSTy = LHSTy;
11432 if (CompLHSTy) *CompLHSTy = compType;
11441 *CompLHSTy = compType;
11450 *CompLHSTy = compType;
11463 if (CompLHSTy) *CompLHSTy = compType;
11497 CheckArrayAccess(LHS.
get(), RHS.
get(),
nullptr,
11500 if (CompLHSTy) *CompLHSTy = LHS.
get()->
getType();
11544 if (ElementSize.
isZero()) {
11545 Diag(Loc,diag::warn_sub_ptr_zero_size_types)
11551 if (CompLHSTy) *CompLHSTy = LHS.
get()->
getType();
11561 return ET->getDecl()->isScoped();
11578 llvm::APSInt Right = RHSResult.
Val.
getInt();
11580 if (Right.isNegative()) {
11582 S.
PDiag(diag::warn_shift_negative)
11593 LeftSize = FXSema.getWidth() - (
unsigned)FXSema.hasUnsignedPadding();
11595 if (Right.uge(LeftSize)) {
11597 S.
PDiag(diag::warn_shift_gt_typewidth)
11617 llvm::APSInt Left = LHSResult.
Val.
getInt();
11628 if (Left.isNegative()) {
11630 S.
PDiag(diag::warn_shift_lhs_negative)
11635 llvm::APInt ResultBits =
11636 static_cast<llvm::APInt &
>(Right) + Left.getSignificantBits();
11637 if (ResultBits.ule(LeftSize))
11639 llvm::APSInt
Result = Left.extend(ResultBits.getLimitedValue());
11645 Result.toString(HexResult, 16,
false,
true);
11651 if (ResultBits - 1 == LeftSize) {
11652 S.
Diag(Loc, diag::warn_shift_result_sets_sign_bit)
11653 << HexResult << LHSType
11658 S.
Diag(Loc, diag::warn_shift_result_gt_typewidth)
11659 << HexResult.str() <<
Result.getSignificantBits() << LHSType
11671 S.
Diag(Loc, diag::err_shift_rhs_only_vector)
11677 if (!IsCompAssign) {
11699 S.
Diag(Loc, diag::err_typecheck_invalid_operands)
11706 if (!LHSEleType->isIntegerType()) {
11707 S.
Diag(Loc, diag::err_typecheck_expect_int)
11712 if (!RHSEleType->isIntegerType()) {
11713 S.
Diag(Loc, diag::err_typecheck_expect_int)
11722 if (LHSEleType != RHSEleType) {
11724 LHSEleType = RHSEleType;
11730 }
else if (RHSVecTy) {
11735 S.
Diag(Loc, diag::err_typecheck_vector_lengths_not_equal)
11743 if (LHSBT != RHSBT &&
11745 S.
Diag(Loc, diag::warn_typecheck_vector_element_sizes_not_equal)
11762 bool IsCompAssign) {
11763 if (!IsCompAssign) {
11786 if ((LHSBuiltinTy && LHSBuiltinTy->
isSVEBool()) ||
11787 (RHSBuiltinTy && RHSBuiltinTy->
isSVEBool())) {
11788 S.
Diag(Loc, diag::err_typecheck_invalid_operands)
11793 if (!LHSEleType->isIntegerType()) {
11794 S.
Diag(Loc, diag::err_typecheck_expect_int)
11799 if (!RHSEleType->isIntegerType()) {
11800 S.
Diag(Loc, diag::err_typecheck_expect_int)
11808 S.
Diag(Loc, diag::err_typecheck_invalid_operands)
11818 if (LHSEleType != RHSEleType) {
11820 LHSEleType = RHSEleType;
11822 const llvm::ElementCount VecSize =
11831 S.
Diag(Loc, diag::err_typecheck_vector_lengths_not_equal)
11837 const llvm::ElementCount VecSize =
11839 if (LHSEleType != RHSEleType) {
11841 RHSEleType = LHSEleType;
11854 bool IsCompAssign) {
11888 if (IsCompAssign) LHS = OldLHS;
11919 S.
Diag(Loc, IsError ? diag::err_typecheck_comparison_of_distinct_pointers
11920 : diag::ext_typecheck_comparison_of_distinct_pointers)
11960 S.
Diag(Loc, IsError ? diag::err_typecheck_comparison_of_fptr_to_void
11961 : diag::ext_typecheck_comparison_of_fptr_to_void)
11968 case Stmt::ObjCArrayLiteralClass:
11969 case Stmt::ObjCDictionaryLiteralClass:
11970 case Stmt::ObjCStringLiteralClass:
11971 case Stmt::ObjCBoxedExprClass:
12030 case Stmt::ObjCStringLiteralClass:
12033 case Stmt::ObjCArrayLiteralClass:
12036 case Stmt::ObjCDictionaryLiteralClass:
12039 case Stmt::BlockExprClass:
12041 case Stmt::ObjCBoxedExprClass: {
12042 Expr *Inner = cast<ObjCBoxedExpr>(FromE)->getSubExpr()->IgnoreParens();
12043 switch (Inner->getStmtClass()) {
12044 case Stmt::IntegerLiteralClass:
12045 case Stmt::FloatingLiteralClass:
12046 case Stmt::CharacterLiteralClass:
12047 case Stmt::ObjCBoolLiteralExprClass:
12048 case Stmt::CXXBoolLiteralExprClass:
12051 case Stmt::ImplicitCastExprClass: {
12052 CastKind CK = cast<CastExpr>(Inner)->getCastKind();
12054 if (CK == CK_IntegralToBoolean || CK == CK_IntegralCast)
12073 Literal = LHS.
get();
12076 Literal = RHS.
get();
12092 llvm_unreachable(
"Unknown Objective-C object literal kind");
12096 S.
Diag(Loc, diag::warn_objc_string_literal_comparison)
12097 << Literal->getSourceRange();
12099 S.
Diag(Loc, diag::warn_objc_literal_comparison)
12100 << LiteralKind << Literal->getSourceRange();
12109 S.
Diag(Loc, diag::note_objc_literal_comparison_isequal)
12122 if (!UO || UO->
getOpcode() != UO_LNot)
return;
12132 bool IsBitwiseOp = Opc == BO_And || Opc == BO_Or || Opc == BO_Xor;
12134 << Loc << IsBitwiseOp;
12161 if (
const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(E)) {
12163 }
else if (
const MemberExpr *Mem = dyn_cast<MemberExpr>(E)) {
12164 if (Mem->isImplicitAccess())
12165 D = Mem->getMemberDecl();
12220 S.
Diag(Loc, diag::warn_depr_array_comparison)
12246 Result = AlwaysConstant;
12250 S.
PDiag(diag::warn_comparison_always)
12265 Result = AlwaysConstant;
12269 S.
PDiag(diag::warn_comparison_always)
12275 if (isa<CastExpr>(LHSStripped))
12277 if (isa<CastExpr>(RHSStripped))
12282 Expr *LiteralString =
nullptr;
12283 Expr *LiteralStringStripped =
nullptr;
12284 if ((isa<StringLiteral>(LHSStripped) || isa<ObjCEncodeExpr>(LHSStripped)) &&
12287 LiteralString = LHS;
12288 LiteralStringStripped = LHSStripped;
12289 }
else if ((isa<StringLiteral>(RHSStripped) ||
12290 isa<ObjCEncodeExpr>(RHSStripped)) &&
12293 LiteralString = RHS;
12294 LiteralStringStripped = RHSStripped;
12297 if (LiteralString) {
12299 S.
PDiag(diag::warn_stringcompare)
12300 << isa<ObjCEncodeExpr>(LiteralStringStripped)
12312 llvm_unreachable(
"unhandled cast kind");
12314 case CK_UserDefinedConversion:
12316 case CK_LValueToRValue:
12318 case CK_ArrayToPointerDecay:
12320 case CK_FunctionToPointerDecay:
12322 case CK_IntegralCast:
12324 case CK_FloatingCast:
12326 case CK_IntegralToFloating:
12327 case CK_FloatingToIntegral:
12329 case CK_IntegralComplexCast:
12330 case CK_FloatingComplexCast:
12331 case CK_FloatingComplexToIntegralComplex:
12332 case CK_IntegralComplexToFloatingComplex:
12334 case CK_FloatingComplexToReal:
12335 case CK_FloatingRealToComplex:
12336 case CK_IntegralComplexToReal:
12337 case CK_IntegralRealToComplex:
12339 case CK_HLSLArrayRValue:
12352 if (
const auto *ICE = dyn_cast<ImplicitCastExpr>(E))
12379 << 0 << FromType << ToType;
12384 llvm_unreachable(
"unhandled case in switch");
12411 if (NumEnumArgs == 1) {
12413 QualType OtherTy = LHSIsEnum ? RHSStrippedType : LHSStrippedType;
12419 if (NumEnumArgs == 2) {
12428 LHSStrippedType->
castAs<
EnumType>()->getDecl()->getIntegerType();
12439 LHSType = RHSType = IntType;
12451 std::optional<ComparisonCategoryType> CCT =
12463 assert(!
Type.isNull() &&
"composite type for <=> has not been set");
12504 if (
const auto *CL = dyn_cast<CharacterLiteral>(E.
get())) {
12505 if (CL->getValue() == 0)
12509 NullValue ?
"NULL" :
"(void *)0");
12510 }
else if (
const auto *CE = dyn_cast<CStyleCastExpr>(E.
get())) {
12517 NullValue ?
"NULL" :
"(void *)0");
12527 bool IsThreeWay = Opc == BO_Cmp;
12528 bool IsOrdered = IsRelational || IsThreeWay;
12539 if (!IsThreeWay || IsAnyPointerType(LHS) || IsAnyPointerType(RHS)) {
12592 auto computeResultTy = [&]() {
12601 std::optional<ComparisonCategoryType> CCT =
12606 if (CompositeTy->
isPointerType() && LHSIsNull != RHSIsNull) {
12610 Diag(Loc, diag::err_typecheck_three_way_comparison_of_pointer_and_zero)
12620 if (!IsOrdered && LHSIsNull != RHSIsNull) {
12621 bool IsEquality = Opc == BO_EQ;
12633 bool IsError = Opc == BO_Cmp;
12635 IsError ? diag::err_typecheck_ordered_comparison_of_function_pointers
12637 ? diag::warn_typecheck_ordered_comparison_of_function_pointers
12638 : diag::ext_typecheck_ordered_comparison_of_function_pointers;
12667 return computeResultTy();
12683 (IsOrdered ? 2 : 1) &&
12688 return computeResultTy();
12702 if (IsRelational) {
12707 Diag(Loc, diag::ext_typecheck_compare_complete_incomplete_pointers)
12713 }
else if (!IsRelational &&
12717 && !LHSIsNull && !RHSIsNull)
12724 if (LCanPointeeTy != RCanPointeeTy) {
12729 diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
12730 << LHSType << RHSType << 0
12736 CastKind Kind = AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion
12738 if (LHSIsNull && !RHSIsNull)
12743 return computeResultTy();
12755 if (!IsOrdered && LHSIsNull && RHSIsNull) {
12758 return computeResultTy();
12762 return computeResultTy();
12773 return computeResultTy();
12777 return computeResultTy();
12786 return computeResultTy();
12791 return computeResultTy();
12795 if (IsRelational &&
12804 if (isa<FunctionDecl>(DC))
12806 if (
auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
12807 if (CTSD->isInStdNamespace() &&
12808 llvm::StringSwitch<bool>(CTSD->getName())
12809 .Cases(
"less",
"less_equal",
"greater",
"greater_equal",
true)
12815 return computeResultTy();
12828 return computeResultTy();
12838 if (!LHSIsNull && !RHSIsNull &&
12840 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks)
12845 return computeResultTy();
12852 if (!LHSIsNull && !RHSIsNull) {
12857 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks)
12861 if (LHSIsNull && !RHSIsNull)
12864 : CK_AnyPointerToBlockPointerCast);
12868 : CK_AnyPointerToBlockPointerCast);
12869 return computeResultTy();
12878 bool RPtrToVoid = RPT ? RPT->getPointeeType()->isVoidType() :
false;
12880 if (!LPtrToVoid && !RPtrToVoid &&
12888 if (LHSIsNull && !RHSIsNull) {
12894 RPT ? CK_BitCast :CK_CPointerToObjCPointerCast);
12904 LPT ? CK_BitCast :CK_CPointerToObjCPointerCast);
12906 return computeResultTy();
12916 if (LHSIsNull && !RHSIsNull)
12920 return computeResultTy();
12926 CK_BlockPointerToObjCPointerCast);
12927 return computeResultTy();
12928 }
else if (!IsOrdered &&
12932 CK_BlockPointerToObjCPointerCast);
12933 return computeResultTy();
12938 unsigned DiagID = 0;
12939 bool isError =
false;
12948 isError ? diag::err_typecheck_ordered_comparison_of_pointer_and_zero
12949 : diag::ext_typecheck_ordered_comparison_of_pointer_and_zero;
12952 DiagID = diag::err_typecheck_comparison_of_pointer_integer;
12954 }
else if (IsOrdered)
12955 DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_integer;
12957 DiagID = diag::ext_typecheck_comparison_of_pointer_integer;
12969 LHSIsNull ? CK_NullToPointer : CK_IntegralToPointer);
12972 RHSIsNull ? CK_NullToPointer : CK_IntegralToPointer);
12973 return computeResultTy();
12977 if (!IsOrdered && RHSIsNull
12980 return computeResultTy();
12982 if (!IsOrdered && LHSIsNull
12985 return computeResultTy();
12988 if (
getLangOpts().getOpenCLCompatibleVersion() >= 200) {
12990 return computeResultTy();
12994 return computeResultTy();
12997 if (LHSIsNull && RHSType->
isQueueT()) {
12999 return computeResultTy();
13002 if (LHSType->
isQueueT() && RHSIsNull) {
13004 return computeResultTy();
13020 if (isa<ExtVectorType>(VTy)) {
13034 "Unhandled vector element size in vector compare");
13054 "Unhandled vector element size in vector compare");
13078 if (Opc == BO_Cmp) {
13079 Diag(Loc, diag::err_three_way_vector_comparison);
13110 Diag(Loc, diag::warn_deprecated_altivec_src_compat);
13140 if (Opc == BO_Cmp) {
13141 Diag(Loc, diag::err_three_way_vector_comparison);
13169 if (LHSBuiltinTy && RHSBuiltinTy && LHSBuiltinTy->
isSVEBool() &&
13170 RHSBuiltinTy->isSVEBool())
13189 bool Negative =
false;
13190 bool ExplicitPlus =
false;
13191 const auto *LHSInt = dyn_cast<IntegerLiteral>(XorLHS.
get());
13192 const auto *RHSInt = dyn_cast<IntegerLiteral>(XorRHS.
get());
13198 if (
const auto *UO = dyn_cast<UnaryOperator>(XorRHS.
get())) {
13200 if (Opc != UO_Minus && Opc != UO_Plus)
13202 RHSInt = dyn_cast<IntegerLiteral>(UO->getSubExpr());
13205 Negative = (Opc == UO_Minus);
13206 ExplicitPlus = !Negative;
13212 const llvm::APInt &LeftSideValue = LHSInt->getValue();
13213 llvm::APInt RightSideValue = RHSInt->getValue();
13214 if (LeftSideValue != 2 && LeftSideValue != 10)
13217 if (LeftSideValue.getBitWidth() != RightSideValue.getBitWidth())
13222 llvm::StringRef ExprStr =
13227 llvm::StringRef XorStr =
13230 if (XorStr ==
"xor")
13241 RightSideValue = -RightSideValue;
13242 RHSStr =
"-" + RHSStr;
13243 }
else if (ExplicitPlus) {
13244 RHSStr =
"+" + RHSStr;
13247 StringRef LHSStrRef = LHSStr;
13248 StringRef RHSStrRef = RHSStr;
13251 if (LHSStrRef.starts_with(
"0b") || LHSStrRef.starts_with(
"0B") ||
13252 RHSStrRef.starts_with(
"0b") || RHSStrRef.starts_with(
"0B") ||
13253 LHSStrRef.starts_with(
"0x") || LHSStrRef.starts_with(
"0X") ||
13254 RHSStrRef.starts_with(
"0x") || RHSStrRef.starts_with(
"0X") ||
13255 (LHSStrRef.size() > 1 && LHSStrRef.starts_with(
"0")) ||
13256 (RHSStrRef.size() > 1 && RHSStrRef.starts_with(
"0")) ||
13257 LHSStrRef.contains(
'\'') || RHSStrRef.contains(
'\''))
13262 const llvm::APInt XorValue = LeftSideValue ^ RightSideValue;
13263 int64_t RightSideIntValue = RightSideValue.getSExtValue();
13264 if (LeftSideValue == 2 && RightSideIntValue >= 0) {
13265 std::string SuggestedExpr =
"1 << " + RHSStr;
13266 bool Overflow =
false;
13267 llvm::APInt One = (LeftSideValue - 1);
13268 llvm::APInt PowValue = One.sshl_ov(RightSideValue, Overflow);
13270 if (RightSideIntValue < 64)
13271 S.
Diag(Loc, diag::warn_xor_used_as_pow_base)
13272 << ExprStr <<
toString(XorValue, 10,
true) << (
"1LL << " + RHSStr)
13274 else if (RightSideIntValue == 64)
13275 S.
Diag(Loc, diag::warn_xor_used_as_pow)
13276 << ExprStr <<
toString(XorValue, 10,
true);
13280 S.
Diag(Loc, diag::warn_xor_used_as_pow_base_extra)
13281 << ExprStr <<
toString(XorValue, 10,
true) << SuggestedExpr
13284 ExprRange, (RightSideIntValue == 0) ?
"1" : SuggestedExpr);
13287 S.
Diag(Loc, diag::note_xor_used_as_pow_silence)
13288 << (
"0x2 ^ " + RHSStr) << SuggestXor;
13289 }
else if (LeftSideValue == 10) {
13290 std::string SuggestedValue =
"1e" + std::to_string(RightSideIntValue);
13291 S.
Diag(Loc, diag::warn_xor_used_as_pow_base)
13292 << ExprStr <<
toString(XorValue, 10,
true) << SuggestedValue
13294 S.
Diag(Loc, diag::note_xor_used_as_pow_silence)
13295 << (
"0xA ^ " + RHSStr) << SuggestXor;
13311 getLangOpts().getOpenCLCompatibleVersion() < 120 &&
13326 bool IsCompAssign) {
13327 if (!IsCompAssign) {
13343 assert((LHSMatType || RHSMatType) &&
"At least one operand must be a matrix");
13352 if (LHSMatType && !RHSMatType) {
13360 if (!LHSMatType && RHSMatType) {
13372 bool IsCompAssign) {
13373 if (!IsCompAssign) {
13384 assert((LHSMatType || RHSMatType) &&
"At least one operand must be a matrix");
13386 if (LHSMatType && RHSMatType) {
13387 if (LHSMatType->getNumColumns() != RHSMatType->
getNumRows())
13395 QualType LHSELTy = LHSMatType->getElementType(),
13426 bool IsCompAssign =
13427 Opc == BO_AndAssign || Opc == BO_OrAssign || Opc == BO_XorAssign;
13438 LegalBoolVecOperator,
13468 ExprResult LHSResult = LHS, RHSResult = RHS;
13471 if (LHSResult.
isInvalid() || RHSResult.isInvalid())
13473 LHS = LHSResult.
get();
13474 RHS = RHSResult.
get();
13493 bool EnumConstantInBoolContext =
false;
13495 if (
const auto *DREHS = dyn_cast<DeclRefExpr>(HS.get())) {
13496 const auto *ECDHS = dyn_cast<EnumConstantDecl>(DREHS->getDecl());
13497 if (ECDHS && ECDHS->getInitVal() != 0 && ECDHS->getInitVal() != 1)
13498 EnumConstantInBoolContext =
true;
13502 if (EnumConstantInBoolContext)
13503 Diag(Loc, diag::warn_enum_constant_in_bool_context);
13508 const auto *LHSATy = dyn_cast<ArrayType>(LHSTy);
13509 const auto *RHSATy = dyn_cast<ArrayType>(RHSTy);
13510 if ((LHSATy && LHSATy->getElementType().isWebAssemblyReferenceType()) ||
13511 (RHSATy && RHSATy->getElementType().isWebAssemblyReferenceType())) {
13533 Diag(Loc, diag::warn_logical_instead_of_bitwise)
13536 Diag(Loc, diag::note_logical_instead_of_bitwise_change_operator)
13537 << (Opc == BO_LAnd ?
"&" :
"|")
13540 Opc == BO_LAnd ?
"&" :
"|");
13541 if (Opc == BO_LAnd)
13543 Diag(Loc, diag::note_logical_instead_of_bitwise_remove_constant)
13599 const MemberExpr *ME = dyn_cast<MemberExpr>(E);
13600 if (!ME)
return false;
13604 if (!
Base)
return false;
13605 return Base->getMethodDecl() !=
nullptr;
13625 assert(var->
hasLocalStorage() &&
"capture added 'const' to non-local?");
13633 if (
auto *FD = dyn_cast<FunctionDecl>(DC))
13676 bool DiagnosticEmitted =
false;
13680 bool IsDereference =
false;
13681 bool NextIsDereference =
false;
13685 IsDereference = NextIsDereference;
13688 if (
const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
13689 NextIsDereference = ME->isArrow();
13690 const ValueDecl *VD = ME->getMemberDecl();
13691 if (
const FieldDecl *Field = dyn_cast<FieldDecl>(VD)) {
13693 if (Field->isMutable()) {
13694 assert(DiagnosticEmitted &&
"Expected diagnostic not emitted.");
13699 if (!DiagnosticEmitted) {
13700 S.
Diag(Loc, diag::err_typecheck_assign_const)
13702 << Field->getType();
13703 DiagnosticEmitted =
true;
13706 <<
ConstMember <<
false << Field << Field->getType()
13707 << Field->getSourceRange();
13711 }
else if (
const VarDecl *VDecl = dyn_cast<VarDecl>(VD)) {
13712 if (VDecl->getType().isConstQualified()) {
13713 if (!DiagnosticEmitted) {
13714 S.
Diag(Loc, diag::err_typecheck_assign_const)
13716 << VDecl->getType();
13717 DiagnosticEmitted =
true;
13720 <<
ConstMember <<
true << VDecl << VDecl->getType()
13721 << VDecl->getSourceRange();
13728 dyn_cast<ArraySubscriptExpr>(E)) {
13732 dyn_cast<ExtVectorElementExpr>(E)) {
13739 if (
const CallExpr *CE = dyn_cast<CallExpr>(E)) {
13743 if (!DiagnosticEmitted) {
13744 S.
Diag(Loc, diag::err_typecheck_assign_const) << ExprRange
13746 DiagnosticEmitted =
true;
13749 diag::note_typecheck_assign_const)
13753 }
else if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
13755 if (
const ValueDecl *VD = DRE->getDecl()) {
13757 if (!DiagnosticEmitted) {
13758 S.
Diag(Loc, diag::err_typecheck_assign_const)
13760 DiagnosticEmitted =
true;
13762 S.
Diag(VD->getLocation(), diag::note_typecheck_assign_const)
13763 <<
ConstVariable << VD << VD->getType() << VD->getSourceRange();
13766 }
else if (isa<CXXThisExpr>(E)) {
13768 if (
const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(DC)) {
13769 if (MD->isConst()) {
13770 if (!DiagnosticEmitted) {
13771 S.
Diag(Loc, diag::err_typecheck_assign_const) << ExprRange
13773 DiagnosticEmitted =
true;
13775 S.
Diag(MD->getLocation(), diag::note_typecheck_assign_const)
13782 if (DiagnosticEmitted)
13786 S.
Diag(Loc, diag::err_typecheck_assign_const) << ExprRange <<
ConstUnknown;
13799 bool &DiagnosticEmitted) {
13800 std::vector<const RecordType *> RecordTypeList;
13801 RecordTypeList.push_back(Ty);
13802 unsigned NextToCheckIndex = 0;
13805 while (RecordTypeList.size() > NextToCheckIndex) {
13806 bool IsNested = NextToCheckIndex > 0;
13808 RecordTypeList[NextToCheckIndex]->getDecl()->fields()) {
13810 QualType FieldTy = Field->getType();
13812 if (!DiagnosticEmitted) {
13813 S.
Diag(Loc, diag::err_typecheck_assign_const)
13815 << IsNested << Field;
13816 DiagnosticEmitted =
true;
13818 S.
Diag(Field->getLocation(), diag::note_typecheck_assign_const)
13820 << FieldTy << Field->getSourceRange();
13826 if (!llvm::is_contained(RecordTypeList, FieldRecTy))
13827 RecordTypeList.push_back(FieldRecTy);
13830 ++NextToCheckIndex;
13839 assert(Ty->
isRecordType() &&
"lvalue was not record?");
13842 bool DiagEmitted =
false;
13844 if (
const MemberExpr *ME = dyn_cast<MemberExpr>(E))
13847 else if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
13872 unsigned DiagID = 0;
13873 bool NeedType =
false;
13880 DiagID = diag::err_block_decl_ref_not_modifiable_lvalue;
13882 DiagID = diag::err_lambda_decl_ref_not_modifiable_lvalue;
13890 if (declRef && isa<VarDecl>(declRef->
getDecl())) {
13903 ? diag::err_typecheck_arc_assign_self_class_method
13904 : diag::err_typecheck_arc_assign_self;
13907 }
else if (var->
hasAttr<ObjCExternallyRetainedAttr>() ||
13908 isa<ParmVarDecl>(var)) {
13909 DiagID = diag::err_typecheck_arc_assign_externally_retained;
13913 DiagID = diag::err_typecheck_arr_assign_enumeration;
13917 if (Loc != OrigLoc)
13943 DiagID = diag::err_typecheck_array_not_modifiable_lvalue;
13947 DiagID = diag::err_typecheck_non_object_not_modifiable_lvalue;
13951 DiagID = diag::err_typecheck_lvalue_casts_not_supported;
13954 llvm_unreachable(
"did not take early return for MLV_Valid");
13958 DiagID = diag::err_typecheck_expression_not_modifiable_lvalue;
13963 diag::err_typecheck_incomplete_type_not_modifiable_lvalue, E);
13965 DiagID = diag::err_typecheck_duplicate_vector_components_not_mlvalue;
13968 llvm_unreachable(
"readonly properties should be processed differently");
13970 DiagID = diag::err_readonly_message_assignment;
13973 DiagID = diag::err_no_subobject_property_setting;
13978 if (Loc != OrigLoc)
14000 MemberExpr *ML = dyn_cast<MemberExpr>(LHSExpr);
14001 MemberExpr *MR = dyn_cast<MemberExpr>(RHSExpr);
14003 if (!(isa<CXXThisExpr>(ML->
getBase()) && isa<CXXThisExpr>(MR->
getBase())))
14009 if (LHSDecl != RHSDecl)
14014 if (RefTy->getPointeeType().isVolatileQualified())
14017 Sema.
Diag(Loc, diag::warn_identity_field_assign) << 0;
14027 Sema.
Diag(Loc, diag::warn_identity_field_assign) << 1;
14051 Diag(Loc, diag::err_opencl_half_load_store) << 1
14058 Diag(Loc, diag::err_wasm_table_art) << 0;
14063 if (CompoundType.
isNull()) {
14082 Diag(Loc, diag::err_objc_object_assignment)
14089 RHSCheck = ICE->getSubExpr();
14090 if (
UnaryOperator *UO = dyn_cast<UnaryOperator>(RHSCheck)) {
14091 if ((UO->getOpcode() == UO_Plus || UO->getOpcode() == UO_Minus) &&
14092 Loc.
isFileID() && UO->getOperatorLoc().isFileID() &&
14098 UO->getSubExpr()->getBeginLoc().
isFileID()) {
14099 Diag(Loc, diag::warn_not_compound_assign)
14100 << (UO->getOpcode() == UO_Plus ?
"+" :
"-")
14101 <<
SourceRange(UO->getOperatorLoc(), UO->getOperatorLoc());
14111 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InnerLHS);
14147 if (CompoundType.
isNull()) {
14173 if (
const CastExpr *CE = dyn_cast<CastExpr>(E)) {
14174 if (CE->getCastKind() == CK_ToVoid) {
14180 CE->getSubExpr()->getType()->isDependentType()) {
14185 if (
const auto *CE = dyn_cast<CallExpr>(E))
14186 return CE->getCallReturnType(Context)->isVoidType();
14209 const unsigned ForIncrementFlags =
14215 if ((ScopeFlags & ForIncrementFlags) == ForIncrementFlags ||
14216 (ScopeFlags & ForInitFlags) == ForInitFlags)
14221 while (
const BinaryOperator *BO = dyn_cast<BinaryOperator>(LHS)) {
14222 if (BO->getOpcode() != BO_Comma)
14224 LHS = BO->getRHS();
14231 Diag(Loc, diag::warn_comma_operator);
14235 LangOpts.CPlusPlus ?
"static_cast<void>("
14267 diag::err_incomplete_type);
14282 bool IsInc,
bool IsPrefix) {
14291 ResType = ResAtomicType->getValueType();
14293 assert(!ResType.
isNull() &&
"no type for increment/decrement expression");
14303 : diag::warn_increment_bool)
14307 S.
Diag(OpLoc, diag::err_increment_decrement_enum) << IsInc << ResType;
14323 S.
Diag(OpLoc, diag::ext_increment_complex)
14340 S.
Diag(OpLoc, diag::err_typecheck_illegal_increment_decrement)
14351 S.
Diag(OpLoc, diag::warn_deprecated_increment_decrement_volatile)
14352 << IsInc << ResType;
14385 case Stmt::DeclRefExprClass:
14386 return cast<DeclRefExpr>(E)->getDecl();
14387 case Stmt::MemberExprClass:
14391 if (cast<MemberExpr>(E)->isArrow())
14395 case Stmt::ArraySubscriptExprClass: {
14398 Expr*
Base = cast<ArraySubscriptExpr>(E)->getBase();
14400 if (ICE->getSubExpr()->getType()->isArrayType())
14405 case Stmt::UnaryOperatorClass: {
14417 case Stmt::ParenExprClass:
14419 case Stmt::ImplicitCastExprClass:
14423 case Stmt::CXXUuidofExprClass:
14424 return cast<CXXUuidofExpr>(E)->getGuidDecl();
14433 AO_Vector_Element = 1,
14434 AO_Property_Expansion = 2,
14435 AO_Register_Variable = 3,
14436 AO_Matrix_Element = 4,
14451 const auto *DRE = cast<DeclRefExpr>(Op->
IgnoreParens());
14454 return Diag(OpLoc, diag::err_parens_pointer_member_function)
14458 if (isa<CXXDestructorDecl>(MD))
14459 return Diag(OpLoc, diag::err_typecheck_addrof_dtor)
14460 << DRE->getSourceRange();
14462 if (DRE->getQualifier())
14466 return Diag(OpLoc, diag::err_unqualified_pointer_member_function)
14467 << DRE->getSourceRange();
14471 return Diag(OpLoc, diag::err_unqualified_pointer_member_function)
14472 << DRE->getSourceRange()
14485 if (PTy->getKind() == BuiltinType::Overload) {
14487 if (!isa<OverloadExpr>(E)) {
14488 assert(cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf);
14489 Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof_addrof_function)
14495 if (isa<UnresolvedMemberExpr>(Ovl))
14497 Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
14505 if (PTy->getKind() == BuiltinType::UnknownAny)
14508 if (PTy->getKind() == BuiltinType::BoundMember) {
14509 Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
14532 auto* VarRef = dyn_cast<DeclRefExpr>(op);
14533 if (VarRef && VarRef->refersToEnclosingVariableOrCapture()) {
14534 Diag(op->
getExprLoc(), diag::err_opencl_taking_address_capture);
14542 if (uOp->getOpcode() == UO_Deref)
14545 return uOp->getSubExpr()->getType();
14552 if (
auto *FD = dyn_cast_or_null<FunctionDecl>(dcl))
14558 unsigned AddressOfError = AO_No_Error;
14563 : diag::ext_typecheck_addrof_temporary)
14570 }
else if (isa<ObjCSelectorExpr>(op)) {
14577 if (!isa<DeclRefExpr>(op)) {
14578 Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
14598 if (isa<PseudoObjectExpr>(op)) {
14599 AddressOfError = AO_Property_Expansion;
14601 Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof)
14605 }
else if (
const auto *DRE = dyn_cast<DeclRefExpr>(op)) {
14606 if (
const auto *MD = dyn_cast_or_null<CXXMethodDecl>(DRE->getDecl()))
14612 AddressOfError = AO_Bit_Field;
14615 AddressOfError = AO_Vector_Element;
14618 AddressOfError = AO_Matrix_Element;
14622 if (
const VarDecl *vd = dyn_cast<VarDecl>(dcl)) {
14627 AddressOfError = AO_Register_Variable;
14629 }
else if (isa<MSPropertyDecl>(dcl)) {
14630 AddressOfError = AO_Property_Expansion;
14631 }
else if (isa<FunctionTemplateDecl>(dcl)) {
14633 }
else if (isa<FieldDecl>(dcl) || isa<IndirectFieldDecl>(dcl)) {
14637 if (isa<DeclRefExpr>(op) && cast<DeclRefExpr>(op)->getQualifier()) {
14642 diag::err_cannot_form_pointer_to_member_of_reference_type)
14647 while (cast<RecordDecl>(Ctx)->isAnonymousStructOrUnion())
14661 llvm_unreachable(
"Unknown/unexpected decl type");
14664 if (AddressOfError != AO_No_Error) {
14684 Diag(OpLoc, diag::err_wasm_ca_reference)
14689 Diag(OpLoc, diag::err_wasm_table_pr)
14695 CheckAddressOfPackedMember(op);
14701 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Exp);
14707 const ParmVarDecl *Param = dyn_cast<ParmVarDecl>(D);
14711 if (!FD->hasAttr<NonNullAttr>() && !Param->
hasAttr<NonNullAttr>())
14714 FD->ModifiedNonNullParams.insert(Param);
14720 bool IsAfterAmp =
false) {
14727 Op = ConvResult.
get();
14731 if (isa<CXXReinterpretCastExpr>(Op)) {
14739 Result = PT->getPointeeType();
14743 Result = OPT->getPointeeType();
14747 if (PR.
get() != Op)
14752 S.
Diag(OpLoc, diag::err_typecheck_indirection_requires_pointer)
14757 if (
Result->isVoidType()) {
14763 S.
Diag(OpLoc, diag::err_typecheck_indirection_through_void_pointer_cpp)
14766 S.
Diag(OpLoc, diag::ext_typecheck_indirection_through_void_pointer)
14783 default: llvm_unreachable(
"Unknown binop!");
14784 case tok::periodstar: Opc = BO_PtrMemD;
break;
14785 case tok::arrowstar: Opc = BO_PtrMemI;
break;
14786 case tok::star: Opc = BO_Mul;
break;
14787 case tok::slash: Opc = BO_Div;
break;
14788 case tok::percent: Opc = BO_Rem;
break;
14789 case tok::plus: Opc = BO_Add;
break;
14790 case tok::minus: Opc = BO_Sub;
break;
14791 case tok::lessless: Opc = BO_Shl;
break;
14792 case tok::greatergreater: Opc = BO_Shr;
break;
14793 case tok::lessequal: Opc = BO_LE;
break;
14794 case tok::less: Opc = BO_LT;
break;
14795 case tok::greaterequal: Opc = BO_GE;
break;
14796 case tok::greater: Opc = BO_GT;
break;
14797 case tok::exclaimequal: Opc = BO_NE;
break;
14798 case tok::equalequal: Opc = BO_EQ;
break;
14799 case tok::spaceship: Opc = BO_Cmp;
break;
14800 case tok::amp: Opc = BO_And;
break;
14801 case tok::caret: Opc = BO_Xor;
break;
14802 case tok::pipe: Opc = BO_Or;
break;
14803 case tok::ampamp: Opc = BO_LAnd;
break;
14804 case tok::pipepipe: Opc = BO_LOr;
break;
14805 case tok::equal: Opc = BO_Assign;
break;
14806 case tok::starequal: Opc = BO_MulAssign;
break;
14807 case tok::slashequal: Opc = BO_DivAssign;
break;
14808 case tok::percentequal: Opc = BO_RemAssign;
break;
14809 case tok::plusequal: Opc = BO_AddAssign;
break;
14810 case tok::minusequal: Opc = BO_SubAssign;
break;
14811 case tok::lesslessequal: Opc = BO_ShlAssign;
break;
14812 case tok::greatergreaterequal: Opc = BO_ShrAssign;
break;
14813 case tok::ampequal: Opc = BO_AndAssign;
break;
14814 case tok::caretequal: Opc = BO_XorAssign;
break;
14815 case tok::pipeequal: Opc = BO_OrAssign;
break;
14816 case tok::comma: Opc = BO_Comma;
break;
14825 default: llvm_unreachable(
"Unknown unary op!");
14826 case tok::plusplus: Opc = UO_PreInc;
break;
14827 case tok::minusminus: Opc = UO_PreDec;
break;
14828 case tok::amp: Opc = UO_AddrOf;
break;
14829 case tok::star: Opc = UO_Deref;
break;
14830 case tok::plus: Opc = UO_Plus;
break;
14831 case tok::minus: Opc = UO_Minus;
break;
14832 case tok::tilde: Opc = UO_Not;
break;
14833 case tok::exclaim: Opc = UO_LNot;
break;
14834 case tok::kw___real: Opc = UO_Real;
break;
14835 case tok::kw___imag: Opc = UO_Imag;
break;
14836 case tok::kw___extension__: Opc = UO_Extension;
break;
14852 if (!isa<ParmVarDecl>(SelfAssigned))
14854 const auto *Method =
14868 llvm::find_if(
Parent->fields(),
14870 return F->getDeclName() == Name;
14872 return (Field !=
Parent->field_end()) ? *Field :
nullptr;
14887 const DeclRefExpr *LHSDeclRef = dyn_cast<DeclRefExpr>(LHSExpr);
14888 const DeclRefExpr *RHSDeclRef = dyn_cast<DeclRefExpr>(RHSExpr);
14889 if (!LHSDeclRef || !RHSDeclRef ||
14897 if (LHSDecl != RHSDecl)
14902 if (RefTy->getPointeeType().isVolatileQualified())
14905 auto Diag = S.
Diag(OpLoc, IsBuiltin ? diag::warn_self_assignment_builtin
14906 : diag::warn_self_assignment_overloaded)
14911 Diag << 1 << SelfAssignField
14924 const Expr *ObjCPointerExpr =
nullptr, *OtherExpr =
nullptr;
14929 ObjCPointerExpr = LHS;
14933 ObjCPointerExpr = RHS;
14941 if (ObjCPointerExpr && isa<IntegerLiteral>(OtherExpr->IgnoreParenCasts())) {
14942 unsigned Diag = diag::warn_objc_pointer_masking;
14950 StringRef SelArg0 = S.getNameForSlot(0);
14951 if (SelArg0.starts_with(
"performSelector"))
14952 Diag = diag::warn_objc_pointer_masking_performSelector;
14963 if (
auto *DRE = dyn_cast<DeclRefExpr>(E))
14964 return DRE->getDecl();
14965 if (
auto *ME = dyn_cast<MemberExpr>(E))
14966 return ME->getMemberDecl();
14967 if (
auto *IRE = dyn_cast<ObjCIvarRefExpr>(E))
14968 return IRE->getDecl();
14983 "Result must be a vector of half or short");
14986 "both operands expected to be a half vector");
14998 ResultTy, VK, OK, OpLoc, FPFeatures,
14999 BinOpResTy, BinOpResTy);
15003 BinOpResTy, VK, OK, OpLoc, FPFeatures);
15007static std::pair<ExprResult, ExprResult>
15017 RHS,
nullptr,
false,
15018 [Opc, LHS](
Expr *E) {
15019 if (Opc != BO_Assign)
15026 return std::make_pair(LHS, RHS);
15033 if (!OpRequiresConversion || Ctx.
getLangOpts().NativeHalfType ||
15037 auto HasVectorOfHalfType = [&Ctx](
Expr *E) {
15047 return VT->getElementType().getCanonicalType() == Ctx.
HalfTy;
15052 return HasVectorOfHalfType(E0) && (!E1 || HasVectorOfHalfType(E1));
15074 if (
Init.isInvalid())
15076 RHSExpr =
Init.get();
15086 bool ConvertHalfVec =
false;
15089 if (!LHS.
isUsable() || !RHS.isUsable())
15099 if (BO_Assign == Opc)
15100 Diag(OpLoc, diag::err_opencl_atomic_init) << 0 << SR;
15128 if (!ResultTy.
isNull()) {
15145 if (
auto *BE = dyn_cast<BlockExpr>(RHS.get()->IgnoreParens()))
15147 if (
auto *VD = dyn_cast<VarDecl>(DRE->getDecl()))
15148 if (VD->hasLocalStorage() &&
getCurScope()->isDeclScope(VD))
15149 BE->getBlockDecl()->setCanAvoidCopyToHeap();
15160 Opc == BO_PtrMemI);
15164 ConvertHalfVec =
true;
15172 ConvertHalfVec =
true;
15176 ConvertHalfVec =
true;
15187 ConvertHalfVec =
true;
15192 ConvertHalfVec =
true;
15196 ConvertHalfVec =
true;
15209 ConvertHalfVec =
true;
15214 ConvertHalfVec =
true;
15216 Opc == BO_DivAssign);
15217 CompLHSTy = CompResultTy;
15224 CompLHSTy = CompResultTy;
15230 ConvertHalfVec =
true;
15237 ConvertHalfVec =
true;
15246 CompLHSTy = CompResultTy;
15257 CompLHSTy = CompResultTy;
15265 VK = RHS.get()->getValueKind();
15266 OK = RHS.get()->getObjectKind();
15280 "both sides are half vectors or neither sides are");
15285 CheckArrayAccess(LHS.
get());
15286 CheckArrayAccess(RHS.get());
15292 if (ObjectSetClass && isa<ObjCIsaExpr>(LHS.
get())) {
15296 "object_setClass(")
15309 if (CompResultTy.
isNull()) {
15310 if (ConvertHalfVec)
15330 if (ConvertHalfVec)
15335 Context, LHS.
get(), RHS.get(), Opc, ResultTy, VK, OK, OpLoc,
15352 if (isLeftComp == isRightComp)
15357 bool isLeftBitwise = LHSBO && LHSBO->
isBitwiseOp();
15358 bool isRightBitwise = RHSBO && RHSBO->
isBitwiseOp();
15359 if (isLeftBitwise || isRightBitwise)
15371 Self.Diag(OpLoc, diag::warn_precedence_bitwise_rel)
15374 Self.PDiag(diag::note_precedence_silence) << OpStr,
15375 (isLeftComp ? LHSExpr : RHSExpr)->getSourceRange());
15377 Self.PDiag(diag::note_precedence_bitwise_first)
15392 Self.PDiag(diag::note_precedence_silence)
15401 if (Bop->getOpcode() == BO_LAnd) {
15404 if (!isa<StringLiteral>(Bop->getLHS()->IgnoreParenImpCasts()))
15406 }
else if (Bop->getOpcode() == BO_LOr) {
15407 if (
BinaryOperator *RBop = dyn_cast<BinaryOperator>(Bop->getRHS())) {
15410 if (RBop->getOpcode() == BO_LAnd &&
15411 isa<StringLiteral>(RBop->getRHS()->IgnoreParenImpCasts()))
15422 if (Bop->getOpcode() == BO_LAnd) {
15425 if (!isa<StringLiteral>(Bop->getRHS()->IgnoreParenImpCasts()))
15437 if (Bop->isBitwiseOp() && Bop->getOpcode() < Opc) {
15438 S.
Diag(Bop->getOperatorLoc(), diag::warn_bitwise_op_in_bitwise_op)
15440 << Bop->getSourceRange() << OpLoc;
15442 S.
PDiag(diag::note_precedence_silence)
15443 << Bop->getOpcodeStr(),
15444 Bop->getSourceRange());
15450 Expr *SubExpr, StringRef Shift) {
15452 if (Bop->getOpcode() == BO_Add || Bop->getOpcode() == BO_Sub) {
15453 StringRef Op = Bop->getOpcodeStr();
15454 S.
Diag(Bop->getOperatorLoc(), diag::warn_addition_in_bitshift)
15455 << Bop->getSourceRange() << OpLoc << Shift << Op;
15457 S.
PDiag(diag::note_precedence_silence) << Op,
15458 Bop->getSourceRange());
15474 if (Kind != OO_LessLess && Kind != OO_GreaterGreater)
15477 S.
Diag(OpLoc, diag::warn_overloaded_shift_in_comparison)
15479 << (Kind == OO_LessLess);
15481 S.
PDiag(diag::note_precedence_silence)
15482 << (Kind == OO_LessLess ?
"<<" :
">>"),
15485 S, OpLoc, S.
PDiag(diag::note_evaluate_comparison_first),
15499 if ((Opc == BO_Or || Opc == BO_Xor) &&
15507 if (Opc == BO_LOr && !OpLoc.
isMacroID()) {
15513 || Opc == BO_Shr) {
15530 assert(LHSExpr &&
"ActOnBinOp(): missing left expression");
15531 assert(RHSExpr &&
"ActOnBinOp(): missing right expression");
15536 return BuildBinOp(S, TokLoc, Opc, LHSExpr, RHSExpr);
15542 if (OverOp !=
OO_None && OverOp != OO_Equal)
15596 LHSExpr = LHS.
get();
15597 RHSExpr = RHS.
get();
15608 if (pty->getKind() == BuiltinType::PseudoObject &&
15621 RHSExpr = resolvedRHS.
get();
15635 (pty->getKind() == BuiltinType::BoundMember ||
15636 pty->getKind() == BuiltinType::Overload)) {
15637 auto *OE = dyn_cast<OverloadExpr>(LHSExpr);
15638 if (OE && !OE->hasTemplateKeyword() && !OE->hasExplicitTemplateArgs() &&
15639 llvm::any_of(OE->decls(), [](
NamedDecl *ND) {
15640 return isa<FunctionTemplateDecl>(ND);
15642 Diag(OE->getQualifier() ? OE->getQualifierLoc().getBeginLoc()
15643 : OE->getNameLoc(),
15644 diag::err_template_kw_missing)
15645 << OE->getName().getAsString() <<
"";
15652 LHSExpr = LHS.
get();
15659 if (Opc == BO_Assign && pty->getKind() == BuiltinType::Overload) {
15675 RHSExpr = resolvedRHS.
get();
15695 "Should only occur in error-recovery path.");
15701 Context, LHSExpr, RHSExpr, Opc,
15721 ResultType = RHSExpr->
getType();
15753 bool CanOverflow =
false;
15755 bool ConvertHalfVec =
false;
15764 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15771 if (Opc == UO_AddrOf)
15772 return ExprError(
Diag(OpLoc, diag::err_hlsl_operator_unsupported) << 0);
15773 if (Opc == UO_Deref)
15774 return ExprError(
Diag(OpLoc, diag::err_hlsl_operator_unsupported) << 1);
15784 Opc == UO_PreInc ||
15786 Opc == UO_PreInc ||
15792 CheckAddressOfNoDeref(InputExpr);
15804 CanOverflow = Opc == UO_Minus &&
15815 if (ConvertHalfVec)
15835 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15848 Diag(OpLoc, diag::ext_integer_complement_complex)
15857 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15860 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15880 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15898 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15908 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15917 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15924 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15956 "the co_await expression must be non-dependant before "
15957 "building operator co_await");
15967 if (Opc != UO_AddrOf && Opc != UO_Deref)
15968 CheckArrayAccess(Input.
get());
15974 if (Opc == UO_Deref && UO->getType()->hasAttr(attr::NoDeref) &&
15975 !isa<ArrayType>(UO->getType().getDesugaredType(
Context)) &&
15980 if (ConvertHalfVec)
15989 if (
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
15990 if (!DRE->getQualifier())
15997 if (isa<FieldDecl>(VD) || isa<IndirectFieldDecl>(VD))
16000 return Method->isImplicitObjectMemberFunction();
16006 if (!ULE->getQualifier())
16011 if (Method->isImplicitObjectMemberFunction())
16032 if (pty->getKind() == BuiltinType::PseudoObject &&
16037 if (Opc == UO_Extension)
16042 if (Opc == UO_AddrOf &&
16043 (pty->getKind() == BuiltinType::Overload ||
16044 pty->getKind() == BuiltinType::UnknownAny ||
16045 pty->getKind() == BuiltinType::BoundMember))
16071 Expr *Input,
bool IsAfterAmp) {
16111 assert(SubStmt && isa<CompoundStmt>(SubStmt) &&
"Invalid action invocation!");
16117 "cleanups within StmtExpr not correctly bound!");
16127 bool StmtExprMayBindToTemp =
false;
16130 if (
const auto *LastStmt =
16132 if (
const Expr *
Value = LastStmt->getExprStmt()) {
16133 StmtExprMayBindToTemp =
true;
16141 Expr *ResStmtExpr =
16143 if (StmtExprMayBindToTemp)
16145 return ResStmtExpr;
16168 auto *Cast = dyn_cast<ImplicitCastExpr>(E);
16169 if (Cast && Cast->getCastKind() == CK_ARCConsumeObject)
16170 return Cast->getSubExpr();
16191 return ExprError(
Diag(BuiltinLoc, diag::err_offsetof_record_type)
16192 << ArgTy << TypeRange);
16198 diag::err_offsetof_incomplete_type, TypeRange))
16201 bool DidWarnAboutNonPOD =
false;
16206 if (OC.isBrackets) {
16211 return ExprError(
Diag(OC.LocEnd, diag::err_offsetof_array_type)
16231 Comps.push_back(
OffsetOfNode(OC.LocStart, Exprs.size(), OC.LocEnd));
16232 Exprs.push_back(Idx);
16240 Comps.push_back(
OffsetOfNode(OC.LocStart, OC.U.IdentInfo, OC.LocEnd));
16247 diag::err_offsetof_incomplete_type))
16253 return ExprError(
Diag(OC.LocEnd, diag::err_offsetof_record_type)
16265 bool IsSafe =
LangOpts.CPlusPlus11? CRD->isStandardLayout() : CRD->isPOD();
16267 LangOpts.CPlusPlus11? diag::ext_offsetof_non_standardlayout_type
16268 : diag::ext_offsetof_non_pod_type;
16271 Diag(BuiltinLoc, DiagID)
16272 <<
SourceRange(Components[0].LocStart, OC.LocEnd) << CurrentType;
16273 DidWarnAboutNonPOD =
true;
16284 MemberDecl = IndirectMemberDecl->getAnonField();
16292 Diag(BuiltinLoc, diag::err_no_member)
16293 << OC.U.IdentInfo << RD <<
SourceRange(OC.LocStart, OC.LocEnd);
16302 Diag(OC.LocEnd, diag::err_offsetof_bitfield)
16310 if (IndirectMemberDecl)
16311 Parent = cast<RecordDecl>(IndirectMemberDecl->getDeclContext());
16318 if (Paths.getDetectedVirtual()) {
16319 Diag(OC.LocEnd, diag::err_offsetof_field_of_virtual_base)
16330 if (IndirectMemberDecl) {
16331 for (
auto *FI : IndirectMemberDecl->chain()) {
16332 assert(isa<FieldDecl>(FI));
16334 cast<FieldDecl>(FI), OC.LocEnd));
16337 Comps.push_back(
OffsetOfNode(OC.LocStart, MemberDecl, OC.LocEnd));
16343 Comps, Exprs, RParenLoc);
16369 assert((CondExpr && LHSExpr && RHSExpr) &&
"Missing type argument(s)");
16374 bool CondIsTrue =
false;
16379 llvm::APSInt condEval(32);
16381 CondExpr, &condEval, diag::err_typecheck_choose_expr_requires_constant);
16384 CondExpr = CondICE.
get();
16385 CondIsTrue = condEval.getZExtValue();
16388 Expr *ActiveExpr = CondIsTrue ? LHSExpr : RHSExpr;
16390 resType = ActiveExpr->
getType();
16396 resType, VK, OK, RPLoc, CondIsTrue);
16409 Decl *ManglingContextDecl;
16410 std::tie(MCtx, ManglingContextDecl) =
16414 Block->setBlockMangling(ManglingNumber, ManglingContextDecl);
16436 "block-id should have no identifier!");
16458 "GetTypeForDeclarator made a non-function block signature");
16474 unsigned Size =
Result.getFullDataSize();
16486 QualType RetTy = Fn->getReturnType();
16488 (isa<FunctionProtoType>(Fn) && cast<FunctionProtoType>(Fn)->isVariadic());
16504 if (ExplicitSignature) {
16505 for (
unsigned I = 0, E = ExplicitSignature.
getNumParams(); I != E; ++I) {
16513 Params.push_back(Param);
16519 for (
const auto &I : Fn->param_types()) {
16522 Params.push_back(Param);
16527 if (!Params.empty()) {
16538 AI->setOwningFunction(CurBlock->
TheDecl);
16541 if (AI->getIdentifier()) {
16547 if (AI->isInvalidDecl())
16570 Diag(CaretLoc, diag::err_blocks_disable) <<
LangOpts.OpenCL;
16576 "cleanups within block not correctly bound!");
16589 bool NoReturn = BD->
hasAttr<NoReturnAttr>();
16597 if (NoReturn && !Ext.getNoReturn()) Ext = Ext.
withNoReturn(
true);
16600 if (isa<FunctionNoProtoType>(FTy)) {
16635 BD->
setBody(cast<CompoundStmt>(Body));
16637 if (Body &&
getCurFunction()->HasPotentialAvailabilityViolations)
16662 Expr *CopyExpr =
nullptr;
16671 if (isa<ParmVarDecl>(Var))
16690 if (!
Result.isInvalid() &&
16691 !
Result.get()->getType().isConstQualified()) {
16693 Result.get()->getType().withConst(),
16697 if (!
Result.isInvalid()) {
16707 if (!
Result.isInvalid() &&
16708 !cast<CXXConstructExpr>(
Result.get())->getConstructor()
16711 CopyExpr =
Result.get();
16718 Captures.push_back(NewCap);
16730 if (
Result->getBlockDecl()->hasCaptures()) {
16737 for (
const auto &CI :
Result->getBlockDecl()->captures()) {
16738 const VarDecl *var = CI.getVariable();
16751 {Result},
Result->getType());
16765 Expr *OrigExpr = E;
16815 if (
Init.isInvalid())
16831 diag::err_first_argument_to_va_arg_not_of_type_va_list)
16836 diag::err_second_parameter_to_va_arg_incomplete,
16842 diag::err_second_parameter_to_va_arg_abstract,
16849 ? diag::warn_second_parameter_to_va_arg_ownership_qualified
16850 : diag::warn_second_parameter_to_va_arg_not_pod)
16883 UnderlyingType = ET->getDecl()->getIntegerType();
16906 if (!PromoteType.
isNull())
16908 PDiag(diag::warn_second_parameter_to_va_arg_never_compatible)
16930 llvm_unreachable(
"I don't know size of pointer!");
16947 if ((SLDecl->isCompleteDefinition() || SLDecl->isBeingDefined()) &&
16956 S.
Diag(Loc, diag::err_std_source_location_impl_not_found);
16964 S.
Diag(Loc, diag::err_std_source_location_impl_malformed);
16968 unsigned Count = 0;
16970 StringRef Name = F->getName();
16972 if (Name ==
"_M_file_name") {
16973 if (F->getType() !=
16977 }
else if (Name ==
"_M_function_name") {
16978 if (F->getType() !=
16982 }
else if (Name ==
"_M_line") {
16983 if (!F->getType()->isIntegerType())
16986 }
else if (Name ==
"_M_column") {
16987 if (!F->getType()->isIntegerType())
16996 S.
Diag(Loc, diag::err_std_source_location_impl_malformed);
17059 if (OV->getSourceExpr())
17062 if (
auto *SL = dyn_cast<StringLiteral>(SrcExpr)) {
17064 !(ID && ID->getIdentifier()->isStr(
"NSString")))
17066 if (!SL->isOrdinary())
17070 Diag(SL->getBeginLoc(), diag::err_missing_atsign_prefix)
17077 if ((isa<IntegerLiteral>(SrcExpr) || isa<CharacterLiteral>(SrcExpr) ||
17078 isa<FloatingLiteral>(SrcExpr) || isa<ObjCBoolLiteralExpr>(SrcExpr) ||
17079 isa<CXXBoolLiteralExpr>(SrcExpr)) &&
17082 if (!ID || !ID->getIdentifier()->isStr(
"NSNumber"))
17100 const Expr *SrcExpr) {
17109 auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl());
17122 bool *Complained) {
17124 *Complained =
false;
17127 bool CheckInferredResultType =
false;
17129 unsigned DiagKind = 0;
17131 bool MayHaveConvFixit =
false;
17132 bool MayHaveFunctionDiff =
false;
17143 DiagKind = diag::err_typecheck_convert_pointer_int;
17146 DiagKind = diag::ext_typecheck_convert_pointer_int;
17149 MayHaveConvFixit =
true;
17153 DiagKind = diag::err_typecheck_convert_int_pointer;
17156 DiagKind = diag::ext_typecheck_convert_int_pointer;
17159 MayHaveConvFixit =
true;
17163 diag::warn_typecheck_convert_incompatible_function_pointer_strict;
17165 MayHaveConvFixit =
true;
17169 DiagKind = diag::err_typecheck_convert_incompatible_function_pointer;
17172 DiagKind = diag::ext_typecheck_convert_incompatible_function_pointer;
17175 MayHaveConvFixit =
true;
17179 DiagKind = diag::err_arc_typecheck_convert_incompatible_pointer;
17181 DiagKind = diag::err_typecheck_convert_incompatible_pointer;
17184 DiagKind = diag::ext_typecheck_convert_incompatible_pointer;
17188 if (!CheckInferredResultType) {
17190 }
else if (CheckInferredResultType) {
17194 MayHaveConvFixit =
true;
17198 DiagKind = diag::err_typecheck_convert_incompatible_pointer_sign;
17201 DiagKind = diag::ext_typecheck_convert_incompatible_pointer_sign;
17206 DiagKind = diag::err_typecheck_convert_pointer_void_func;
17209 DiagKind = diag::ext_typecheck_convert_pointer_void_func;
17221 DiagKind = diag::err_typecheck_incompatible_address_space;
17224 DiagKind = diag::err_typecheck_incompatible_ownership;
17228 llvm_unreachable(
"unknown error case for discarding qualifiers!");
17245 DiagKind = diag::err_typecheck_convert_discards_qualifiers;
17248 DiagKind = diag::ext_typecheck_convert_discards_qualifiers;
17255 DiagKind = diag::err_nested_pointer_qualifier_mismatch;
17257 DiagKind = diag::ext_nested_pointer_qualifier_mismatch;
17261 DiagKind = diag::err_typecheck_incompatible_nested_address_space;
17265 DiagKind = diag::err_int_to_block_pointer;
17269 DiagKind = diag::err_typecheck_convert_incompatible_block_pointer;
17276 for (
auto *srcProto : srcOPT->
quals()) {
17282 IFace = IFaceT->getDecl();
17287 for (
auto *dstProto : dstOPT->
quals()) {
17293 IFace = IFaceT->getDecl();
17296 DiagKind = diag::err_incompatible_qualified_id;
17299 DiagKind = diag::warn_incompatible_qualified_id;
17305 DiagKind = diag::err_incompatible_vectors;
17308 DiagKind = diag::warn_incompatible_vectors;
17312 DiagKind = diag::err_arc_weak_unavailable_assign;
17318 *Complained =
true;
17322 DiagKind = diag::err_typecheck_convert_incompatible;
17324 MayHaveConvFixit =
true;
17326 MayHaveFunctionDiff =
true;
17335 FirstType = DstType;
17336 SecondType = SrcType;
17346 FirstType = SrcType;
17347 SecondType = DstType;
17356 FDiag << FirstType << SecondType << ActionForDiag
17359 if (DiagKind == diag::ext_typecheck_convert_incompatible_pointer_sign ||
17360 DiagKind == diag::err_typecheck_convert_incompatible_pointer_sign) {
17370 if (!ConvHints.
isNull()) {
17375 if (MayHaveConvFixit) { FDiag << (
unsigned) (ConvHints.
Kind); }
17377 if (MayHaveFunctionDiff)
17381 if ((DiagKind == diag::warn_incompatible_qualified_id ||
17382 DiagKind == diag::err_incompatible_qualified_id) &&
17384 Diag(IFace->
getLocation(), diag::note_incomplete_class_and_qualified_id)
17391 if (CheckInferredResultType)
17398 *Complained =
true;
17409 return S.
Diag(Loc, diag::err_ice_not_integral)
17413 return S.
Diag(Loc, diag::err_expr_not_ice) << S.
LangOpts.CPlusPlus;
17428 IDDiagnoser(
unsigned DiagID)
17432 return S.
Diag(Loc, DiagID);
17434 } Diagnoser(DiagID);
17447 return S.
Diag(Loc, diag::ext_expr_not_ice) << S.
LangOpts.CPlusPlus;
17469 BaseDiagnoser(BaseDiagnoser) {}
17478 return S.
Diag(Loc, diag::err_ice_incomplete_type) <<
T;
17483 return S.
Diag(Loc, diag::err_ice_explicit_conversion) <<
T << ConvTy;
17494 return S.
Diag(Loc, diag::err_ice_ambiguous_conversion) <<
T;
17505 llvm_unreachable(
"conversion functions are permitted");
17507 } ConvertDiagnoser(Diagnoser);
17513 E = Converted.
get();
17518 if (isa<RecoveryExpr>(E))
17534 E = RValueExpr.
get();
17541 if (!isa<ConstantExpr>(E))
17549 EvalResult.
Diag = &Notes;
17557 if (!isa<ConstantExpr>(E))
17572 if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
17573 diag::note_invalid_subexpr_in_const_expr) {
17574 DiagLoc = Notes[0].first;
17578 if (!Folded || !CanFold) {
17600 class TransformToPE :
public TreeTransform<TransformToPE> {
17604 TransformToPE(
Sema &SemaRef) : BaseTransform(SemaRef) { }
17607 bool AlwaysRebuild() {
return true; }
17608 bool ReplacingOriginal() {
return true; }
17618 if (isa<FieldDecl>(E->
getDecl()) &&
17619 !SemaRef.isUnevaluatedContext())
17621 diag::err_invalid_non_static_member_use)
17624 return BaseTransform::TransformDeclRefExpr(E);
17632 return BaseTransform::TransformUnaryOperator(E);
17640 return SkipLambdaBody(E, Body);
17647 "Should only transform unevaluated expressions");
17652 return TransformToPE(*this).TransformExpr(E);
17657 "Should only transform unevaluated expressions");
17662 return TransformToPE(*this).TransformType(TInfo);
17670 LambdaContextDecl, ExprContext);
17677 .isDiscardedStatementContext();
17685 Prev.isImmediateFunctionContext() || Prev.isConstantEvaluated();
17688 Prev.InImmediateEscalatingFunctionContext;
17707 if (
const auto *E = dyn_cast<UnaryOperator>(PossibleDeref)) {
17708 if (E->getOpcode() == UO_Deref)
17709 return CheckPossibleDeref(S, E->getSubExpr());
17710 }
else if (
const auto *E = dyn_cast<ArraySubscriptExpr>(PossibleDeref)) {
17711 return CheckPossibleDeref(S, E->getBase());
17712 }
else if (
const auto *E = dyn_cast<MemberExpr>(PossibleDeref)) {
17713 return CheckPossibleDeref(S, E->getBase());
17714 }
else if (
const auto E = dyn_cast<DeclRefExpr>(PossibleDeref)) {
17718 Inner = Ptr->getPointeeType();
17720 Inner = Arr->getElementType();
17724 if (Inner->hasAttr(attr::NoDeref))
17734 const DeclRefExpr *DeclRef = CheckPossibleDeref(*
this, E);
17741 Diag(E->
getExprLoc(), diag::warn_dereference_of_noderef_type_no_decl)
17760 if (BO->getOpcode() == BO_Assign) {
17762 llvm::erase(LHSs, BO->getLHS());
17770 "Cannot mark an immediate escalating expression outside of an "
17771 "immediate escalating context");
17774 if (
auto *DeclRef =
17775 dyn_cast<DeclRefExpr>(
Call->getCallee()->IgnoreImplicit()))
17776 DeclRef->setIsImmediateEscalating(
true);
17777 }
else if (
auto *Ctr = dyn_cast<CXXConstructExpr>(E->
IgnoreImplicit())) {
17778 Ctr->setIsImmediateEscalating(
true);
17779 }
else if (
auto *DeclRef = dyn_cast<DeclRefExpr>(E->
IgnoreImplicit())) {
17780 DeclRef->setIsImmediateEscalating(
true);
17782 assert(
false &&
"expected an immediately escalating expression");
17785 FI->FoundImmediateEscalatingExpression =
true;
17800 if (
auto *DeclRef =
17801 dyn_cast<DeclRefExpr>(
Call->getCallee()->IgnoreImplicit()))
17810 auto CheckConstantExpressionAndKeepResult = [&]() {
17813 Eval.
Diag = &Notes;
17815 Eval,
getASTContext(), ConstantExprKind::ImmediateInvocation);
17816 if (Res && Notes.empty()) {
17817 Cached = std::move(Eval.
Val);
17825 !CheckConstantExpressionAndKeepResult()) {
17860 ExprEvalContexts.back().ImmediateInvocationCandidates.emplace_back(Res, 0);
17868 Eval.
Diag = &Notes;
17872 if (!
Result || !Notes.empty()) {
17875 if (
auto *
FunctionalCast = dyn_cast<CXXFunctionalCastExpr>(InnerExpr))
17878 if (
auto *
Call = dyn_cast<CallExpr>(InnerExpr))
17879 FD = cast<FunctionDecl>(
Call->getCalleeDecl());
17880 else if (
auto *
Call = dyn_cast<CXXConstructExpr>(InnerExpr))
17881 FD =
Call->getConstructor();
17882 else if (
auto *Cast = dyn_cast<CastExpr>(InnerExpr))
17883 FD = dyn_cast_or_null<FunctionDecl>(Cast->getConversionFunction());
17886 "could not find an immediate function in this expression");
17899 for (
auto &
Note : Notes)
17911 llvm::SmallPtrSetImpl<DeclRefExpr *> &DRSet;
17915 ComplexRemove(
Sema &SemaRef, llvm::SmallPtrSetImpl<DeclRefExpr *> &DR,
17918 4>::reverse_iterator Current)
17919 :
Base(SemaRef), DRSet(DR), IISet(II), CurrentII(Current) {}
17921 auto It = std::find_if(CurrentII, IISet.rend(),
17923 return Elem.getPointer() == E;
17929 if (It == IISet.rend()) {
17931 CurrentII->setInt(1);
17938 return Base::TransformConstantExpr(E);
17939 RemoveImmediateInvocation(E);
17940 return Base::TransformExpr(E->
getSubExpr());
17946 return Base::TransformCXXOperatorCallExpr(E);
17958 if (
auto *CE = dyn_cast<ConstantExpr>(
Init))
17959 if (CE->isImmediateInvocation())
17960 RemoveImmediateInvocation(CE);
17961 return Base::TransformInitializer(
Init, NotCopyInit);
17972 bool AlwaysRebuild() {
return false; }
17973 bool ReplacingOriginal() {
return true; }
17974 bool AllowSkippingCXXConstructExpr() {
17975 bool Res = AllowSkippingFirstCXXConstructExpr;
17976 AllowSkippingFirstCXXConstructExpr =
true;
17979 bool AllowSkippingFirstCXXConstructExpr =
true;
17989 if (isa<CXXConstructExpr>(It->getPointer()->IgnoreImplicit()))
17990 Transformer.AllowSkippingFirstCXXConstructExpr =
false;
17992 ExprResult Res = Transformer.TransformExpr(It->getPointer()->getSubExpr());
17998 It->getPointer()->setSubExpr(Res.
get());
18033 llvm::SmallPtrSetImpl<DeclRefExpr *> &DRSet;
18034 SimpleRemove(llvm::SmallPtrSetImpl<DeclRefExpr *> &S) : DRSet(S) {}
18037 return DRSet.size();
18040 Visitor.TraverseStmt(
18050 if (DR->isImmediateEscalating())
18052 auto *FD = cast<FunctionDecl>(DR->getDecl());
18054 if (
const auto *MD = dyn_cast<CXXMethodDecl>(ND);
18056 ND = MD->getParent();
18063 bool ImmediateEscalating =
false;
18064 bool IsPotentiallyEvaluated =
18074 SemaRef.
Diag(DR->getBeginLoc(), diag::err_invalid_consteval_take_address)
18075 << ND << isa<CXXRecordDecl>(ND) << FD->isConsteval();
18083 if (FD->isImmediateEscalating() && !FD->isConsteval())
18099 (Rec.
ExprContext == ExpressionKind::EK_TemplateArgument ||
18107 D = diag::err_lambda_unevaluated_operand;
18113 D = diag::err_lambda_in_constant_expression;
18114 }
else if (Rec.
ExprContext == ExpressionKind::EK_TemplateArgument) {
18117 D = diag::err_lambda_in_invalid_context;
18119 llvm_unreachable(
"Couldn't infer lambda error message.");
18121 for (
const auto *L : Rec.
Lambdas)
18122 Diag(L->getBeginLoc(), D);
18130 PrevRecord.InLifetimeExtendingContext &&
18132 PrevRecord.ForRangeLifetimeExtendTemps.append(
18143 Diag(BO->getBeginLoc(), diag::warn_deprecated_simple_assign_volatile)
18216 llvm_unreachable(
"Invalid context");
18225 if (!TT.isOSWindows() || !TT.isX86())
18263 : FD(FD), Param(Param) {}
18270 CCName =
"stdcall";
18273 CCName =
"fastcall";
18276 CCName =
"vectorcall";
18279 llvm_unreachable(
"CC does not need mangling");
18282 S.
Diag(Loc, diag::err_cconv_incomplete_param_type)
18288 ParamIncompleteTypeDiagnoser Diagnoser(FD, Param);
18294enum class OdrUseContext {
18316 return OdrUseContext::None;
18321 Result = OdrUseContext::Used;
18325 Result = OdrUseContext::FormallyOdrUsed;
18331 Result = OdrUseContext::FormallyOdrUsed;
18336 return OdrUseContext::Dependent;
18342 if (!
Func->isConstexpr())
18345 if (
Func->isImplicitlyInstantiable() || !
Func->isUserProvided())
18347 auto *CCD = dyn_cast<CXXConstructorDecl>(
Func);
18348 return CCD && CCD->getInheritedConstructor();
18354 bool MightBeOdrUse) {
18355 assert(
Func &&
"No function?");
18357 Func->setReferenced();
18370 OdrUseContext OdrUse =
18372 if (IsRecursiveCall && OdrUse == OdrUseContext::Used)
18373 OdrUse = OdrUseContext::FormallyOdrUsed;
18377 if (
Func->isTrivial() && !
Func->hasAttr<DLLExportAttr>() &&
18378 OdrUse == OdrUseContext::Used) {
18379 if (
auto *Constructor = dyn_cast<CXXConstructorDecl>(
Func))
18380 if (Constructor->isDefaultConstructor())
18381 OdrUse = OdrUseContext::FormallyOdrUsed;
18382 if (isa<CXXDestructorDecl>(
Func))
18383 OdrUse = OdrUseContext::FormallyOdrUsed;
18390 bool NeededForConstantEvaluation =
18415 bool NeedDefinition =
18416 !IsRecursiveCall &&
18417 (OdrUse == OdrUseContext::Used ||
18418 (NeededForConstantEvaluation && !
Func->isPureVirtual()));
18425 if (NeedDefinition &&
18427 Func->getMemberSpecializationInfo()))
18434 if (NeedDefinition && !
Func->getBody()) {
18437 dyn_cast<CXXConstructorDecl>(
Func)) {
18438 Constructor = cast<CXXConstructorDecl>(Constructor->getFirstDecl());
18439 if (Constructor->isDefaulted() && !Constructor->isDeleted()) {
18440 if (Constructor->isDefaultConstructor()) {
18441 if (Constructor->isTrivial() &&
18442 !Constructor->hasAttr<DLLExportAttr>())
18445 }
else if (Constructor->isCopyConstructor()) {
18447 }
else if (Constructor->isMoveConstructor()) {
18450 }
else if (Constructor->getInheritedConstructor()) {
18454 dyn_cast<CXXDestructorDecl>(
Func)) {
18464 if (MethodDecl->isOverloadedOperator() &&
18465 MethodDecl->getOverloadedOperator() == OO_Equal) {
18466 MethodDecl = cast<CXXMethodDecl>(MethodDecl->getFirstDecl());
18467 if (MethodDecl->isDefaulted() && !MethodDecl->isDeleted()) {
18468 if (MethodDecl->isCopyAssignmentOperator())
18470 else if (MethodDecl->isMoveAssignmentOperator())
18473 }
else if (isa<CXXConversionDecl>(MethodDecl) &&
18474 MethodDecl->getParent()->isLambda()) {
18476 cast<CXXConversionDecl>(MethodDecl->getFirstDecl());
18481 }
else if (MethodDecl->isVirtual() &&
getLangOpts().AppleKext)
18485 if (
Func->isDefaulted() && !
Func->isDeleted()) {
18493 if (
Func->isImplicitlyInstantiable()) {
18495 Func->getTemplateSpecializationKindForInstantiation();
18497 bool FirstInstantiation = PointOfInstantiation.
isInvalid();
18498 if (FirstInstantiation) {
18499 PointOfInstantiation = Loc;
18500 if (
auto *MSI =
Func->getMemberSpecializationInfo())
18501 MSI->setPointOfInstantiation(Loc);
18504 Func->setTemplateSpecializationKind(TSK, PointOfInstantiation);
18509 PointOfInstantiation = Loc;
18513 Func->isConstexpr()) {
18514 if (isa<CXXRecordDecl>(
Func->getDeclContext()) &&
18515 cast<CXXRecordDecl>(
Func->getDeclContext())->isLocalClass() &&
18518 std::make_pair(
Func, PointOfInstantiation));
18519 else if (
Func->isConstexpr())
18525 Func->setInstantiationIsPending(
true);
18527 std::make_pair(
Func, PointOfInstantiation));
18534 for (
auto *i :
Func->redecls()) {
18535 if (!i->isUsed(
false) && i->isImplicitlyInstantiable())
18548 Constructor->isImmediateFunction()
18553 if (
Init->isInClassMemberInitializer())
18555 MarkDeclarationsReferencedInExpr(Init->getInit());
18576 if (
LangOpts.OffloadImplicitHostDeviceTemplates &&
LangOpts.CUDAIsDevice &&
18581 if (OdrUse == OdrUseContext::Used && !
Func->isUsed(
false)) {
18583 if (!
Func->isDefined()) {
18584 if (mightHaveNonExternalLinkage(
Func))
18586 else if (
Func->getMostRecentDecl()->isInlined() &&
18588 !
Func->getMostRecentDecl()->hasAttr<GNUInlineAttr>())
18607 if (
auto *Dtor = dyn_cast<CXXDestructorDecl>(
Func)) {
18609 if (
Parent->getNumVBases() > 0 && !Dtor->getBody())
18627 const unsigned *
const FunctionScopeIndexToStopAt =
nullptr) {
18630 VarDecl *Var =
V->getPotentiallyDecomposedVarDecl();
18631 assert(Var &&
"expected a capturable variable");
18641 QualType CaptureType, DeclRefType;
18647 DeclRefType, FunctionScopeIndexToStopAt);
18663 << llvm::to_underlying(UserTarget);
18666 ? diag::note_cuda_const_var_unpromoted
18667 : diag::note_cuda_host_var);
18670 !Var->
hasAttr<CUDASharedAttr>() &&
18686 (!FD || (!FD->getDescribedFunctionTemplate() &&
18698 unsigned CapturingScopeIndex) {
18709 if (isa<ParmVarDecl>(var) &&
18710 isa<TranslationUnitDecl>(VarDC))
18723 unsigned ValueKind = isa<BindingDecl>(var) ? 1 : 0;
18724 unsigned ContextKind = 3;
18725 if (isa<CXXMethodDecl>(VarDC) &&
18726 cast<CXXRecordDecl>(VarDC->
getParent())->isLambda()) {
18728 }
else if (isa<FunctionDecl>(VarDC)) {
18730 }
else if (isa<BlockDecl>(VarDC)) {
18734 S.
Diag(loc, diag::err_reference_to_local_in_enclosing_context)
18735 << var << ValueKind << ContextKind << VarDC;
18745 bool &SubCapturesAreNested,
18751 SubCapturesAreNested =
true;
18764 !(isa<LambdaScopeInfo>(CSI) &&
18765 !cast<LambdaScopeInfo>(CSI)->lambdaCaptureShouldBeConst()) &&
18766 !(isa<CapturedRegionScopeInfo>(CSI) &&
18767 cast<CapturedRegionScopeInfo>(CSI)->CapRegionKind ==
CR_OpenMP))
18799 assert((isa<VarDecl, BindingDecl>(Var)) &&
18800 "Only variables and structured bindings can be captured");
18802 bool IsBlock = isa<BlockScopeInfo>(CSI);
18803 bool IsLambda = isa<LambdaScopeInfo>(CSI);
18811 S.
Diag(Loc, diag::err_lambda_capture_anonymous_var);
18820 S.
Diag(Loc, diag::err_ref_vm_type);
18828 if (VTTy->getDecl()->hasFlexibleArrayMember()) {
18831 S.
Diag(Loc, diag::err_ref_flexarray_type);
18833 S.
Diag(Loc, diag::err_lambda_capture_flexarray_type) << Var;
18839 const bool HasBlocksAttr = Var->
hasAttr<BlocksAttr>();
18842 if (HasBlocksAttr && (IsLambda || isa<CapturedRegionScopeInfo>(CSI))) {
18844 S.
Diag(Loc, diag::err_capture_block_variable) << Var << !IsLambda;
18853 S.
Diag(Loc, diag::err_opencl_block_ref_block);
18857 if (isa<BindingDecl>(Var)) {
18864 ? diag::warn_cxx17_compat_capture_binding
18865 : diag::ext_capture_binding)
18879 bool ByRef =
false;
18885 if (BuildAndDiagnose) {
18886 S.
Diag(Loc, diag::err_ref_array_type);
18897 if (BuildAndDiagnose) {
18898 S.
Diag(Loc, diag::err_arc_autoreleasing_capture)
18914 if (BuildAndDiagnose) {
18916 S.
Diag(Loc, diag::warn_block_capture_autoreleasing);
18917 S.
Diag(VarLoc, diag::note_declare_parameter_strong);
18922 const bool HasBlocksAttr = Var->
hasAttr<BlocksAttr>();
18931 DeclRefType = CaptureType;
18935 if (BuildAndDiagnose)
18945 const bool BuildAndDiagnose,
QualType &CaptureType,
QualType &DeclRefType,
18972 CaptureType = DeclRefType;
18975 if (BuildAndDiagnose)
18976 RSI->
addCapture(Var,
false, ByRef, RefersToCapturedVariable,
18986 const bool RefersToCapturedVariable,
18991 bool ByRef =
false;
18995 ByRef = (LSI->
ImpCaptureStyle == LambdaScopeInfo::ImpCap_LambdaByref);
19000 S.
Diag(Loc, diag::err_wasm_ca_reference) << 0;
19031 if (!RefType->getPointeeType()->isFunctionType())
19038 if (BuildAndDiagnose) {
19039 S.
Diag(Loc, diag::err_arc_autoreleasing_capture) << 1;
19049 if (!
Invalid && BuildAndDiagnose) {
19053 diag::err_capture_of_incomplete_or_sizeless_type,
19057 diag::err_capture_of_abstract_type))
19078 if (BuildAndDiagnose)
19079 LSI->
addCapture(Var,
false, ByRef, RefersToCapturedVariable,
19080 Loc, EllipsisLoc, CaptureType,
Invalid);
19091 if (
T.isTriviallyCopyableType(
Context))
19095 if (!(RD = RD->getDefinition()))
19097 if (RD->hasSimpleCopyConstructor())
19099 if (RD->hasUserDeclaredCopyConstructor())
19101 if (Ctor->isCopyConstructor())
19102 return !Ctor->isDeleted();
19122 if (ShouldOfferCopyFix) {
19126 FixBuffer.assign({Separator, Var->
getName()});
19127 Sema.
Diag(VarInsertLoc, diag::note_lambda_variable_capture_fixit)
19132 FixBuffer.assign({Separator,
"&", Var->
getName()});
19133 Sema.
Diag(VarInsertLoc, diag::note_lambda_variable_capture_fixit)
19145 return !C.isThisCapture() && !C.isInitCapture();
19154 if (ShouldOfferCopyFix) {
19155 bool CanDefaultCopyCapture =
true;
19164 if (CanDefaultCopyCapture && llvm::none_of(LSI->
Captures, [](
Capture &
C) {
19165 return !C.isThisCapture() && !C.isInitCapture() && C.isCopyCapture();
19167 FixBuffer.assign({
"=", Separator});
19168 Sema.
Diag(DefaultInsertLoc, diag::note_lambda_default_capture_fixit)
19177 return !C.isInitCapture() && C.isReferenceCapture() &&
19178 !C.isThisCapture();
19180 FixBuffer.assign({
"&", Separator});
19181 Sema.
Diag(DefaultInsertLoc, diag::note_lambda_default_capture_fixit)
19190 QualType &DeclRefType,
const unsigned *
const FunctionScopeIndexToStopAt) {
19203 const auto *VD = dyn_cast<VarDecl>(Var);
19205 if (VD->isInitCapture())
19210 assert(VD &&
"Cannot capture a null variable");
19212 const unsigned MaxFunctionScopesIndex = FunctionScopeIndexToStopAt
19216 if (FunctionScopeIndexToStopAt) {
19218 while (FSIndex != MaxFunctionScopesIndex) {
19226 bool IsGlobal = !VD->hasLocalStorage();
19227 if (IsGlobal && !(
LangOpts.OpenMP &&
19228 OpenMP().isOpenMPCapturedDecl(Var,
true,
19229 MaxFunctionScopesIndex)))
19232 if (isa<VarDecl>(Var))
19243 CaptureType = Var->
getType();
19245 bool Nested =
false;
19247 unsigned FunctionScopesIndex = MaxFunctionScopesIndex;
19252 LSI = dyn_cast_or_null<LambdaScopeInfo>(
19255 bool IsInScopeDeclarationContext =
19266 if (IsInScopeDeclarationContext &&
19267 FunctionScopesIndex == MaxFunctionScopesIndex && VarDC == DC)
19273 !IsInScopeDeclarationContext
19276 BuildAndDiagnose, *
this);
19282 FunctionScopesIndex = MaxFunctionScopesIndex - 1;
19301 if (
const auto *Parm = dyn_cast<ParmVarDecl>(Var);
19302 Parm && Parm->getDeclContext() == DC)
19310 if (BuildAndDiagnose) {
19313 Diag(ExprLoc, diag::err_lambda_impcap) << Var;
19328 if (
ParmVarDecl *PVD = dyn_cast_or_null<ParmVarDecl>(Var))
19329 QTy = PVD->getOriginalType();
19334 if (
auto *RSI = dyn_cast<CapturedRegionScopeInfo>(CSI)) {
19340 if (isa<BindingDecl>(Var)) {
19341 if (BuildAndDiagnose) {
19342 Diag(ExprLoc, diag::err_capture_binding_openmp) << Var;
19348 Var, RSI->OpenMPLevel, RSI->OpenMPCaptureLevel);
19353 if (IsOpenMPPrivateDecl != OMPC_unknown &&
19356 if (
ParmVarDecl *PVD = dyn_cast_or_null<ParmVarDecl>(Var))
19357 QTy = PVD->getOriginalType();
19359 E =
OpenMP().getNumberOfConstructScopes(RSI->OpenMPLevel);
19361 auto *OuterRSI = cast<CapturedRegionScopeInfo>(
19363 assert(RSI->OpenMPLevel == OuterRSI->OpenMPLevel &&
19364 "Wrong number of captured regions associated with the "
19365 "OpenMP construct.");
19370 IsOpenMPPrivateDecl != OMPC_private &&
19372 RSI->OpenMPCaptureLevel);
19376 Var, RSI->OpenMPLevel, RSI->OpenMPCaptureLevel);
19382 OpenMP().adjustOpenMPTargetScopeIndex(FunctionScopesIndex,
19385 if (IsTargetCap || IsOpenMPPrivateDecl == OMPC_private ||
19386 (IsGlobal && !IsGlobalCap)) {
19387 Nested = !IsTargetCap;
19402 if (BuildAndDiagnose) {
19403 Diag(ExprLoc, diag::err_lambda_impcap) << Var;
19405 auto *LSI = cast<LambdaScopeInfo>(CSI);
19425 FunctionScopesIndex--;
19426 if (IsInScopeDeclarationContext)
19428 }
while (!VarDC->
Equals(DC));
19436 for (
unsigned I = ++FunctionScopesIndex, N = MaxFunctionScopesIndex + 1; I != N;
19449 if (
Invalid && !BuildAndDiagnose)
19454 DeclRefType, Nested, *
this,
Invalid);
19458 RSI, Var, ExprLoc, BuildAndDiagnose, CaptureType, DeclRefType, Nested,
19459 Kind, I == N - 1, *
this,
Invalid);
19465 DeclRefType, Nested, Kind, EllipsisLoc,
19470 if (
Invalid && !BuildAndDiagnose)
19482 DeclRefType,
nullptr);
19489 false, CaptureType,
19490 DeclRefType,
nullptr);
19499 false, CaptureType,
19500 DeclRefType,
nullptr))
19503 return DeclRefType;
19511class CopiedTemplateArgs {
19515 template<
typename RefExpr>
19516 CopiedTemplateArgs(RefExpr *E) : HasArgs(E->hasExplicitTemplateArgs()) {
19518 E->copyTemplateArgumentsInto(TemplateArgStorage);
19521#ifdef __has_cpp_attribute
19522#
if __has_cpp_attribute(clang::lifetimebound)
19523 [[clang::lifetimebound]]
19527 return HasArgs ? &TemplateArgStorage :
nullptr;
19553 auto Rebuild = [&](
Expr *Sub) {
19558 auto IsPotentialResultOdrUsed = [&](
NamedDecl *D) {
19561 auto *VD = dyn_cast<VarDecl>(D);
19584 llvm_unreachable(
"unexpected non-odr-use-reason");
19588 if (VD->getType()->isReferenceType())
19590 if (
auto *RD = VD->getType()->getAsCXXRecordDecl())
19591 if (RD->hasMutableFields())
19593 if (!VD->isUsableInConstantExpressions(S.
Context))
19598 if (VD->getType()->isReferenceType())
19606 auto MarkNotOdrUsed = [&] {
19609 LSI->markVariableExprAsNonODRUsed(E);
19616 case Expr::DeclRefExprClass: {
19617 auto *DRE = cast<DeclRefExpr>(E);
19618 if (DRE->isNonOdrUse() || IsPotentialResultOdrUsed(DRE->getDecl()))
19624 S.
Context, DRE->getQualifierLoc(), DRE->getTemplateKeywordLoc(),
19625 DRE->getDecl(), DRE->refersToEnclosingVariableOrCapture(),
19626 DRE->getNameInfo(), DRE->getType(), DRE->getValueKind(),
19627 DRE->getFoundDecl(), CopiedTemplateArgs(DRE), NOUR);
19630 case Expr::FunctionParmPackExprClass: {
19631 auto *FPPE = cast<FunctionParmPackExpr>(E);
19635 if (IsPotentialResultOdrUsed(D))
19646 case Expr::ArraySubscriptExprClass: {
19647 auto *ASE = cast<ArraySubscriptExpr>(E);
19652 if (!
Base.isUsable())
19654 Expr *LHS = ASE->getBase() == ASE->getLHS() ?
Base.get() : ASE->getLHS();
19655 Expr *RHS = ASE->getBase() == ASE->getRHS() ?
Base.get() : ASE->getRHS();
19658 ASE->getRBracketLoc());
19661 case Expr::MemberExprClass: {
19662 auto *ME = cast<MemberExpr>(E);
19665 if (isa<FieldDecl>(ME->getMemberDecl())) {
19667 if (!
Base.isUsable())
19670 S.
Context,
Base.get(), ME->isArrow(), ME->getOperatorLoc(),
19671 ME->getQualifierLoc(), ME->getTemplateKeywordLoc(),
19672 ME->getMemberDecl(), ME->getFoundDecl(), ME->getMemberNameInfo(),
19673 CopiedTemplateArgs(ME), ME->getType(), ME->getValueKind(),
19674 ME->getObjectKind(), ME->isNonOdrUse());
19677 if (ME->getMemberDecl()->isCXXInstanceMember())
19682 if (ME->isNonOdrUse() || IsPotentialResultOdrUsed(ME->getMemberDecl()))
19688 S.
Context, ME->getBase(), ME->isArrow(), ME->getOperatorLoc(),
19689 ME->getQualifierLoc(), ME->getTemplateKeywordLoc(), ME->getMemberDecl(),
19690 ME->getFoundDecl(), ME->getMemberNameInfo(), CopiedTemplateArgs(ME),
19691 ME->getType(), ME->getValueKind(), ME->getObjectKind(), NOUR);
19694 case Expr::BinaryOperatorClass: {
19695 auto *BO = cast<BinaryOperator>(E);
19696 Expr *LHS = BO->getLHS();
19697 Expr *RHS = BO->getRHS();
19699 if (BO->getOpcode() == BO_PtrMemD) {
19701 if (!Sub.isUsable())
19705 }
else if (BO->getOpcode() == BO_Comma) {
19707 if (!Sub.isUsable())
19713 return S.
BuildBinOp(
nullptr, BO->getOperatorLoc(), BO->getOpcode(),
19718 case Expr::ParenExprClass: {
19719 auto *PE = cast<ParenExpr>(E);
19721 if (!Sub.isUsable())
19723 return S.
ActOnParenExpr(PE->getLParen(), PE->getRParen(), Sub.get());
19728 case Expr::ConditionalOperatorClass: {
19729 auto *CO = cast<ConditionalOperator>(E);
19739 LHS = CO->getLHS();
19741 RHS = CO->getRHS();
19743 CO->getCond(), LHS.
get(), RHS.
get());
19748 case Expr::UnaryOperatorClass: {
19749 auto *UO = cast<UnaryOperator>(E);
19750 if (UO->getOpcode() != UO_Extension)
19753 if (!Sub.isUsable())
19755 return S.
BuildUnaryOp(
nullptr, UO->getOperatorLoc(), UO_Extension,
19762 case Expr::GenericSelectionExprClass: {
19763 auto *GSE = cast<GenericSelectionExpr>(E);
19766 bool AnyChanged =
false;
19767 for (
Expr *OrigAssocExpr : GSE->getAssocExprs()) {
19768 ExprResult AssocExpr = Rebuild(OrigAssocExpr);
19772 AssocExprs.push_back(AssocExpr.
get());
19775 AssocExprs.push_back(OrigAssocExpr);
19779 void *ExOrTy =
nullptr;
19780 bool IsExpr = GSE->isExprPredicate();
19782 ExOrTy = GSE->getControllingExpr();
19784 ExOrTy = GSE->getControllingType();
19786 GSE->getGenericLoc(), GSE->getDefaultLoc(),
19787 GSE->getRParenLoc(), IsExpr, ExOrTy,
19788 GSE->getAssocTypeSourceInfos(), AssocExprs)
19796 case Expr::ChooseExprClass: {
19797 auto *CE = cast<ChooseExpr>(E);
19807 if (!LHS.
get() && !RHS.
get())
19810 LHS = CE->getLHS();
19812 RHS = CE->getRHS();
19815 RHS.
get(), CE->getRParenLoc());
19819 case Expr::ConstantExprClass: {
19820 auto *CE = cast<ConstantExpr>(E);
19822 if (!Sub.isUsable())
19829 case Expr::ImplicitCastExprClass: {
19830 auto *ICE = cast<ImplicitCastExpr>(E);
19834 switch (ICE->getCastKind()) {
19836 case CK_DerivedToBase:
19837 case CK_UncheckedDerivedToBase: {
19838 ExprResult Sub = Rebuild(ICE->getSubExpr());
19839 if (!Sub.isUsable())
19843 ICE->getValueKind(), &Path);
19902 for (
Expr *E : LocalMaybeODRUseExprs) {
19903 if (
auto *DRE = dyn_cast<DeclRefExpr>(E)) {
19905 DRE->getLocation(), *
this);
19906 }
else if (
auto *ME = dyn_cast<MemberExpr>(E)) {
19909 }
else if (
auto *FP = dyn_cast<FunctionParmPackExpr>(E)) {
19913 llvm_unreachable(
"Unexpected expression");
19918 "MarkVarDeclODRUsed failed to cleanup MaybeODRUseExprs?");
19927 const bool RefersToEnclosingScope =
19930 if (RefersToEnclosingScope) {
19945 assert(E &&
"Capture variable should be used in an expression.");
19956 assert((!E || isa<DeclRefExpr>(E) || isa<MemberExpr>(E) ||
19957 isa<FunctionParmPackExpr>(E)) &&
19958 "Invalid Expr argument to DoMarkVarDeclReferenced");
19969 bool UsableInConstantExpr =
19981 bool NeededForConstantEvaluation =
19984 bool NeedDefinition =
19985 OdrUse == OdrUseContext::Used || NeededForConstantEvaluation;
19987 assert(!isa<VarTemplatePartialSpecializationDecl>(Var) &&
19988 "Can't instantiate a partial template specialization.");
19994 !isa<VarTemplateSpecializationDecl>(Var))
20005 bool TryInstantiating =
20009 if (TryInstantiating) {
20012 bool FirstInstantiation = PointOfInstantiation.
isInvalid();
20013 if (FirstInstantiation) {
20014 PointOfInstantiation = Loc;
20016 MSI->setPointOfInstantiation(PointOfInstantiation);
20022 if (UsableInConstantExpr) {
20031 if (
auto *DRE = dyn_cast_or_null<DeclRefExpr>(E))
20032 DRE->setDecl(DRE->getDecl());
20033 else if (
auto *ME = dyn_cast_or_null<MemberExpr>(E))
20034 ME->setMemberDecl(ME->getMemberDecl());
20035 }
else if (FirstInstantiation) {
20037 .push_back(std::make_pair(Var, PointOfInstantiation));
20039 bool Inserted =
false;
20041 auto Iter = llvm::find_if(
20043 return P.first == Var;
20045 if (
Iter != I.end()) {
20058 if (isa<VarTemplateSpecializationDecl>(Var) && !Inserted)
20060 .push_back(std::make_pair(Var, PointOfInstantiation));
20084 if (
DeclRefExpr *DRE = dyn_cast_or_null<DeclRefExpr>(E))
20085 if (DRE->isNonOdrUse())
20087 if (
MemberExpr *ME = dyn_cast_or_null<MemberExpr>(E))
20088 if (ME->isNonOdrUse())
20092 case OdrUseContext::None:
20095 assert((!E || isa<FunctionParmPackExpr>(E) ||
20097 "missing non-odr-use marking for unevaluated decl ref");
20100 case OdrUseContext::FormallyOdrUsed:
20105 case OdrUseContext::Used:
20114 case OdrUseContext::Dependent:
20132 if (OdrUse == OdrUseContext::Used) {
20133 QualType CaptureType, DeclRefType;
20139 }
else if (OdrUse == OdrUseContext::Dependent) {
20158 auto *ID = dyn_cast<DeclRefExpr>(E);
20159 if (!ID || ID->isTypeDependent() || !ID->refersToEnclosingVariableOrCapture())
20166 auto IsDependent = [&]() {
20168 auto *LSI = dyn_cast<sema::LambdaScopeInfo>(
Scope);
20173 LSI->AfterParameterList)
20176 const auto *MD = LSI->CallOperator;
20177 if (MD->getType().isNull())
20181 if (!Ty || !MD->isExplicitObjectMemberFunction() ||
20185 if (
auto *
C = LSI->CaptureMap.count(D) ? &LSI->getCapture(D) :
nullptr) {
20186 if (
C->isCopyCapture())
20191 if (LSI->ImpCaptureStyle == LambdaScopeInfo::ImpCap_LambdaByval)
20197 ID->setCapturedByCopyInLambdaWithExplicitObjectParameter(
20203 bool MightBeOdrUse,
20208 if (
VarDecl *Var = dyn_cast<VarDecl>(D)) {
20227 const MemberExpr *ME = dyn_cast<MemberExpr>(E);
20234 bool IsVirtualCall = MD->
isVirtual() &&
20236 if (!IsVirtualCall)
20255 bool OdrUse =
true;
20257 if (Method->isVirtual() &&
20261 if (
auto *FD = dyn_cast<FunctionDecl>(E->
getDecl())) {
20266 !FD->isDependentContext())
20281 bool MightBeOdrUse =
true;
20284 if (Method->isPureVirtual())
20285 MightBeOdrUse =
false;
20305 bool MightBeOdrUse) {
20306 if (MightBeOdrUse) {
20307 if (
auto *VD = dyn_cast<VarDecl>(D)) {
20312 if (
auto *FD = dyn_cast<FunctionDecl>(D)) {
20340bool MarkReferencedDecls::TraverseTemplateArgument(
20354 return Inherited::TraverseTemplateArgument(Arg);
20358 MarkReferencedDecls Marker(*
this, Loc);
20359 Marker.TraverseType(
T);
20365class EvaluatedExprMarker :
public UsedDeclVisitor<EvaluatedExprMarker> {
20368 bool SkipLocalVariables;
20371 EvaluatedExprMarker(
Sema &S,
bool SkipLocalVariables,
20373 : Inherited(S), SkipLocalVariables(SkipLocalVariables), StopAt(StopAt) {}
20379 void Visit(
Expr *E) {
20380 if (llvm::is_contained(StopAt, E))
20382 Inherited::Visit(E);
20392 if (SkipLocalVariables) {
20394 if (VD->hasLocalStorage())
20418 bool SkipLocalVariables,
20420 EvaluatedExprMarker(*
this, SkipLocalVariables, StopAt).Visit(E);
20442 if (
auto *VD = dyn_cast_or_null<VarDecl>(
20444 if (VD->isConstexpr() ||
20445 (VD->isStaticDataMember() && VD->isFirstDecl() && !VD->isInline()))
20517 class CallReturnIncompleteDiagnoser :
public TypeDiagnoser {
20523 : FD(FD), CE(CE) { }
20527 S.
Diag(Loc, diag::err_call_incomplete_return)
20532 S.
Diag(Loc, diag::err_call_function_incomplete_return)
20537 } Diagnoser(FD, CE);
20550 unsigned diagnostic = diag::warn_condition_is_assignment;
20551 bool IsOrAssign =
false;
20554 if (Op->getOpcode() != BO_Assign && Op->getOpcode() != BO_OrAssign)
20557 IsOrAssign = Op->getOpcode() == BO_OrAssign;
20566 diagnostic = diag::warn_condition_is_idiomatic_assignment;
20570 diagnostic = diag::warn_condition_is_idiomatic_assignment;
20573 Loc = Op->getOperatorLoc();
20575 if (Op->getOperator() != OO_Equal && Op->getOperator() != OO_PipeEqual)
20578 IsOrAssign = Op->getOperator() == OO_PipeEqual;
20579 Loc = Op->getOperatorLoc();
20591 Diag(Loc, diag::note_condition_assign_silence)
20596 Diag(Loc, diag::note_condition_or_assign_to_comparison)
20599 Diag(Loc, diag::note_condition_assign_to_comparison)
20617 if (opE->getOpcode() == BO_EQ &&
20618 opE->getLHS()->IgnoreParenImpCasts()->isModifiableLvalue(
Context)
20624 Diag(Loc, diag::note_equality_comparison_silence)
20627 Diag(Loc, diag::note_equality_comparison_to_assign)
20633 bool IsConstexpr) {
20635 if (
ParenExpr *parenE = dyn_cast<ParenExpr>(E))
20653 Diag(Loc, diag::err_typecheck_statement_requires_scalar)
20657 CheckBoolLikeConversion(E, Loc);
20703 struct RebuildUnknownAnyFunction
20704 :
StmtVisitor<RebuildUnknownAnyFunction, ExprResult> {
20708 RebuildUnknownAnyFunction(
Sema &S) : S(S) {}
20711 llvm_unreachable(
"unexpected statement!");
20722 template <
class T>
ExprResult rebuildSugarExpr(
T *E) {
20723 ExprResult SubResult = Visit(E->getSubExpr());
20726 Expr *SubExpr = SubResult.
get();
20727 E->setSubExpr(SubExpr);
20735 return rebuildSugarExpr(E);
20739 return rebuildSugarExpr(E);
20746 Expr *SubExpr = SubResult.
get();
20755 if (!isa<FunctionDecl>(VD))
return VisitExpr(E);
20761 !(isa<CXXMethodDecl>(VD) &&
20762 cast<CXXMethodDecl>(VD)->isInstance()))
20773 return resolveDecl(E, E->
getDecl());
20791 struct RebuildUnknownAnyExpr
20792 :
StmtVisitor<RebuildUnknownAnyExpr, ExprResult> {
20803 llvm_unreachable(
"unexpected statement!");
20817 template <
class T>
ExprResult rebuildSugarExpr(
T *E) {
20818 ExprResult SubResult = Visit(E->getSubExpr());
20820 Expr *SubExpr = SubResult.
get();
20821 E->setSubExpr(SubExpr);
20829 return rebuildSugarExpr(E);
20833 return rebuildSugarExpr(E);
20871 return resolveDecl(E, E->
getDecl());
20882 FK_FunctionPointer,
20889 assert(isa<CXXMemberCallExpr>(E) || isa<CXXOperatorCallExpr>(E));
20890 Kind = FK_MemberFunction;
20894 Kind = FK_FunctionPointer;
20897 Kind = FK_BlockPointer;
20903 unsigned diagID = diag::err_func_returning_array_function;
20904 if (Kind == FK_BlockPointer)
20905 diagID = diag::err_block_returning_array_function;
20941 if (ParamTypes.empty() && Proto->
isVariadic()) {
20943 for (
unsigned i = 0, e = E->
getNumArgs(); i != e; ++i) {
20946 ParamTypes = ArgTypes;
20957 case FK_MemberFunction:
20961 case FK_FunctionPointer:
20965 case FK_BlockPointer:
20971 ExprResult CalleeResult = Visit(CalleeExpr);
20982 S.
Diag(E->
getExprLoc(), diag::err_func_returning_array_function)
20990 Method->setReturnType(DestType);
21002 if (E->
getCastKind() == CK_FunctionToPointerDecay) {
21016 }
else if (E->
getCastKind() == CK_LValueToRValue) {
21020 assert(isa<BlockPointerType>(E->
getType()));
21033 llvm_unreachable(
"Unhandled cast type!");
21066 if (DRE && Proto && Proto->getParamTypes().empty() && Proto->isVariadic()) {
21069 S.
Context, FD->getDeclContext(), Loc, Loc,
21070 FD->getNameInfo().getName(), DestType, FD->getTypeSourceInfo(),
21072 false , FD->hasPrototype(),
21075 if (FD->getQualifier())
21079 for (
const auto &AI : FT->param_types()) {
21083 Params.push_back(Param);
21085 NewFD->setParams(Params);
21092 if (MD->isInstance()) {
21102 }
else if (isa<VarDecl>(VD)) {
21106 S.
Diag(E->
getExprLoc(), diag::err_unknown_any_var_function_type)
21134 diag::err_typecheck_cast_to_incomplete))
21149 return RebuildUnknownAnyExpr(*
this, ToType).Visit(E);
21156 ExplicitCastExpr *castArg = dyn_cast<ExplicitCastExpr>(arg->IgnoreParens());
21165 assert(!arg->hasPlaceholderType());
21177 unsigned diagID = diag::err_uncasted_use_of_unknown_any;
21180 if (
CallExpr *call = dyn_cast<CallExpr>(E)) {
21181 E = call->getCallee();
21182 diagID = diag::err_uncasted_call_of_unknown_any;
21190 if (
DeclRefExpr *ref = dyn_cast<DeclRefExpr>(E)) {
21191 loc = ref->getLocation();
21192 d = ref->getDecl();
21193 }
else if (
MemberExpr *mem = dyn_cast<MemberExpr>(E)) {
21194 loc = mem->getMemberLoc();
21195 d = mem->getMemberDecl();
21197 diagID = diag::err_uncasted_call_of_unknown_any;
21198 loc = msg->getSelectorStartLoc();
21199 d = msg->getMethodDecl();
21201 S.
Diag(loc, diag::err_uncasted_send_to_unknown_any_method)
21202 <<
static_cast<unsigned>(msg->isClassMessage()) << msg->getSelector()
21231 if (!placeholderType)
return E;
21233 switch (placeholderType->
getKind()) {
21236 case BuiltinType::Overload: {
21256 case BuiltinType::BoundMember: {
21261 if (isa<CXXPseudoDestructorExpr>(BME)) {
21262 PD =
PDiag(diag::err_dtor_expr_without_call) << 1;
21263 }
else if (
const auto *ME = dyn_cast<MemberExpr>(BME)) {
21264 if (ME->getMemberNameInfo().getName().getNameKind() ==
21266 PD =
PDiag(diag::err_dtor_expr_without_call) << 0;
21274 case BuiltinType::ARCUnbridgedCast: {
21281 case BuiltinType::UnknownAny:
21285 case BuiltinType::PseudoObject:
21288 case BuiltinType::BuiltinFn: {
21292 auto *FD = cast<FunctionDecl>(DRE->
getDecl());
21293 unsigned BuiltinID = FD->getBuiltinID();
21294 if (BuiltinID == Builtin::BI__noop) {
21296 CK_BuiltinFnToFnPtr)
21309 ? diag::err_use_of_unaddressable_function
21310 : diag::warn_cxx20_compat_use_of_unaddressable_function);
21311 if (FD->isImplicitlyInstantiable()) {
21338 case BuiltinType::IncompleteMatrixIdx:
21342 diag::err_matrix_incomplete_index);
21346 case BuiltinType::OMPArraySection:
21351 case BuiltinType::OMPArrayShaping:
21354 case BuiltinType::OMPIterator:
21358#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
21359 case BuiltinType::Id:
21360#include "clang/Basic/OpenCLImageTypes.def"
21361#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
21362 case BuiltinType::Id:
21363#include "clang/Basic/OpenCLExtensionTypes.def"
21364#define SVE_TYPE(Name, Id, SingletonId) \
21365 case BuiltinType::Id:
21366#include "clang/Basic/AArch64SVEACLETypes.def"
21367#define PPC_VECTOR_TYPE(Name, Id, Size) \
21368 case BuiltinType::Id:
21369#include "clang/Basic/PPCTypes.def"
21370#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
21371#include "clang/Basic/RISCVVTypes.def"
21372#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
21373#include "clang/Basic/WebAssemblyReferenceTypes.def"
21374#define BUILTIN_TYPE(Id, SingletonId) case BuiltinType::Id:
21375#define PLACEHOLDER_TYPE(Id, SingletonId)
21376#include "clang/AST/BuiltinTypes.def"
21380 llvm_unreachable(
"invalid placeholder type!");
21394 assert((Kind == tok::kw___objc_yes || Kind == tok::kw___objc_no) &&
21395 "Unknown Objective-C Boolean value!");
21415 auto FindSpecVersion =
21416 [&](StringRef Platform) -> std::optional<VersionTuple> {
21422 if (Spec == AvailSpecs.end() && Platform ==
"maccatalyst") {
21427 if (Spec == AvailSpecs.end())
21428 return std::nullopt;
21432 VersionTuple Version;
21433 if (
auto MaybeVersion =
21435 Version = *MaybeVersion;
21440 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 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.