21#include "clang/AST/Attrs.inc"
63#include "llvm/ADT/STLExtras.h"
64#include "llvm/ADT/StringExtras.h"
65#include "llvm/Support/ConvertUTF.h"
66#include "llvm/Support/SaveAndRestore.h"
67#include "llvm/Support/TimeProfiler.h"
68#include "llvm/Support/TypeSize.h"
93 if (TreatUnavailableAsInvalid &&
103 if (isa<UnresolvedUsingIfExistsDecl>(
D))
111 if (
const auto *A =
D->
getAttr<UnusedAttr>()) {
114 if (A->getSemanticSpelling() != UnusedAttr::CXX11_maybe_unused &&
115 A->getSemanticSpelling() != UnusedAttr::C23_maybe_unused) {
117 if (DC && !DC->
hasAttr<UnusedAttr>())
118 S.
Diag(
Loc, diag::warn_used_but_marked_unused) <<
D;
126 if (
Decl->isDefaulted()) {
137 auto *Ctor = dyn_cast<CXXConstructorDecl>(
Decl);
138 if (Ctor && Ctor->isInheritingConstructor())
149 if (I->getStorageClass() !=
SC_None)
176 if (!Current->isInlined())
178 if (!Current->isExternallyVisible())
194 if (!DowngradeWarning && UsedFn)
197 S.
Diag(
Loc, DowngradeWarning ? diag::ext_internal_in_extern_inline_quiet
198 : diag::ext_internal_in_extern_inline)
213 Diag(DeclBegin, diag::note_convert_inline_to_static)
220 bool ObjCPropertyAccess,
221 bool AvoidPartialAvailabilityChecks,
223 bool SkipTrailingRequiresClause) {
230 for (
const auto &[DiagLoc, PD] : Pos->second) {
243 if (cast<FunctionDecl>(
D)->isMain())
244 Diag(
Loc, diag::ext_main_used);
251 if (isa<BindingDecl>(
D)) {
252 Diag(
Loc, diag::err_binding_cannot_appear_in_own_initializer)
255 Diag(
Loc, diag::err_auto_variable_cannot_appear_in_own_initializer)
256 << diag::ParsingInitFor::Var <<
D->getDeclName()
257 << cast<VarDecl>(
D)->getType();
264 if (FD->isDeleted()) {
265 auto *Ctor = dyn_cast<CXXConstructorDecl>(FD);
266 if (Ctor && Ctor->isInheritingConstructor())
267 Diag(
Loc, diag::err_deleted_inherited_ctor_use)
269 << Ctor->getInheritedConstructor().getConstructor()->getParent();
272 Diag(
Loc, diag::err_deleted_function_use)
273 << (Msg !=
nullptr) << (Msg ? Msg->
getString() : StringRef());
287 if (!SkipTrailingRequiresClause && FD->getTrailingRequiresClause()) {
296 diag::err_reference_to_function_with_unsatisfied_constraints)
314 if (
auto *
Concept = dyn_cast<ConceptDecl>(
D);
318 if (
auto *MD = dyn_cast<CXXMethodDecl>(
D)) {
320 if (MD->getParent()->isLambda() &&
321 ((isa<CXXConstructorDecl>(MD) &&
322 cast<CXXConstructorDecl>(MD)->isDefaultConstructor()) ||
323 MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator())) {
324 Diag(
Loc, diag::warn_cxx17_compat_lambda_def_ctor_assign)
325 << !isa<CXXConstructorDecl>(MD);
329 auto getReferencedObjCProp = [](
const NamedDecl *
D) ->
331 if (
const auto *MD = dyn_cast<ObjCMethodDecl>(
D))
346 auto *DRD = dyn_cast<OMPDeclareReductionDecl>(
CurContext);
349 Diag(
Loc, diag::err_omp_wrong_var_in_declare_reduction)
360 if (
LangOpts.OpenMP && isa<VarDecl>(
D) &&
361 !
OpenMP().isOpenMPDeclareMapperVarDeclAllowed(cast<VarDecl>(
D))) {
362 Diag(
Loc, diag::err_omp_declare_mapper_wrong_var)
368 if (
const auto *EmptyD = dyn_cast<UnresolvedUsingIfExistsDecl>(
D)) {
369 Diag(
Loc, diag::err_use_of_empty_using_if_exists);
370 Diag(EmptyD->getLocation(), diag::note_empty_using_if_exists_here);
375 AvoidPartialAvailabilityChecks, ClassReceiver);
381 if (
D->
hasAttr<AvailableOnlyInDefaultEvalMethodAttr>()) {
387 diag::err_type_available_only_in_default_eval_method)
391 if (
auto *VD = dyn_cast<ValueDecl>(
D))
397 if (
const auto *VD = dyn_cast<VarDecl>(
D))
399 targetDiag(*Locs.begin(), diag::err_thread_unsupported);
412 unsigned NumFormalParams;
416 enum { CK_Function, CK_Method, CK_Block } CalleeKind;
418 if (
const auto *MD = dyn_cast<ObjCMethodDecl>(
D)) {
419 NumFormalParams = MD->param_size();
420 CalleeKind = CK_Method;
421 }
else if (
const auto *FD = dyn_cast<FunctionDecl>(
D)) {
422 NumFormalParams = FD->param_size();
423 CalleeKind = CK_Function;
424 }
else if (
const auto *VD = dyn_cast<VarDecl>(
D)) {
431 CalleeKind = CK_Function;
434 CalleeKind = CK_Block;
439 if (
const auto *proto = dyn_cast<FunctionProtoType>(Fn))
440 NumFormalParams = proto->getNumParams();
451 unsigned NullPos =
Attr->getNullPos();
452 assert((NullPos == 0 || NullPos == 1) &&
"invalid null position on sentinel");
453 NumFormalParams = (NullPos > NumFormalParams ? 0 : NumFormalParams - NullPos);
456 unsigned NumArgsAfterSentinel =
Attr->getSentinel();
460 if (Args.size() < NumFormalParams + NumArgsAfterSentinel + 1) {
461 Diag(
Loc, diag::warn_not_enough_argument) <<
D->getDeclName();
467 const Expr *SentinelExpr = Args[Args.size() - NumArgsAfterSentinel - 1];
480 std::string NullValue;
484 NullValue =
"nullptr";
488 NullValue =
"(void*) 0";
491 Diag(
Loc, diag::warn_missing_sentinel) <<
int(CalleeKind);
493 Diag(MissingNilLoc, diag::warn_missing_sentinel)
518 assert(!Ty.
isNull() &&
"DefaultFunctionArrayConversion - missing type");
522 if (
auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl()))
527 CK_FunctionToPointerDecay).
get();
542 CK_ArrayToPointerDecay);
558 if (UO && UO->getOpcode() == UO_Deref &&
559 UO->getSubExpr()->getType()->isPointerType()) {
561 UO->getSubExpr()->getType()->getPointeeType().getAddressSpace();
564 UO->getSubExpr()->IgnoreParenCasts()->isNullPointerConstant(
566 !UO->getType().isVolatileQualified()) {
568 S.
PDiag(diag::warn_indirection_through_null)
569 << UO->getSubExpr()->getSourceRange());
571 S.
PDiag(diag::note_indirection_through_null));
603 if (ObjectSetClass) {
647 assert(!
T.isNull() &&
"r-value conversion on typeless expression?");
689 SourceRange(OISA->getOpLoc(), OISA->getIsaMemberLoc()),
")");
706 if (
T.hasQualifiers())
707 T =
T.getUnqualifiedType();
740 T =
Atomic->getValueType().getUnqualifiedType();
765 CK_FunctionToPointerDecay);
779 assert(!Ty.
isNull() &&
"UsualUnaryFPConversions - missing type");
786 switch (EvalMethod) {
788 llvm_unreachable(
"Unrecognized float evaluation method");
791 llvm_unreachable(
"Float evaluation method should be set by now");
799 CK_FloatingComplexCast)
808 CK_FloatingComplexCast)
840 assert(!Ty.
isNull() &&
"UsualUnaryConversions - missing type");
879 assert(!Ty.
isNull() &&
"DefaultArgumentPromotion - missing type");
891 if (BTy && (BTy->
getKind() == BuiltinType::Half ||
892 BTy->
getKind() == BuiltinType::Float)) {
895 if (BTy->
getKind() == BuiltinType::Half) {
913 "Unexpected typesize for LongLongTy");
982 if (!
Record->hasNonTrivialCopyConstructor() &&
983 !
Record->hasNonTrivialMoveConstructor() &&
984 !
Record->hasNonTrivialDestructor())
1017 PDiag(diag::warn_cxx98_compat_pass_non_pod_arg_to_vararg) << Ty << CT);
1024 PDiag(diag::warn_pass_class_arg_to_vararg)
1032 PDiag(diag::warn_cannot_pass_non_pod_arg_to_vararg)
1039 diag::err_cannot_pass_non_trivial_c_struct_to_vararg)
1043 PDiag(diag::err_cannot_pass_objc_interface_to_vararg)
1047 << isa<InitListExpr>(
E) << Ty << CT;
1056 if (PlaceholderTy->getKind() == BuiltinType::ARCUnbridgedCast &&
1058 (FDecl && FDecl->
hasAttr<CFAuditedTransferAttr>()))) {
1097 if (
Call.isInvalid())
1102 if (Comma.isInvalid())
1109 diag::err_call_incomplete_argument))
1127 if (SkipCast)
return false;
1134 CK_IntegralComplexToFloatingComplex);
1152 bool PromotePrecision) {
1157 if (PromotePrecision) {
1162 if (LongerIsComplex)
1174 QualType RHSType,
bool IsCompAssign) {
1199 bool ConvertFloat,
bool ConvertInt) {
1204 CK_IntegralToFloating);
1215 CK_IntegralComplexToFloatingComplex);
1220 CK_FloatingRealToComplex);
1229 QualType RHSType,
bool IsCompAssign) {
1239 else if (!IsCompAssign)
1241 return LHSFloat ? LHSType : RHSType;
1246 if (LHSFloat && RHSFloat) {
1253 assert(order < 0 &&
"illegal float comparison");
1287 QualType LHSElem = LHSComplex ? LHSComplex->getElementType() : LHSType;
1293 if ((&LHSSem != &llvm::APFloat::PPCDoubleDouble() ||
1294 &RHSSem != &llvm::APFloat::IEEEquad()) &&
1295 (&LHSSem != &llvm::APFloat::IEEEquad() ||
1296 &RHSSem != &llvm::APFloat::PPCDoubleDouble()))
1313 CK_IntegralComplexCast);
1319template <PerformCastFn doLHSCast, PerformCastFn doRHSCast>
1322 QualType RHSType,
bool IsCompAssign) {
1327 if (LHSSigned == RHSSigned) {
1330 RHS = (*doRHSCast)(S, RHS.
get(), LHSType);
1332 }
else if (!IsCompAssign)
1333 LHS = (*doLHSCast)(S, LHS.
get(), RHSType);
1335 }
else if (order != (LHSSigned ? 1 : -1)) {
1339 RHS = (*doRHSCast)(S, RHS.
get(), LHSType);
1341 }
else if (!IsCompAssign)
1342 LHS = (*doLHSCast)(S, LHS.
get(), RHSType);
1349 RHS = (*doRHSCast)(S, RHS.
get(), LHSType);
1351 }
else if (!IsCompAssign)
1352 LHS = (*doLHSCast)(S, LHS.
get(), RHSType);
1361 RHS = (*doRHSCast)(S, RHS.
get(), result);
1363 LHS = (*doLHSCast)(S, LHS.
get(), result);
1373 bool IsCompAssign) {
1377 if (LHSComplexInt && RHSComplexInt) {
1381 handleIntegerConversion<doComplexIntegralCast, doComplexIntegralCast>
1382 (S, LHS, RHS, LHSEltType, RHSEltType, IsCompAssign);
1387 if (LHSComplexInt) {
1390 handleIntegerConversion<doComplexIntegralCast, doIntegralCast>
1391 (S, LHS, RHS, LHSEltType, RHSType, IsCompAssign);
1394 CK_IntegralRealToComplex);
1399 assert(RHSComplexInt);
1403 handleIntegerConversion<doIntegralCast, doComplexIntegralCast>
1404 (S, LHS, RHS, LHSType, RHSEltType, IsCompAssign);
1409 CK_IntegralRealToComplex);
1418 assert(BTy &&
"Expected a builtin type.");
1420 switch (BTy->getKind()) {
1421 case BuiltinType::ShortFract:
1422 case BuiltinType::UShortFract:
1423 case BuiltinType::SatShortFract:
1424 case BuiltinType::SatUShortFract:
1426 case BuiltinType::Fract:
1427 case BuiltinType::UFract:
1428 case BuiltinType::SatFract:
1429 case BuiltinType::SatUFract:
1431 case BuiltinType::LongFract:
1432 case BuiltinType::ULongFract:
1433 case BuiltinType::SatLongFract:
1434 case BuiltinType::SatULongFract:
1436 case BuiltinType::ShortAccum:
1437 case BuiltinType::UShortAccum:
1438 case BuiltinType::SatShortAccum:
1439 case BuiltinType::SatUShortAccum:
1441 case BuiltinType::Accum:
1442 case BuiltinType::UAccum:
1443 case BuiltinType::SatAccum:
1444 case BuiltinType::SatUAccum:
1446 case BuiltinType::LongAccum:
1447 case BuiltinType::ULongAccum:
1448 case BuiltinType::SatLongAccum:
1449 case BuiltinType::SatULongAccum:
1452 if (BTy->isInteger())
1454 llvm_unreachable(
"Unexpected fixed point or integer type");
1466 "Expected at least one of the operands to be a fixed point type");
1469 "Special fixed point arithmetic operation conversions are only "
1470 "applied to ints or other fixed point types");
1492 QualType ResultTy = LHSTyRank > RHSTyRank ? LHSTy : RHSTy;
1515 REnum = R->isUnscopedEnumerationType();
1517 if ((!IsCompAssign && LEnum && R->isFloatingType()) ||
1521 ? diag::warn_arith_conv_enum_float_cxx20
1522 : diag::warn_arith_conv_enum_float)
1525 }
else if (!IsCompAssign && LEnum && REnum &&
1531 DiagID = diag::warn_conv_mixed_enum_types_cxx26;
1537 ->hasNameForLinkage()) {
1542 ? diag::warn_arith_conv_mixed_anon_enum_types_cxx20
1543 : diag::warn_arith_conv_mixed_anon_enum_types;
1548 ? diag::warn_conditional_mixed_enum_types_cxx20
1549 : diag::warn_conditional_mixed_enum_types;
1554 ? diag::warn_comparison_mixed_enum_types_cxx20
1555 : diag::warn_comparison_mixed_enum_types;
1558 ? diag::warn_arith_conv_mixed_enum_types_cxx20
1559 : diag::warn_arith_conv_mixed_enum_types;
1562 << (
int)ACK << L << R;
1580 auto IsSingleCodeUnitCP = [](
const QualType &
T,
const llvm::APSInt &
Value) {
1582 return llvm::IsSingleCodeUnitUTF8Codepoint(
Value.getExtValue());
1584 return llvm::IsSingleCodeUnitUTF16Codepoint(
Value.getExtValue());
1586 return llvm::IsSingleCodeUnitUTF32Codepoint(
Value.getExtValue());
1599 if (LHSSuccess != RHSuccess) {
1601 if (IsSingleCodeUnitCP(LHSType, Res.
Val.
getInt()) &&
1602 IsSingleCodeUnitCP(RHSType, Res.
Val.
getInt()))
1606 if (!LHSSuccess || !RHSuccess) {
1607 SemaRef.
Diag(
Loc, diag::warn_comparison_unicode_mixed_types)
1613 llvm::APSInt LHSValue(32);
1615 llvm::APSInt RHSValue(32);
1618 bool LHSSafe = IsSingleCodeUnitCP(LHSType, LHSValue);
1619 bool RHSSafe = IsSingleCodeUnitCP(RHSType, RHSValue);
1620 if (LHSSafe && RHSSafe)
1623 SemaRef.
Diag(
Loc, diag::warn_comparison_unicode_mixed_types_constant)
1633 SemaRef.
Diag(
Loc, diag::warn_arith_conv_mixed_unicode_types)
1667 LHSType = AtomicLHS->getValueType();
1679 QualType LHSUnpromotedType = LHSType;
1683 if (!LHSBitfieldPromoteTy.
isNull())
1684 LHSType = LHSBitfieldPromoteTy;
1718 return handleIntegerConversion<doIntegralCast, doIntegralCast>(
1729 bool PredicateIsExpr,
void *ControllingExprOrType,
1731 unsigned NumAssocs = ArgTypes.size();
1732 assert(NumAssocs == ArgExprs.size());
1735 for (
unsigned i = 0; i < NumAssocs; ++i) {
1744 if (!PredicateIsExpr) {
1748 assert(ControllingType &&
"couldn't get the type out of the parser");
1749 ControllingExprOrType = ControllingType;
1753 KeyLoc, DefaultLoc, RParenLoc, PredicateIsExpr, ControllingExprOrType,
1761 bool PredicateIsExpr,
void *ControllingExprOrType,
1763 unsigned NumAssocs = Types.size();
1764 assert(NumAssocs == Exprs.size());
1765 assert(ControllingExprOrType &&
1766 "Must have either a controlling expression or a controlling type");
1768 Expr *ControllingExpr =
nullptr;
1770 if (PredicateIsExpr) {
1777 reinterpret_cast<Expr *
>(ControllingExprOrType));
1780 ControllingExpr = R.
get();
1783 ControllingType =
reinterpret_cast<TypeSourceInfo *
>(ControllingExprOrType);
1784 if (!ControllingType)
1788 bool TypeErrorFound =
false,
1789 IsResultDependent = ControllingExpr
1792 ContainsUnexpandedParameterPack =
1802 diag::warn_side_effects_unevaluated_context);
1804 for (
unsigned i = 0; i < NumAssocs; ++i) {
1805 if (Exprs[i]->containsUnexpandedParameterPack())
1806 ContainsUnexpandedParameterPack =
true;
1809 if (Types[i]->getType()->containsUnexpandedParameterPack())
1810 ContainsUnexpandedParameterPack =
true;
1812 if (Types[i]->getType()->isDependentType()) {
1813 IsResultDependent =
true;
1830 if (ControllingExpr && Types[i]->getType()->isIncompleteType())
1831 D =
LangOpts.C2y ? diag::warn_c2y_compat_assoc_type_incomplete
1832 : diag::ext_assoc_type_incomplete;
1833 else if (ControllingExpr && !Types[i]->getType()->isObjectType())
1834 D = diag::err_assoc_type_nonobject;
1835 else if (Types[i]->getType()->isVariablyModifiedType())
1836 D = diag::err_assoc_type_variably_modified;
1837 else if (ControllingExpr) {
1856 unsigned Reason = 0;
1865 Diag(Types[i]->getTypeLoc().getBeginLoc(),
1866 diag::warn_unreachable_association)
1867 << QT << (Reason - 1);
1871 Diag(Types[i]->getTypeLoc().getBeginLoc(),
D)
1872 << Types[i]->getTypeLoc().getSourceRange() << Types[i]->getType();
1874 D, Types[i]->getTypeLoc().getBeginLoc()) >=
1876 TypeErrorFound =
true;
1881 for (
unsigned j = i+1; j < NumAssocs; ++j)
1882 if (Types[j] && !Types[j]->getType()->isDependentType() &&
1884 Types[j]->getType())) {
1885 Diag(Types[j]->getTypeLoc().getBeginLoc(),
1886 diag::err_assoc_compatible_types)
1887 << Types[j]->getTypeLoc().getSourceRange()
1888 << Types[j]->getType()
1889 << Types[i]->getType();
1890 Diag(Types[i]->getTypeLoc().getBeginLoc(),
1891 diag::note_compat_assoc)
1892 << Types[i]->getTypeLoc().getSourceRange()
1893 << Types[i]->getType();
1894 TypeErrorFound =
true;
1904 if (IsResultDependent) {
1905 if (ControllingExpr)
1907 Types, Exprs, DefaultLoc, RParenLoc,
1908 ContainsUnexpandedParameterPack);
1910 Exprs, DefaultLoc, RParenLoc,
1911 ContainsUnexpandedParameterPack);
1915 unsigned DefaultIndex = std::numeric_limits<unsigned>::max();
1919 for (
unsigned i = 0; i < NumAssocs; ++i) {
1922 else if (ControllingExpr &&
1925 Types[i]->getType()))
1926 CompatIndices.push_back(i);
1927 else if (ControllingType &&
1930 Types[i]->getType()))
1931 CompatIndices.push_back(i);
1934 auto GetControllingRangeAndType = [](
Expr *ControllingExpr,
1938 if (ControllingExpr)
1947 return std::make_pair(SR, QT);
1953 if (CompatIndices.size() > 1) {
1954 auto P = GetControllingRangeAndType(ControllingExpr, ControllingType);
1957 << SR <<
P.second << (
unsigned)CompatIndices.size();
1958 for (
unsigned I : CompatIndices) {
1959 Diag(Types[I]->getTypeLoc().getBeginLoc(),
1960 diag::note_compat_assoc)
1961 << Types[I]->getTypeLoc().getSourceRange()
1962 << Types[I]->getType();
1970 if (DefaultIndex == std::numeric_limits<unsigned>::max() &&
1971 CompatIndices.size() == 0) {
1972 auto P = GetControllingRangeAndType(ControllingExpr, ControllingType);
1974 Diag(SR.
getBegin(), diag::err_generic_sel_no_match) << SR <<
P.second;
1983 unsigned ResultIndex =
1984 CompatIndices.size() ? CompatIndices[0] : DefaultIndex;
1986 if (ControllingExpr) {
1988 Context, KeyLoc, ControllingExpr, Types, Exprs, DefaultLoc, RParenLoc,
1989 ContainsUnexpandedParameterPack, ResultIndex);
1992 Context, KeyLoc, ControllingType, Types, Exprs, DefaultLoc, RParenLoc,
1993 ContainsUnexpandedParameterPack, ResultIndex);
1999 llvm_unreachable(
"unexpected TokenKind");
2000 case tok::kw___func__:
2002 case tok::kw___FUNCTION__:
2004 case tok::kw___FUNCDNAME__:
2006 case tok::kw___FUNCSIG__:
2008 case tok::kw_L__FUNCTION__:
2010 case tok::kw_L__FUNCSIG__:
2012 case tok::kw___PRETTY_FUNCTION__:
2021 while (DC && !isa<BlockDecl, CapturedDecl, FunctionDecl, ObjCMethodDecl>(DC))
2023 return cast_or_null<Decl>(DC);
2041 assert(Args.size() <= 2 &&
"too many arguments for literal operator");
2044 for (
unsigned ArgIdx = 0; ArgIdx != Args.size(); ++ArgIdx) {
2045 ArgTy[ArgIdx] = Args[ArgIdx]->getType();
2046 if (ArgTy[ArgIdx]->isArrayType())
2067 std::vector<Token> ExpandedToks;
2073 if (Literal.hadError)
2077 for (
const Token &Tok : StringToks)
2078 StringTokLocs.push_back(Tok.getLocation());
2082 false, {}, StringTokLocs);
2084 if (!Literal.getUDSuffix().empty()) {
2087 Literal.getUDSuffixOffset());
2088 return ExprError(
Diag(UDSuffixLoc, diag::err_invalid_string_udl));
2110 std::vector<Token> ExpandedToks;
2111 ExpandedToks.reserve(Toks.size());
2112 for (
const Token &Tok : Toks) {
2115 ExpandedToks.emplace_back(Tok);
2118 if (isa<TranslationUnitDecl>(CurrentDecl))
2119 Diag(Tok.getLocation(), diag::ext_predef_outside_function);
2121 Diag(Tok.getLocation(), diag::ext_string_literal_from_predefined)
2124 llvm::raw_svector_ostream
OS(Str);
2125 Token &Exp = ExpandedToks.emplace_back();
2127 if (Tok.getKind() == tok::kw_L__FUNCTION__ ||
2128 Tok.getKind() == tok::kw_L__FUNCSIG__) {
2130 Exp.
setKind(tok::wide_string_literal);
2132 Exp.
setKind(tok::string_literal);
2140 return ExpandedToks;
2145 assert(!StringToks.empty() &&
"Must have at least one string!");
2148 std::vector<Token> ExpandedToks;
2153 if (Literal.hadError)
2157 for (
const Token &Tok : StringToks)
2158 StringTokLocs.push_back(Tok.getLocation());
2162 if (Literal.isWide()) {
2165 }
else if (Literal.isUTF8()) {
2171 }
else if (Literal.isUTF16()) {
2174 }
else if (Literal.isUTF32()) {
2177 }
else if (Literal.isPascal()) {
2190 ? diag::warn_cxx20_compat_utf8_string
2191 : diag::warn_c23_compat_utf8_string);
2197 auto RemovalDiag =
PDiag(diag::note_cxx20_c23_compat_utf8_string_remove_u8);
2199 for (
const Token &Tok : StringToks) {
2200 if (Tok.getKind() == tok::utf8_string_literal) {
2202 RemovalDiagLoc = Tok.getLocation();
2209 Diag(RemovalDiagLoc, RemovalDiag);
2217 Context, Literal.GetString(), Kind, Literal.Pascal, StrTy, StringTokLocs);
2218 if (Literal.getUDSuffix().empty())
2225 Literal.getUDSuffixOffset());
2229 return ExprError(
Diag(UDSuffixLoc, diag::err_invalid_string_udl));
2254 Expr *Args[] = { Lit, LenArg };
2273 llvm::APSInt
Value(CharBits, CharIsUnsigned);
2279 for (
unsigned I = 0, N = Lit->
getLength(); I != N; ++I) {
2290 llvm_unreachable(
"unexpected literal operator lookup result");
2294 llvm_unreachable(
"unexpected literal operator lookup result");
2326 auto *DRE = dyn_cast<DeclRefExpr>(VD->
getInit());
2329 auto *Referee = dyn_cast<VarDecl>(DRE->getDecl());
2330 if (!Referee || !Referee->hasGlobalStorage() ||
2331 Referee->hasAttr<CUDADeviceAttr>())
2337 auto *MD = dyn_cast_or_null<CXXMethodDecl>(S.
CurContext);
2338 if (MD && MD->getParent()->isLambda() &&
2339 MD->getOverloadedOperator() == OO_Call && MD->hasAttr<CUDADeviceAttr>() &&
2361 if (
VarDecl *VD = dyn_cast<VarDecl>(
D)) {
2362 if (VD->getType()->isReferenceType() &&
2365 VD->isUsableInConstantExpressions(
Context))
2380 bool RefersToCapturedVariable = isa<VarDecl, BindingDecl>(
D) &&
2384 Context, NNS, TemplateKWLoc,
D, RefersToCapturedVariable, NameInfo, Ty,
2412 const auto *FD = dyn_cast<FieldDecl>(
D);
2413 if (
const auto *IFD = dyn_cast<IndirectFieldDecl>(
D))
2414 FD = IFD->getAnonField();
2418 if (FD->isBitField())
2424 if (
const auto *BD = dyn_cast<BindingDecl>(
D))
2425 if (
const auto *BE = BD->getBinding())
2441 Id.TemplateId->NumArgs);
2447 TemplateArgs = &Buffer;
2450 TemplateArgs =
nullptr;
2458 bool isDefaultArgument =
2462 const auto *CurMethod = dyn_cast<CXXMethodDecl>(
CurContext);
2463 bool isInstance = CurMethod && CurMethod->isInstance() &&
2472 unsigned DiagID = diag::err_found_in_dependent_base;
2473 unsigned NoteID = diag::note_member_declared_at;
2475 DiagID =
getLangOpts().MSVCCompat ? diag::ext_found_later_in_class
2476 : diag::err_found_later_in_class;
2478 DiagID = diag::ext_found_in_dependent_base;
2479 NoteID = diag::note_dependent_member_use;
2504 if (isDefaultArgument && ((*R.
begin())->isCXXInstanceMember())) {
2520 unsigned diagnostic = diag::err_undeclared_var_use;
2521 unsigned diagnostic_suggest = diag::err_undeclared_var_use_suggest;
2525 diagnostic = diag::err_undeclared_use;
2526 diagnostic_suggest = diag::err_undeclared_use_suggest;
2536 if (isa<CXXRecordDecl>(DC)) {
2537 if (ExplicitTemplateArgs) {
2560 R.
addDecl(Best->FoundDecl.getDecl(), Best->FoundDecl.getAccess());
2575 if (S && (Corrected =
2579 bool DroppedSpecifier =
2583 bool AcceptableWithRecovery =
false;
2584 bool AcceptableWithoutRecovery =
false;
2593 dyn_cast<FunctionTemplateDecl>(CD))
2597 else if (
FunctionDecl *FD = dyn_cast<FunctionDecl>(CD))
2598 if (!ExplicitTemplateArgs || ExplicitTemplateArgs->
size() == 0)
2604 ND = Best->FoundDecl;
2605 Corrected.setCorrectionDecl(ND);
2609 Corrected.setCorrectionDecl(ND);
2618 Record = cast<CXXRecordDecl>(
2624 AcceptableWithRecovery = isa<ValueDecl>(UnderlyingND) ||
2625 isa<FunctionTemplateDecl>(UnderlyingND);
2631 AcceptableWithoutRecovery = isa<TypeDecl>(UnderlyingND) ||
2633 isa<ObjCInterfaceDecl>(UnderlyingND);
2637 AcceptableWithoutRecovery =
true;
2640 if (AcceptableWithRecovery || AcceptableWithoutRecovery) {
2642 ? diag::note_implicit_param_decl
2643 : diag::note_previous_decl;
2646 PDiag(NoteID), AcceptableWithRecovery);
2649 PDiag(diag::err_no_member_suggest)
2651 << DroppedSpecifier << NameRange,
2652 PDiag(NoteID), AcceptableWithRecovery);
2655 return !AcceptableWithRecovery;
2690 else if (
auto *MD = dyn_cast<CXXMethodDecl>(S.
CurContext))
2698 auto DB = S.
Diag(
Loc, diag::ext_undeclared_unqual_id_with_dependent_base);
2699 DB << NameInfo.
getName() << RD;
2701 if (!ThisType.
isNull()) {
2704 Context,
nullptr, ThisType,
true,
2706 nullptr, NameInfo, TemplateArgs);
2722 bool HasTrailingLParen,
bool IsAddressOfOperand,
2724 bool IsInlineAsmIdentifier,
Token *KeywordReplacement) {
2725 assert(!(IsAddressOfOperand && HasTrailingLParen) &&
2726 "cannot be direct & operand and have a trailing lparen");
2755 if (
auto *VD = dyn_cast<ValueDecl>(R.
getFoundDecl())) {
2769 if (TemplateKWLoc.
isValid() || TemplateArgs) {
2777 false, TemplateKWLoc,
2783 IsAddressOfOperand, TemplateArgs);
2787 !IvarLookupFollowUp);
2793 IsAddressOfOperand, TemplateArgs);
2797 if (IvarLookupFollowUp) {
2812 if (R.
empty() && HasTrailingLParen && II &&
2822 if (R.
empty() && !ADL) {
2825 TemplateKWLoc, TemplateArgs))
2830 if (IsInlineAsmIdentifier)
2838 "Typo correction callback misconfigured");
2852 assert(!R.
empty() &&
2853 "DiagnoseEmptyLookup returned false but added no results");
2863 if (!
E.isInvalid() && !
E.get())
2870 assert(!R.
empty() || ADL);
2900 if (TemplateArgs || TemplateKWLoc.
isValid()) {
2909 "There should only be one declaration found.");
2937 if (
const auto *CD = dyn_cast<CXXRecordDecl>(DC))
2938 if (CD->isInvalidDecl())
2948 if (
auto *TagD = dyn_cast<TagDecl>(TD)) {
2955 TL.setNameLoc(NameInfo.
getLoc());
2956 }
else if (
auto *TypedefD = dyn_cast<TypedefNameDecl>(TD)) {
2972 unsigned DiagID = diag::err_typename_missing;
2974 DiagID = diag::ext_typename_missing;
3007 const auto *RD = dyn_cast<CXXRecordDecl>(
Member->getDeclContext());
3015 bool PointerConversions =
false;
3016 if (isa<FieldDecl>(
Member)) {
3020 DestRecordType, FromPtrType
3027 PointerConversions =
true;
3029 DestType = DestRecordType;
3030 FromRecordType = FromType;
3032 }
else if (
const auto *
Method = dyn_cast<CXXMethodDecl>(
Member)) {
3033 if (!
Method->isImplicitObjectMemberFunction())
3036 DestType =
Method->getThisType().getNonReferenceType();
3037 DestRecordType =
Method->getFunctionObjectParameterType();
3041 PointerConversions =
true;
3043 FromRecordType = FromType;
3044 DestType = DestRecordType;
3049 if (FromAS != DestAS) {
3054 if (PointerConversions)
3097 assert(QType->
isRecordType() &&
"lookup done with non-record type");
3107 FromLoc, FromRange, &BasePath))
3110 if (PointerConversions)
3113 VK, &BasePath).
get();
3116 FromRecordType = QRecordType;
3127 FromLoc, FromRange, &BasePath,
3144 bool HasTrailingLParen) {
3146 if (!HasTrailingLParen)
3164 if (
D->isCXXClassMember())
3173 if (isa<UsingShadowDecl>(
D))
3174 D = cast<UsingShadowDecl>(
D)->getTargetDecl();
3182 if (
const auto *FDecl = dyn_cast<FunctionDecl>(
D)) {
3184 if (FDecl->getBuiltinID() && FDecl->isImplicit())
3186 }
else if (!isa<FunctionTemplateDecl>(
D))
3199 bool AcceptInvalid) {
3203 if (isa<TypedefNameDecl>(
D)) {
3204 S.
Diag(
Loc, diag::err_unexpected_typedef) <<
D->getDeclName();
3208 if (isa<ObjCInterfaceDecl>(
D)) {
3209 S.
Diag(
Loc, diag::err_unexpected_interface) <<
D->getDeclName();
3213 if (isa<NamespaceDecl>(
D)) {
3214 S.
Diag(
Loc, diag::err_unexpected_namespace) <<
D->getDeclName();
3225 const auto *FD = dyn_cast<FunctionDecl>(R.
getFoundDecl());
3227 (FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion());
3232 bool AcceptInvalidDecl) {
3266 bool AcceptInvalidDecl) {
3267 assert(
D &&
"Cannot refer to a NULL declaration");
3268 assert(!isa<FunctionTemplateDecl>(
D) &&
3269 "Cannot refer unambiguously to a function template");
3287 if (!isa<ValueDecl, UnresolvedUsingIfExistsDecl>(
D)) {
3300 auto *VD = cast<ValueDecl>(
D);
3303 if (VD->isInvalidDecl() && !AcceptInvalidDecl)
3309 if (
auto *IndirectField = dyn_cast<IndirectFieldDecl>(VD);
3310 IndirectField && !IndirectField->isCXXClassMember())
3322 type =
type.getNonPackExpansionType();
3326#define ABSTRACT_DECL(kind)
3327#define VALUE(type, base)
3328#define DECL(type, base) case Decl::type:
3329#include "clang/AST/DeclNodes.inc"
3330 llvm_unreachable(
"invalid value decl kind");
3333 case Decl::ObjCAtDefsField:
3334 llvm_unreachable(
"forming non-member reference to ivar?");
3338 case Decl::EnumConstant:
3339 case Decl::UnresolvedUsingValue:
3340 case Decl::OMPDeclareReduction:
3341 case Decl::OMPDeclareMapper:
3350 case Decl::IndirectField:
3351 case Decl::ObjCIvar:
3353 "building reference to field in C?");
3363 case Decl::NonTypeTemplateParm: {
3365 type = reftype->getPointeeType();
3375 if (
type->isRecordType()) {
3376 type =
type.getUnqualifiedType().withConst();
3389 case Decl::VarTemplateSpecialization:
3390 case Decl::VarTemplatePartialSpecialization:
3391 case Decl::Decomposition:
3393 case Decl::OMPCapturedExpr:
3396 type->isVoidType()) {
3402 case Decl::ImplicitParam:
3403 case Decl::ParmVar: {
3413 if (!CapturedType.
isNull())
3414 type = CapturedType;
3419 case Decl::Function: {
3420 if (
unsigned BID = cast<FunctionDecl>(VD)->getBuiltinID()) {
3449 if (!cast<FunctionDecl>(VD)->hasPrototype() && isa<FunctionProtoType>(fty))
3458 case Decl::CXXDeductionGuide:
3459 llvm_unreachable(
"building reference to deduction guide");
3461 case Decl::MSProperty:
3463 case Decl::TemplateParamObject:
3469 case Decl::UnnamedGlobalConstant:
3473 case Decl::CXXMethod:
3478 dyn_cast<FunctionProtoType>(VD->getType()))
3486 if (cast<CXXMethodDecl>(VD)->isStatic()) {
3492 case Decl::CXXConversion:
3493 case Decl::CXXDestructor:
3494 case Decl::CXXConstructor:
3506 if (VD->isInvalidDecl() &&
E)
3513 Target.resize(CharByteWidth * (Source.size() + 1));
3514 char *ResultPtr = &
Target[0];
3515 const llvm::UTF8 *ErrorPtr;
3517 llvm::ConvertUTF8toWide(CharByteWidth, Source, ResultPtr, ErrorPtr);
3527 Diag(
Loc, diag::ext_predef_outside_function);
3533 if (cast<DeclContext>(currentDecl)->isDependentContext())
3538 bool ForceElaboratedPrinting =
3542 unsigned Length = Str.length();
3544 llvm::APInt LengthI(32, Length + 1);
3584 if (Literal.hadError())
3588 if (Literal.isWide())
3594 else if (Literal.isUTF16())
3596 else if (Literal.isUTF32())
3605 if (Literal.isWide())
3607 else if (Literal.isUTF16())
3609 else if (Literal.isUTF32())
3611 else if (Literal.isUTF8())
3617 if (Literal.getUDSuffix().empty())
3627 return ExprError(
Diag(UDSuffixLoc, diag::err_invalid_character_udl));
3638 llvm::APInt(IntSize, Val,
true),
3646 using llvm::APFloat;
3647 APFloat Val(Format);
3650 if (RM == llvm::RoundingMode::Dynamic)
3651 RM = llvm::RoundingMode::NearestTiesToEven;
3652 APFloat::opStatus result = Literal.GetFloatValue(Val, RM);
3656 if ((result & APFloat::opOverflow) ||
3657 ((result & APFloat::opUnderflow) && Val.isZero())) {
3658 unsigned diagnostic;
3660 if (result & APFloat::opOverflow) {
3661 diagnostic = diag::warn_float_overflow;
3662 APFloat::getLargest(Format).toString(buffer);
3664 diagnostic = diag::warn_float_underflow;
3665 APFloat::getSmallest(Format).toString(buffer);
3668 S.
Diag(
Loc, diagnostic) << Ty << buffer.str();
3671 bool isExact = (result == APFloat::opOK);
3676 assert(
E &&
"Invalid expression");
3683 Diag(
E->
getExprLoc(), diag::err_pragma_loop_invalid_argument_type) << QT;
3687 llvm::APSInt ValueAPS;
3698 bool ValueIsPositive =
3699 AllowZero ? ValueAPS.isNonNegative() : ValueAPS.isStrictlyPositive();
3700 if (!ValueIsPositive || ValueAPS.getActiveBits() > 31) {
3702 <<
toString(ValueAPS, 10) << ValueIsPositive;
3722 SpellingBuffer.resize(Tok.
getLength() + 1);
3733 if (Literal.hadError)
3736 if (Literal.hasUDSuffix()) {
3744 return ExprError(
Diag(UDSuffixLoc, diag::err_invalid_numeric_udl));
3747 if (Literal.isFloatingLiteral()) {
3772 !Literal.isImaginary)) {
3781 if (Literal.isFloatingLiteral()) {
3785 if (Literal.GetIntegerValue(ResultVal))
3798 unsigned Length = Literal.getUDSuffixOffset();
3805 false, StrTy, TokLoc);
3816 bool CharIsUnsigned =
Context.
CharTy->isUnsignedIntegerType();
3817 llvm::APSInt
Value(CharBits, CharIsUnsigned);
3818 for (
unsigned I = 0, N = Literal.getUDSuffixOffset(); I != N; ++I) {
3819 Value = TokSpelling[I];
3827 llvm_unreachable(
"unexpected literal operator lookup result");
3833 if (Literal.isFixedPointLiteral()) {
3836 if (Literal.isAccum) {
3837 if (Literal.isHalf) {
3839 }
else if (Literal.isLong) {
3844 }
else if (Literal.isFract) {
3845 if (Literal.isHalf) {
3847 }
else if (Literal.isLong) {
3856 bool isSigned = !Literal.isUnsigned;
3860 llvm::APInt Val(bit_width, 0, isSigned);
3861 bool Overflowed = Literal.GetFixedPointValue(Val, scale);
3862 bool ValIsZero = Val.isZero() && !Overflowed;
3865 if (Literal.isFract && Val == MaxVal + 1 && !ValIsZero)
3871 else if (Val.ugt(MaxVal) || Overflowed)
3876 }
else if (Literal.isFloatingLiteral()) {
3878 if (Literal.isHalf){
3886 }
else if (Literal.isFloat)
3888 else if (Literal.isLong)
3890 else if (Literal.isFloat16)
3892 else if (Literal.isFloat128)
3914 }
else if (!Literal.isIntegerLiteral()) {
3920 if (Literal.isSizeT)
3923 ? diag::warn_cxx20_compat_size_t_suffix
3924 : diag::ext_cxx23_size_t_suffix
3925 : diag::err_cxx23_size_t_suffix);
3932 if (Literal.isBitInt)
3936 : diag::ext_c23_bitint_suffix);
3946 if (Literal.isBitInt)
3947 BitsNeeded = llvm::APInt::getSufficientBitsNeeded(
3948 Literal.getLiteralDigits(), Literal.getRadix());
3949 if (Literal.MicrosoftInteger) {
3950 if (Literal.MicrosoftInteger == 128 &&
3953 << Literal.isUnsigned;
3954 BitsNeeded = Literal.MicrosoftInteger;
3957 llvm::APInt ResultVal(BitsNeeded, 0);
3959 if (Literal.GetIntegerValue(ResultVal)) {
3965 "long long is not intmax_t?");
3972 bool AllowUnsigned = Literal.isUnsigned || Literal.getRadix() != 10;
3979 Literal.isLong =
true;
3980 Literal.isLongLong =
false;
3987 if (Literal.MicrosoftInteger) {
3988 if (Literal.MicrosoftInteger == 8 && !Literal.isUnsigned) {
3992 Width = Literal.MicrosoftInteger;
3994 !Literal.isUnsigned);
4000 if (Literal.isBitInt) {
4003 Width = std::max(ResultVal.getActiveBits(), 1u) +
4004 (Literal.isUnsigned ? 0u : 1u);
4008 unsigned int MaxBitIntWidth =
4010 if (Width > MaxBitIntWidth) {
4012 << Literal.isUnsigned;
4013 Width = MaxBitIntWidth;
4020 ResultVal = ResultVal.zextOrTrunc(Width);
4025 if (Literal.isSizeT) {
4026 assert(!Literal.MicrosoftInteger &&
4027 "size_t literals can't be Microsoft literals");
4032 if (ResultVal.isIntN(SizeTSize)) {
4034 if (!Literal.isUnsigned && ResultVal[SizeTSize - 1] == 0)
4036 else if (AllowUnsigned)
4042 if (Ty.
isNull() && !Literal.isLong && !Literal.isLongLong &&
4048 if (ResultVal.isIntN(IntSize)) {
4050 if (!Literal.isUnsigned && ResultVal[IntSize-1] == 0)
4052 else if (AllowUnsigned)
4059 if (Ty.
isNull() && !Literal.isLongLong && !Literal.isSizeT) {
4063 if (ResultVal.isIntN(LongSize)) {
4065 if (!Literal.isUnsigned && ResultVal[LongSize-1] == 0)
4067 else if (AllowUnsigned)
4072 const unsigned LongLongSize =
4077 ? diag::warn_old_implicitly_unsigned_long_cxx
4079 ext_old_implicitly_unsigned_long_cxx
4080 : diag::warn_old_implicitly_unsigned_long)
4081 << (LongLongSize > LongSize ? 0
4090 if (Ty.
isNull() && !Literal.isSizeT) {
4094 if (ResultVal.isIntN(LongLongSize)) {
4098 if (!Literal.isUnsigned && (ResultVal[LongLongSize-1] == 0 ||
4099 (
getLangOpts().MSVCCompat && Literal.isLongLong)))
4101 else if (AllowUnsigned)
4103 Width = LongLongSize;
4109 ? diag::warn_cxx98_compat_longlong
4110 : diag::ext_cxx11_longlong);
4120 if (Literal.isSizeT)
4122 << Literal.isUnsigned;
4125 diag::ext_integer_literal_too_large_for_signed);
4130 if (ResultVal.getBitWidth() != Width)
4131 ResultVal = ResultVal.trunc(Width);
4137 if (Literal.isImaginary) {
4144 DiagId = diag::ext_gnu_imaginary_constant;
4146 DiagId = diag::warn_c23_compat_imaginary_constant;
4148 DiagId = diag::ext_c2y_imaginary_constant;
4155 assert(
E &&
"ActOnParenExpr() missing expr");
4171 S.
Diag(
Loc, diag::err_vecstep_non_scalar_vector_type)
4177 "Scalar types should always be complete");
4186 return S.
Diag(
Loc, diag::err_builtin_non_vector_type)
4188 <<
"__builtin_vectorelements" <<
T << ArgRange;
4201 S.
Diag(
Loc, diag::err_ptrauth_type_disc_undiscriminated) <<
T << ArgRange;
4218 (TraitKind == UETT_SizeOf || TraitKind == UETT_AlignOf ||
4219 TraitKind == UETT_PreferredAlignOf)) {
4221 S.
Diag(
Loc, diag::ext_sizeof_alignof_function_type)
4229 unsigned DiagID = S.
LangOpts.OpenCL ? diag::err_opencl_sizeof_alignof_type
4230 : diag::ext_sizeof_alignof_void_type;
4245 S.
Diag(
Loc, diag::err_sizeof_nonfragile_interface)
4246 <<
T << (TraitKind == UETT_SizeOf)
4263 const auto *ICE = dyn_cast<ImplicitCastExpr>(
E);
4264 if (!ICE || ICE->getCastKind() != CK_ArrayToPointerDecay)
4267 S.
Diag(
Loc, diag::warn_sizeof_array_decay) << ICE->getSourceRange()
4269 << ICE->getSubExpr()->getType();
4277 bool IsUnevaluatedOperand =
4278 (ExprKind == UETT_SizeOf || ExprKind == UETT_DataSizeOf ||
4279 ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf ||
4280 ExprKind == UETT_VecStep || ExprKind == UETT_CountOf);
4281 if (IsUnevaluatedOperand) {
4299 if (ExprKind == UETT_VecStep)
4303 if (ExprKind == UETT_VectorElements)
4325 if (ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf) {
4328 diag::err_sizeof_alignof_incomplete_or_sizeless_type,
4333 E, diag::err_sizeof_alignof_incomplete_or_sizeless_type,
4352 if (ExprKind == UETT_CountOf) {
4357 Diag(
E->
getExprLoc(), diag::err_countof_arg_not_array_type) << ExprType;
4367 if (ExprKind == UETT_SizeOf) {
4368 if (
const auto *DeclRef = dyn_cast<DeclRefExpr>(
E->
IgnoreParens())) {
4369 if (
const auto *PVD = dyn_cast<ParmVarDecl>(DeclRef->getFoundDecl())) {
4370 QualType OType = PVD->getOriginalType();
4375 Diag(PVD->getLocation(), diag::note_declared_at);
4383 if (
const auto *BO = dyn_cast<BinaryOperator>(
E->
IgnoreParens())) {
4407 if (
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Inner)) {
4409 }
else if (
MemberExpr *ME = dyn_cast<MemberExpr>(Inner)) {
4410 D = ME->getMemberDecl();
4430 if (
FieldDecl *FD = dyn_cast_or_null<FieldDecl>(
D)) {
4433 if (!FD->getParent()->isCompleteDefinition()) {
4443 if (!FD->getType()->isReferenceType())
4463 assert(CSI !=
nullptr);
4467 const Type *Ty =
T.getTypePtr();
4469#define TYPE(Class, Base)
4470#define ABSTRACT_TYPE(Class, Base)
4471#define NON_CANONICAL_TYPE(Class, Base)
4472#define DEPENDENT_TYPE(Class, Base) case Type::Class:
4473#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base)
4474#include "clang/AST/TypeNodes.inc"
4481 case Type::ExtVector:
4482 case Type::ConstantMatrix:
4485 case Type::TemplateSpecialization:
4486 case Type::ObjCObject:
4487 case Type::ObjCInterface:
4488 case Type::ObjCObjectPointer:
4489 case Type::ObjCTypeParam:
4492 case Type::HLSLInlineSpirv:
4493 llvm_unreachable(
"type class is never variably-modified!");
4494 case Type::Adjusted:
4495 T = cast<AdjustedType>(Ty)->getOriginalType();
4500 case Type::ArrayParameter:
4501 T = cast<ArrayParameterType>(Ty)->getElementType();
4506 case Type::BlockPointer:
4509 case Type::LValueReference:
4510 case Type::RValueReference:
4513 case Type::MemberPointer:
4516 case Type::ConstantArray:
4517 case Type::IncompleteArray:
4519 T = cast<ArrayType>(Ty)->getElementType();
4521 case Type::VariableArray: {
4529 (isa<CapturedRegionScopeInfo>(CSI) || isa<LambdaScopeInfo>(CSI)))
4535 case Type::FunctionProto:
4536 case Type::FunctionNoProto:
4541 case Type::UnaryTransform:
4542 case Type::Attributed:
4543 case Type::BTFTagAttributed:
4544 case Type::HLSLAttributedResource:
4545 case Type::SubstTemplateTypeParm:
4546 case Type::MacroQualified:
4547 case Type::CountAttributed:
4549 T =
T.getSingleStepDesugaredType(Context);
4552 T = cast<TypedefType>(Ty)->
desugar();
4554 case Type::Decltype:
4555 T = cast<DecltypeType>(Ty)->
desugar();
4557 case Type::PackIndexing:
4558 T = cast<PackIndexingType>(Ty)->
desugar();
4561 T = cast<UsingType>(Ty)->
desugar();
4564 case Type::DeducedTemplateSpecialization:
4565 T = cast<DeducedType>(Ty)->getDeducedType();
4567 case Type::TypeOfExpr:
4568 T = cast<TypeOfExprType>(Ty)->getUnderlyingExpr()->getType();
4571 T = cast<AtomicType>(Ty)->getValueType();
4573 case Type::PredefinedSugar:
4574 T = cast<PredefinedSugarType>(Ty)->
desugar();
4600 if (ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf ||
4601 ExprKind == UETT_OpenMPRequiredSimdAlign) {
4607 ? diag::warn_c2y_compat_alignof_incomplete_array
4608 : diag::ext_c2y_alignof_incomplete_array);
4612 if (ExprKind == UETT_VecStep)
4615 if (ExprKind == UETT_VectorElements)
4619 if (ExprKind == UETT_PtrAuthTypeDiscriminator)
4629 OpLoc, ExprType, diag::err_sizeof_alignof_incomplete_or_sizeless_type,
4634 Diag(OpLoc, diag::err_sizeof_alignof_function_type) << KWName << ExprRange;
4638 if (ExprKind == UETT_CountOf) {
4642 Diag(OpLoc, diag::err_countof_arg_not_array_type) << ExprType;
4651 Diag(OpLoc, diag::err_wasm_table_invalid_uett_operand)
4665 auto *CSI = dyn_cast<CapturingScopeInfo>(*I);
4669 if (
auto *LSI = dyn_cast<LambdaScopeInfo>(CSI))
4670 DC = LSI->CallOperator;
4671 else if (
auto *CRSI = dyn_cast<CapturedRegionScopeInfo>(CSI))
4672 DC = CRSI->TheCapturedDecl;
4673 else if (
auto *BSI = dyn_cast<BlockScopeInfo>(CSI))
4705 (ExprKind == UETT_SizeOf || ExprKind == UETT_CountOf) &&
4731 }
else if (ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf) {
4733 }
else if (ExprKind == UETT_VecStep) {
4735 }
else if (ExprKind == UETT_OpenMPRequiredSimdAlign) {
4741 }
else if (ExprKind == UETT_VectorElements || ExprKind == UETT_SizeOf ||
4742 ExprKind == UETT_CountOf) {
4749 if ((ExprKind == UETT_SizeOf || ExprKind == UETT_CountOf) &&
4784 UETT_AlignOf, KWName);
4797 if (
V.get()->isTypeDependent())
4809 return CT->getElementType();
4812 if (
V.get()->getType()->isArithmeticType())
4813 return V.get()->getType();
4818 if (PR.
get() !=
V.get()) {
4824 S.
Diag(
Loc, diag::err_realimag_invalid_type) <<
V.get()->getType()
4825 << (IsReal ?
"__real" :
"__imag");
4836 default: llvm_unreachable(
"Unknown unary op!");
4837 case tok::plusplus: Opc = UO_PostInc;
break;
4838 case tok::minusminus: Opc = UO_PostDec;
break;
4857 !S.
LangOpts.ObjCSubscriptingLegacyRuntime)
4860 S.
Diag(opLoc, diag::err_arithmetic_nonfragile_interface)
4867 auto *BaseNoParens =
Base->IgnoreParens();
4868 if (
auto *MSProp = dyn_cast<MSPropertyRefExpr>(BaseNoParens))
4869 return MSProp->getPropertyDecl()->getType()->isArrayType();
4870 return isa<MSPropertySubscriptExpr>(BaseNoParens);
4890 if (RTy->isIntegralOrUnscopedEnumerationType()) {
4892 Result = PT->getPointeeType();
4894 Result = AT->getElementType();
4897 Result = PT->getPointeeType();
4899 Result = AT->getElementType();
4912 auto *AS = cast<ArraySectionExpr>(base);
4913 if (AS->isOMPArraySection())
4925 if (isa<ParenListExpr>(base)) {
4929 base = result.
get();
4936 auto CheckAndReportCommaError = [
this, base, rbLoc](
Expr *
E) {
4937 if (isa<BinaryOperator>(
E) && cast<BinaryOperator>(
E)->isCommaOp()) {
4948 !isa<MatrixSubscriptExpr>(base)) {
4949 Diag(base->
getExprLoc(), diag::err_matrix_separate_incomplete_index)
4955 auto *matSubscriptE = dyn_cast<MatrixSubscriptExpr>(base);
4956 if (matSubscriptE) {
4957 assert(ArgExprs.size() == 1);
4958 if (CheckAndReportCommaError(ArgExprs.front()))
4961 assert(matSubscriptE->isIncomplete() &&
4962 "base has to be an incomplete matrix subscript");
4964 matSubscriptE->getRowIdx(),
4965 ArgExprs.front(), rbLoc);
4973 CheckInvalidBuiltinCountedByRef(base,
4981 bool IsMSPropertySubscript =
false;
4984 if (!IsMSPropertySubscript) {
4988 base = result.
get();
4994 assert(ArgExprs.size() == 1);
4995 if (CheckAndReportCommaError(ArgExprs.front()))
5003 Expr *idx = ArgExprs[0];
5004 if ((isa<BinaryOperator>(idx) && cast<BinaryOperator>(idx)->isCommaOp()) ||
5005 (isa<CXXOperatorCallExpr>(idx) &&
5006 cast<CXXOperatorCallExpr>(idx)->getOperator() == OO_Comma)) {
5012 if (ArgExprs.size() == 1 &&
5013 ArgExprs[0]->getType()->isNonOverloadPlaceholderType()) {
5017 ArgExprs[0] = result.
get();
5027 !isa<PackExpansionExpr>(ArgExprs[0])) {
5029 base, ArgExprs.front(),
5042 if (IsMSPropertySubscript) {
5043 assert(ArgExprs.size() == 1);
5061 (ArgExprs.size() != 1 || isa<PackExpansionExpr>(ArgExprs[0]) ||
5062 ArgExprs[0]->getType()->isRecordType())))) {
5069 if (!Res.
isInvalid() && isa<ArraySubscriptExpr>(Res.
get()))
5070 CheckSubscriptAccessOfNoDeref(cast<ArraySubscriptExpr>(Res.
get()));
5080 return InitSeq.
Perform(*
this, Entity, Kind,
E);
5094 RowIdx = RowR.
get();
5109 ColumnIdx = ColumnR.
get();
5114 auto IsIndexValid = [&](
Expr *IndexExpr,
unsigned Dim,
5115 bool IsColumnIdx) ->
Expr * {
5123 if (std::optional<llvm::APSInt> Idx =
5125 if ((*Idx < 0 || *Idx >=
Dim)) {
5127 << IsColumnIdx <<
Dim;
5134 "should be able to convert any integer type to size type");
5135 return ConvExpr.
get();
5139 RowIdx = IsIndexValid(RowIdx, MTy->getNumRows(),
false);
5140 ColumnIdx = IsIndexValid(ColumnIdx, MTy->getNumColumns(),
true);
5141 if (!RowIdx || !ColumnIdx)
5145 MTy->getElementType(), RBLoc);
5148void Sema::CheckAddressOfNoDeref(
const Expr *
E) {
5155 while ((
Member = dyn_cast<MemberExpr>(StrippedExpr)) && !
Member->isArrow())
5156 StrippedExpr =
Member->getBase()->IgnoreParenImpCasts();
5158 LastRecord.PossibleDerefs.erase(StrippedExpr);
5169 if (isa<ArrayType>(ResultTy))
5172 if (ResultTy->
hasAttr(attr::NoDeref)) {
5173 LastRecord.PossibleDerefs.insert(
E);
5181 if (!(isa<ArrayType>(BaseTy) || isa<PointerType>(BaseTy)))
5186 while ((
Member = dyn_cast<MemberExpr>(
Base->IgnoreParenCasts())) &&
5190 if (
const auto *Ptr = dyn_cast<PointerType>(
Base->getType())) {
5191 if (Ptr->getPointeeType()->hasAttr(attr::NoDeref))
5192 LastRecord.PossibleDerefs.insert(
E);
5208 for (
auto *Op : {LHSExp, RHSExp}) {
5209 Op = Op->IgnoreImplicit();
5210 if (Op->getType()->isArrayType() && !Op->isLValue())
5233 Expr *BaseExpr, *IndexExpr;
5268 Diag(LLoc, diag::err_subscript_nonfragile_interface)
5292 LHSExp = Materialized.
get();
5301 Qualifiers Combined = BaseQuals + MemberQuals;
5302 if (Combined != MemberQuals)
5313 CK_ArrayToPointerDecay).
get();
5319 }
else if (RHSTy->isArrayType()) {
5324 CK_ArrayToPointerDecay).
get();
5331 return ExprError(
Diag(LLoc, diag::err_typecheck_subscript_value)
5336 return ExprError(
Diag(LLoc, diag::err_typecheck_subscript_not_integer)
5342 std::optional<llvm::APSInt> IntegerContantExpr =
5344 if (!IntegerContantExpr.has_value() ||
5345 IntegerContantExpr.value().isNegative())
5361 Diag(LLoc, diag::ext_gnu_subscript_void_type)
5372 diag::err_subscript_incomplete_or_sizeless_type, BaseExpr))
5385 auto *CSI = dyn_cast<CapturingScopeInfo>(*I);
5389 if (
auto *LSI = dyn_cast<LambdaScopeInfo>(CSI))
5390 DC = LSI->CallOperator;
5391 else if (
auto *CRSI = dyn_cast<CapturedRegionScopeInfo>(CSI))
5392 DC = CRSI->TheCapturedDecl;
5393 else if (
auto *BSI = dyn_cast<BlockScopeInfo>(CSI))
5411 bool SkipImmediateInvocations) {
5413 assert(!RewrittenInit &&
"Should not have a rewritten init expression yet");
5417 Diag(Param->
getBeginLoc(), diag::err_recursive_default_argument) << FD;
5418 Diag(CallLoc, diag::note_recursive_default_argument_used_here);
5423 Diag(CallLoc, diag::err_use_of_default_argument_to_function_declared_later)
5426 diag::note_default_argument_declared_here);
5431 assert(!RewrittenInit &&
"Should not have a rewitten init expression yet");
5437 assert(
Init &&
"default argument but no initializer?");
5446 if (
auto *InitWithCleanup = dyn_cast<ExprWithCleanups>(
Init)) {
5453 assert(!InitWithCleanup->getNumObjects() &&
5454 "default argument expression has capturing blocks?");
5467 SkipImmediateInvocations;
5477 ShouldVisitImplicitCode =
true;
5480 bool HasImmediateCalls =
false;
5484 HasImmediateCalls |= FD->isImmediateFunction();
5490 HasImmediateCalls |= FD->isImmediateFunction();
5499 HasImmediateCalls =
true;
5510 return VisitCXXMethodDecl(
E->getCallOperator());
5514 return TraverseStmt(
E->getExpr());
5518 return TraverseStmt(
E->getExpr());
5544 if (DC == SemaRef.CurContext)
5555 if (!SemaRef.CurrentInstantiationScope ||
5557 DC = SemaRef.CurContext;
5559 return getDerived().RebuildSourceLocExpr(
5567 assert(Param->
hasDefaultArg() &&
"can't build nonexistent default arg");
5571 std::optional<ExpressionEvaluationContextRecord::InitializationContext>
5572 InitializationContext =
5574 if (!InitializationContext.has_value())
5575 InitializationContext.emplace(CallLoc, Param,
CurContext);
5601 if (!NestedDefaultChecking)
5602 V.TraverseDecl(Param);
5606 if (
V.HasImmediateCalls ||
5607 (NeedRebuild && isa_and_present<ExprWithCleanups>(Param->
getInit()))) {
5608 if (
V.HasImmediateCalls)
5618 Res = Immediate.TransformInitializer(Param->
getInit(),
5632 CallLoc, FD, Param,
Init,
5633 NestedDefaultChecking))
5637 Init, InitializationContext->Context);
5644 auto *ParentRD = cast<CXXRecordDecl>(Field->getParent());
5647 ClassPattern->
lookup(Field->getDeclName());
5648 auto Rng = llvm::make_filter_range(
5649 Lookup, [](
auto &&L) {
return isa<FieldDecl>(*L); });
5655 return cast<FieldDecl>(*Rng.begin());
5659 assert(Field->hasInClassInitializer());
5663 auto *ParentRD = cast<CXXRecordDecl>(Field->getParent());
5665 std::optional<ExpressionEvaluationContextRecord::InitializationContext>
5666 InitializationContext =
5668 if (!InitializationContext.has_value())
5678 if (!Field->getInClassInitializer()) {
5684 assert(Pattern &&
"We must have set the Pattern!");
5688 Field->setInvalidDecl();
5700 if (!NestedDefaultChecking)
5701 V.TraverseDecl(Field);
5710 bool ContainsAnyTemporaries =
5711 isa_and_present<ExprWithCleanups>(Field->getInClassInitializer());
5712 if (Field->getInClassInitializer() &&
5713 !Field->getInClassInitializer()->containsErrors() &&
5714 (
V.HasImmediateCalls || (NeedRebuild && ContainsAnyTemporaries))) {
5718 NestedDefaultChecking;
5726 Res = Immediate.TransformInitializer(Field->getInClassInitializer(),
5732 Field->setInvalidDecl();
5738 if (Field->getInClassInitializer()) {
5740 if (!NestedDefaultChecking)
5751 Field->setInvalidDecl();
5757 Field, InitializationContext->Context,
5776 Diag(
Loc, diag::err_default_member_initializer_not_yet_parsed)
5777 << OutermostClass << Field;
5778 Diag(Field->getEndLoc(),
5779 diag::note_default_member_initializer_not_yet_parsed);
5782 Field->setInvalidDecl();
5790 if (isa_and_nonnull<CXXConstructorDecl>(FDecl))
5792 else if (Fn && Fn->getType()->isBlockPointerType())
5796 if (
Method->isInstance())
5811 FunctionName(FuncName) {}
5813 bool ValidateCandidate(
const TypoCorrection &candidate)
override {
5822 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
5823 return std::make_unique<FunctionCallCCC>(*
this);
5843 if (
NamedDecl *ND = Corrected.getFoundDecl()) {
5844 if (Corrected.isOverloaded()) {
5854 ND = Best->FoundDecl;
5855 Corrected.setCorrectionDecl(ND);
5861 ND = ND->getUnderlyingDecl();
5862 if (isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND))
5873 if (!isa<ParenExpr>(Fn))
5876 Fn = Fn->IgnoreParens();
5878 auto *UO = dyn_cast<UnaryOperator>(Fn);
5879 if (!UO || UO->getOpcode() != clang::UO_AddrOf)
5881 if (
auto *DRE = dyn_cast<DeclRefExpr>(UO->getSubExpr()->IgnoreParens())) {
5882 return DRE->hasQualifier();
5884 if (
auto *OVL = dyn_cast<OverloadExpr>(UO->getSubExpr()->IgnoreParens()))
5885 return bool(OVL->getQualifier());
5895 bool IsExecConfig) {
5906 bool HasExplicitObjectParameter =
5908 unsigned ExplicitObjectParameterOffset = HasExplicitObjectParameter ? 1 : 0;
5912 unsigned FnKind = Fn->getType()->isBlockPointerType()
5919 if (Args.size() < NumParams) {
5920 if (Args.size() < MinArgs) {
5925 ? diag::err_typecheck_call_too_few_args_suggest
5926 : diag::err_typecheck_call_too_few_args_at_least_suggest;
5929 << FnKind << MinArgs - ExplicitObjectParameterOffset
5930 <<
static_cast<unsigned>(Args.size()) -
5931 ExplicitObjectParameterOffset
5933 }
else if (MinArgs - ExplicitObjectParameterOffset == 1 && FDecl &&
5938 ? diag::err_typecheck_call_too_few_args_one
5939 : diag::err_typecheck_call_too_few_args_at_least_one)
5940 << FnKind << FDecl->
getParamDecl(ExplicitObjectParameterOffset)
5941 << HasExplicitObjectParameter << Fn->getSourceRange();
5944 ? diag::err_typecheck_call_too_few_args
5945 : diag::err_typecheck_call_too_few_args_at_least)
5946 << FnKind << MinArgs - ExplicitObjectParameterOffset
5947 <<
static_cast<unsigned>(Args.size()) -
5948 ExplicitObjectParameterOffset
5949 << HasExplicitObjectParameter << Fn->getSourceRange();
5952 if (!TC && FDecl && !FDecl->
getBuiltinID() && !IsExecConfig)
5960 assert((
Call->getNumArgs() == NumParams) &&
5961 "We should have reserved space for the default arguments before!");
5966 if (Args.size() > NumParams) {
5972 ? diag::err_typecheck_call_too_many_args_suggest
5973 : diag::err_typecheck_call_too_many_args_at_most_suggest;
5976 << FnKind << NumParams - ExplicitObjectParameterOffset
5977 <<
static_cast<unsigned>(Args.size()) -
5978 ExplicitObjectParameterOffset
5980 }
else if (NumParams - ExplicitObjectParameterOffset == 1 && FDecl &&
5983 Diag(Args[NumParams]->getBeginLoc(),
5984 MinArgs == NumParams
5985 ? diag::err_typecheck_call_too_many_args_one
5986 : diag::err_typecheck_call_too_many_args_at_most_one)
5987 << FnKind << FDecl->
getParamDecl(ExplicitObjectParameterOffset)
5988 <<
static_cast<unsigned>(Args.size()) -
5989 ExplicitObjectParameterOffset
5990 << HasExplicitObjectParameter << Fn->getSourceRange()
5992 Args.back()->getEndLoc());
5994 Diag(Args[NumParams]->getBeginLoc(),
5995 MinArgs == NumParams
5996 ? diag::err_typecheck_call_too_many_args
5997 : diag::err_typecheck_call_too_many_args_at_most)
5998 << FnKind << NumParams - ExplicitObjectParameterOffset
5999 <<
static_cast<unsigned>(Args.size()) -
6000 ExplicitObjectParameterOffset
6001 << HasExplicitObjectParameter << Fn->getSourceRange()
6003 Args.back()->getEndLoc());
6006 if (!TC && FDecl && !FDecl->
getBuiltinID() && !IsExecConfig)
6011 Call->shrinkNumArgs(NumParams);
6022 unsigned TotalNumArgs = AllArgs.size();
6023 for (
unsigned i = 0; i < TotalNumArgs; ++i)
6024 Call->setArg(i, AllArgs[i]);
6026 Call->computeDependence();
6035 bool IsListInitialization) {
6040 for (
unsigned i = FirstParam; i < NumParams; i++) {
6045 if (ArgIx < Args.size()) {
6046 Arg = Args[ArgIx++];
6049 diag::err_call_incomplete_argument, Arg))
6053 bool CFAudited =
false;
6055 FDecl && FDecl->
hasAttr<CFAuditedTransferAttr>() &&
6056 (!Param || !Param->
hasAttr<CFConsumedAttr>()))
6059 FDecl && FDecl->
hasAttr<CFAuditedTransferAttr>() &&
6060 (!Param || !Param->
hasAttr<CFConsumedAttr>()))
6066 BE->getBlockDecl()->setDoesNotEscape();
6086 Entity,
SourceLocation(), Arg, IsListInitialization, AllowExplicit);
6092 assert(Param &&
"can't use default arguments without a known callee");
6104 CheckArrayAccess(Arg);
6109 AllArgs.push_back(Arg);
6118 for (
Expr *A : Args.slice(ArgIx)) {
6122 AllArgs.push_back(arg.get());
6127 for (
Expr *A : Args.slice(ArgIx)) {
6130 AllArgs.push_back(Arg.
get());
6135 for (
Expr *A : Args.slice(ArgIx))
6136 CheckArrayAccess(A);
6144 TL = DTL.getOriginalLoc();
6147 << ATL.getLocalSourceRange();
6153 const Expr *ArgExpr) {
6183 Diag(CallLoc, diag::warn_static_array_too_small)
6191 std::optional<CharUnits> ArgSize =
6193 std::optional<CharUnits> ParmSize =
6195 if (ArgSize && ParmSize && *ArgSize < *ParmSize) {
6196 Diag(CallLoc, diag::warn_static_array_too_small)
6198 << (
unsigned)ParmSize->getQuantity() << 1;
6212 if (!placeholder)
return false;
6214 switch (placeholder->
getKind()) {
6216#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
6217 case BuiltinType::Id:
6218#include "clang/Basic/OpenCLImageTypes.def"
6219#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
6220 case BuiltinType::Id:
6221#include "clang/Basic/OpenCLExtensionTypes.def"
6224#define SVE_TYPE(Name, Id, SingletonId) \
6225 case BuiltinType::Id:
6226#include "clang/Basic/AArch64ACLETypes.def"
6227#define PPC_VECTOR_TYPE(Name, Id, Size) \
6228 case BuiltinType::Id:
6229#include "clang/Basic/PPCTypes.def"
6230#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
6231#include "clang/Basic/RISCVVTypes.def"
6232#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
6233#include "clang/Basic/WebAssemblyReferenceTypes.def"
6234#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) case BuiltinType::Id:
6235#include "clang/Basic/AMDGPUTypes.def"
6236#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
6237#include "clang/Basic/HLSLIntangibleTypes.def"
6238#define PLACEHOLDER_TYPE(ID, SINGLETON_ID)
6239#define BUILTIN_TYPE(ID, SINGLETON_ID) case BuiltinType::ID:
6240#include "clang/AST/BuiltinTypes.def"
6243 case BuiltinType::UnresolvedTemplate:
6246 case BuiltinType::Overload:
6251 case BuiltinType::ARCUnbridgedCast:
6255 case BuiltinType::PseudoObject:
6260 case BuiltinType::UnknownAny:
6264 case BuiltinType::BoundMember:
6265 case BuiltinType::BuiltinFn:
6266 case BuiltinType::IncompleteMatrixIdx:
6267 case BuiltinType::ArraySection:
6268 case BuiltinType::OMPArrayShaping:
6269 case BuiltinType::OMPIterator:
6273 llvm_unreachable(
"bad builtin type kind");
6279 bool hasInvalid =
false;
6280 for (
size_t i = 0, e = args.size(); i != e; i++) {
6283 if (result.
isInvalid()) hasInvalid =
true;
6284 else args[i] = result.
get();
6312 bool NeedsNewDecl =
false;
6325 if (!ParamType->isPointerType() ||
6326 ParamType->getPointeeType().hasAddressSpace() ||
6330 OverloadParams.push_back(ParamType);
6335 NeedsNewDecl =
true;
6348 OverloadParams, EPI);
6357 FT = cast<FunctionProtoType>(OverloadTy);
6358 for (
unsigned i = 0, e = FT->
getNumParams(); i != e; ++i) {
6365 Params.push_back(Parm);
6367 OverloadDecl->setParams(Params);
6371 if (FDecl->
hasAttr<CUDAHostAttr>())
6372 OverloadDecl->
addAttr(CUDAHostAttr::CreateImplicit(Context));
6373 if (FDecl->
hasAttr<CUDADeviceAttr>())
6374 OverloadDecl->
addAttr(CUDADeviceAttr::CreateImplicit(Context));
6377 return OverloadDecl;
6388 !Callee->isVariadic())
6390 if (Callee->getMinRequiredArguments() > ArgExprs.size())
6393 if (
const EnableIfAttr *
Attr =
6394 S.
CheckEnableIf(Callee, Fn->getBeginLoc(), ArgExprs,
true)) {
6395 S.
Diag(Fn->getBeginLoc(),
6396 isa<CXXMethodDecl>(Callee)
6397 ? diag::err_ovl_no_viable_member_function_in_call
6398 : diag::err_ovl_no_viable_function_in_call)
6399 << Callee << Callee->getSourceRange();
6400 S.
Diag(Callee->getLocation(),
6401 diag::note_ovl_candidate_disabled_by_function_cond_attr)
6402 <<
Attr->getCond()->getSourceRange() <<
Attr->getMessage();
6410 const auto GetFunctionLevelDCIfCXXClass =
6418 if (
const auto *MD = dyn_cast<CXXMethodDecl>(DC))
6419 return MD->
getParent()->getCanonicalDecl();
6422 if (
const auto *RD = dyn_cast<CXXRecordDecl>(DC))
6423 return RD->getCanonicalDecl();
6430 const CXXRecordDecl *
const CurParentClass = GetFunctionLevelDCIfCXXClass(S);
6431 if (!CurParentClass)
6438 assert(NamingClass &&
"Must have naming class even for implicit access");
6444 return CurParentClass == NamingClass ||
6493 if (
Call->getNumArgs() != 1)
6496 const Expr *
E =
Call->getCallee()->IgnoreParenImpCasts();
6497 if (!
E || isa<UnresolvedLookupExpr>(
E))
6499 const DeclRefExpr *DRE = dyn_cast_if_present<DeclRefExpr>(
E);
6512 if (BuiltinID != Builtin::BImove && BuiltinID != Builtin::BIforward)
6515 S.
Diag(DRE->
getLocation(), diag::warn_unqualified_call_to_std_cast_function)
6526 if (
Call.isInvalid())
6531 if (
const auto *ULE = dyn_cast<UnresolvedLookupExpr>(Fn);
6532 ULE && ULE->hasExplicitTemplateArgs() && ULE->decls().empty()) {
6533 DiagCompat(Fn->getExprLoc(), diag_compat::adl_only_template_id)
6541 if (
const auto *CE = dyn_cast<CallExpr>(
Call.get()))
6547 if (
auto *DRE = dyn_cast<DeclRefExpr>(Fn->IgnoreParens());
6548 DRE &&
Call.get()->isValueDependent()) {
6574 Expr *ExecConfig,
bool IsExecConfig,
6575 bool AllowRecovery) {
6586 for (
const Expr *Arg : ArgExprs)
6587 if (CheckInvalidBuiltinCountedByRef(Arg,
6593 if (isa<CXXPseudoDestructorExpr>(Fn)) {
6594 if (!ArgExprs.empty()) {
6596 Diag(Fn->getBeginLoc(), diag::err_pseudo_dtor_call_with_args)
6599 ArgExprs.back()->getEndLoc()));
6616 cast<CallExpr>(ExecConfig), ArgExprs,
6622 *
this, dyn_cast<UnresolvedMemberExpr>(Fn->IgnoreParens()),
6630 Diag(LParenLoc, diag::err_typecheck_call_not_function)
6631 << Fn->getType() << Fn->getSourceRange());
6639 if (Fn->getType()->isRecordType())
6651 RParenLoc, ExecConfig, IsExecConfig,
6668 Scope, Fn, ULE, LParenLoc, ArgExprs, RParenLoc, ExecConfig,
6671 RParenLoc, ExecConfig, IsExecConfig,
6683 Expr *NakedFn = Fn->IgnoreParens();
6685 bool CallingNDeclIndirectly =
false;
6687 if (
UnaryOperator *UnOp = dyn_cast<UnaryOperator>(NakedFn)) {
6688 if (UnOp->getOpcode() == UO_AddrOf) {
6689 CallingNDeclIndirectly =
true;
6694 if (
auto *DRE = dyn_cast<DeclRefExpr>(NakedFn)) {
6695 NDecl = DRE->getDecl();
6708 nullptr, DRE->isNonOdrUse());
6711 }
else if (
auto *ME = dyn_cast<MemberExpr>(NakedFn))
6712 NDecl = ME->getMemberDecl();
6714 if (
FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(NDecl)) {
6716 FD,
true, Fn->getBeginLoc()))
6728 FD->getBuiltinID()) {
6729 for (
unsigned Idx = 0; Idx < ArgExprs.size() && Idx < FD->param_size();
6733 !ArgExprs[Idx]->getType()->isPointerType())
6737 auto ArgTy = ArgExprs[Idx]->getType();
6738 auto ArgPtTy = ArgTy->getPointeeType();
6739 auto ArgAS = ArgPtTy.getAddressSpace();
6742 bool NeedImplicitASC =
6747 if (!NeedImplicitASC)
6751 if (ArgExprs[Idx]->isGLValue()) {
6753 Context, ArgExprs[Idx]->getType(), CK_NoOp, ArgExprs[Idx],
6758 Qualifiers ArgPtQuals = ArgPtTy.getQualifiers();
6768 CK_AddressSpaceConversion)
6777 assert((Fn->containsErrors() ||
6778 llvm::any_of(ArgExprs,
6779 [](
clang::Expr *
E) { return E->containsErrors(); })) &&
6780 "should only occur in error-recovery path.");
6785 ExecConfig, IsExecConfig);
6796 assert(BuiltInDecl &&
"failed to find builtin declaration");
6800 assert(DeclRef.
isUsable() &&
"Builtin reference cannot fail");
6805 assert(!
Call.isInvalid() &&
"Call to builtin cannot fail!");
6825 Diag(BuiltinLoc, diag::err_invalid_astype_of_different_size)
6843 FunctionDecl *FDecl = dyn_cast_or_null<FunctionDecl>(NDecl);
6844 unsigned BuiltinID = (FDecl ? FDecl->
getBuiltinID() : 0);
6848 if (FDecl->
hasAttr<AnyX86InterruptAttr>()) {
6849 Diag(Fn->getExprLoc(), diag::err_anyx86_interrupt_called);
6852 if (FDecl->
hasAttr<ARMInterruptAttr>()) {
6853 Diag(Fn->getExprLoc(), diag::err_arm_interrupt_called);
6862 if (Caller->hasAttr<AnyX86InterruptAttr>() ||
6863 Caller->hasAttr<AnyX86NoCallerSavedRegistersAttr>()) {
6865 bool HasNonGPRRegisters =
6867 if (HasNonGPRRegisters &&
6868 (!FDecl || !FDecl->
hasAttr<AnyX86NoCallerSavedRegistersAttr>())) {
6869 Diag(Fn->getExprLoc(), diag::warn_anyx86_excessive_regsave)
6870 << (Caller->hasAttr<AnyX86InterruptAttr>() ? 0 : 1);
6883 Fn->getType()->isSpecificBuiltinType(BuiltinType::BuiltinFn)) {
6910 return ExprError(
Diag(LParenLoc, diag::err_typecheck_call_not_function)
6911 << Fn->getType() << Fn->getSourceRange());
6925 return ExprError(
Diag(LParenLoc, diag::err_typecheck_call_not_function)
6926 << Fn->getType() << Fn->getSourceRange());
6933 const auto *Proto = dyn_cast_or_null<FunctionProtoType>(FuncT);
6934 unsigned NumParams = Proto ? Proto->getNumParams() : 0;
6938 assert(UsesADL == ADLCallKind::NotADL &&
6939 "CUDAKernelCallExpr should not use ADL");
6951 ExprResult E = CheckBuiltinFunctionCall(FDecl, BuiltinID, TheCall);
6960 if (FDecl && !FDecl->
hasAttr<CUDAGlobalAttr>())
6961 return ExprError(
Diag(LParenLoc,diag::err_kern_call_not_global_function)
6962 << FDecl << Fn->getSourceRange());
6968 return ExprError(
Diag(LParenLoc, diag::err_kern_type_not_void_return)
6969 << Fn->getType() << Fn->getSourceRange());
6972 if (FDecl && FDecl->
hasAttr<CUDAGlobalAttr>())
6973 return ExprError(
Diag(LParenLoc, diag::err_global_call_not_config)
6974 << FDecl << Fn->getSourceRange());
6989 for (
const Expr *Arg : Args) {
6990 if (Arg && Arg->getType()->isWebAssemblyTableType()) {
6992 diag::err_wasm_table_as_function_parameter));
7002 assert(isa<FunctionNoProtoType>(FuncT) &&
"Unknown FunctionType!");
7010 if (!Proto || !(Proto->isVariadic() && Args.size() >= Def->
param_size()))
7011 Diag(RParenLoc, diag::warn_call_wrong_number_of_arguments)
7012 << (Args.size() > Def->
param_size()) << FDecl << Fn->getSourceRange();
7031 if (!Proto && !Args.empty() &&
7035 Diag(LParenLoc, diag::warn_strict_uses_without_prototype)
7036 << (FDecl !=
nullptr) << FDecl;
7039 for (
unsigned i = 0, e = Args.size(); i != e; i++) {
7040 Expr *Arg = Args[i];
7042 if (Proto && i < Proto->getNumParams()) {
7044 Context, Proto->getParamType(i), Proto->isParamConsumed(i));
7062 diag::err_call_incomplete_argument, Arg))
7071 if (
Method->isImplicitObjectMemberFunction())
7072 return ExprError(
Diag(LParenLoc, diag::err_member_call_without_object)
7073 << Fn->getSourceRange() << 0);
7081 for (
unsigned i = 0, e = Args.size(); i != e; i++) {
7082 if (
const auto *RT =
7083 dyn_cast<RecordType>(Args[i]->getType().getCanonicalType())) {
7084 if (RT->getOriginalDecl()->isOrContainsUnion())
7085 Diag(Args[i]->getBeginLoc(), diag::warn_cmse_nonsecure_union)
7096 checkFortifiedBuiltinMemoryFunction(FDecl, TheCall);
7099 return CheckBuiltinFunctionCall(FDecl, BuiltinID, TheCall);
7101 if (CheckPointerCall(NDecl, TheCall, Proto))
7104 if (CheckOtherCall(TheCall, Proto))
7114 assert(Ty &&
"ActOnCompoundLiteral(): missing type");
7115 assert(InitExpr &&
"ActOnCompoundLiteral(): missing expression");
7133 diag::err_array_incomplete_or_sizeless_type,
7156 ? diag::err_variable_object_no_init
7157 : diag::err_compound_literal_with_vla_type;
7164 diag::err_typecheck_decl_incomplete_type,
7179 LiteralExpr =
Result.get();
7187 !S->isInCFunctionScope() &&
7188 (!S || !S->isFunctionPrototypeScope());
7217 if (
auto ILE = dyn_cast<InitListExpr>(LiteralExpr))
7218 for (
unsigned i = 0, j = ILE->getNumInits(); i != j; i++) {
7220 if (!
Init->isTypeDependent() && !
Init->isValueDependent() &&
7222 Diag(
Init->getExprLoc(), diag::err_init_element_not_constant)
7223 <<
Init->getSourceBitField();
7231 LiteralExpr, IsFileScope);
7243 Diag(LParenLoc, diag::err_compound_literal_with_address_space)
7280 bool DiagnosedArrayDesignator =
false;
7281 bool DiagnosedNestedDesignator =
false;
7282 bool DiagnosedMixedDesignator =
false;
7286 for (
unsigned I = 0,
E = InitArgList.size(); I !=
E; ++I) {
7287 if (
auto *DIE = dyn_cast<DesignatedInitExpr>(InitArgList[I])) {
7289 FirstDesignator = DIE->getBeginLoc();
7294 if (!DiagnosedNestedDesignator && DIE->size() > 1) {
7295 DiagnosedNestedDesignator =
true;
7296 Diag(DIE->getBeginLoc(), diag::ext_designated_init_nested)
7297 << DIE->getDesignatorsSourceRange();
7300 for (
auto &Desig : DIE->designators()) {
7301 if (!Desig.isFieldDesignator() && !DiagnosedArrayDesignator) {
7302 DiagnosedArrayDesignator =
true;
7303 Diag(Desig.getBeginLoc(), diag::ext_designated_init_array)
7304 << Desig.getSourceRange();
7308 if (!DiagnosedMixedDesignator &&
7309 !isa<DesignatedInitExpr>(InitArgList[0])) {
7310 DiagnosedMixedDesignator =
true;
7311 Diag(DIE->getBeginLoc(), diag::ext_designated_init_mixed)
7312 << DIE->getSourceRange();
7313 Diag(InitArgList[0]->getBeginLoc(), diag::note_designated_init_mixed)
7314 << InitArgList[0]->getSourceRange();
7317 isa<DesignatedInitExpr>(InitArgList[0])) {
7318 DiagnosedMixedDesignator =
true;
7319 auto *DIE = cast<DesignatedInitExpr>(InitArgList[0]);
7320 Diag(DIE->getBeginLoc(), diag::ext_designated_init_mixed)
7321 << DIE->getSourceRange();
7322 Diag(InitArgList[I]->getBeginLoc(), diag::note_designated_init_mixed)
7323 << InitArgList[I]->getSourceRange();
7327 if (FirstDesignator.
isValid()) {
7331 !DiagnosedNestedDesignator && !DiagnosedMixedDesignator) {
7333 ? diag::warn_cxx17_compat_designated_init
7334 : diag::ext_cxx_designated_init);
7336 Diag(FirstDesignator, diag::ext_designated_init);
7351 for (
unsigned I = 0,
E = InitArgList.size(); I !=
E; ++I) {
7352 if (InitArgList[I]->getType()->isNonOverloadPlaceholderType()) {
7359 InitArgList[I] = result.
get();
7393 llvm_unreachable(
"member pointer type in C");
7402 if (SrcAS != DestAS)
7403 return CK_AddressSpaceConversion;
7410 ? CK_BitCast : CK_AnyPointerToBlockPointerCast);
7415 return CK_CPointerToObjCPointerCast;
7417 return CK_BlockPointerToObjCPointerCast;
7419 return CK_PointerToBoolean;
7421 return CK_PointerToIntegral;
7427 llvm_unreachable(
"illegal cast from pointer");
7429 llvm_unreachable(
"Should have returned before this");
7434 return CK_FixedPointCast;
7436 return CK_FixedPointToBoolean;
7438 return CK_FixedPointToIntegral;
7440 return CK_FixedPointToFloating;
7444 diag::err_unimplemented_conversion_with_fixed_point_type)
7446 return CK_IntegralCast;
7451 llvm_unreachable(
"illegal cast to pointer type");
7453 llvm_unreachable(
"Should have returned before this");
7463 return CK_NullToPointer;
7464 return CK_IntegralToPointer;
7466 return CK_IntegralToBoolean;
7468 return CK_IntegralCast;
7470 return CK_IntegralToFloating;
7475 return CK_IntegralRealToComplex;
7479 CK_IntegralToFloating);
7480 return CK_FloatingRealToComplex;
7482 llvm_unreachable(
"member pointer type in C");
7484 return CK_IntegralToFixedPoint;
7486 llvm_unreachable(
"Should have returned before this");
7491 return CK_FloatingCast;
7493 return CK_FloatingToBoolean;
7495 return CK_FloatingToIntegral;
7500 return CK_FloatingRealToComplex;
7504 CK_FloatingToIntegral);
7505 return CK_IntegralRealToComplex;
7509 llvm_unreachable(
"valid float->pointer cast?");
7511 llvm_unreachable(
"member pointer type in C");
7513 return CK_FloatingToFixedPoint;
7515 llvm_unreachable(
"Should have returned before this");
7520 return CK_FloatingComplexCast;
7522 return CK_FloatingComplexToIntegralComplex;
7526 return CK_FloatingComplexToReal;
7528 return CK_FloatingCast;
7531 return CK_FloatingComplexToBoolean;
7535 CK_FloatingComplexToReal);
7536 return CK_FloatingToIntegral;
7540 llvm_unreachable(
"valid complex float->pointer cast?");
7542 llvm_unreachable(
"member pointer type in C");
7545 diag::err_unimplemented_conversion_with_fixed_point_type)
7547 return CK_IntegralCast;
7549 llvm_unreachable(
"Should have returned before this");
7554 return CK_IntegralComplexToFloatingComplex;
7556 return CK_IntegralComplexCast;
7560 return CK_IntegralComplexToReal;
7562 return CK_IntegralCast;
7565 return CK_IntegralComplexToBoolean;
7569 CK_IntegralComplexToReal);
7570 return CK_IntegralToFloating;
7574 llvm_unreachable(
"valid complex int->pointer cast?");
7576 llvm_unreachable(
"member pointer type in C");
7579 diag::err_unimplemented_conversion_with_fixed_point_type)
7581 return CK_IntegralCast;
7583 llvm_unreachable(
"Should have returned before this");
7586 llvm_unreachable(
"Unhandled scalar cast");
7593 len = vecType->getNumElements();
7594 eltType = vecType->getElementType();
7601 if (!
type->isRealType())
return false;
7611 auto ValidScalableConversion = [](
QualType FirstType,
QualType SecondType) {
7615 const auto *VecTy = SecondType->getAs<
VectorType>();
7619 return ValidScalableConversion(srcTy, destTy) ||
7620 ValidScalableConversion(destTy, srcTy);
7630 return matSrcType->
getNumRows() == matDestType->getNumRows() &&
7631 matSrcType->
getNumColumns() == matDestType->getNumColumns();
7637 uint64_t SrcLen, DestLen;
7650 return (SrcLen * SrcEltSize == DestLen * DestEltSize);
7655 "expected at least one type to be a vector here");
7657 bool IsSrcTyAltivec =
7673 return (IsSrcTyAltivec || IsDestTyAltivec);
7700 if (!Vec || !Vec->getElementType()->isIntegralOrEnumerationType())
7705 if (!Vec || !Vec->getElementType()->isIntegralOrEnumerationType())
7722 return Diag(R.
getBegin(), diag::err_invalid_conversion_between_matrixes)
7723 << DestTy << SrcTy << R;
7727 diag::err_invalid_conversion_between_matrix_and_type)
7728 << SrcTy << DestTy << R;
7731 diag::err_invalid_conversion_between_matrix_and_type)
7732 << DestTy << SrcTy << R;
7735 Kind = CK_MatrixCast;
7741 assert(VectorTy->
isVectorType() &&
"Not a vector type!");
7747 diag::err_invalid_conversion_between_vectors :
7748 diag::err_invalid_conversion_between_vector_and_integer)
7749 << VectorTy << Ty << R;
7752 diag::err_invalid_conversion_between_vector_and_scalar)
7753 << VectorTy << Ty << R;
7762 if (DestElemTy == SplattedExpr->
getType())
7763 return SplattedExpr;
7776 CK_BooleanToSignedIntegral);
7777 SplattedExpr = CastExprRes.
get();
7778 CK = CK_IntegralToFloating;
7780 CK = CK_BooleanToSignedIntegral;
7787 SplattedExpr = CastExprRes.
get();
7806 Diag(R.
getBegin(),diag::err_invalid_conversion_between_ext_vectors)
7807 << DestTy << SrcTy << R;
7819 diag::err_invalid_conversion_between_vector_and_scalar)
7820 << DestTy << SrcTy << R;
7822 Kind = CK_VectorSplat;
7832 DestType == SourceType)
7840 if (!CE->getCalleeAllocSizeAttr())
7842 std::optional<llvm::APInt> AllocSize =
7843 CE->evaluateBytesReturnedByAllocSizeCall(S.
Context);
7846 if (!AllocSize || AllocSize->isZero())
7856 if (LhsSize && Size < LhsSize)
7858 << Size.getQuantity() << TargetType << LhsSize->getQuantity();
7865 assert(!
D.isInvalidType() && (
CastExpr !=
nullptr) &&
7866 "ActOnCastExpr(): missing type or expr");
7869 if (
D.isInvalidType())
7882 bool isVectorLiteral =
false;
7897 isVectorLiteral =
true;
7900 isVectorLiteral =
true;
7905 if (isVectorLiteral)
7911 if (isa<ParenListExpr>(
CastExpr)) {
7934 assert((isa<ParenListExpr>(
E) || isa<ParenExpr>(
E)) &&
7935 "Expected paren or paren list expression");
7942 LiteralLParenLoc = PE->getLParenLoc();
7943 LiteralRParenLoc = PE->getRParenLoc();
7944 exprs = PE->getExprs();
7945 numExprs = PE->getNumExprs();
7947 LiteralLParenLoc = cast<ParenExpr>(
E)->getLParen();
7948 LiteralRParenLoc = cast<ParenExpr>(
E)->getRParen();
7949 subExpr = cast<ParenExpr>(
E)->getSubExpr();
7972 if (numExprs == 1) {
7975 if (Literal.isInvalid())
7981 else if (numExprs < numElems) {
7983 diag::err_incorrect_number_of_vector_initializers);
7987 initExprs.append(exprs, exprs + numExprs);
7996 if (Literal.isInvalid())
8003 initExprs.append(exprs, exprs + numExprs);
8008 initExprs, LiteralRParenLoc);
8021 for (
unsigned i = 1, e =
E->getNumExprs(); i != e && !
Result.isInvalid(); ++i)
8037 unsigned NumUserSpecifiedExprs,
8042 InitLoc, LParenLoc, RParenLoc);
8047 const Expr *NullExpr = LHSExpr;
8048 const Expr *NonPointerExpr = RHSExpr;
8055 NonPointerExpr = LHSExpr;
8077 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands_null)
8078 << NonPointerExpr->
getType() << DiagType
8090 S.
Diag(QuestionLoc, diag::err_typecheck_cond_expect_nonfloat)
8098 S.
Diag(QuestionLoc, diag::err_typecheck_cond_expect_scalar)
8132 bool IsBlockPointer =
false;
8136 IsBlockPointer =
true;
8161 ResultAddrSpace = LAddrSpace;
8163 ResultAddrSpace = RAddrSpace;
8165 S.
Diag(
Loc, diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
8172 auto LHSCastKind = CK_BitCast, RHSCastKind = CK_BitCast;
8177 S.
Diag(
Loc, diag::err_typecheck_cond_incompatible_ptrauth)
8194 LAddrSpace == ResultAddrSpace ? CK_BitCast : CK_AddressSpaceConversion;
8196 RAddrSpace == ResultAddrSpace ? CK_BitCast : CK_AddressSpaceConversion;
8204 lhptee, rhptee,
false,
false,
8207 if (CompositeTy.
isNull()) {
8224 S.
Diag(
Loc, diag::ext_typecheck_cond_incompatible_pointers)
8235 QualType ResultTy = [&, ResultAddrSpace]() {
8241 .withCVRQualifiers(MergedCVRQual);
8270 S.
Diag(
Loc, diag::err_typecheck_cond_incompatible_operands)
8323 bool IsIntFirstExpr) {
8325 !Int.get()->getType()->isIntegerType())
8328 Expr *Expr1 = IsIntFirstExpr ? Int.get() : PointerExpr;
8329 Expr *Expr2 = IsIntFirstExpr ? PointerExpr : Int.get();
8331 S.
Diag(
Loc, diag::ext_typecheck_cond_pointer_integer_mismatch)
8335 CK_IntegralToPointer);
8369 S.
Diag(QuestionLoc, diag::err_typecheck_cond_expect_int_float)
8375 S.
Diag(QuestionLoc, diag::err_typecheck_cond_expect_int_float)
8381 if (LHSType == RHSType)
8390 return handleIntegerConversion<doIntegralCast, doIntegralCast>
8391 (S, LHS, RHS, LHSType, RHSType,
false);
8425 llvm::raw_svector_ostream OS(Str);
8426 OS <<
"(vector of " << NumElements <<
" '" << EleTyName <<
"' values)";
8427 S.
Diag(QuestionLoc, diag::err_conditional_vector_element_size)
8428 << CondTy << OS.str();
8449 S.
Diag(QuestionLoc, diag::err_typecheck_cond_expect_nonfloat)
8467 S.
Diag(QuestionLoc, diag::err_conditional_vector_size)
8468 << CondTy << VecResTy;
8473 QualType RVE = RV->getElementType();
8478 S.
Diag(QuestionLoc, diag::err_conditional_vector_element_size)
8479 << CondTy << VecResTy;
8505 bool IsBoolVecLang =
8534 if (
const CallExpr *CE = dyn_cast<CallExpr>(
E)) {
8535 QualType Ty = CE->getCallee()->getType();
8573 "should only occur in error-recovery path.");
8608 Diag(QuestionLoc, diag::err_wasm_table_conditional_expression)
8617 diag::err_typecheck_cond_incompatible_operands) << LHSTy << RHSTy
8636 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
8692 if (!compositeType.
isNull())
8693 return compositeType;
8727 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
8766 const Expr **RHSExprs) {
8771 if (
const auto *MTE = dyn_cast<MaterializeTemporaryExpr>(
E)) {
8772 E = MTE->getSubExpr();
8777 if (
const auto *OP = dyn_cast<BinaryOperator>(
E);
8779 *Opcode = OP->getOpcode();
8780 *RHSExprs = OP->getRHS();
8785 if (
const auto *
Call = dyn_cast<CXXOperatorCallExpr>(
E)) {
8786 if (
Call->getNumArgs() != 2)
8792 if (OO < OO_Plus || OO > OO_Arrow ||
8793 OO == OO_PlusPlus || OO == OO_MinusMinus)
8799 *RHSExprs =
Call->getArg(1);
8815 if (
const auto *OP = dyn_cast<BinaryOperator>(
E))
8816 return OP->isComparisonOp() || OP->isLogicalOp();
8817 if (
const auto *OP = dyn_cast<UnaryOperator>(
E))
8818 return OP->getOpcode() == UO_LNot;
8833 const Expr *RHSExpr) {
8835 const Expr *CondRHS;
8846 ? diag::warn_precedence_bitwise_conditional
8847 : diag::warn_precedence_conditional;
8849 Self.Diag(OpLoc, DiagID)
8855 Self.PDiag(diag::note_precedence_silence)
8860 Self.PDiag(diag::note_precedence_conditional_first),
8871 auto GetNullability = [](
QualType Ty) {
8872 std::optional<NullabilityKind> Kind = Ty->getNullability();
8882 auto LHSKind = GetNullability(LHSTy), RHSKind = GetNullability(RHSTy);
8890 MergedKind = RHSKind;
8897 MergedKind = RHSKind;
8899 MergedKind = LHSKind;
8905 if (GetNullability(ResTy) == MergedKind)
8923 Expr *commonExpr =
nullptr;
8925 commonExpr = CondExpr;
8932 commonExpr = result.
get();
8946 commonExpr = commonRes.
get();
8956 commonExpr = MatExpr.
get();
8964 LHSExpr = CondExpr = opaqueValue;
8970 ExprResult Cond = CondExpr, LHS = LHSExpr, RHS = RHSExpr;
8972 VK, OK, QuestionLoc);
8980 CheckBoolLikeConversion(Cond.
get(), QuestionLoc);
8988 RHS.get(), result,
VK, OK);
8991 commonExpr, opaqueValue, Cond.
get(), LHS.get(), RHS.get(), QuestionLoc,
8992 ColonLoc, result,
VK, OK);
8996 unsigned FromAttributes = 0, ToAttributes = 0;
8997 if (
const auto *FromFn =
9001 if (
const auto *ToFn =
9006 return FromAttributes != ToAttributes;
9014 if (
const auto *ToFn =
9016 if (
const auto *FromFn =
9036 assert(LHSType.
isCanonical() &&
"LHS not canonicalized!");
9037 assert(RHSType.
isCanonical() &&
"RHS not canonicalized!");
9040 const Type *lhptee, *rhptee;
9042 std::tie(lhptee, lhq) =
9043 cast<PointerType>(LHSType)->getPointeeType().split().asPair();
9044 std::tie(rhptee, rhq) =
9045 cast<PointerType>(RHSType)->getPointeeType().split().asPair();
9115 diag::warn_typecheck_convert_incompatible_function_pointer_strict,
9138 if (ltrans == rtrans) {
9152 if (isa<PointerType>(lhptee) && isa<PointerType>(rhptee)) {
9154 std::tie(lhptee, lhq) =
9155 cast<PointerType>(lhptee)->getPointeeType().split().asPair();
9156 std::tie(rhptee, rhq) =
9157 cast<PointerType>(rhptee)->getPointeeType().split().asPair();
9171 }
while (isa<PointerType>(lhptee) && isa<PointerType>(rhptee));
9173 if (lhptee == rhptee)
9182 bool DiscardingCFIUncheckedCallee, AddingCFIUncheckedCallee;
9185 &AddingCFIUncheckedCallee)) {
9187 if (!DiscardingCFIUncheckedCallee && !AddingCFIUncheckedCallee)
9204 assert(LHSType.
isCanonical() &&
"LHS not canonicalized!");
9205 assert(RHSType.
isCanonical() &&
"RHS not canonicalized!");
9226 if (LQuals != RQuals)
9255 assert(LHSType.
isCanonical() &&
"LHS was not canonicalized!");
9256 assert(RHSType.
isCanonical() &&
"RHS was not canonicalized!");
9304 return VT->getElementType().getCanonicalType() == ElementType;
9338 if (LHSType == RHSType) {
9345 if (
const auto *AT = dyn_cast<AutoType>(LHSType)) {
9346 if (AT->isGNUAutoType()) {
9354 if (
const AtomicType *AtomicTy = dyn_cast<AtomicType>(LHSType)) {
9359 if (Kind != CK_NoOp && ConvertRHS)
9361 Kind = CK_NonAtomicToAtomic;
9374 Kind = CK_LValueBitCast;
9389 Kind = CK_VectorSplat;
9415 << RHSType << LHSType;
9434 << RHSType << LHSType;
9445 if (
ARM().areCompatibleSveTypes(LHSType, RHSType) ||
9446 ARM().areLaxCompatibleSveTypes(LHSType, RHSType)) {
9484 if (
const PointerType *LHSPointer = dyn_cast<PointerType>(LHSType)) {
9486 if (isa<PointerType>(RHSType)) {
9487 LangAS AddrSpaceL = LHSPointer->getPointeeType().getAddressSpace();
9489 if (AddrSpaceL != AddrSpaceR)
9490 Kind = CK_AddressSpaceConversion;
9501 Kind = CK_IntegralToPointer;
9507 if (isa<ObjCObjectPointerType>(RHSType)) {
9509 if (LHSPointer->getPointeeType()->isVoidType()) {
9528 if (LHSPointer->getPointeeType()->isVoidType()) {
9529 LangAS AddrSpaceL = LHSPointer->getPointeeType().getAddressSpace();
9534 AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion : CK_BitCast;
9543 if (isa<BlockPointerType>(LHSType)) {
9552 Kind = AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion : CK_BitCast;
9558 Kind = CK_IntegralToPointer;
9564 Kind = CK_AnyPointerToBlockPointerCast;
9570 if (RHSPT->getPointeeType()->isVoidType()) {
9571 Kind = CK_AnyPointerToBlockPointerCast;
9579 if (isa<ObjCObjectPointerType>(LHSType)) {
9585 if (
getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
9587 !
ObjC().CheckObjCARCUnavailableWeakConversion(OrigLHSType, RHSType))
9594 Kind = CK_IntegralToPointer;
9600 if (isa<PointerType>(RHSType)) {
9601 Kind = CK_CPointerToObjCPointerCast;
9623 Kind = CK_BlockPointerToObjCPointerCast;
9635 Kind = CK_NullToPointer;
9640 if (isa<PointerType>(RHSType)) {
9643 Kind = CK_PointerToBoolean;
9649 Kind = CK_PointerToIntegral;
9657 if (isa<ObjCObjectPointerType>(RHSType)) {
9660 Kind = CK_PointerToBoolean;
9666 Kind = CK_PointerToIntegral;
9674 if (isa<TagType>(LHSType) && isa<TagType>(RHSType)) {
9682 Kind = CK_IntToOCLSampler;
9721 if (!UD->
hasAttr<TransparentUnionAttr>())
9727 for (
auto *it : UD->
fields()) {
9728 if (it->getType()->isPointerType()) {
9767 bool DiagnoseCFAudited,
9771 assert((ConvertRHS || !
Diagnose) &&
"can't indicate whether we diagnosed");
9777 ExprResult &RHS = ConvertRHS ? CallerRHS : LocalRHS;
9781 if (RHSPtrType->getPointeeType()->hasAttr(attr::NoDeref) &&
9782 !LHSPtrType->getPointeeType()->hasAttr(attr::NoDeref)) {
9784 diag::warn_noderef_to_dereferenceable_pointer)
9803 AllowedExplicit::None,
9815 if (
getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
9816 !
ObjC().CheckObjCARCUnavailableWeakConversion(LHSType, RHSType))
9830 RHS.
get(), LHSType,
false, DAP))
9953 if (
getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
9963 ObjC().CheckConversionToObjCLiteral(LHSType,
E,
Diagnose))) {
9983struct OriginalOperand {
9984 explicit OriginalOperand(
Expr *Op) : Orig(Op), Conversion(nullptr) {
9985 if (
auto *MTE = dyn_cast<MaterializeTemporaryExpr>(Op))
9986 Op = MTE->getSubExpr();
9987 if (
auto *BTE = dyn_cast<CXXBindTemporaryExpr>(Op))
9988 Op = BTE->getSubExpr();
9989 if (
auto *ICE = dyn_cast<ImplicitCastExpr>(Op)) {
9990 Orig = ICE->getSubExprAsWritten();
9991 Conversion = ICE->getConversionFunction();
9995 QualType getType()
const {
return Orig->getType(); }
10004 OriginalOperand OrigLHS(LHS.
get()), OrigRHS(RHS.
get());
10006 Diag(
Loc, diag::err_typecheck_invalid_operands)
10007 << OrigLHS.getType() << OrigRHS.getType()
10012 if (OrigLHS.Conversion) {
10013 Diag(OrigLHS.Conversion->getLocation(),
10014 diag::note_typecheck_invalid_operands_converted)
10017 if (OrigRHS.Conversion) {
10018 Diag(OrigRHS.Conversion->getLocation(),
10019 diag::note_typecheck_invalid_operands_converted)
10034 if (!(LHSNatVec && RHSNatVec)) {
10036 Expr *NonVector = !LHSNatVec ? LHS.
get() : RHS.
get();
10037 Diag(
Loc, diag::err_typecheck_logical_vector_expr_gnu_cpp_restrict)
10039 <<
Vector->getSourceRange();
10043 Diag(
Loc, diag::err_typecheck_logical_vector_expr_gnu_cpp_restrict)
10066 unsigned &DiagID) {
10072 scalarCast = CK_IntegralToBoolean;
10077 DiagID = diag::err_opencl_scalar_type_rank_greater_than_vector_type;
10082 scalarCast = CK_IntegralCast;
10087 DiagID = diag::err_opencl_scalar_type_rank_greater_than_vector_type;
10090 scalarCast = CK_FloatingCast;
10093 scalarCast = CK_IntegralToFloating;
10102 if (scalarCast != CK_NoOp)
10113 assert(VecTy &&
"Expression E must be a vector");
10118 VecTy->getVectorKind());
10122 if (
auto *ICE = dyn_cast<ImplicitCastExpr>(
E))
10123 if (ICE->getSubExpr()->getType() == NewVecTy)
10124 return ICE->getSubExpr();
10126 auto Cast = ElementType->
isIntegerType() ? CK_IntegralCast : CK_FloatingCast;
10134 if (Int->get()->containsErrors())
10137 QualType IntTy = Int->get()->getType().getUnqualifiedType();
10143 bool CstInt = Int->get()->EvaluateAsInt(EVResult, S.
Context);
10152 unsigned NumBits = IntSigned
10154 :
Result.getActiveBits())
10155 :
Result.getActiveBits();
10162 return (IntSigned != OtherIntSigned &&
10168 return (Order < 0);
10175 if (Int->get()->containsErrors())
10178 QualType IntTy = Int->get()->getType().getUnqualifiedType();
10183 bool CstInt = Int->get()->EvaluateAsInt(EVResult, S.
Context);
10195 llvm::APFloat::rmTowardZero);
10198 bool Ignored =
false;
10199 Float.convertToInteger(ConvertBack, llvm::APFloat::rmNearestTiesToEven,
10201 if (
Result != ConvertBack)
10207 unsigned FloatPrec = llvm::APFloat::semanticsPrecision(
10209 if (Bits > FloatPrec)
10222 QualType ScalarTy = Scalar->get()->getType().getUnqualifiedType();
10223 QualType VectorTy =
Vector->get()->getType().getUnqualifiedType();
10227 assert(!isa<ExtVectorType>(VT) &&
10228 "ExtVectorTypes should not be handled here!");
10229 VectorEltTy = VT->getElementType();
10234 llvm_unreachable(
"Only Fixed-Length and SVE Vector types are handled here");
10260 ScalarCast = CK_IntegralCast;
10264 ScalarCast = CK_FloatingToIntegral;
10272 llvm::APFloat
Result(0.0);
10278 bool CstScalar = Scalar->get()->isValueDependent() ||
10281 if (!CstScalar && Order < 0)
10287 bool Truncated =
false;
10289 llvm::APFloat::rmNearestTiesToEven, &Truncated);
10294 ScalarCast = CK_FloatingCast;
10299 ScalarCast = CK_IntegralToFloating;
10306 if (ScalarCast != CK_NoOp)
10314 bool AllowBothBool,
10315 bool AllowBoolConversions,
10316 bool AllowBoolOperation,
10317 bool ReportInvalid) {
10318 if (!IsCompAssign) {
10334 assert(LHSVecType || RHSVecType);
10342 (RHSVecType && RHSVecType->getElementType()->isMFloat8Type()))
10347 if (!AllowBothBool && LHSVecType &&
10353 if (!AllowBoolOperation &&
10362 if (LHSVecType && RHSVecType &&
10364 if (isa<ExtVectorType>(LHSVecType)) {
10377 if (AllowBoolConversions && LHSVecType && RHSVecType &&
10387 if (!IsCompAssign &&
10390 RHSVecType->getElementType()->isIntegerType()) {
10399 unsigned &SVEorRVV) {
10420 if (IsSveRVVConversion(LHSType, RHSType, SVEorRVV) ||
10421 IsSveRVVConversion(RHSType, LHSType, SVEorRVV)) {
10422 Diag(
Loc, diag::err_typecheck_sve_rvv_ambiguous)
10423 << SVEorRVV << LHSType << RHSType;
10430 unsigned &SVEorRVV) {
10435 if (FirstVecType && SecondVecType) {
10438 SecondVecType->getVectorKind() ==
10443 SecondVecType->getVectorKind() ==
10445 SecondVecType->getVectorKind() ==
10447 SecondVecType->getVectorKind() ==
10456 if (SecondVecType &&
10469 if (IsSveRVVGnuConversion(LHSType, RHSType, SVEorRVV) ||
10470 IsSveRVVGnuConversion(RHSType, LHSType, SVEorRVV)) {
10471 Diag(
Loc, diag::err_typecheck_sve_rvv_gnu_ambiguous)
10472 << SVEorRVV << LHSType << RHSType;
10478 unsigned DiagID = diag::err_typecheck_vector_not_convertable;
10480 if (isa<ExtVectorType>(LHSVecType)) {
10491 if (isa<ExtVectorType>(RHSVecType)) {
10493 LHSType, RHSVecType->getElementType(),
10506 QualType VecType = LHSVecType ? LHSType : RHSType;
10507 const VectorType *VT = LHSVecType ? LHSVecType : RHSVecType;
10508 QualType OtherType = LHSVecType ? RHSType : LHSType;
10509 ExprResult *OtherExpr = LHSVecType ? &RHS : &LHS;
10514 Diag(
Loc, diag::warn_deprecated_lax_vec_conv_all) << RHSType << LHSType;
10518 if (!IsCompAssign) {
10537 if ((!RHSVecType && !RHSType->
isRealType()) ||
10539 Diag(
Loc, diag::err_typecheck_vector_not_convertable_non_scalar)
10540 << LHSType << RHSType
10550 RHSVecType && isa<ExtVectorType>(RHSVecType) &&
10551 LHSVecType && isa<ExtVectorType>(LHSVecType)) {
10552 Diag(
Loc, diag::err_opencl_implicit_vector_conversion) << LHSType
10561 if ((RHSVecType && !isa<ExtVectorType>(RHSVecType)) ||
10562 (LHSVecType && !isa<ExtVectorType>(LHSVecType))) {
10563 QualType Scalar = LHSVecType ? RHSType : LHSType;
10565 unsigned ScalarOrVector = LHSVecType && RHSVecType ? 1 : 0;
10567 diag::err_typecheck_vector_not_convertable_implict_truncation)
10568 << ScalarOrVector << Scalar <<
Vector;
10575 << LHSType << RHSType
10584 if (!IsCompAssign) {
10599 unsigned DiagID = diag::err_typecheck_invalid_operands;
10601 ((LHSBuiltinTy && LHSBuiltinTy->
isSVEBool()) ||
10602 (RHSBuiltinTy && RHSBuiltinTy->isSVEBool()))) {
10623 Diag(
Loc, diag::err_typecheck_vector_not_convertable_non_scalar)
10632 Diag(
Loc, diag::err_typecheck_vector_lengths_not_equal)
10641 bool ScalarOrVector =
10644 Diag(
Loc, diag::err_typecheck_vector_not_convertable_implict_truncation)
10645 << ScalarOrVector << Scalar <<
Vector;
10677 S.
Diag(
Loc, diag::warn_null_in_arithmetic_operation)
10689 S.
Diag(
Loc, diag::warn_null_in_comparison_operation)
10690 << LHSNull << NonNullType
10702 QualType ElementType = CT->getElementType();
10703 bool IsComplexRangePromoted = S.
getLangOpts().getComplexRange() ==
10710 const llvm::fltSemantics &ElementTypeSemantics =
10712 const llvm::fltSemantics &HigherElementTypeSemantics =
10715 if ((llvm::APFloat::semanticsMaxExponent(ElementTypeSemantics) * 2 + 1 >
10716 llvm::APFloat::semanticsMaxExponent(HigherElementTypeSemantics)) ||
10723 if (
Type == HigherElementType) {
10735 const auto *LUE = dyn_cast<UnaryExprOrTypeTraitExpr>(LHS);
10736 const auto *RUE = dyn_cast<UnaryExprOrTypeTraitExpr>(RHS);
10739 if (LUE->getKind() != UETT_SizeOf || LUE->isArgumentType() ||
10740 RUE->getKind() != UETT_SizeOf)
10747 if (RUE->isArgumentType())
10748 RHSTy = RUE->getArgumentType().getNonReferenceType();
10750 RHSTy = RUE->getArgumentExpr()->IgnoreParens()->getType();
10757 if (
const auto *DRE = dyn_cast<DeclRefExpr>(LHSArg)) {
10758 if (
const ValueDecl *LHSArgDecl = DRE->getDecl())
10759 S.
Diag(LHSArgDecl->getLocation(), diag::note_pointer_declared_here)
10763 QualType ArrayElemTy = ArrayTy->getElementType();
10769 S.
Diag(
Loc, diag::warn_division_sizeof_array)
10771 if (
const auto *DRE = dyn_cast<DeclRefExpr>(LHSArg)) {
10772 if (
const ValueDecl *LHSArgDecl = DRE->getDecl())
10773 S.
Diag(LHSArgDecl->getLocation(), diag::note_array_declared_here)
10777 S.
Diag(
Loc, diag::note_precedence_silence) << RHS;
10790 S.
PDiag(diag::warn_remainder_division_by_zero)
10799 const Expr *LHSExpr = LHS.
get();
10800 const Expr *RHSExpr = RHS.
get();
10805 if (!LHSIsScoped && !RHSIsScoped)
10816 ->getOriginalDecl()
10817 ->getDefinitionOrSelf()
10818 ->getIntegerType();
10819 std::string InsertionString =
"static_cast<" + IntType.
getAsString() +
">(";
10820 S.
Diag(BeginLoc, diag::note_no_implicit_conversion_for_scoped_enum)
10825 DiagnosticHelper(LHSExpr, LHSType);
10828 DiagnosticHelper(RHSExpr, RHSType);
10835 bool IsCompAssign = Opc == BO_MulAssign || Opc == BO_DivAssign;
10836 bool IsDiv = Opc == BO_Div || Opc == BO_DivAssign;
10930 if (compType.
isNull() ||
10935 IsCompAssign ? BO_RemAssign : BO_Rem);
10946 ? diag::err_typecheck_pointer_arith_void_type
10947 : diag::ext_gnu_void_ptr)
10956 ? diag::err_typecheck_pointer_arith_void_type
10957 : diag::ext_gnu_void_ptr)
10958 << 0 <<
Pointer->getSourceRange();
10969 S.
Diag(
Loc, diag::warn_gnu_null_ptr_arith)
10970 <<
Pointer->getSourceRange();
10972 S.
Diag(
Loc, diag::warn_pointer_arith_null_ptr)
10989 S.
PDiag(diag::warn_pointer_sub_null_ptr)
10991 <<
Pointer->getSourceRange());
11000 ? diag::err_typecheck_pointer_arith_function_type
11001 : diag::ext_gnu_ptr_func_arith)
11013 assert(
Pointer->getType()->isAnyPointerType());
11015 ? diag::err_typecheck_pointer_arith_function_type
11016 : diag::ext_gnu_ptr_func_arith)
11017 << 0 <<
Pointer->getType()->getPointeeType()
11019 <<
Pointer->getSourceRange();
11027 QualType ResType = Operand->getType();
11029 ResType = ResAtomicType->getValueType();
11035 diag::err_typecheck_arithmetic_incomplete_or_sizeless_type,
11036 Operand->getSourceRange());
11049 QualType ResType = Operand->getType();
11051 ResType = ResAtomicType->getValueType();
11083 if (!isLHSPointer && !isRHSPointer)
return true;
11085 QualType LHSPointeeTy, RHSPointeeTy;
11090 if (isLHSPointer && isRHSPointer) {
11094 diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
11102 bool isLHSVoidPtr = isLHSPointer && LHSPointeeTy->
isVoidType();
11103 bool isRHSVoidPtr = isRHSPointer && RHSPointeeTy->
isVoidType();
11104 if (isLHSVoidPtr || isRHSVoidPtr) {
11112 bool isLHSFuncPtr = isLHSPointer && LHSPointeeTy->
isFunctionType();
11113 bool isRHSFuncPtr = isRHSPointer && RHSPointeeTy->
isFunctionType();
11114 if (isLHSFuncPtr || isRHSFuncPtr) {
11136 Expr* IndexExpr = RHSExpr;
11139 IndexExpr = LHSExpr;
11142 bool IsStringPlusInt = StrExpr &&
11148 Self.Diag(OpLoc, diag::warn_string_plus_int)
11152 if (IndexExpr == RHSExpr) {
11154 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence)
11159 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence);
11165 const Expr *StringRefExpr = LHSExpr;
11170 CharExpr = dyn_cast<CharacterLiteral>(LHSExpr->
IgnoreImpCasts());
11171 StringRefExpr = RHSExpr;
11174 if (!CharExpr || !StringRefExpr)
11194 Self.Diag(OpLoc, diag::warn_string_plus_char)
11195 << DiagRange << Ctx.
CharTy;
11197 Self.Diag(OpLoc, diag::warn_string_plus_char)
11198 << DiagRange << CharExpr->
getType();
11204 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence)
11209 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence);
11218 S.
Diag(
Loc, diag::err_typecheck_sub_ptr_compatible)
11237 if (CompLHSTy) *CompLHSTy = compType;
11246 *CompLHSTy = compType;
11255 *CompLHSTy = compType;
11266 if (Opc == BO_Add) {
11273 if (CompLHSTy) *CompLHSTy = compType;
11287 std::swap(PExp, IExp);
11300 if (!IExp->getType()->isIntegerType())
11309 (!IExp->isValueDependent() &&
11310 (!IExp->EvaluateAsInt(KnownVal,
Context) ||
11314 Context, BO_Add, PExp, IExp);
11327 if (isa<AddrLabelExpr>(PExp) &&
getLangOpts().PointerAuthIndirectGotos) {
11328 Diag(
Loc, diag::err_ptrauth_indirect_goto_addrlabel_arithmetic)
11334 CheckArrayAccess(PExp, IExp);
11343 *CompLHSTy = LHSTy;
11364 if (CompLHSTy) *CompLHSTy = compType;
11373 *CompLHSTy = compType;
11382 *CompLHSTy = compType;
11396 if (CompLHSTy) *CompLHSTy = compType;
11411 if (isa<AddrLabelExpr>(LHS.
get()) &&
11413 Diag(
Loc, diag::err_ptrauth_indirect_goto_addrlabel_arithmetic)
11439 CheckArrayAccess(LHS.
get(), RHS.
get(),
nullptr,
11442 if (CompLHSTy) *CompLHSTy = LHS.
get()->
getType();
11486 if (ElementSize.
isZero()) {
11487 Diag(
Loc,diag::warn_sub_ptr_zero_size_types)
11493 if (CompLHSTy) *CompLHSTy = LHS.
get()->
getType();
11505 return ET->getOriginalDecl()->isScoped();
11517 if (Opc == BO_Shr &&
11526 llvm::APSInt Right = RHSResult.
Val.
getInt();
11528 if (Right.isNegative()) {
11530 S.
PDiag(diag::warn_shift_negative)
11541 LeftSize = FXSema.getWidth() - (
unsigned)FXSema.hasUnsignedPadding();
11543 if (Right.uge(LeftSize)) {
11545 S.
PDiag(diag::warn_shift_gt_typewidth)
11565 llvm::APSInt Left = LHSResult.
Val.
getInt();
11576 if (Left.isNegative()) {
11578 S.
PDiag(diag::warn_shift_lhs_negative)
11583 llvm::APInt ResultBits =
11584 static_cast<llvm::APInt &
>(Right) + Left.getSignificantBits();
11585 if (ResultBits.ule(LeftSize))
11587 llvm::APSInt
Result = Left.extend(ResultBits.getLimitedValue());
11593 Result.toString(HexResult, 16,
false,
true);
11599 if (ResultBits - 1 == LeftSize) {
11600 S.
Diag(
Loc, diag::warn_shift_result_sets_sign_bit)
11601 << HexResult << LHSType
11606 S.
Diag(
Loc, diag::warn_shift_result_gt_typewidth)
11607 << HexResult.str() <<
Result.getSignificantBits() << LHSType
11619 S.
Diag(
Loc, diag::err_shift_rhs_only_vector)
11625 if (!IsCompAssign) {
11647 S.
Diag(
Loc, diag::err_typecheck_invalid_operands)
11654 if (!LHSEleType->isIntegerType()) {
11655 S.
Diag(
Loc, diag::err_typecheck_expect_int)
11660 if (!RHSEleType->isIntegerType()) {
11661 S.
Diag(
Loc, diag::err_typecheck_expect_int)
11670 if (LHSEleType != RHSEleType) {
11672 LHSEleType = RHSEleType;
11678 }
else if (RHSVecTy) {
11683 S.
Diag(
Loc, diag::err_typecheck_vector_lengths_not_equal)
11691 if (LHSBT != RHSBT &&
11693 S.
Diag(
Loc, diag::warn_typecheck_vector_element_sizes_not_equal)
11710 bool IsCompAssign) {
11711 if (!IsCompAssign) {
11734 if ((LHSBuiltinTy && LHSBuiltinTy->
isSVEBool()) ||
11735 (RHSBuiltinTy && RHSBuiltinTy->
isSVEBool())) {
11736 S.
Diag(
Loc, diag::err_typecheck_invalid_operands)
11741 if (!LHSEleType->isIntegerType()) {
11742 S.
Diag(
Loc, diag::err_typecheck_expect_int)
11747 if (!RHSEleType->isIntegerType()) {
11748 S.
Diag(
Loc, diag::err_typecheck_expect_int)
11756 S.
Diag(
Loc, diag::err_typecheck_invalid_operands)
11766 if (LHSEleType != RHSEleType) {
11768 LHSEleType = RHSEleType;
11770 const llvm::ElementCount VecSize =
11779 S.
Diag(
Loc, diag::err_typecheck_vector_lengths_not_equal)
11785 const llvm::ElementCount VecSize =
11787 if (LHSEleType != RHSEleType) {
11789 RHSEleType = LHSEleType;
11802 bool IsCompAssign) {
11836 if (IsCompAssign) LHS = OldLHS;
11864 S.
Diag(
Loc, IsError ? diag::err_typecheck_comparison_of_distinct_pointers
11865 : diag::ext_typecheck_comparison_of_distinct_pointers)
11905 S.
Diag(
Loc, IsError ? diag::err_typecheck_comparison_of_fptr_to_void
11906 : diag::ext_typecheck_comparison_of_fptr_to_void)
11913 case Stmt::ObjCArrayLiteralClass:
11914 case Stmt::ObjCDictionaryLiteralClass:
11915 case Stmt::ObjCStringLiteralClass:
11916 case Stmt::ObjCBoxedExprClass:
11977 Literal = LHS.
get();
11980 Literal = RHS.
get();
11996 llvm_unreachable(
"Unknown Objective-C object literal kind");
12000 S.
Diag(
Loc, diag::warn_objc_string_literal_comparison)
12001 << Literal->getSourceRange();
12003 S.
Diag(
Loc, diag::warn_objc_literal_comparison)
12004 << LiteralKind << Literal->getSourceRange();
12013 S.
Diag(
Loc, diag::note_objc_literal_comparison_isequal)
12026 if (!UO || UO->
getOpcode() != UO_LNot)
return;
12036 bool IsBitwiseOp = Opc == BO_And || Opc == BO_Or || Opc == BO_Xor;
12038 <<
Loc << IsBitwiseOp;
12065 if (
const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(
E)) {
12067 }
else if (
const MemberExpr *Mem = dyn_cast<MemberExpr>(
E)) {
12068 if (Mem->isImplicitAccess())
12069 D = Mem->getMemberDecl();
12073 return D->getType()->isArrayType() && !
D->isWeak();
12084 return std::nullopt;
12092 std::swap(LHS, RHS);
12096 std::swap(LHS, RHS);
12100 return std::nullopt;
12103 auto *BO = dyn_cast<BinaryOperator>(LHS);
12104 if (!BO || BO->getOpcode() != BO_Add)
12105 return std::nullopt;
12109 Other = BO->getRHS();
12111 Other = BO->getLHS();
12113 return std::nullopt;
12115 if (!
Other->getType()->isUnsignedIntegerType())
12116 return std::nullopt;
12118 return Opc == BO_GE;
12172 auto IsDeprArrayComparionIgnored =
12175 ? diag::warn_array_comparison_cxx26
12176 : !S.
getLangOpts().CPlusPlus20 || IsDeprArrayComparionIgnored
12177 ? diag::warn_array_comparison
12178 : diag::warn_depr_array_comparison;
12204 Result = AlwaysConstant;
12208 S.
PDiag(diag::warn_comparison_always)
12223 Result = AlwaysConstant;
12227 S.
PDiag(diag::warn_comparison_always)
12230 }
else if (std::optional<bool> Res =
12233 S.
PDiag(diag::warn_comparison_always)
12235 << (*Res ? AlwaysTrue : AlwaysFalse));
12239 if (isa<CastExpr>(LHSStripped))
12241 if (isa<CastExpr>(RHSStripped))
12246 Expr *LiteralString =
nullptr;
12247 Expr *LiteralStringStripped =
nullptr;
12248 if ((isa<StringLiteral>(LHSStripped) || isa<ObjCEncodeExpr>(LHSStripped)) &&
12251 LiteralString = LHS;
12252 LiteralStringStripped = LHSStripped;
12253 }
else if ((isa<StringLiteral>(RHSStripped) ||
12254 isa<ObjCEncodeExpr>(RHSStripped)) &&
12257 LiteralString = RHS;
12258 LiteralStringStripped = RHSStripped;
12261 if (LiteralString) {
12263 S.
PDiag(diag::warn_stringcompare)
12264 << isa<ObjCEncodeExpr>(LiteralStringStripped)
12276 llvm_unreachable(
"unhandled cast kind");
12278 case CK_UserDefinedConversion:
12280 case CK_LValueToRValue:
12282 case CK_ArrayToPointerDecay:
12284 case CK_FunctionToPointerDecay:
12286 case CK_IntegralCast:
12288 case CK_FloatingCast:
12290 case CK_IntegralToFloating:
12291 case CK_FloatingToIntegral:
12293 case CK_IntegralComplexCast:
12294 case CK_FloatingComplexCast:
12295 case CK_FloatingComplexToIntegralComplex:
12296 case CK_IntegralComplexToFloatingComplex:
12298 case CK_FloatingComplexToReal:
12299 case CK_FloatingRealToComplex:
12300 case CK_IntegralComplexToReal:
12301 case CK_IntegralRealToComplex:
12303 case CK_HLSLArrayRValue:
12316 if (
const auto *ICE = dyn_cast<ImplicitCastExpr>(
E))
12343 << 0 << FromType << ToType;
12348 llvm_unreachable(
"unhandled case in switch");
12375 if (NumEnumArgs == 1) {
12377 QualType OtherTy = LHSIsEnum ? RHSStrippedType : LHSStrippedType;
12383 if (NumEnumArgs == 2) {
12402 LHSType = RHSType = IntType;
12411 if (
Type.isNull()) {
12417 std::optional<ComparisonCategoryType> CCT =
12429 assert(!
Type.isNull() &&
"composite type for <=> has not been set");
12447 if (
Type.isNull()) {
12473 if (
const auto *
CL = dyn_cast<CharacterLiteral>(
E.get())) {
12474 if (
CL->getValue() == 0)
12478 NullValue ?
"NULL" :
"(void *)0");
12479 }
else if (
const auto *CE = dyn_cast<CStyleCastExpr>(
E.get())) {
12486 NullValue ?
"NULL" :
"(void *)0");
12496 bool IsThreeWay = Opc == BO_Cmp;
12497 bool IsOrdered = IsRelational || IsThreeWay;
12508 if (!IsThreeWay || IsAnyPointerType(LHS) || IsAnyPointerType(RHS)) {
12561 auto computeResultTy = [&]() {
12570 std::optional<ComparisonCategoryType> CCT =
12575 if (CompositeTy->
isPointerType() && LHSIsNull != RHSIsNull) {
12579 Diag(
Loc, diag::err_typecheck_three_way_comparison_of_pointer_and_zero)
12589 if (!IsOrdered && LHSIsNull != RHSIsNull) {
12590 bool IsEquality = Opc == BO_EQ;
12602 bool IsError = Opc == BO_Cmp;
12604 IsError ? diag::err_typecheck_ordered_comparison_of_function_pointers
12606 ? diag::warn_typecheck_ordered_comparison_of_function_pointers
12607 : diag::ext_typecheck_ordered_comparison_of_function_pointers;
12636 return computeResultTy();
12652 (IsOrdered ? 2 : 1) &&
12657 return computeResultTy();
12671 if (IsRelational) {
12676 Diag(
Loc, diag::ext_typecheck_compare_complete_incomplete_pointers)
12682 }
else if (!IsRelational &&
12686 && !LHSIsNull && !RHSIsNull)
12693 if (LCanPointeeTy != RCanPointeeTy) {
12699 diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
12700 << LHSType << RHSType << 0
12706 CastKind Kind = AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion
12712 bool RHSHasCFIUncheckedCallee = RFn && RFn->getCFIUncheckedCalleeAttr();
12713 bool ChangingCFIUncheckedCallee =
12714 LHSHasCFIUncheckedCallee != RHSHasCFIUncheckedCallee;
12716 if (LHSIsNull && !RHSIsNull)
12718 else if (!ChangingCFIUncheckedCallee)
12721 return computeResultTy();
12733 if (!IsOrdered && LHSIsNull && RHSIsNull) {
12736 return computeResultTy();
12740 return computeResultTy();
12751 return computeResultTy();
12755 return computeResultTy();
12764 return computeResultTy();
12769 return computeResultTy();
12773 if (IsRelational &&
12782 if (isa<FunctionDecl>(DC))
12784 if (
auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
12785 if (CTSD->isInStdNamespace() &&
12786 llvm::StringSwitch<bool>(CTSD->getName())
12787 .Cases(
"less",
"less_equal",
"greater",
"greater_equal",
true)
12793 return computeResultTy();
12806 return computeResultTy();
12816 if (!LHSIsNull && !RHSIsNull &&
12818 Diag(
Loc, diag::err_typecheck_comparison_of_distinct_blocks)
12823 return computeResultTy();
12830 if (!LHSIsNull && !RHSIsNull) {
12835 Diag(
Loc, diag::err_typecheck_comparison_of_distinct_blocks)
12839 if (LHSIsNull && !RHSIsNull)
12842 : CK_AnyPointerToBlockPointerCast);
12846 : CK_AnyPointerToBlockPointerCast);
12847 return computeResultTy();
12856 bool RPtrToVoid = RPT ? RPT->getPointeeType()->isVoidType() :
false;
12858 if (!LPtrToVoid && !RPtrToVoid &&
12866 if (LHSIsNull && !RHSIsNull) {
12872 RPT ? CK_BitCast :CK_CPointerToObjCPointerCast);
12882 LPT ? CK_BitCast :CK_CPointerToObjCPointerCast);
12884 return computeResultTy();
12894 if (LHSIsNull && !RHSIsNull)
12898 return computeResultTy();
12904 CK_BlockPointerToObjCPointerCast);
12905 return computeResultTy();
12906 }
else if (!IsOrdered &&
12910 CK_BlockPointerToObjCPointerCast);
12911 return computeResultTy();
12916 unsigned DiagID = 0;
12917 bool isError =
false;
12926 isError ? diag::err_typecheck_ordered_comparison_of_pointer_and_zero
12927 : diag::ext_typecheck_ordered_comparison_of_pointer_and_zero;
12930 DiagID = diag::err_typecheck_comparison_of_pointer_integer;
12932 }
else if (IsOrdered)
12933 DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_integer;
12935 DiagID = diag::ext_typecheck_comparison_of_pointer_integer;
12947 LHSIsNull ? CK_NullToPointer : CK_IntegralToPointer);
12950 RHSIsNull ? CK_NullToPointer : CK_IntegralToPointer);
12951 return computeResultTy();
12955 if (!IsOrdered && RHSIsNull
12958 return computeResultTy();
12960 if (!IsOrdered && LHSIsNull
12963 return computeResultTy();
12966 if (
getLangOpts().getOpenCLCompatibleVersion() >= 200) {
12968 return computeResultTy();
12972 return computeResultTy();
12975 if (LHSIsNull && RHSType->
isQueueT()) {
12977 return computeResultTy();
12980 if (LHSType->
isQueueT() && RHSIsNull) {
12982 return computeResultTy();
12993 if (isa<ExtVectorType>(VTy)) {
13007 "Unhandled vector element size in vector compare");
13027 "Unhandled vector element size in vector compare");
13047 if (Opc == BO_Cmp) {
13048 Diag(
Loc, diag::err_three_way_vector_comparison);
13079 Diag(
Loc, diag::warn_deprecated_altivec_src_compat);
13109 if (Opc == BO_Cmp) {
13110 Diag(
Loc, diag::err_three_way_vector_comparison);
13138 if (LHSBuiltinTy && RHSBuiltinTy && LHSBuiltinTy->
isSVEBool() &&
13139 RHSBuiltinTy->isSVEBool())
13158 bool Negative =
false;
13159 bool ExplicitPlus =
false;
13160 const auto *LHSInt = dyn_cast<IntegerLiteral>(XorLHS.
get());
13161 const auto *RHSInt = dyn_cast<IntegerLiteral>(XorRHS.
get());
13167 if (
const auto *UO = dyn_cast<UnaryOperator>(XorRHS.
get())) {
13169 if (Opc != UO_Minus && Opc != UO_Plus)
13171 RHSInt = dyn_cast<IntegerLiteral>(UO->getSubExpr());
13174 Negative = (Opc == UO_Minus);
13175 ExplicitPlus = !Negative;
13181 const llvm::APInt &LeftSideValue = LHSInt->getValue();
13182 llvm::APInt RightSideValue = RHSInt->getValue();
13183 if (LeftSideValue != 2 && LeftSideValue != 10)
13186 if (LeftSideValue.getBitWidth() != RightSideValue.getBitWidth())
13191 llvm::StringRef ExprStr =
13196 llvm::StringRef XorStr =
13199 if (XorStr ==
"xor")
13210 RightSideValue = -RightSideValue;
13211 RHSStr =
"-" + RHSStr;
13212 }
else if (ExplicitPlus) {
13213 RHSStr =
"+" + RHSStr;
13216 StringRef LHSStrRef = LHSStr;
13217 StringRef RHSStrRef = RHSStr;
13220 if (LHSStrRef.starts_with(
"0b") || LHSStrRef.starts_with(
"0B") ||
13221 RHSStrRef.starts_with(
"0b") || RHSStrRef.starts_with(
"0B") ||
13222 LHSStrRef.starts_with(
"0x") || LHSStrRef.starts_with(
"0X") ||
13223 RHSStrRef.starts_with(
"0x") || RHSStrRef.starts_with(
"0X") ||
13224 (LHSStrRef.size() > 1 && LHSStrRef.starts_with(
"0")) ||
13225 (RHSStrRef.size() > 1 && RHSStrRef.starts_with(
"0")) ||
13226 LHSStrRef.contains(
'\'') || RHSStrRef.contains(
'\''))
13231 const llvm::APInt XorValue = LeftSideValue ^ RightSideValue;
13232 int64_t RightSideIntValue = RightSideValue.getSExtValue();
13233 if (LeftSideValue == 2 && RightSideIntValue >= 0) {
13234 std::string SuggestedExpr =
"1 << " + RHSStr;
13235 bool Overflow =
false;
13236 llvm::APInt One = (LeftSideValue - 1);
13237 llvm::APInt PowValue = One.sshl_ov(RightSideValue, Overflow);
13239 if (RightSideIntValue < 64)
13240 S.
Diag(
Loc, diag::warn_xor_used_as_pow_base)
13241 << ExprStr <<
toString(XorValue, 10,
true) << (
"1LL << " + RHSStr)
13243 else if (RightSideIntValue == 64)
13244 S.
Diag(
Loc, diag::warn_xor_used_as_pow)
13245 << ExprStr <<
toString(XorValue, 10,
true);
13249 S.
Diag(
Loc, diag::warn_xor_used_as_pow_base_extra)
13250 << ExprStr <<
toString(XorValue, 10,
true) << SuggestedExpr
13253 ExprRange, (RightSideIntValue == 0) ?
"1" : SuggestedExpr);
13256 S.
Diag(
Loc, diag::note_xor_used_as_pow_silence)
13257 << (
"0x2 ^ " + RHSStr) << SuggestXor;
13258 }
else if (LeftSideValue == 10) {
13259 std::string SuggestedValue =
"1e" + std::to_string(RightSideIntValue);
13260 S.
Diag(
Loc, diag::warn_xor_used_as_pow_base)
13261 << ExprStr <<
toString(XorValue, 10,
true) << SuggestedValue
13263 S.
Diag(
Loc, diag::note_xor_used_as_pow_silence)
13264 << (
"0xA ^ " + RHSStr) << SuggestXor;
13281 getLangOpts().getOpenCLCompatibleVersion() < 120 &&
13305 bool IsCompAssign) {
13306 if (!IsCompAssign) {
13322 assert((LHSMatType || RHSMatType) &&
"At least one operand must be a matrix");
13331 if (LHSMatType && !RHSMatType) {
13339 if (!LHSMatType && RHSMatType) {
13351 bool IsCompAssign) {
13352 if (!IsCompAssign) {
13363 assert((LHSMatType || RHSMatType) &&
"At least one operand must be a matrix");
13365 if (LHSMatType && RHSMatType) {
13366 if (LHSMatType->getNumColumns() != RHSMatType->
getNumRows())
13374 QualType LHSELTy = LHSMatType->getElementType(),
13405 bool IsCompAssign =
13406 Opc == BO_AndAssign || Opc == BO_OrAssign || Opc == BO_XorAssign;
13417 LegalBoolVecOperator,
13447 ExprResult LHSResult = LHS, RHSResult = RHS;
13449 LHSResult, RHSResult,
Loc,
13451 if (LHSResult.
isInvalid() || RHSResult.isInvalid())
13453 LHS = LHSResult.
get();
13454 RHS = RHSResult.
get();
13475 bool EnumConstantInBoolContext =
false;
13477 if (
const auto *DREHS = dyn_cast<DeclRefExpr>(HS.get())) {
13478 const auto *ECDHS = dyn_cast<EnumConstantDecl>(DREHS->getDecl());
13479 if (ECDHS && ECDHS->getInitVal() != 0 && ECDHS->getInitVal() != 1)
13480 EnumConstantInBoolContext =
true;
13484 if (EnumConstantInBoolContext)
13485 Diag(
Loc, diag::warn_enum_constant_in_bool_context);
13490 const auto *LHSATy = dyn_cast<ArrayType>(LHSTy);
13491 const auto *RHSATy = dyn_cast<ArrayType>(RHSTy);
13492 if ((LHSATy && LHSATy->getElementType().isWebAssemblyReferenceType()) ||
13493 (RHSATy && RHSATy->getElementType().isWebAssemblyReferenceType())) {
13515 Diag(
Loc, diag::warn_logical_instead_of_bitwise)
13518 Diag(
Loc, diag::note_logical_instead_of_bitwise_change_operator)
13519 << (Opc == BO_LAnd ?
"&" :
"|")
13522 Opc == BO_LAnd ?
"&" :
"|");
13523 if (Opc == BO_LAnd)
13525 Diag(
Loc, diag::note_logical_instead_of_bitwise_remove_constant)
13588 if (!ME)
return false;
13592 if (!
Base)
return false;
13593 return Base->getMethodDecl() !=
nullptr;
13617 assert(S.
getLangOpts().CPlusPlus &&
"BindingDecl outside of C++?");
13628 assert(Var->
hasLocalStorage() &&
"capture added 'const' to non-local?");
13636 if (
auto *FD = dyn_cast<FunctionDecl>(DC))
13679 bool DiagnosticEmitted =
false;
13683 bool IsDereference =
false;
13684 bool NextIsDereference =
false;
13688 IsDereference = NextIsDereference;
13691 if (
const MemberExpr *ME = dyn_cast<MemberExpr>(
E)) {
13692 NextIsDereference = ME->isArrow();
13693 const ValueDecl *VD = ME->getMemberDecl();
13694 if (
const FieldDecl *Field = dyn_cast<FieldDecl>(VD)) {
13696 if (Field->isMutable()) {
13697 assert(DiagnosticEmitted &&
"Expected diagnostic not emitted.");
13702 if (!DiagnosticEmitted) {
13703 S.
Diag(
Loc, diag::err_typecheck_assign_const)
13705 << Field->getType();
13706 DiagnosticEmitted =
true;
13709 <<
ConstMember <<
false << Field << Field->getType()
13710 << Field->getSourceRange();
13714 }
else if (
const VarDecl *VDecl = dyn_cast<VarDecl>(VD)) {
13715 if (VDecl->getType().isConstQualified()) {
13716 if (!DiagnosticEmitted) {
13717 S.
Diag(
Loc, diag::err_typecheck_assign_const)
13719 << VDecl->getType();
13720 DiagnosticEmitted =
true;
13723 <<
ConstMember <<
true << VDecl << VDecl->getType()
13724 << VDecl->getSourceRange();
13731 dyn_cast<ArraySubscriptExpr>(
E)) {
13735 dyn_cast<ExtVectorElementExpr>(
E)) {
13742 if (
const CallExpr *CE = dyn_cast<CallExpr>(
E)) {
13746 if (!DiagnosticEmitted) {
13747 S.
Diag(
Loc, diag::err_typecheck_assign_const) << ExprRange
13749 DiagnosticEmitted =
true;
13752 diag::note_typecheck_assign_const)
13756 }
else if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(
E)) {
13758 if (
const ValueDecl *VD = DRE->getDecl()) {
13760 if (!DiagnosticEmitted) {
13761 S.
Diag(
Loc, diag::err_typecheck_assign_const)
13763 DiagnosticEmitted =
true;
13765 S.
Diag(VD->getLocation(), diag::note_typecheck_assign_const)
13766 <<
ConstVariable << VD << VD->getType() << VD->getSourceRange();
13769 }
else if (isa<CXXThisExpr>(
E)) {
13771 if (
const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(DC)) {
13772 if (MD->isConst()) {
13773 if (!DiagnosticEmitted) {
13774 S.
Diag(
Loc, diag::err_typecheck_assign_const) << ExprRange
13776 DiagnosticEmitted =
true;
13778 S.
Diag(MD->getLocation(), diag::note_typecheck_assign_const)
13785 if (DiagnosticEmitted)
13802 bool &DiagnosticEmitted) {
13803 std::vector<const RecordType *> RecordTypeList;
13804 RecordTypeList.push_back(Ty);
13805 unsigned NextToCheckIndex = 0;
13808 while (RecordTypeList.size() > NextToCheckIndex) {
13809 bool IsNested = NextToCheckIndex > 0;
13810 for (
const FieldDecl *Field : RecordTypeList[NextToCheckIndex]
13811 ->getOriginalDecl()
13815 QualType FieldTy = Field->getType();
13817 if (!DiagnosticEmitted) {
13818 S.
Diag(
Loc, diag::err_typecheck_assign_const)
13820 << IsNested << Field;
13821 DiagnosticEmitted =
true;
13823 S.
Diag(Field->getLocation(), diag::note_typecheck_assign_const)
13825 << FieldTy << Field->getSourceRange();
13831 if (!llvm::is_contained(RecordTypeList, FieldRecTy))
13832 RecordTypeList.push_back(FieldRecTy);
13835 ++NextToCheckIndex;
13844 assert(Ty->
isRecordType() &&
"lvalue was not record?");
13847 bool DiagEmitted =
false;
13849 if (
const MemberExpr *ME = dyn_cast<MemberExpr>(
E))
13852 else if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(
E))
13877 unsigned DiagID = 0;
13878 bool NeedType =
false;
13885 DiagID = diag::err_block_decl_ref_not_modifiable_lvalue;
13887 DiagID = diag::err_lambda_decl_ref_not_modifiable_lvalue;
13895 if (declRef && isa<VarDecl>(declRef->
getDecl())) {
13900 if (var->isARCPseudoStrong() &&
13901 (!var->getTypeSourceInfo() ||
13902 !var->getTypeSourceInfo()->getType().isConstQualified())) {
13908 ? diag::err_typecheck_arc_assign_self_class_method
13909 : diag::err_typecheck_arc_assign_self;
13912 }
else if (var->hasAttr<ObjCExternallyRetainedAttr>() ||
13913 isa<ParmVarDecl>(var)) {
13914 DiagID = diag::err_typecheck_arc_assign_externally_retained;
13918 DiagID = diag::err_typecheck_arr_assign_enumeration;
13922 if (
Loc != OrigLoc)
13948 DiagID = diag::err_typecheck_array_not_modifiable_lvalue;
13952 DiagID = diag::err_typecheck_non_object_not_modifiable_lvalue;
13956 DiagID = diag::err_typecheck_lvalue_casts_not_supported;
13959 llvm_unreachable(
"did not take early return for MLV_Valid");
13963 DiagID = diag::err_typecheck_expression_not_modifiable_lvalue;
13968 diag::err_typecheck_incomplete_type_not_modifiable_lvalue,
E);
13970 DiagID = diag::err_typecheck_duplicate_vector_components_not_mlvalue;
13973 llvm_unreachable(
"readonly properties should be processed differently");
13975 DiagID = diag::err_readonly_message_assignment;
13978 DiagID = diag::err_no_subobject_property_setting;
13983 if (
Loc != OrigLoc)
14005 MemberExpr *ML = dyn_cast<MemberExpr>(LHSExpr);
14006 MemberExpr *MR = dyn_cast<MemberExpr>(RHSExpr);
14008 if (!(isa<CXXThisExpr>(ML->
getBase()) && isa<CXXThisExpr>(MR->
getBase())))
14014 if (LHSDecl != RHSDecl)
14019 if (RefTy->getPointeeType().isVolatileQualified())
14022 Sema.
Diag(
Loc, diag::warn_identity_field_assign) << 0;
14032 Sema.
Diag(
Loc, diag::warn_identity_field_assign) << 1;
14056 bool ShowFullyQualifiedAssigneeName =
false;
14059 Assignee = DR->getDecl();
14060 }
else if (
auto *ME = dyn_cast<MemberExpr>(LHSExpr->
IgnoreParenCasts())) {
14061 Assignee = ME->getMemberDecl();
14062 ShowFullyQualifiedAssigneeName =
true;
14067 ShowFullyQualifiedAssigneeName);
14076 Diag(
Loc, diag::err_opencl_half_load_store) << 1
14083 Diag(
Loc, diag::err_wasm_table_art) << 0;
14088 if (CompoundType.
isNull()) {
14106 Diag(
Loc, diag::err_objc_object_assignment) << LHSType;
14112 RHSCheck = ICE->getSubExpr();
14113 if (
UnaryOperator *UO = dyn_cast<UnaryOperator>(RHSCheck)) {
14114 if ((UO->getOpcode() == UO_Plus || UO->getOpcode() == UO_Minus) &&
14115 Loc.
isFileID() && UO->getOperatorLoc().isFileID() &&
14121 UO->getSubExpr()->getBeginLoc().
isFileID()) {
14122 Diag(
Loc, diag::warn_not_compound_assign)
14123 << (UO->getOpcode() == UO_Plus ?
"+" :
"-")
14124 <<
SourceRange(UO->getOperatorLoc(), UO->getOperatorLoc());
14134 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InnerLHS);
14173 if (CompoundType.
isNull()) {
14199 if (
const CastExpr *CE = dyn_cast<CastExpr>(
E)) {
14200 if (CE->getCastKind() == CK_ToVoid) {
14206 CE->getSubExpr()->getType()->isDependentType()) {
14211 if (
const auto *CE = dyn_cast<CallExpr>(
E))
14212 return CE->getCallReturnType(Context)->isVoidType();
14232 const unsigned ForIncrementFlags =
14238 if ((ScopeFlags & ForIncrementFlags) == ForIncrementFlags ||
14239 (ScopeFlags & ForInitFlags) == ForInitFlags)
14244 while (
const BinaryOperator *BO = dyn_cast<BinaryOperator>(LHS)) {
14245 if (BO->getOpcode() != BO_Comma)
14247 LHS = BO->getRHS();
14254 Diag(
Loc, diag::warn_comma_operator);
14258 LangOpts.CPlusPlus ?
"static_cast<void>("
14290 diag::err_incomplete_type);
14311 ResType = ResAtomicType->getValueType();
14313 assert(!ResType.
isNull() &&
"no type for increment/decrement expression");
14323 : diag::warn_increment_bool)
14327 S.
Diag(OpLoc, diag::err_increment_decrement_enum) << IsInc << ResType;
14343 S.
Diag(OpLoc, S.
getLangOpts().C2y ? diag::warn_c2y_compat_increment_complex
14344 : diag::ext_c2y_increment_complex)
14361 S.
Diag(OpLoc, diag::err_typecheck_illegal_increment_decrement)
14372 S.
Diag(OpLoc, diag::warn_deprecated_increment_decrement_volatile)
14373 << IsInc << ResType;
14405 case Stmt::DeclRefExprClass:
14406 return cast<DeclRefExpr>(
E)->getDecl();
14407 case Stmt::MemberExprClass:
14411 if (cast<MemberExpr>(
E)->isArrow())
14415 case Stmt::ArraySubscriptExprClass: {
14418 Expr*
Base = cast<ArraySubscriptExpr>(
E)->getBase();
14420 if (ICE->getSubExpr()->getType()->isArrayType())
14425 case Stmt::UnaryOperatorClass: {
14437 case Stmt::ParenExprClass:
14439 case Stmt::ImplicitCastExprClass:
14443 case Stmt::CXXUuidofExprClass:
14444 return cast<CXXUuidofExpr>(
E)->getGuidDecl();
14453 AO_Vector_Element = 1,
14454 AO_Property_Expansion = 2,
14455 AO_Register_Variable = 3,
14456 AO_Matrix_Element = 4,
14471 const auto *DRE = cast<DeclRefExpr>(Op->
IgnoreParens());
14474 return Diag(OpLoc, diag::err_parens_pointer_member_function)
14478 if (isa<CXXDestructorDecl>(MD))
14479 return Diag(OpLoc, diag::err_typecheck_addrof_dtor)
14480 << DRE->getSourceRange();
14482 if (DRE->getQualifier())
14486 return Diag(OpLoc, diag::err_unqualified_pointer_member_function)
14487 << DRE->getSourceRange();
14491 return Diag(OpLoc, diag::err_unqualified_pointer_member_function)
14492 << DRE->getSourceRange()
14498 if (PTy->getKind() == BuiltinType::Overload) {
14500 if (!isa<OverloadExpr>(
E)) {
14501 assert(cast<UnaryOperator>(
E)->getOpcode() == UO_AddrOf);
14502 Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof_addrof_function)
14508 if (isa<UnresolvedMemberExpr>(Ovl))
14510 Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
14518 if (PTy->getKind() == BuiltinType::UnknownAny)
14521 if (PTy->getKind() == BuiltinType::BoundMember) {
14522 Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
14545 auto* VarRef = dyn_cast<DeclRefExpr>(op);
14546 if (VarRef && VarRef->refersToEnclosingVariableOrCapture()) {
14547 Diag(op->
getExprLoc(), diag::err_opencl_taking_address_capture);
14555 if (uOp->getOpcode() == UO_Deref)
14558 return uOp->getSubExpr()->getType();
14565 if (
auto *FD = dyn_cast_or_null<FunctionDecl>(dcl))
14571 unsigned AddressOfError = AO_No_Error;
14576 : diag::ext_typecheck_addrof_temporary)
14583 }
else if (isa<ObjCSelectorExpr>(op)) {
14590 if (!isa<DeclRefExpr>(op)) {
14591 Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
14609 auto ReturnOrParamTypeIsIncomplete = [&](
QualType T,
14614 diag::note_ptrauth_virtual_function_pointer_incomplete_arg_ret);
14615 Diag(RetArgTypeLoc,
14616 diag::note_ptrauth_virtual_function_incomplete_arg_ret_type)
14623 bool IsIncomplete =
14625 ReturnOrParamTypeIsIncomplete(
14628 IsIncomplete |= ReturnOrParamTypeIsIncomplete(PVD->getType(), OpLoc,
14629 PVD->getBeginLoc());
14643 if (isa<PseudoObjectExpr>(op)) {
14644 AddressOfError = AO_Property_Expansion;
14646 Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof)
14650 }
else if (
const auto *DRE = dyn_cast<DeclRefExpr>(op)) {
14651 if (
const auto *MD = dyn_cast_or_null<CXXMethodDecl>(DRE->getDecl()))
14657 AddressOfError = AO_Bit_Field;
14660 AddressOfError = AO_Vector_Element;
14663 AddressOfError = AO_Matrix_Element;
14667 if (
const VarDecl *vd = dyn_cast<VarDecl>(dcl)) {
14672 AddressOfError = AO_Register_Variable;
14674 }
else if (isa<MSPropertyDecl>(dcl)) {
14675 AddressOfError = AO_Property_Expansion;
14676 }
else if (isa<FunctionTemplateDecl>(dcl)) {
14678 }
else if (isa<FieldDecl>(dcl) || isa<IndirectFieldDecl>(dcl)) {
14688 if (
auto *DRE = dyn_cast<DeclRefExpr>(op);
14689 DRE && DRE->getQualifier() && !isa<ParenExpr>(OrigOp.
get())) {
14691 if (Ctx && Ctx->isRecord()) {
14694 diag::err_cannot_form_pointer_to_member_of_reference_type)
14699 while (cast<RecordDecl>(Ctx)->isAnonymousStructOrUnion())
14700 Ctx = Ctx->getParent();
14703 op->
getType(), DRE->getQualifier(), cast<CXXRecordDecl>(Ctx));
14712 llvm_unreachable(
"Unknown/unexpected decl type");
14715 if (AddressOfError != AO_No_Error) {
14735 Diag(OpLoc, diag::err_wasm_ca_reference)
14740 Diag(OpLoc, diag::err_wasm_table_pr)
14746 CheckAddressOfPackedMember(op);
14752 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Exp);
14762 if (!FD->hasAttr<NonNullAttr>() && !Param->
hasAttr<NonNullAttr>())
14765 FD->ModifiedNonNullParams.insert(Param);
14771 bool IsAfterAmp =
false) {
14775 Op = ConvResult.
get();
14779 if (isa<CXXReinterpretCastExpr>(Op)) {
14787 Result = PT->getPointeeType();
14791 Result = OPT->getPointeeType();
14795 if (PR.
get() != Op)
14800 S.
Diag(OpLoc, diag::err_typecheck_indirection_requires_pointer)
14805 if (
Result->isVoidType()) {
14811 S.
Diag(OpLoc, diag::err_typecheck_indirection_through_void_pointer_cpp)
14814 S.
Diag(OpLoc, diag::ext_typecheck_indirection_through_void_pointer)
14831 default: llvm_unreachable(
"Unknown binop!");
14832 case tok::periodstar: Opc = BO_PtrMemD;
break;
14833 case tok::arrowstar: Opc = BO_PtrMemI;
break;
14834 case tok::star: Opc = BO_Mul;
break;
14835 case tok::slash: Opc = BO_Div;
break;
14836 case tok::percent: Opc = BO_Rem;
break;
14837 case tok::plus: Opc = BO_Add;
break;
14838 case tok::minus: Opc = BO_Sub;
break;
14839 case tok::lessless: Opc = BO_Shl;
break;
14840 case tok::greatergreater: Opc = BO_Shr;
break;
14841 case tok::lessequal: Opc = BO_LE;
break;
14842 case tok::less: Opc = BO_LT;
break;
14843 case tok::greaterequal: Opc = BO_GE;
break;
14844 case tok::greater: Opc = BO_GT;
break;
14845 case tok::exclaimequal: Opc = BO_NE;
break;
14846 case tok::equalequal: Opc = BO_EQ;
break;
14847 case tok::spaceship: Opc = BO_Cmp;
break;
14848 case tok::amp: Opc = BO_And;
break;
14849 case tok::caret: Opc = BO_Xor;
break;
14850 case tok::pipe: Opc = BO_Or;
break;
14851 case tok::ampamp: Opc = BO_LAnd;
break;
14852 case tok::pipepipe: Opc = BO_LOr;
break;
14853 case tok::equal: Opc = BO_Assign;
break;
14854 case tok::starequal: Opc = BO_MulAssign;
break;
14855 case tok::slashequal: Opc = BO_DivAssign;
break;
14856 case tok::percentequal: Opc = BO_RemAssign;
break;
14857 case tok::plusequal: Opc = BO_AddAssign;
break;
14858 case tok::minusequal: Opc = BO_SubAssign;
break;
14859 case tok::lesslessequal: Opc = BO_ShlAssign;
break;
14860 case tok::greatergreaterequal: Opc = BO_ShrAssign;
break;
14861 case tok::ampequal: Opc = BO_AndAssign;
break;
14862 case tok::caretequal: Opc = BO_XorAssign;
break;
14863 case tok::pipeequal: Opc = BO_OrAssign;
break;
14864 case tok::comma: Opc = BO_Comma;
break;
14873 default: llvm_unreachable(
"Unknown unary op!");
14874 case tok::plusplus: Opc = UO_PreInc;
break;
14875 case tok::minusminus: Opc = UO_PreDec;
break;
14876 case tok::amp: Opc = UO_AddrOf;
break;
14877 case tok::star: Opc = UO_Deref;
break;
14878 case tok::plus: Opc = UO_Plus;
break;
14879 case tok::minus: Opc = UO_Minus;
break;
14880 case tok::tilde: Opc = UO_Not;
break;
14881 case tok::exclaim: Opc = UO_LNot;
break;
14882 case tok::kw___real: Opc = UO_Real;
break;
14883 case tok::kw___imag: Opc = UO_Imag;
break;
14884 case tok::kw___extension__: Opc = UO_Extension;
break;
14900 if (!isa<ParmVarDecl>(SelfAssigned))
14916 llvm::find_if(
Parent->fields(),
14918 return F->getDeclName() == Name;
14920 return (Field !=
Parent->field_end()) ? *Field :
nullptr;
14935 const DeclRefExpr *LHSDeclRef = dyn_cast<DeclRefExpr>(LHSExpr);
14936 const DeclRefExpr *RHSDeclRef = dyn_cast<DeclRefExpr>(RHSExpr);
14937 if (!LHSDeclRef || !RHSDeclRef ||
14945 if (LHSDecl != RHSDecl)
14950 if (RefTy->getPointeeType().isVolatileQualified())
14953 auto Diag = S.
Diag(OpLoc, IsBuiltin ? diag::warn_self_assignment_builtin
14954 : diag::warn_self_assignment_overloaded)
14959 Diag << 1 << SelfAssignField
14972 const Expr *ObjCPointerExpr =
nullptr, *OtherExpr =
nullptr;
14977 ObjCPointerExpr = LHS;
14981 ObjCPointerExpr = RHS;
14989 if (ObjCPointerExpr && isa<IntegerLiteral>(OtherExpr->IgnoreParenCasts())) {
14990 unsigned Diag = diag::warn_objc_pointer_masking;
14998 StringRef SelArg0 = S.getNameForSlot(0);
14999 if (SelArg0.starts_with(
"performSelector"))
15000 Diag = diag::warn_objc_pointer_masking_performSelector;
15019 "Result must be a vector of half or short");
15022 "both operands expected to be a half vector");
15034 ResultTy,
VK, OK, OpLoc, FPFeatures,
15035 BinOpResTy, BinOpResTy);
15039 BinOpResTy,
VK, OK, OpLoc, FPFeatures);
15047 if (!OpRequiresConversion || Ctx.
getLangOpts().NativeHalfType ||
15051 auto HasVectorOfHalfType = [&Ctx](
Expr *
E) {
15061 return VT->getElementType().getCanonicalType() == Ctx.
HalfTy;
15066 return HasVectorOfHalfType(E0) && (!E1 || HasVectorOfHalfType(E1));
15071 Expr *RHSExpr,
bool ForFoldExpression) {
15085 if (
Init.isInvalid())
15087 RHSExpr =
Init.get();
15097 bool ConvertHalfVec =
false;
15099 if (!LHS.
isUsable() || !RHS.isUsable())
15109 if (BO_Assign == Opc)
15110 Diag(OpLoc, diag::err_opencl_atomic_init) << 0 << SR;
15138 if (!ResultTy.
isNull()) {
15155 if (
auto *BE = dyn_cast<BlockExpr>(RHS.get()->IgnoreParens()))
15157 if (
auto *VD = dyn_cast<VarDecl>(DRE->getDecl()))
15158 if (VD->hasLocalStorage() &&
getCurScope()->isDeclScope(VD))
15159 BE->getBlockDecl()->setCanAvoidCopyToHeap();
15170 Opc == BO_PtrMemI);
15174 ConvertHalfVec =
true;
15181 ConvertHalfVec =
true;
15185 ConvertHalfVec =
true;
15196 ConvertHalfVec =
true;
15199 if (
const auto *BI = dyn_cast<BinaryOperator>(LHSExpr);
15200 !ForFoldExpression && BI && BI->isComparisonOp())
15201 Diag(OpLoc, diag::warn_consecutive_comparison)
15207 ConvertHalfVec =
true;
15211 ConvertHalfVec =
true;
15224 ConvertHalfVec =
true;
15229 ConvertHalfVec =
true;
15231 CompLHSTy = CompResultTy;
15238 CompLHSTy = CompResultTy;
15244 ConvertHalfVec =
true;
15251 ConvertHalfVec =
true;
15260 CompLHSTy = CompResultTy;
15271 CompLHSTy = CompResultTy;
15279 VK = RHS.get()->getValueKind();
15280 OK = RHS.get()->getObjectKind();
15294 "both sides are half vectors or neither sides are");
15299 CheckArrayAccess(LHS.
get());
15300 CheckArrayAccess(RHS.get());
15306 if (ObjectSetClass && isa<ObjCIsaExpr>(LHS.
get())) {
15310 "object_setClass(")
15323 if (CompResultTy.
isNull()) {
15324 if (ConvertHalfVec)
15344 if (ConvertHalfVec)
15349 Context, LHS.
get(), RHS.get(), Opc, ResultTy,
VK, OK, OpLoc,
15366 if (isLeftComp == isRightComp)
15371 bool isLeftBitwise = LHSBO && LHSBO->
isBitwiseOp();
15372 bool isRightBitwise = RHSBO && RHSBO->
isBitwiseOp();
15373 if (isLeftBitwise || isRightBitwise)
15385 Self.Diag(OpLoc, diag::warn_precedence_bitwise_rel)
15388 Self.PDiag(diag::note_precedence_silence) << OpStr,
15389 (isLeftComp ? LHSExpr : RHSExpr)->getSourceRange());
15391 Self.PDiag(diag::note_precedence_bitwise_first)
15406 Self.PDiag(diag::note_precedence_silence)
15415 if (Bop->getOpcode() == BO_LAnd) {
15418 if (!isa<StringLiteral>(Bop->getLHS()->IgnoreParenImpCasts()))
15420 }
else if (Bop->getOpcode() == BO_LOr) {
15421 if (
BinaryOperator *RBop = dyn_cast<BinaryOperator>(Bop->getRHS())) {
15424 if (RBop->getOpcode() == BO_LAnd &&
15425 isa<StringLiteral>(RBop->getRHS()->IgnoreParenImpCasts()))
15436 if (Bop->getOpcode() == BO_LAnd) {
15439 if (!isa<StringLiteral>(Bop->getRHS()->IgnoreParenImpCasts()))
15451 if (Bop->isBitwiseOp() && Bop->getOpcode() < Opc) {
15452 S.
Diag(Bop->getOperatorLoc(), diag::warn_bitwise_op_in_bitwise_op)
15454 << Bop->getSourceRange() << OpLoc;
15456 S.
PDiag(diag::note_precedence_silence)
15457 << Bop->getOpcodeStr(),
15458 Bop->getSourceRange());
15464 Expr *SubExpr, StringRef Shift) {
15466 if (Bop->getOpcode() == BO_Add || Bop->getOpcode() == BO_Sub) {
15467 StringRef Op = Bop->getOpcodeStr();
15468 S.
Diag(Bop->getOperatorLoc(), diag::warn_addition_in_bitshift)
15469 << Bop->getSourceRange() << OpLoc << Shift << Op;
15471 S.
PDiag(diag::note_precedence_silence) << Op,
15472 Bop->getSourceRange());
15488 if (Kind != OO_LessLess && Kind != OO_GreaterGreater)
15491 S.
Diag(OpLoc, diag::warn_overloaded_shift_in_comparison)
15493 << (Kind == OO_LessLess);
15495 S.
PDiag(diag::note_precedence_silence)
15496 << (Kind == OO_LessLess ?
"<<" :
">>"),
15499 S, OpLoc, S.
PDiag(diag::note_evaluate_comparison_first),
15513 if ((Opc == BO_Or || Opc == BO_Xor) &&
15521 if (Opc == BO_LOr && !OpLoc.
isMacroID()) {
15527 || Opc == BO_Shr) {
15543 assert(LHSExpr &&
"ActOnBinOp(): missing left expression");
15544 assert(RHSExpr &&
"ActOnBinOp(): missing right expression");
15553 CheckInvalidBuiltinCountedByRef(LHSExpr, K);
15554 CheckInvalidBuiltinCountedByRef(RHSExpr, K);
15556 return BuildBinOp(S, TokLoc, Opc, LHSExpr, RHSExpr);
15562 if (OverOp !=
OO_None && OverOp != OO_Equal)
15611 Expr *RHSExpr,
bool ForFoldExpression) {
15612 if (!LHSExpr || !RHSExpr)
15624 if (pty->getKind() == BuiltinType::PseudoObject &&
15637 RHSExpr = resolvedRHS.
get();
15651 (pty->getKind() == BuiltinType::BoundMember ||
15652 pty->getKind() == BuiltinType::Overload)) {
15653 auto *OE = dyn_cast<OverloadExpr>(LHSExpr);
15654 if (OE && !OE->hasTemplateKeyword() && !OE->hasExplicitTemplateArgs() &&
15655 llvm::any_of(OE->decls(), [](
NamedDecl *ND) {
15656 return isa<FunctionTemplateDecl>(ND);
15658 Diag(OE->getQualifier() ? OE->getQualifierLoc().getBeginLoc()
15659 : OE->getNameLoc(),
15660 diag::err_template_kw_missing)
15661 << OE->getName().getAsIdentifierInfo();
15668 LHSExpr = LHS.
get();
15675 if (Opc == BO_Assign && pty->getKind() == BuiltinType::Overload) {
15682 ForFoldExpression);
15692 RHSExpr = resolvedRHS.
get();
15708 "Should only occur in error-recovery path.");
15714 Context, LHSExpr, RHSExpr, Opc,
15734 ResultType = RHSExpr->
getType();
15766 bool CanOverflow =
false;
15768 bool ConvertHalfVec =
false;
15777 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15784 if (Opc == UO_AddrOf)
15785 return ExprError(
Diag(OpLoc, diag::err_hlsl_operator_unsupported) << 0);
15786 if (Opc == UO_Deref)
15787 return ExprError(
Diag(OpLoc, diag::err_hlsl_operator_unsupported) << 1);
15801 Opc == UO_PreInc || Opc == UO_PostInc,
15802 Opc == UO_PreInc || Opc == UO_PreDec);
15807 CheckAddressOfNoDeref(InputExpr);
15820 CanOverflow = Opc == UO_Minus &&
15832 if (ConvertHalfVec)
15849 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15860 Diag(OpLoc, diag::ext_integer_complement_complex)
15869 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15872 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15894 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15910 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15920 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15930 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15937 return ExprError(
Diag(OpLoc, diag::err_typecheck_unary_expr)
15971 "the co_await expression must be non-dependant before "
15972 "building operator co_await");
15983 if (Opc != UO_AddrOf && Opc != UO_Deref)
15984 CheckArrayAccess(Input.
get());
15990 if (Opc == UO_Deref && UO->getType()->hasAttr(attr::NoDeref) &&
15991 !isa<ArrayType>(UO->getType().getDesugaredType(
Context)) &&
15996 if (ConvertHalfVec)
16003 if (!DRE->getQualifier())
16010 if (isa<FieldDecl>(VD) || isa<IndirectFieldDecl>(VD))
16013 return Method->isImplicitObjectMemberFunction();
16019 if (!ULE->getQualifier())
16024 if (
Method->isImplicitObjectMemberFunction())
16045 if (pty->getKind() == BuiltinType::PseudoObject &&
16050 if (Opc == UO_Extension)
16055 if (Opc == UO_AddrOf &&
16056 (pty->getKind() == BuiltinType::Overload ||
16057 pty->getKind() == BuiltinType::UnknownAny ||
16058 pty->getKind() == BuiltinType::BoundMember))
16083 Expr *Input,
bool IsAfterAmp) {
16122 assert(SubStmt && isa<CompoundStmt>(SubStmt) &&
"Invalid action invocation!");
16128 "cleanups within StmtExpr not correctly bound!");
16138 bool StmtExprMayBindToTemp =
false;
16141 if (
const auto *LastStmt =
16143 if (
const Expr *
Value = LastStmt->getExprStmt()) {
16144 StmtExprMayBindToTemp =
true;
16152 Expr *ResStmtExpr =
16154 if (StmtExprMayBindToTemp)
16156 return ResStmtExpr;
16179 auto *Cast = dyn_cast<ImplicitCastExpr>(
E);
16180 if (Cast && Cast->getCastKind() == CK_ARCConsumeObject)
16181 return Cast->getSubExpr();
16202 return ExprError(
Diag(BuiltinLoc, diag::err_offsetof_record_type)
16203 << ArgTy << TypeRange);
16209 diag::err_offsetof_incomplete_type, TypeRange))
16212 bool DidWarnAboutNonPOD =
false;
16217 if (OC.isBrackets) {
16222 return ExprError(
Diag(OC.LocEnd, diag::err_offsetof_array_type)
16242 Comps.push_back(
OffsetOfNode(OC.LocStart, Exprs.size(), OC.LocEnd));
16243 Exprs.push_back(Idx);
16251 Comps.push_back(
OffsetOfNode(OC.LocStart, OC.U.IdentInfo, OC.LocEnd));
16258 diag::err_offsetof_incomplete_type))
16264 return ExprError(
Diag(OC.LocEnd, diag::err_offsetof_record_type)
16275 bool IsSafe =
LangOpts.CPlusPlus11? CRD->isStandardLayout() : CRD->isPOD();
16277 LangOpts.CPlusPlus11? diag::ext_offsetof_non_standardlayout_type
16278 : diag::ext_offsetof_non_pod_type;
16281 Diag(BuiltinLoc, DiagID)
16282 <<
SourceRange(Components[0].LocStart, OC.LocEnd) << CurrentType;
16283 DidWarnAboutNonPOD =
true;
16294 MemberDecl = IndirectMemberDecl->getAnonField();
16302 Diag(BuiltinLoc, diag::err_no_member)
16303 << OC.U.IdentInfo << RD <<
SourceRange(OC.LocStart, OC.LocEnd);
16312 Diag(OC.LocEnd, diag::err_offsetof_bitfield)
16320 if (IndirectMemberDecl)
16321 Parent = cast<RecordDecl>(IndirectMemberDecl->getDeclContext());
16328 if (Paths.getDetectedVirtual()) {
16329 Diag(OC.LocEnd, diag::err_offsetof_field_of_virtual_base)
16340 if (IndirectMemberDecl) {
16341 for (
auto *FI : IndirectMemberDecl->chain()) {
16342 assert(isa<FieldDecl>(FI));
16344 cast<FieldDecl>(FI), OC.LocEnd));
16347 Comps.push_back(
OffsetOfNode(OC.LocStart, MemberDecl, OC.LocEnd));
16353 Comps, Exprs, RParenLoc);
16379 assert((CondExpr && LHSExpr && RHSExpr) &&
"Missing type argument(s)");
16384 bool CondIsTrue =
false;
16389 llvm::APSInt condEval(32);
16391 CondExpr, &condEval, diag::err_typecheck_choose_expr_requires_constant);
16394 CondExpr = CondICE.
get();
16395 CondIsTrue = condEval.getZExtValue();
16398 Expr *ActiveExpr = CondIsTrue ? LHSExpr : RHSExpr;
16400 resType = ActiveExpr->
getType();
16406 resType,
VK, OK, RPLoc, CondIsTrue);
16418 Decl *ManglingContextDecl;
16419 std::tie(MCtx, ManglingContextDecl) =
16423 Block->setBlockMangling(ManglingNumber, ManglingContextDecl);
16445 "block-id should have no identifier!");
16457 "GetTypeForDeclarator made a non-function block signature");
16473 unsigned Size =
Result.getFullDataSize();
16485 QualType RetTy = Fn->getReturnType();
16487 (isa<FunctionProtoType>(Fn) && cast<FunctionProtoType>(Fn)->isVariadic());
16503 if (ExplicitSignature) {
16504 for (
unsigned I = 0,
E = ExplicitSignature.
getNumParams(); I !=
E; ++I) {
16512 Params.push_back(Param);
16518 for (
const auto &I : Fn->param_types()) {
16521 Params.push_back(Param);
16526 if (!Params.empty()) {
16537 AI->setOwningFunction(CurBlock->
TheDecl);
16540 if (AI->getIdentifier()) {
16546 if (AI->isInvalidDecl())
16565 Diag(CaretLoc, diag::err_blocks_disable) <<
LangOpts.OpenCL;
16571 "cleanups within block not correctly bound!");
16586 bool NoReturn = BD->
hasAttr<NoReturnAttr>();
16594 if (NoReturn && !Ext.getNoReturn()) Ext = Ext.
withNoReturn(
true);
16597 if (isa<FunctionNoProtoType>(FTy)) {
16632 BD->
setBody(cast<CompoundStmt>(Body));
16634 if (Body &&
getCurFunction()->HasPotentialAvailabilityViolations)
16660 Expr *CopyExpr =
nullptr;
16668 if (isa<ParmVarDecl>(Var))
16687 if (!
Result.isInvalid() &&
16688 !
Result.get()->getType().isConstQualified()) {
16690 Result.get()->getType().withConst(),
16694 if (!
Result.isInvalid()) {
16704 if (!
Result.isInvalid() &&
16705 !cast<CXXConstructExpr>(
Result.get())->getConstructor()
16708 CopyExpr =
Result.get();
16715 Captures.push_back(NewCap);
16729 if (
Result->getBlockDecl()->hasCaptures()) {
16736 for (
const auto &CI :
Result->getBlockDecl()->captures()) {
16737 const VarDecl *var = CI.getVariable();
16752 {Result},
Result->getType());
16766 Expr *OrigExpr =
E;
16816 if (
Init.isInvalid())
16832 diag::err_first_argument_to_va_arg_not_of_type_va_list)
16837 diag::err_second_parameter_to_va_arg_incomplete,
16843 diag::err_second_parameter_to_va_arg_abstract,
16850 ? diag::warn_second_parameter_to_va_arg_ownership_qualified
16851 : diag::warn_second_parameter_to_va_arg_not_pod)
16858 PDiag(diag::warn_second_parameter_to_va_arg_array)
16891 UnderlyingType = ED->getIntegerType();
16914 if (!PromoteType.
isNull())
16916 PDiag(diag::warn_second_parameter_to_va_arg_never_compatible)
16938 llvm_unreachable(
"I don't know size of pointer!");
16955 if ((SLDecl->isCompleteDefinition() || SLDecl->isBeingDefined()) &&
16964 S.
Diag(
Loc, diag::err_std_source_location_impl_not_found);
16972 S.
Diag(
Loc, diag::err_std_source_location_impl_malformed);
16976 unsigned Count = 0;
16978 StringRef Name = F->getName();
16980 if (Name ==
"_M_file_name") {
16981 if (F->getType() !=
16985 }
else if (Name ==
"_M_function_name") {
16986 if (F->getType() !=
16990 }
else if (Name ==
"_M_line") {
16991 if (!F->getType()->isIntegerType())
16994 }
else if (Name ==
"_M_column") {
16995 if (!F->getType()->isIntegerType())
17004 S.
Diag(
Loc, diag::err_std_source_location_impl_malformed);
17055 Data->BinaryData = BinaryData;
17059 Data->getDataElementCount());
17063 const Expr *SrcExpr) {
17072 auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl());
17085 bool *Complained) {
17087 *Complained =
false;
17090 bool CheckInferredResultType =
false;
17092 unsigned DiagKind = 0;
17094 bool MayHaveConvFixit =
false;
17095 bool MayHaveFunctionDiff =
false;
17106 DiagKind = diag::warn_compatible_implicit_pointer_conv;
17110 DiagKind = diag::err_typecheck_convert_pointer_int;
17113 DiagKind = diag::ext_typecheck_convert_pointer_int;
17116 MayHaveConvFixit =
true;
17120 DiagKind = diag::err_typecheck_convert_int_pointer;
17123 DiagKind = diag::ext_typecheck_convert_int_pointer;
17126 MayHaveConvFixit =
true;
17130 diag::warn_typecheck_convert_incompatible_function_pointer_strict;
17132 MayHaveConvFixit =
true;
17136 DiagKind = diag::err_typecheck_convert_incompatible_function_pointer;
17139 DiagKind = diag::ext_typecheck_convert_incompatible_function_pointer;
17142 MayHaveConvFixit =
true;
17146 DiagKind = diag::err_arc_typecheck_convert_incompatible_pointer;
17148 DiagKind = diag::err_typecheck_convert_incompatible_pointer;
17151 DiagKind = diag::ext_typecheck_convert_incompatible_pointer;
17155 if (CheckInferredResultType) {
17161 MayHaveConvFixit =
true;
17165 DiagKind = diag::err_typecheck_convert_incompatible_pointer_sign;
17168 DiagKind = diag::ext_typecheck_convert_incompatible_pointer_sign;
17173 DiagKind = diag::err_typecheck_convert_pointer_void_func;
17176 DiagKind = diag::ext_typecheck_convert_pointer_void_func;
17188 DiagKind = diag::err_typecheck_incompatible_address_space;
17191 DiagKind = diag::err_typecheck_incompatible_ownership;
17194 DiagKind = diag::err_typecheck_incompatible_ptrauth;
17198 llvm_unreachable(
"unknown error case for discarding qualifiers!");
17215 DiagKind = diag::err_typecheck_convert_discards_qualifiers;
17218 DiagKind = diag::ext_typecheck_convert_discards_qualifiers;
17225 DiagKind = diag::err_nested_pointer_qualifier_mismatch;
17227 DiagKind = diag::ext_nested_pointer_qualifier_mismatch;
17231 DiagKind = diag::err_typecheck_incompatible_nested_address_space;
17235 DiagKind = diag::err_int_to_block_pointer;
17239 DiagKind = diag::err_typecheck_convert_incompatible_block_pointer;
17246 for (
auto *srcProto : srcOPT->
quals()) {
17252 IFace = IFaceT->getDecl();
17257 for (
auto *dstProto : dstOPT->
quals()) {
17263 IFace = IFaceT->getDecl();
17266 DiagKind = diag::err_incompatible_qualified_id;
17269 DiagKind = diag::warn_incompatible_qualified_id;
17275 DiagKind = diag::err_incompatible_vectors;
17278 DiagKind = diag::warn_incompatible_vectors;
17282 DiagKind = diag::err_arc_weak_unavailable_assign;
17288 *Complained =
true;
17292 DiagKind = diag::err_typecheck_convert_incompatible;
17294 MayHaveConvFixit =
true;
17296 MayHaveFunctionDiff =
true;
17305 FirstType = DstType;
17306 SecondType = SrcType;
17316 FirstType = SrcType;
17317 SecondType = DstType;
17326 FDiag << FirstType << SecondType << ActionForDiag
17329 if (DiagKind == diag::ext_typecheck_convert_incompatible_pointer_sign ||
17330 DiagKind == diag::err_typecheck_convert_incompatible_pointer_sign) {
17340 if (!ConvHints.
isNull()) {
17345 if (MayHaveConvFixit) { FDiag << (
unsigned) (ConvHints.
Kind); }
17347 if (MayHaveFunctionDiff)
17351 if ((DiagKind == diag::warn_incompatible_qualified_id ||
17352 DiagKind == diag::err_incompatible_qualified_id) &&
17354 Diag(IFace->
getLocation(), diag::note_incomplete_class_and_qualified_id)
17361 if (CheckInferredResultType)
17369 *Complained =
true;
17380 return S.
Diag(
Loc, diag::err_ice_not_integral)
17399 IDDiagnoser(
unsigned DiagID)
17405 } Diagnoser(DiagID);
17440 BaseDiagnoser(BaseDiagnoser) {}
17449 return S.
Diag(
Loc, diag::err_ice_incomplete_type) <<
T;
17454 return S.
Diag(
Loc, diag::err_ice_explicit_conversion) <<
T << ConvTy;
17465 return S.
Diag(
Loc, diag::err_ice_ambiguous_conversion) <<
T;
17476 llvm_unreachable(
"conversion functions are permitted");
17478 } ConvertDiagnoser(Diagnoser);
17484 E = Converted.
get();
17489 if (isa<RecoveryExpr>(
E))
17505 E = RValueExpr.
get();
17513 if (!isa<ConstantExpr>(
E))
17523 if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
17524 diag::note_invalid_subexpr_in_const_expr) {
17525 DiagLoc = Notes[0].first;
17547 EvalResult.
Diag = &Notes;
17556 if (!isa<ConstantExpr>(
E))
17562 if (Folded &&
getLangOpts().CPlusPlus11 && Notes.empty()) {
17571 if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
17572 diag::note_invalid_subexpr_in_const_expr) {
17573 DiagLoc = Notes[0].first;
17599 class TransformToPE :
public TreeTransform<TransformToPE> {
17603 TransformToPE(
Sema &SemaRef) : BaseTransform(SemaRef) { }
17606 bool AlwaysRebuild() {
return true; }
17607 bool ReplacingOriginal() {
return true; }
17617 if (isa<FieldDecl>(
E->getDecl()) &&
17618 !SemaRef.isUnevaluatedContext())
17619 return SemaRef.Diag(
E->getLocation(),
17620 diag::err_invalid_non_static_member_use)
17623 return BaseTransform::TransformDeclRefExpr(
E);
17631 return BaseTransform::TransformUnaryOperator(
E);
17639 return SkipLambdaBody(
E, Body);
17646 "Should only transform unevaluated expressions");
17651 return TransformToPE(*this).TransformExpr(
E);
17656 "Should only transform unevaluated expressions");
17660 return TransformToPE(*this).TransformType(TInfo);
17668 LambdaContextDecl, ExprContext);
17682 Prev.isImmediateFunctionContext() || Prev.isConstantEvaluated();
17685 Prev.InImmediateEscalatingFunctionContext;
17714 Current.InDiscardedStatement =
false;
17726 Current.InImmediateEscalatingFunctionContext =
17730 Current.InImmediateFunctionContext =
17733 Parent.isImmediateFunctionContext()));
17735 Current.InImmediateFunctionContext = FD->
isConsteval();
17743 if (
const auto *
E = dyn_cast<UnaryOperator>(PossibleDeref)) {
17744 if (
E->getOpcode() == UO_Deref)
17745 return CheckPossibleDeref(S,
E->getSubExpr());
17746 }
else if (
const auto *
E = dyn_cast<ArraySubscriptExpr>(PossibleDeref)) {
17747 return CheckPossibleDeref(S,
E->getBase());
17748 }
else if (
const auto *
E = dyn_cast<MemberExpr>(PossibleDeref)) {
17749 return CheckPossibleDeref(S,
E->getBase());
17750 }
else if (
const auto E = dyn_cast<DeclRefExpr>(PossibleDeref)) {
17754 Inner = Ptr->getPointeeType();
17756 Inner = Arr->getElementType();
17760 if (Inner->hasAttr(attr::NoDeref))
17770 const DeclRefExpr *DeclRef = CheckPossibleDeref(*
this,
E);
17777 Diag(
E->
getExprLoc(), diag::warn_dereference_of_noderef_type_no_decl)
17792 if (BO->getOpcode() == BO_Assign) {
17794 llvm::erase(LHSs, BO->getLHS());
17802 "Cannot mark an immediate escalating expression outside of an "
17803 "immediate escalating context");
17806 if (
auto *DeclRef =
17807 dyn_cast<DeclRefExpr>(
Call->getCallee()->IgnoreImplicit()))
17808 DeclRef->setIsImmediateEscalating(
true);
17809 }
else if (
auto *Ctr = dyn_cast<CXXConstructExpr>(
E->
IgnoreImplicit())) {
17810 Ctr->setIsImmediateEscalating(
true);
17811 }
else if (
auto *DeclRef = dyn_cast<DeclRefExpr>(
E->
IgnoreImplicit())) {
17812 DeclRef->setIsImmediateEscalating(
true);
17814 assert(
false &&
"expected an immediately escalating expression");
17817 FI->FoundImmediateEscalatingExpression =
true;
17832 if (
auto *DeclRef =
17833 dyn_cast<DeclRefExpr>(
Call->getCallee()->IgnoreImplicit()))
17842 auto CheckConstantExpressionAndKeepResult = [&]() {
17845 Eval.
Diag = &Notes;
17847 Eval,
getASTContext(), ConstantExprKind::ImmediateInvocation);
17848 if (Res && Notes.empty()) {
17849 Cached = std::move(Eval.
Val);
17857 !CheckConstantExpressionAndKeepResult()) {
17892 ExprEvalContexts.back().ImmediateInvocationCandidates.emplace_back(Res, 0);
17900 Eval.
Diag = &Notes;
17904 if (!
Result || !Notes.empty()) {
17907 if (
auto *
FunctionalCast = dyn_cast<CXXFunctionalCastExpr>(InnerExpr))
17910 if (
auto *
Call = dyn_cast<CallExpr>(InnerExpr))
17911 FD = cast<FunctionDecl>(
Call->getCalleeDecl());
17912 else if (
auto *
Call = dyn_cast<CXXConstructExpr>(InnerExpr))
17913 FD =
Call->getConstructor();
17914 else if (
auto *Cast = dyn_cast<CastExpr>(InnerExpr))
17915 FD = dyn_cast_or_null<FunctionDecl>(Cast->getConversionFunction());
17918 "could not find an immediate function in this expression");
17931 for (
auto &
Note : Notes)
17943 llvm::SmallPtrSetImpl<DeclRefExpr *> &DRSet;
17947 ComplexRemove(
Sema &SemaRef, llvm::SmallPtrSetImpl<DeclRefExpr *> &DR,
17950 4>::reverse_iterator Current)
17951 :
Base(SemaRef), DRSet(DR), IISet(II), CurrentII(Current) {}
17953 auto It = std::find_if(CurrentII, IISet.rend(),
17955 return Elem.getPointer() == E;
17961 if (It == IISet.rend()) {
17963 CurrentII->setInt(1);
17969 if (!
E->isImmediateInvocation())
17970 return Base::TransformConstantExpr(
E);
17971 RemoveImmediateInvocation(
E);
17972 return Base::TransformExpr(
E->getSubExpr());
17978 return Base::TransformCXXOperatorCallExpr(
E);
17992 if (
auto *ICE = dyn_cast<ImplicitCastExpr>(
Init))
17993 Init = ICE->getSubExpr();
17994 else if (
auto *ICE = dyn_cast<MaterializeTemporaryExpr>(
Init))
17995 Init = ICE->getSubExpr();
18001 if (
auto *CE = dyn_cast<ConstantExpr>(
Init);
18002 CE && CE->isImmediateInvocation())
18003 RemoveImmediateInvocation(CE);
18004 return Base::TransformInitializer(
Init, NotCopyInit);
18015 bool AlwaysRebuild() {
return false; }
18016 bool ReplacingOriginal() {
return true; }
18017 bool AllowSkippingCXXConstructExpr() {
18018 bool Res = AllowSkippingFirstCXXConstructExpr;
18019 AllowSkippingFirstCXXConstructExpr =
true;
18022 bool AllowSkippingFirstCXXConstructExpr =
true;
18032 if (isa<CXXConstructExpr>(It->getPointer()->IgnoreImplicit()))
18033 Transformer.AllowSkippingFirstCXXConstructExpr =
false;
18035 ExprResult Res = Transformer.TransformExpr(It->getPointer()->getSubExpr());
18041 It->getPointer()->setSubExpr(Res.
get());
18062 VD->hasConstantInitialization()) {
18095 llvm::SmallPtrSetImpl<DeclRefExpr *> &DRSet;
18096 SimpleRemove(llvm::SmallPtrSetImpl<DeclRefExpr *> &S) : DRSet(S) {}
18099 return DRSet.size();
18102 Visitor.TraverseStmt(
18112 if (DR->isImmediateEscalating())
18114 auto *FD = cast<FunctionDecl>(DR->getDecl());
18116 if (
const auto *MD = dyn_cast<CXXMethodDecl>(ND);
18118 ND = MD->getParent();
18125 bool ImmediateEscalating =
false;
18126 bool IsPotentiallyEvaluated =
18136 SemaRef.
Diag(DR->getBeginLoc(), diag::err_invalid_consteval_take_address)
18137 << ND << isa<CXXRecordDecl>(ND) << FD->isConsteval();
18138 if (!FD->getBuiltinID())
18146 if (FD->isImmediateEscalating() && !FD->isConsteval())
18160 (Rec.
ExprContext == ExpressionKind::EK_TemplateArgument ||
18168 D = diag::err_lambda_unevaluated_operand;
18174 D = diag::err_lambda_in_constant_expression;
18175 }
else if (Rec.
ExprContext == ExpressionKind::EK_TemplateArgument) {
18178 D = diag::err_lambda_in_invalid_context;
18180 llvm_unreachable(
"Couldn't infer lambda error message.");
18182 for (
const auto *L : Rec.
Lambdas)
18183 Diag(L->getBeginLoc(),
D);
18203 Diag(BO->getBeginLoc(), diag::warn_deprecated_simple_assign_volatile)
18274 llvm_unreachable(
"Invalid context");
18320 : FD(FD), Param(Param) {}
18327 CCName =
"stdcall";
18330 CCName =
"fastcall";
18333 CCName =
"vectorcall";
18336 llvm_unreachable(
"CC does not need mangling");
18339 S.
Diag(
Loc, diag::err_cconv_incomplete_param_type)
18345 ParamIncompleteTypeDiagnoser Diagnoser(FD, Param);
18351enum class OdrUseContext {
18371 return OdrUseContext::None;
18374 return OdrUseContext::Dependent;
18376 if (
Context.isDiscardedStatementContext())
18377 return OdrUseContext::FormallyOdrUsed;
18381 return OdrUseContext::FormallyOdrUsed;
18383 return OdrUseContext::Used;
18387 if (!
Func->isConstexpr())
18390 if (
Func->isImplicitlyInstantiable() || !
Func->isUserProvided())
18397 auto *CCD = dyn_cast<CXXConstructorDecl>(
Func);
18398 return CCD && CCD->getInheritedConstructor();
18402 bool MightBeOdrUse) {
18403 assert(
Func &&
"No function?");
18405 Func->setReferenced();
18418 OdrUseContext OdrUse =
18420 if (IsRecursiveCall && OdrUse == OdrUseContext::Used)
18421 OdrUse = OdrUseContext::FormallyOdrUsed;
18425 if (
Func->isTrivial() && !
Func->hasAttr<DLLExportAttr>() &&
18426 OdrUse == OdrUseContext::Used) {
18429 OdrUse = OdrUseContext::FormallyOdrUsed;
18430 if (isa<CXXDestructorDecl>(
Func))
18431 OdrUse = OdrUseContext::FormallyOdrUsed;
18438 bool NeededForConstantEvaluation =
18463 bool NeedDefinition =
18464 !IsRecursiveCall &&
18465 (OdrUse == OdrUseContext::Used ||
18466 (NeededForConstantEvaluation && !
Func->isPureVirtual()));
18473 if (NeedDefinition &&
18475 Func->getMemberSpecializationInfo()))
18482 if (NeedDefinition && !
Func->getBody()) {
18485 dyn_cast<CXXConstructorDecl>(
Func)) {
18498 }
else if (
Constructor->getInheritedConstructor()) {
18502 dyn_cast<CXXDestructorDecl>(
Func)) {
18512 if (MethodDecl->isOverloadedOperator() &&
18513 MethodDecl->getOverloadedOperator() == OO_Equal) {
18514 MethodDecl = cast<CXXMethodDecl>(MethodDecl->getFirstDecl());
18515 if (MethodDecl->isDefaulted() && !MethodDecl->isDeleted()) {
18516 if (MethodDecl->isCopyAssignmentOperator())
18518 else if (MethodDecl->isMoveAssignmentOperator())
18521 }
else if (isa<CXXConversionDecl>(MethodDecl) &&
18522 MethodDecl->getParent()->isLambda()) {
18524 cast<CXXConversionDecl>(MethodDecl->getFirstDecl());
18529 }
else if (MethodDecl->isVirtual() &&
getLangOpts().AppleKext)
18533 if (
Func->isDefaulted() && !
Func->isDeleted()) {
18541 if (
Func->isImplicitlyInstantiable()) {
18543 Func->getTemplateSpecializationKindForInstantiation();
18545 bool FirstInstantiation = PointOfInstantiation.
isInvalid();
18546 if (FirstInstantiation) {
18547 PointOfInstantiation =
Loc;
18548 if (
auto *MSI =
Func->getMemberSpecializationInfo())
18549 MSI->setPointOfInstantiation(
Loc);
18552 Func->setTemplateSpecializationKind(TSK, PointOfInstantiation);
18557 PointOfInstantiation =
Loc;
18561 Func->isConstexpr()) {
18562 if (isa<CXXRecordDecl>(
Func->getDeclContext()) &&
18563 cast<CXXRecordDecl>(
Func->getDeclContext())->isLocalClass() &&
18566 std::make_pair(
Func, PointOfInstantiation));
18567 else if (
Func->isConstexpr())
18573 Func->setInstantiationIsPending(
true);
18575 std::make_pair(
Func, PointOfInstantiation));
18576 if (llvm::isTimeTraceVerbose()) {
18577 llvm::timeTraceAddInstantEvent(
"DeferInstantiation", [&] {
18579 llvm::raw_string_ostream
OS(Name);
18591 for (
auto *i :
Func->redecls()) {
18592 if (!i->isUsed(
false) && i->isImplicitlyInstantiable())
18610 if (
Init->isInClassMemberInitializer())
18612 MarkDeclarationsReferencedInExpr(Init->getInit());
18633 if (
LangOpts.OffloadImplicitHostDeviceTemplates &&
LangOpts.CUDAIsDevice &&
18638 if (OdrUse == OdrUseContext::Used && !
Func->isUsed(
false)) {
18640 if (!
Func->isDefined() && !
Func->isInAnotherModuleUnit()) {
18641 if (mightHaveNonExternalLinkage(
Func))
18643 else if (
Func->getMostRecentDecl()->isInlined() &&
18645 !
Func->getMostRecentDecl()->hasAttr<GNUInlineAttr>())
18664 if (
auto *Dtor = dyn_cast<CXXDestructorDecl>(
Func)) {
18666 if (
Parent->getNumVBases() > 0 && !Dtor->getBody())
18684 const unsigned *
const FunctionScopeIndexToStopAt =
nullptr) {
18687 VarDecl *Var =
V->getPotentiallyDecomposedVarDecl();
18688 assert(Var &&
"expected a capturable variable");
18698 QualType CaptureType, DeclRefType;
18704 DeclRefType, FunctionScopeIndexToStopAt);
18719 << 2 << 1 << Var << UserTarget;
18722 ? diag::note_cuda_const_var_unpromoted
18723 : diag::note_cuda_host_var);
18726 !Var->
hasAttr<CUDASharedAttr>() &&
18742 (!FD || (!FD->getDescribedFunctionTemplate() &&
18754 unsigned CapturingScopeIndex) {
18766 if (isa<ParmVarDecl>(var) &&
18767 isa<TranslationUnitDecl>(VarDC))
18780 unsigned ValueKind = isa<BindingDecl>(var) ? 1 : 0;
18781 unsigned ContextKind = 3;
18782 if (isa<CXXMethodDecl>(VarDC) &&
18783 cast<CXXRecordDecl>(VarDC->
getParent())->isLambda()) {
18785 }
else if (isa<FunctionDecl>(VarDC)) {
18787 }
else if (isa<BlockDecl>(VarDC)) {
18791 S.
Diag(loc, diag::err_reference_to_local_in_enclosing_context)
18792 << var << ValueKind << ContextKind << VarDC;
18793 S.
Diag(var->getLocation(), diag::note_entity_declared_at)
18802 bool &SubCapturesAreNested,
18808 SubCapturesAreNested =
true;
18825 !(isa<LambdaScopeInfo>(CSI) &&
18826 !cast<LambdaScopeInfo>(CSI)->lambdaCaptureShouldBeConst()) &&
18827 !(isa<CapturedRegionScopeInfo>(CSI) &&
18828 cast<CapturedRegionScopeInfo>(CSI)->CapRegionKind ==
CR_OpenMP))
18860 assert((isa<VarDecl, BindingDecl>(Var)) &&
18861 "Only variables and structured bindings can be captured");
18863 bool IsBlock = isa<BlockScopeInfo>(CSI);
18864 bool IsLambda = isa<LambdaScopeInfo>(CSI);
18872 S.
Diag(
Loc, diag::err_lambda_capture_anonymous_var);
18881 S.
Diag(
Loc, diag::err_ref_vm_type);
18892 S.
Diag(
Loc, diag::err_ref_flexarray_type);
18894 S.
Diag(
Loc, diag::err_lambda_capture_flexarray_type) << Var;
18899 const bool HasBlocksAttr = Var->
hasAttr<BlocksAttr>();
18902 if (HasBlocksAttr && (IsLambda || isa<CapturedRegionScopeInfo>(CSI))) {
18904 S.
Diag(
Loc, diag::err_capture_block_variable) << Var << !IsLambda;
18913 S.
Diag(
Loc, diag::err_opencl_block_ref_block);
18917 if (isa<BindingDecl>(Var)) {
18924 ? diag::warn_cxx17_compat_capture_binding
18925 : diag::ext_capture_binding)
18939 bool ByRef =
false;
18945 if (BuildAndDiagnose) {
18946 S.
Diag(
Loc, diag::err_ref_array_type);
18957 if (BuildAndDiagnose) {
18958 S.
Diag(
Loc, diag::err_arc_autoreleasing_capture)
18974 if (BuildAndDiagnose) {
18976 S.
Diag(
Loc, diag::warn_block_capture_autoreleasing);
18977 S.
Diag(VarLoc, diag::note_declare_parameter_strong);
18982 const bool HasBlocksAttr = Var->
hasAttr<BlocksAttr>();
18991 DeclRefType = CaptureType;
18995 if (BuildAndDiagnose)
19005 const bool BuildAndDiagnose,
QualType &CaptureType,
QualType &DeclRefType,
19006 const bool RefersToCapturedVariable,
TryCaptureKind Kind,
bool IsTopScope,
19032 CaptureType = DeclRefType;
19035 if (BuildAndDiagnose)
19036 RSI->
addCapture(Var,
false, ByRef, RefersToCapturedVariable,
19046 const bool RefersToCapturedVariable,
19051 bool ByRef =
false;
19055 ByRef = (LSI->
ImpCaptureStyle == LambdaScopeInfo::ImpCap_LambdaByref);
19060 S.
Diag(
Loc, diag::err_wasm_ca_reference) << 0;
19091 if (!RefType->getPointeeType()->isFunctionType())
19098 if (BuildAndDiagnose) {
19099 S.
Diag(
Loc, diag::err_arc_autoreleasing_capture) << 1;
19109 if (!
Invalid && BuildAndDiagnose) {
19113 diag::err_capture_of_incomplete_or_sizeless_type,
19117 diag::err_capture_of_abstract_type))
19143 if (BuildAndDiagnose)
19144 LSI->
addCapture(Var,
false, ByRef, RefersToCapturedVariable,
19156 if (
T.isTriviallyCopyableType(
Context))
19160 if (!(RD = RD->getDefinition()))
19162 if (RD->hasSimpleCopyConstructor())
19164 if (RD->hasUserDeclaredCopyConstructor())
19166 if (Ctor->isCopyConstructor())
19167 return !Ctor->isDeleted();
19187 if (ShouldOfferCopyFix) {
19191 FixBuffer.assign({Separator, Var->
getName()});
19192 Sema.
Diag(VarInsertLoc, diag::note_lambda_variable_capture_fixit)
19197 FixBuffer.assign({Separator,
"&", Var->
getName()});
19198 Sema.
Diag(VarInsertLoc, diag::note_lambda_variable_capture_fixit)
19210 return !C.isThisCapture() && !C.isInitCapture();
19219 if (ShouldOfferCopyFix) {
19220 bool CanDefaultCopyCapture =
true;
19229 if (CanDefaultCopyCapture && llvm::none_of(LSI->
Captures, [](
Capture &
C) {
19230 return !C.isThisCapture() && !C.isInitCapture() && C.isCopyCapture();
19232 FixBuffer.assign({
"=", Separator});
19233 Sema.
Diag(DefaultInsertLoc, diag::note_lambda_default_capture_fixit)
19242 return !C.isInitCapture() && C.isReferenceCapture() &&
19243 !C.isThisCapture();
19245 FixBuffer.assign({
"&", Separator});
19246 Sema.
Diag(DefaultInsertLoc, diag::note_lambda_default_capture_fixit)
19255 QualType &DeclRefType,
const unsigned *
const FunctionScopeIndexToStopAt) {
19278 const auto *VD = dyn_cast<VarDecl>(Var);
19280 if (VD->isInitCapture())
19285 assert(VD &&
"Cannot capture a null variable");
19287 const unsigned MaxFunctionScopesIndex = FunctionScopeIndexToStopAt
19291 if (FunctionScopeIndexToStopAt) {
19292 assert(!
FunctionScopes.empty() &&
"No function scopes to stop at?");
19297 if (
auto *LSI = dyn_cast<LambdaScopeInfo>(
FunctionScopes[FSIndex]);
19298 FSIndex && LSI && !LSI->AfterParameterList)
19300 assert(MaxFunctionScopesIndex <= FSIndex &&
19301 "FunctionScopeIndexToStopAt should be no greater than FSIndex into "
19302 "FunctionScopes.");
19303 while (FSIndex != MaxFunctionScopesIndex) {
19311 bool IsGlobal = !VD->hasLocalStorage();
19312 if (IsGlobal && !(
LangOpts.OpenMP &&
19313 OpenMP().isOpenMPCapturedDecl(Var,
true,
19314 MaxFunctionScopesIndex)))
19317 if (isa<VarDecl>(Var))
19328 CaptureType = Var->
getType();
19330 bool Nested =
false;
19332 unsigned FunctionScopesIndex = MaxFunctionScopesIndex;
19337 LSI = dyn_cast_or_null<LambdaScopeInfo>(
19340 bool IsInScopeDeclarationContext =
19351 if (IsInScopeDeclarationContext &&
19352 FunctionScopesIndex == MaxFunctionScopesIndex && VarDC == DC)
19358 !IsInScopeDeclarationContext
19361 BuildAndDiagnose, *
this);
19367 FunctionScopesIndex = MaxFunctionScopesIndex - 1;
19386 if (
const auto *Parm = dyn_cast<ParmVarDecl>(Var);
19387 Parm && Parm->getDeclContext() == DC)
19395 if (BuildAndDiagnose) {
19398 Diag(ExprLoc, diag::err_lambda_impcap) << Var;
19413 if (
ParmVarDecl *PVD = dyn_cast_or_null<ParmVarDecl>(Var))
19414 QTy = PVD->getOriginalType();
19419 if (
auto *RSI = dyn_cast<CapturedRegionScopeInfo>(CSI)) {
19425 if (isa<BindingDecl>(Var)) {
19426 if (BuildAndDiagnose) {
19427 Diag(ExprLoc, diag::err_capture_binding_openmp) << Var;
19433 Var, RSI->OpenMPLevel, RSI->OpenMPCaptureLevel);
19438 if (IsOpenMPPrivateDecl != OMPC_unknown &&
19441 if (
ParmVarDecl *PVD = dyn_cast_or_null<ParmVarDecl>(Var))
19442 QTy = PVD->getOriginalType();
19444 E =
OpenMP().getNumberOfConstructScopes(RSI->OpenMPLevel);
19446 auto *OuterRSI = cast<CapturedRegionScopeInfo>(
19448 assert(RSI->OpenMPLevel == OuterRSI->OpenMPLevel &&
19449 "Wrong number of captured regions associated with the "
19450 "OpenMP construct.");
19455 IsOpenMPPrivateDecl != OMPC_private &&
19457 RSI->OpenMPCaptureLevel);
19461 Var, RSI->OpenMPLevel, RSI->OpenMPCaptureLevel);
19467 OpenMP().adjustOpenMPTargetScopeIndex(FunctionScopesIndex,
19470 if (IsTargetCap || IsOpenMPPrivateDecl == OMPC_private ||
19471 (IsGlobal && !IsGlobalCap)) {
19472 Nested = !IsTargetCap;
19487 if (BuildAndDiagnose) {
19488 Diag(ExprLoc, diag::err_lambda_impcap) << Var;
19490 auto *LSI = cast<LambdaScopeInfo>(CSI);
19510 FunctionScopesIndex--;
19511 if (IsInScopeDeclarationContext)
19513 }
while (!VarDC->
Equals(DC));
19521 for (
unsigned I = ++FunctionScopesIndex, N = MaxFunctionScopesIndex + 1; I != N;
19534 if (
Invalid && !BuildAndDiagnose)
19539 DeclRefType, Nested, *
this,
Invalid);
19543 RSI, Var, ExprLoc, BuildAndDiagnose, CaptureType, DeclRefType, Nested,
19544 Kind, I == N - 1, *
this,
Invalid);
19550 DeclRefType, Nested, Kind, EllipsisLoc,
19555 if (
Invalid && !BuildAndDiagnose)
19567 DeclRefType,
nullptr);
19575 false, CaptureType, DeclRefType,
nullptr);
19579 assert(Var &&
"Null value cannot be captured");
19586 false, CaptureType, DeclRefType,
19590 return DeclRefType;
19598class CopiedTemplateArgs {
19602 template<
typename RefExpr>
19603 CopiedTemplateArgs(RefExpr *
E) : HasArgs(
E->hasExplicitTemplateArgs()) {
19605 E->copyTemplateArgumentsInto(TemplateArgStorage);
19608#ifdef __has_cpp_attribute
19609#
if __has_cpp_attribute(clang::lifetimebound)
19610 [[clang::lifetimebound]]
19614 return HasArgs ? &TemplateArgStorage :
nullptr;
19640 auto Rebuild = [&](
Expr *Sub) {
19645 auto IsPotentialResultOdrUsed = [&](
NamedDecl *
D) {
19648 auto *VD = dyn_cast<VarDecl>(
D);
19671 llvm_unreachable(
"unexpected non-odr-use-reason");
19675 if (VD->getType()->isReferenceType())
19677 if (
auto *RD = VD->getType()->getAsCXXRecordDecl())
19678 if (RD->hasDefinition() && RD->hasMutableFields())
19680 if (!VD->isUsableInConstantExpressions(S.
Context))
19685 if (VD->getType()->isReferenceType())
19693 auto MaybeCUDAODRUsed = [&]() ->
bool {
19699 auto *DRE = dyn_cast<DeclRefExpr>(
E);
19702 auto *VD = dyn_cast<VarDecl>(DRE->getDecl());
19709 auto MarkNotOdrUsed = [&] {
19710 if (!MaybeCUDAODRUsed()) {
19713 LSI->markVariableExprAsNonODRUsed(
E);
19721 case Expr::DeclRefExprClass: {
19722 auto *DRE = cast<DeclRefExpr>(
E);
19723 if (DRE->isNonOdrUse() || IsPotentialResultOdrUsed(DRE->getDecl()))
19729 S.
Context, DRE->getQualifierLoc(), DRE->getTemplateKeywordLoc(),
19730 DRE->getDecl(), DRE->refersToEnclosingVariableOrCapture(),
19731 DRE->getNameInfo(), DRE->getType(), DRE->getValueKind(),
19732 DRE->getFoundDecl(), CopiedTemplateArgs(DRE), NOUR);
19735 case Expr::FunctionParmPackExprClass: {
19736 auto *FPPE = cast<FunctionParmPackExpr>(
E);
19740 if (IsPotentialResultOdrUsed(
D))
19751 case Expr::ArraySubscriptExprClass: {
19752 auto *ASE = cast<ArraySubscriptExpr>(
E);
19757 if (!
Base.isUsable())
19759 Expr *LHS = ASE->getBase() == ASE->getLHS() ?
Base.get() : ASE->getLHS();
19760 Expr *RHS = ASE->getBase() == ASE->getRHS() ?
Base.get() : ASE->getRHS();
19763 ASE->getRBracketLoc());
19766 case Expr::MemberExprClass: {
19767 auto *ME = cast<MemberExpr>(
E);
19770 if (isa<FieldDecl>(ME->getMemberDecl())) {
19772 if (!
Base.isUsable())
19775 S.
Context,
Base.get(), ME->isArrow(), ME->getOperatorLoc(),
19776 ME->getQualifierLoc(), ME->getTemplateKeywordLoc(),
19777 ME->getMemberDecl(), ME->getFoundDecl(), ME->getMemberNameInfo(),
19778 CopiedTemplateArgs(ME), ME->getType(), ME->getValueKind(),
19779 ME->getObjectKind(), ME->isNonOdrUse());
19782 if (ME->getMemberDecl()->isCXXInstanceMember())
19787 if (ME->isNonOdrUse() || IsPotentialResultOdrUsed(ME->getMemberDecl()))
19793 S.
Context, ME->getBase(), ME->isArrow(), ME->getOperatorLoc(),
19794 ME->getQualifierLoc(), ME->getTemplateKeywordLoc(), ME->getMemberDecl(),
19795 ME->getFoundDecl(), ME->getMemberNameInfo(), CopiedTemplateArgs(ME),
19796 ME->getType(), ME->getValueKind(), ME->getObjectKind(), NOUR);
19799 case Expr::BinaryOperatorClass: {
19800 auto *BO = cast<BinaryOperator>(
E);
19801 Expr *LHS = BO->getLHS();
19802 Expr *RHS = BO->getRHS();
19804 if (BO->getOpcode() == BO_PtrMemD) {
19806 if (!Sub.isUsable())
19808 BO->setLHS(Sub.get());
19810 }
else if (BO->getOpcode() == BO_Comma) {
19812 if (!Sub.isUsable())
19814 BO->setRHS(Sub.get());
19822 case Expr::ParenExprClass: {
19823 auto *PE = cast<ParenExpr>(
E);
19825 if (!Sub.isUsable())
19827 return S.
ActOnParenExpr(PE->getLParen(), PE->getRParen(), Sub.get());
19832 case Expr::ConditionalOperatorClass: {
19833 auto *CO = cast<ConditionalOperator>(
E);
19843 LHS = CO->getLHS();
19845 RHS = CO->getRHS();
19847 CO->getCond(), LHS.
get(), RHS.
get());
19852 case Expr::UnaryOperatorClass: {
19853 auto *UO = cast<UnaryOperator>(
E);
19854 if (UO->getOpcode() != UO_Extension)
19857 if (!Sub.isUsable())
19859 return S.
BuildUnaryOp(
nullptr, UO->getOperatorLoc(), UO_Extension,
19866 case Expr::GenericSelectionExprClass: {
19867 auto *GSE = cast<GenericSelectionExpr>(
E);
19870 bool AnyChanged =
false;
19871 for (
Expr *OrigAssocExpr : GSE->getAssocExprs()) {
19872 ExprResult AssocExpr = Rebuild(OrigAssocExpr);
19876 AssocExprs.push_back(AssocExpr.
get());
19879 AssocExprs.push_back(OrigAssocExpr);
19883 void *ExOrTy =
nullptr;
19884 bool IsExpr = GSE->isExprPredicate();
19886 ExOrTy = GSE->getControllingExpr();
19888 ExOrTy = GSE->getControllingType();
19890 GSE->getGenericLoc(), GSE->getDefaultLoc(),
19891 GSE->getRParenLoc(), IsExpr, ExOrTy,
19892 GSE->getAssocTypeSourceInfos(), AssocExprs)
19900 case Expr::ChooseExprClass: {
19901 auto *CE = cast<ChooseExpr>(
E);
19911 if (!LHS.
get() && !RHS.
get())
19914 LHS = CE->getLHS();
19916 RHS = CE->getRHS();
19919 RHS.
get(), CE->getRParenLoc());
19923 case Expr::ConstantExprClass: {
19924 auto *CE = cast<ConstantExpr>(
E);
19926 if (!Sub.isUsable())
19933 case Expr::ImplicitCastExprClass: {
19934 auto *ICE = cast<ImplicitCastExpr>(
E);
19938 switch (ICE->getCastKind()) {
19940 case CK_DerivedToBase:
19941 case CK_UncheckedDerivedToBase: {
19942 ExprResult Sub = Rebuild(ICE->getSubExpr());
19943 if (!Sub.isUsable())
19947 ICE->getValueKind(), &
Path);
20004 for (
Expr *
E : LocalMaybeODRUseExprs) {
20005 if (
auto *DRE = dyn_cast<DeclRefExpr>(
E)) {
20007 DRE->getLocation(), *
this);
20008 }
else if (
auto *ME = dyn_cast<MemberExpr>(
E)) {
20011 }
else if (
auto *FP = dyn_cast<FunctionParmPackExpr>(
E)) {
20015 llvm_unreachable(
"Unexpected expression");
20020 "MarkVarDeclODRUsed failed to cleanup MaybeODRUseExprs?");
20029 const bool RefersToEnclosingScope =
20032 if (RefersToEnclosingScope) {
20047 assert(
E &&
"Capture variable should be used in an expression.");
20058 assert((!
E || isa<DeclRefExpr>(
E) || isa<MemberExpr>(
E) ||
20059 isa<FunctionParmPackExpr>(
E)) &&
20060 "Invalid Expr argument to DoMarkVarDeclReferenced");
20071 bool UsableInConstantExpr =
20083 bool NeededForConstantEvaluation =
20086 bool NeedDefinition =
20087 OdrUse == OdrUseContext::Used || NeededForConstantEvaluation;
20089 assert(!isa<VarTemplatePartialSpecializationDecl>(Var) &&
20090 "Can't instantiate a partial template specialization.");
20096 !isa<VarTemplateSpecializationDecl>(Var))
20107 bool TryInstantiating =
20111 if (TryInstantiating) {
20114 bool FirstInstantiation = PointOfInstantiation.
isInvalid();
20115 if (FirstInstantiation) {
20116 PointOfInstantiation =
Loc;
20118 MSI->setPointOfInstantiation(PointOfInstantiation);
20140 if (
auto *DRE = dyn_cast_or_null<DeclRefExpr>(
E))
20141 DRE->setDecl(DRE->getDecl());
20142 else if (
auto *ME = dyn_cast_or_null<MemberExpr>(
E))
20143 ME->setMemberDecl(ME->getMemberDecl());
20144 }
else if (FirstInstantiation) {
20146 .push_back(std::make_pair(Var, PointOfInstantiation));
20148 bool Inserted =
false;
20150 auto Iter = llvm::find_if(
20152 return P.first == Var;
20154 if (
Iter != I.end()) {
20167 if (isa<VarTemplateSpecializationDecl>(Var) && !Inserted)
20169 .push_back(std::make_pair(Var, PointOfInstantiation));
20193 if (
DeclRefExpr *DRE = dyn_cast_or_null<DeclRefExpr>(
E))
20194 if (DRE->isNonOdrUse())
20196 if (
MemberExpr *ME = dyn_cast_or_null<MemberExpr>(
E))
20197 if (ME->isNonOdrUse())
20201 case OdrUseContext::None:
20204 assert((!
E || isa<FunctionParmPackExpr>(
E) ||
20206 "missing non-odr-use marking for unevaluated decl ref");
20209 case OdrUseContext::FormallyOdrUsed:
20214 case OdrUseContext::Used:
20223 case OdrUseContext::Dependent:
20241 if (OdrUse == OdrUseContext::Used) {
20242 QualType CaptureType, DeclRefType;
20248 }
else if (OdrUse == OdrUseContext::Dependent) {
20264 auto *ID = dyn_cast<DeclRefExpr>(
E);
20265 if (!ID || ID->isTypeDependent() || !ID->refersToEnclosingVariableOrCapture())
20272 auto IsDependent = [&]() {
20274 auto *LSI = dyn_cast<sema::LambdaScopeInfo>(
Scope);
20279 LSI->AfterParameterList)
20282 const auto *MD = LSI->CallOperator;
20283 if (MD->getType().isNull())
20287 if (!Ty || !MD->isExplicitObjectMemberFunction() ||
20291 if (
auto *
C = LSI->CaptureMap.count(
D) ? &LSI->getCapture(
D) :
nullptr) {
20292 if (
C->isCopyCapture())
20297 if (LSI->ImpCaptureStyle == LambdaScopeInfo::ImpCap_LambdaByval)
20303 ID->setCapturedByCopyInLambdaWithExplicitObjectParameter(
20309 bool MightBeOdrUse,
20317 if (
VarDecl *Var = dyn_cast<VarDecl>(
D)) {
20343 bool IsVirtualCall = MD->
isVirtual() &&
20345 if (!IsVirtualCall)
20362 bool OdrUse =
true;
20364 if (
Method->isVirtual() &&
20368 if (
auto *FD = dyn_cast<FunctionDecl>(
E->getDecl())) {
20373 !FD->isDependentContext())
20387 bool MightBeOdrUse =
true;
20390 if (
Method->isPureVirtual())
20391 MightBeOdrUse =
false;
20394 E->getMemberLoc().isValid() ?
E->getMemberLoc() :
E->
getBeginLoc();
20410 bool MightBeOdrUse) {
20411 if (MightBeOdrUse) {
20412 if (
auto *VD = dyn_cast<VarDecl>(
D)) {
20417 if (
auto *FD = dyn_cast<FunctionDecl>(
D)) {
20443bool MarkReferencedDecls::TraverseTemplateArgument(
20461 MarkReferencedDecls Marker(*
this,
Loc);
20462 Marker.TraverseType(
T);
20468class EvaluatedExprMarker :
public UsedDeclVisitor<EvaluatedExprMarker> {
20471 bool SkipLocalVariables;
20474 EvaluatedExprMarker(
Sema &S,
bool SkipLocalVariables,
20476 : Inherited(S), SkipLocalVariables(SkipLocalVariables), StopAt(StopAt) {}
20482 void Visit(
Expr *
E) {
20483 if (llvm::is_contained(StopAt,
E))
20485 Inherited::Visit(
E);
20495 if (SkipLocalVariables) {
20496 if (
VarDecl *VD = dyn_cast<VarDecl>(
E->getDecl()))
20497 if (VD->hasLocalStorage())
20509 Visit(
E->getBase());
20515 bool SkipLocalVariables,
20517 EvaluatedExprMarker(*
this, SkipLocalVariables, StopAt).Visit(
E);
20539 if (
auto *VD = dyn_cast_or_null<VarDecl>(
20541 if (VD->isConstexpr() ||
20542 (VD->isStaticDataMember() && VD->isFirstDecl() && !VD->isInline()))
20615 class CallReturnIncompleteDiagnoser :
public TypeDiagnoser {
20621 : FD(FD), CE(CE) { }
20625 S.
Diag(
Loc, diag::err_call_incomplete_return)
20630 S.
Diag(
Loc, diag::err_call_function_incomplete_return)
20635 } Diagnoser(FD, CE);
20648 unsigned diagnostic = diag::warn_condition_is_assignment;
20649 bool IsOrAssign =
false;
20652 if (Op->getOpcode() != BO_Assign && Op->getOpcode() != BO_OrAssign)
20655 IsOrAssign = Op->getOpcode() == BO_OrAssign;
20663 if (
ObjC().isSelfExpr(Op->getLHS()) && ME->getMethodFamily() ==
OMF_init)
20664 diagnostic = diag::warn_condition_is_idiomatic_assignment;
20668 diagnostic = diag::warn_condition_is_idiomatic_assignment;
20671 Loc = Op->getOperatorLoc();
20673 if (Op->getOperator() != OO_Equal && Op->getOperator() != OO_PipeEqual)
20676 IsOrAssign = Op->getOperator() == OO_PipeEqual;
20677 Loc = Op->getOperatorLoc();
20689 Diag(
Loc, diag::note_condition_assign_silence)
20694 Diag(
Loc, diag::note_condition_or_assign_to_comparison)
20697 Diag(
Loc, diag::note_condition_assign_to_comparison)
20715 if (opE->getOpcode() == BO_EQ &&
20716 opE->getLHS()->IgnoreParenImpCasts()->isModifiableLvalue(
Context)
20722 Diag(
Loc, diag::note_equality_comparison_silence)
20725 Diag(
Loc, diag::note_equality_comparison_to_assign)
20731 bool IsConstexpr) {
20733 if (
ParenExpr *parenE = dyn_cast<ParenExpr>(
E))
20751 Diag(
Loc, diag::err_typecheck_statement_requires_scalar)
20755 CheckBoolLikeConversion(
E,
Loc);
20789 }
else if (Cond.
isUsable() && !isa<FullExpr>(Cond.
get()))
20802 struct RebuildUnknownAnyFunction
20803 :
StmtVisitor<RebuildUnknownAnyFunction, ExprResult> {
20807 RebuildUnknownAnyFunction(
Sema &S) : S(S) {}
20810 llvm_unreachable(
"unexpected statement!");
20821 template <
class T>
ExprResult rebuildSugarExpr(
T *
E) {
20825 Expr *SubExpr = SubResult.
get();
20826 E->setSubExpr(SubExpr);
20834 return rebuildSugarExpr(
E);
20838 return rebuildSugarExpr(
E);
20845 Expr *SubExpr = SubResult.
get();
20846 E->setSubExpr(SubExpr);
20854 if (!isa<FunctionDecl>(VD))
return VisitExpr(
E);
20860 !(isa<CXXMethodDecl>(VD) &&
20861 cast<CXXMethodDecl>(VD)->isInstance()))
20868 return resolveDecl(
E,
E->getMemberDecl());
20872 return resolveDecl(
E,
E->getDecl());
20890 struct RebuildUnknownAnyExpr
20891 :
StmtVisitor<RebuildUnknownAnyExpr, ExprResult> {
20902 llvm_unreachable(
"unexpected statement!");
20916 template <
class T>
ExprResult rebuildSugarExpr(
T *
E) {
20919 Expr *SubExpr = SubResult.
get();
20920 E->setSubExpr(SubExpr);
20928 return rebuildSugarExpr(
E);
20932 return rebuildSugarExpr(
E);
20938 S.
Diag(
E->getOperatorLoc(), diag::err_unknown_any_addrof)
20943 if (isa<CallExpr>(
E->getSubExpr())) {
20944 S.
Diag(
E->getOperatorLoc(), diag::err_unknown_any_addrof_call)
20957 E->setSubExpr(SubResult.
get());
20966 return resolveDecl(
E,
E->getMemberDecl());
20970 return resolveDecl(
E,
E->getDecl());
20977 Expr *CalleeExpr =
E->getCallee();
20981 FK_FunctionPointer,
20988 assert(isa<CXXMemberCallExpr>(
E) || isa<CXXOperatorCallExpr>(
E));
20989 Kind = FK_MemberFunction;
20993 Kind = FK_FunctionPointer;
20996 Kind = FK_BlockPointer;
21003 unsigned diagID = diag::err_func_returning_array_function;
21004 if (Kind == FK_BlockPointer)
21005 diagID = diag::err_block_returning_array_function;
21041 if (ParamTypes.empty() && Proto->
isVariadic()) {
21042 ArgTypes.reserve(
E->getNumArgs());
21043 for (
unsigned i = 0, e =
E->getNumArgs(); i != e; ++i) {
21046 ParamTypes = ArgTypes;
21057 case FK_MemberFunction:
21061 case FK_FunctionPointer:
21065 case FK_BlockPointer:
21071 ExprResult CalleeResult = Visit(CalleeExpr);
21073 E->setCallee(CalleeResult.
get());
21090 Method->setReturnType(DestType);
21102 if (
E->getCastKind() == CK_FunctionToPointerDecay) {
21116 }
else if (
E->getCastKind() == CK_LValueToRValue) {
21120 assert(isa<BlockPointerType>(
E->
getType()));
21133 llvm_unreachable(
"Unhandled cast type!");
21166 if (DRE && Proto && Proto->getParamTypes().empty() && Proto->isVariadic()) {
21170 FD->getNameInfo().getName(), DestType, FD->getTypeSourceInfo(),
21172 false , FD->hasPrototype(),
21175 if (FD->getQualifier())
21179 for (
const auto &AI : FT->param_types()) {
21183 Params.push_back(Param);
21185 NewFD->setParams(Params);
21192 if (MD->isInstance()) {
21202 }
else if (isa<VarDecl>(VD)) {
21232 diag::err_typecheck_cast_to_incomplete))
21247 return RebuildUnknownAnyExpr(*
this, ToType).Visit(
E);
21254 ExplicitCastExpr *castArg = dyn_cast<ExplicitCastExpr>(arg->IgnoreParens());
21263 assert(!arg->hasPlaceholderType());
21275 unsigned diagID = diag::err_uncasted_use_of_unknown_any;
21278 if (
CallExpr *call = dyn_cast<CallExpr>(
E)) {
21279 E = call->getCallee();
21280 diagID = diag::err_uncasted_call_of_unknown_any;
21289 loc = ref->getLocation();
21290 d = ref->getDecl();
21291 }
else if (
MemberExpr *mem = dyn_cast<MemberExpr>(
E)) {
21292 loc = mem->getMemberLoc();
21293 d = mem->getMemberDecl();
21295 diagID = diag::err_uncasted_call_of_unknown_any;
21296 loc = msg->getSelectorStartLoc();
21297 d = msg->getMethodDecl();
21299 S.
Diag(loc, diag::err_uncasted_send_to_unknown_any_method)
21300 <<
static_cast<unsigned>(msg->isClassMessage()) << msg->getSelector()
21318 if (!placeholderType)
return E;
21320 switch (placeholderType->
getKind()) {
21321 case BuiltinType::UnresolvedTemplate: {
21322 auto *ULE = cast<UnresolvedLookupExpr>(
E);
21327 const bool IsTypeAliasTemplateDecl = isa<TypeAliasTemplateDecl>(Temp);
21334 if (
auto *TD = dyn_cast<TemplateDecl>(Temp))
21340 Diag(NameInfo.
getLoc(), diag::err_template_kw_refers_to_type_template)
21341 << TN << ULE->getSourceRange() << IsTypeAliasTemplateDecl;
21343 << IsTypeAliasTemplateDecl;
21346 bool HasAnyDependentTA =
false;
21348 HasAnyDependentTA |= Arg.getArgument().
isDependent();
21368 case BuiltinType::Overload: {
21388 case BuiltinType::BoundMember: {
21393 if (isa<CXXPseudoDestructorExpr>(BME)) {
21394 PD =
PDiag(diag::err_dtor_expr_without_call) << 1;
21395 }
else if (
const auto *ME = dyn_cast<MemberExpr>(BME)) {
21396 if (ME->getMemberNameInfo().getName().getNameKind() ==
21398 PD =
PDiag(diag::err_dtor_expr_without_call) << 0;
21406 case BuiltinType::ARCUnbridgedCast: {
21413 case BuiltinType::UnknownAny:
21417 case BuiltinType::PseudoObject:
21420 case BuiltinType::BuiltinFn: {
21424 auto *FD = cast<FunctionDecl>(DRE->
getDecl());
21425 unsigned BuiltinID = FD->getBuiltinID();
21426 if (BuiltinID == Builtin::BI__noop) {
21428 CK_BuiltinFnToFnPtr)
21441 ? diag::err_use_of_unaddressable_function
21442 : diag::warn_cxx20_compat_use_of_unaddressable_function);
21443 if (FD->isImplicitlyInstantiable()) {
21470 case BuiltinType::IncompleteMatrixIdx:
21474 diag::err_matrix_incomplete_index);
21478 case BuiltinType::ArraySection:
21480 << cast<ArraySectionExpr>(
E)->isOMPArraySection();
21484 case BuiltinType::OMPArrayShaping:
21487 case BuiltinType::OMPIterator:
21491#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
21492 case BuiltinType::Id:
21493#include "clang/Basic/OpenCLImageTypes.def"
21494#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
21495 case BuiltinType::Id:
21496#include "clang/Basic/OpenCLExtensionTypes.def"
21497#define SVE_TYPE(Name, Id, SingletonId) \
21498 case BuiltinType::Id:
21499#include "clang/Basic/AArch64ACLETypes.def"
21500#define PPC_VECTOR_TYPE(Name, Id, Size) \
21501 case BuiltinType::Id:
21502#include "clang/Basic/PPCTypes.def"
21503#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
21504#include "clang/Basic/RISCVVTypes.def"
21505#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
21506#include "clang/Basic/WebAssemblyReferenceTypes.def"
21507#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) case BuiltinType::Id:
21508#include "clang/Basic/AMDGPUTypes.def"
21509#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
21510#include "clang/Basic/HLSLIntangibleTypes.def"
21511#define BUILTIN_TYPE(Id, SingletonId) case BuiltinType::Id:
21512#define PLACEHOLDER_TYPE(Id, SingletonId)
21513#include "clang/AST/BuiltinTypes.def"
21517 llvm_unreachable(
"invalid placeholder type!");
Defines the clang::ASTContext interface.
This file provides some common utility functions for processing Lambda related AST Constructs.
static bool isObjCPointer(const MemRegion *R)
Defines enum values for all the target-independent builtin functions.
Defines the C++ template declaration subclasses.
static DeclT * getDefinitionOrSelf(DeclT *D)
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 functions specific to ARM.
This file declares semantic analysis for CUDA constructs.
static void DetectPrecisionLossInComplexDivision(Sema &S, QualType DivisorTy, SourceLocation OpLoc)
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 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 void diagnoseUncapturableValueReferenceOrBinding(Sema &S, SourceLocation loc, ValueDecl *var)
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 AssignConvertType checkObjCPointerTypesForAssignment(Sema &S, QualType LHSType, QualType RHSType)
checkObjCPointerTypesForAssignment - Compares two objective-c pointer types for assignment compatibil...
static void diagnoseObjCLiteralComparison(Sema &S, SourceLocation Loc, ExprResult &LHS, ExprResult &RHS, BinaryOperator::Opcode Opc)
static bool isParenthetizedAndQualifiedAddressOfExpr(Expr *Fn)
static bool isCapturingReferenceToHostVarInCUDADeviceLambda(const Sema &S, VarDecl *VD)
static UnaryOperatorKind ConvertTokenKindToUnaryOpcode(tok::TokenKind Kind)
static 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 AssignConvertType checkBlockPointerTypesForAssignment(Sema &S, QualType LHSType, QualType RHSType)
checkBlockPointerTypesForAssignment - This routine determines whether two block pointer types are com...
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 bool MayBeFunctionType(const ASTContext &Context, const Expr *E)
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 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 CheckUnicodeArithmeticConversions(Sema &SemaRef, Expr *LHS, Expr *RHS, SourceLocation Loc, ArithConvKind ACK)
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 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 bool captureInLambda(LambdaScopeInfo *LSI, ValueDecl *Var, SourceLocation Loc, const bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType, const bool RefersToCapturedVariable, const TryCaptureKind Kind, SourceLocation EllipsisLoc, const bool IsTopScope, Sema &S, bool Invalid)
Capture the given variable in the lambda.
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 AssignConvertType checkPointerTypesForAssignment(Sema &S, QualType LHSType, QualType RHSType, SourceLocation Loc)
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 void diagnoseScopedEnums(Sema &S, const SourceLocation Loc, const ExprResult &LHS, const ExprResult &RHS, BinaryOperatorKind Opc)
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 void CheckSufficientAllocSize(Sema &S, QualType DestType, const Expr *E)
Check that a call to alloc_size function specifies sufficient space for the destination type.
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 FieldDecl * FindFieldDeclInstantiationPattern(const ASTContext &Ctx, FieldDecl *Field)
ExprResult PerformCastFn(Sema &S, Expr *operand, QualType toType)
static void checkArithmeticNull(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompare)
static bool IsReadonlyMessage(Expr *E, Sema &S)
static std::optional< bool > isTautologicalBoundsCheck(Sema &S, const Expr *LHS, const Expr *RHS, BinaryOperatorKind Opc)
Detect patterns ptr + size >= ptr and ptr + size < ptr, where ptr is a pointer and size is an unsigne...
static void buildLambdaCaptureFixit(Sema &Sema, LambdaScopeInfo *LSI, ValueDecl *Var)
Create up to 4 fix-its for explicit reference and value capture of Var or default capture.
static void tryImplicitlyCaptureThisIfImplicitMemberFunctionAccessWithDependentArgs(Sema &S, const UnresolvedMemberExpr *const UME, SourceLocation CallLoc)
static bool checkPtrAuthTypeDiscriminatorOperandType(Sema &S, QualType T, SourceLocation Loc, SourceRange ArgRange)
static 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 diagnosePointerIncompatibility(Sema &S, SourceLocation Loc, Expr *LHSExpr, Expr *RHSExpr)
Emit error when two pointers are incompatible.
static bool captureInCapturedRegion(CapturedRegionScopeInfo *RSI, ValueDecl *Var, SourceLocation Loc, const bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType, const bool RefersToCapturedVariable, TryCaptureKind Kind, bool IsTopScope, Sema &S, bool Invalid)
Capture the given variable in the captured region.
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 void checkObjCPointerIntrospection(Sema &S, ExprResult &L, ExprResult &R, SourceLocation OpLoc)
Check if a bitwise-& is performed on an Objective-C pointer.
static void DiagnoseDirectIsaAccess(Sema &S, const ObjCIvarRefExpr *OIRE, SourceLocation AssignLoc, const Expr *RHS)
static ExprResult rebuildUnknownAnyFunction(Sema &S, Expr *fn)
Given a function expression of unknown-any type, try to rebuild it to have a function type.
static QualType handleIntToFloatConversion(Sema &S, ExprResult &FloatExpr, ExprResult &IntExpr, QualType FloatTy, QualType IntTy, bool ConvertFloat, bool ConvertInt)
Handle arithmetic conversion from integer to float.
static bool hasIsEqualMethod(Sema &S, const Expr *LHS, const Expr *RHS)
static QualType handleComplexFloatConversion(Sema &S, ExprResult &Shorter, QualType ShorterType, QualType LongerType, bool PromotePrecision)
static FunctionDecl * rewriteBuiltinFunctionDecl(Sema *Sema, ASTContext &Context, FunctionDecl *FDecl, MultiExprArg ArgExprs)
If a builtin function has a pointer argument with no explicit address space, then it should be able t...
static void DoMarkBindingDeclReferenced(Sema &SemaRef, SourceLocation Loc, BindingDecl *BD, Expr *E)
static PredefinedIdentKind getPredefinedExprKind(tok::TokenKind Kind)
static void DiagnoseUnusedOfDecl(Sema &S, NamedDecl *D, SourceLocation Loc)
static QualType handleFixedPointConversion(Sema &S, QualType LHSTy, QualType RHSTy)
handleFixedPointConversion - Fixed point operations between fixed point types and integers or other f...
static QualType handleComplexConversion(Sema &S, ExprResult &LHS, ExprResult &RHS, QualType LHSType, QualType RHSType, bool IsCompAssign)
Handle arithmetic conversion with complex types.
static QualType CheckCommaOperands(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc)
static bool canCaptureVariableByCopy(ValueDecl *Var, const ASTContext &Context)
static void diagnoseArithmeticOnTwoVoidPointers(Sema &S, SourceLocation Loc, Expr *LHSExpr, Expr *RHSExpr)
Diagnose invalid arithmetic on two void pointers.
static void diagnoseDistinctPointerComparison(Sema &S, SourceLocation Loc, ExprResult &LHS, ExprResult &RHS, bool IsError)
Diagnose bad pointer comparisons.
static bool needsConversionOfHalfVec(bool OpRequiresConversion, ASTContext &Ctx, Expr *E0, Expr *E1=nullptr)
Returns true if conversion between vectors of halfs and vectors of floats is needed.
static bool isObjCObjectLiteral(ExprResult &E)
static NonConstCaptureKind isReferenceToNonConstCapture(Sema &S, Expr *E)
static QualType checkConditionalBlockPointerCompatibility(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc)
Return the resulting type when the operands are both block pointers.
static void DiagnoseShiftCompare(Sema &S, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr)
static void DiagnoseAdditionInShift(Sema &S, SourceLocation OpLoc, Expr *SubExpr, StringRef Shift)
static void diagnoseFunctionPointerToVoidComparison(Sema &S, SourceLocation Loc, ExprResult &LHS, ExprResult &RHS, bool IsError)
static void EmitDiagnosticForLogicalAndInLogicalOr(Sema &Self, SourceLocation OpLoc, BinaryOperator *Bop)
It accepts a '&&' expr that is inside a '||' one.
static void captureVariablyModifiedType(ASTContext &Context, QualType T, CapturingScopeInfo *CSI)
static bool canConvertIntToOtherIntTy(Sema &S, ExprResult *Int, QualType OtherIntTy)
Test if a (constant) integer Int can be casted to another integer type IntTy without losing precision...
static DeclContext * getParentOfCapturingContextOrNull(DeclContext *DC, ValueDecl *Var, SourceLocation Loc, const bool Diagnose, Sema &S)
static bool isOverflowingIntegerType(ASTContext &Ctx, QualType T)
static void CheckIdentityFieldAssignment(Expr *LHSExpr, Expr *RHSExpr, SourceLocation Loc, Sema &Sema)
static bool isLegalBoolVectorBinaryOp(BinaryOperatorKind Opc)
static ExprResult rebuildPotentialResultsAsNonOdrUsed(Sema &S, Expr *E, NonOdrUseReason NOUR)
Walk the set of potential results of an expression and mark them all as non-odr-uses if they satisfy ...
static void CheckCompleteParameterTypesForMangler(Sema &S, FunctionDecl *FD, SourceLocation Loc)
Require that all of the parameter types of function be complete.
static bool isScopedEnumerationType(QualType T)
static bool checkArithmeticBinOpPointerOperands(Sema &S, SourceLocation Loc, Expr *LHSExpr, Expr *RHSExpr)
Check the validity of a binary arithmetic operation w.r.t.
static bool breakDownVectorType(QualType type, uint64_t &len, QualType &eltType)
This file declares semantic analysis for HLSL constructs.
This file declares semantic analysis for Objective-C.
This file declares semantic analysis for OpenMP constructs and clauses.
This file declares semantic analysis for expressions involving.
static bool isInvalid(LocType Loc, bool *Invalid)
Defines the SourceManager interface.
Defines various enumerations that describe declaration and type specifiers.
static QualType getPointeeType(const MemRegion *R)
Defines the clang::TypeLoc interface and its subclasses.
Defines enumerations for the type traits support.
C Language Family Type Representation.
@ Open
The standard open() call: int open(const char *path, int oflag, ...);.
a trap message and trap category.
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
CanQualType ARCUnbridgedCastTy
unsigned getIntWidth(QualType T) const
bool areCompatibleRVVTypes(QualType FirstType, QualType SecondType)
Return true if the given types are an RISC-V vector builtin type and a VectorType that is a fixed-len...
const llvm::fltSemantics & getFloatTypeSemantics(QualType T) const
Return the APFloat 'semantics' for the specified scalar floating point type.
QualType getBlockPointerType(QualType T) const
Return the uniqued reference to the type for a block of the specified type.
QualType getBuiltinVaListType() const
Retrieve the type of the __builtin_va_list type.
DeclarationNameTable DeclarationNames
int getIntegerTypeOrder(QualType LHS, QualType RHS) const
Return the highest ranked integer type, see C99 6.3.1.8p1.
QualType getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType, const Attr *attr=nullptr) const
QualType getScalableVectorType(QualType EltTy, unsigned NumElts, unsigned NumFields=1) const
Return the unique reference to a scalable vector type of the specified element type and scalable numb...
QualType getBuiltinMSVaListType() const
Retrieve the type of the __builtin_ms_va_list type.
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like 'int()'.
QualType getCorrespondingSignedFixedPointType(QualType Ty) const
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
QualType getVectorType(QualType VectorType, unsigned NumElts, VectorKind VecKind) const
Return the unique reference to a vector type of the specified element type and size.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
QualType getReferenceQualifiedType(const Expr *e) const
getReferenceQualifiedType - Given an expr, will return the type for that expression,...
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
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
CanQualType getLogicalOperationType() const
The result type of logical operations, '<', '>', '!=', etc.
bool areLaxCompatibleRVVTypes(QualType FirstType, QualType SecondType)
Return true if the given vector types are lax-compatible RISC-V vector types as defined by -flax-vect...
const QualType GetHigherPrecisionFPType(QualType ElementType) const
bool typesAreBlockPointerCompatible(QualType, QualType)
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
QualType getPointerDiffType() const
Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.
llvm::SetVector< const ValueDecl * > CUDAExternalDeviceDeclODRUsedByHost
Keep track of CUDA/HIP external kernels or device variables ODR-used by host code.
int getFloatingTypeOrder(QualType LHS, QualType RHS) const
Compare the rank of the two specified floating point types, ignoring the domain of the type (i....
QualType getIntTypeForBitwidth(unsigned DestWidth, unsigned Signed) const
getIntTypeForBitwidth - sets integer QualTy according to specified details: bitwidth,...
GVALinkage GetGVALinkageForFunction(const FunctionDecl *FD) const
CanQualType UnsignedLongTy
llvm::DenseSet< const FunctionDecl * > CUDAImplicitHostDeviceFunUsedByDevice
Keep track of CUDA/HIP implicit host device functions used on device side in device compilation.
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
TypeInfo getTypeInfo(const Type *T) const
Get the size and alignment of the specified complete type in bits.
QualType getStringLiteralArrayType(QualType EltTy, unsigned Length) const
Return a type for a constant array for a string literal of the specified element type and length.
QualType getCorrespondingSaturatedType(QualType Ty) const
CanQualType BoundMemberTy
QualType removeAddrSpaceQualType(QualType T) const
Remove any existing address space on the type and returns the type with qualifiers intact (or that's ...
llvm::DenseSet< const VarDecl * > CUDADeviceVarODRUsedByHost
Keep track of CUDA/HIP device-side variables ODR-used by host code.
CanQualType PseudoObjectTy
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
bool areComparableObjCPointerTypes(QualType LHS, QualType RHS)
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
llvm::FixedPointSemantics getFixedPointSemantics(QualType Ty) const
QualType mergeTypes(QualType, QualType, bool OfBlockPointer=false, bool Unqualified=false, bool BlockReturnType=false, bool IsConditionalOperator=false)
static bool isObjCNSObjectType(QualType Ty)
Return true if this is an NSObject object with its NSObject attribute set.
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
QualType getTypeDeclType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier Qualifier, const TypeDecl *Decl) const
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
QualType getTypedefType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier Qualifier, const TypedefNameDecl *Decl, QualType UnderlyingType=QualType(), std::optional< bool > TypeMatchesDeclOrNone=std::nullopt) const
Return the unique reference to the type for the specified typedef-name decl.
QualType getTemplateSpecializationType(ElaboratedTypeKeyword Keyword, TemplateName T, ArrayRef< TemplateArgument > SpecifiedArgs, ArrayRef< TemplateArgument > CanonicalArgs, QualType Underlying=QualType()) const
TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const
Allocate an uninitialized TypeSourceInfo.
TemplateName getQualifiedTemplateName(NestedNameSpecifier Qualifier, bool TemplateKeyword, TemplateName Template) const
Retrieve the template name that represents a qualified template name such as std::vector.
QualType getObjCClassRedefinitionType() const
Retrieve the type that Class has been defined to, which may be different from the built-in Class if C...
FieldDecl * getInstantiatedFromUnnamedFieldDecl(FieldDecl *Field) const
CanQualType UnsignedLongLongTy
QualType 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 getMemberPointerType(QualType T, NestedNameSpecifier Qualifier, const CXXRecordDecl *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
QualType getTagType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier Qualifier, const TagDecl *TD, bool OwnsTag) const
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 hasDirectOwnershipQualifier(QualType Ty) const
Return true if the type has been explicitly qualified with ObjC ownership.
QualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
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 getSignedSizeType() const
Return the unique signed counterpart of the integer type corresponding to size_t.
CanQualType getCanonicalTagType(const TagDecl *TD) const
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.
unsigned char getFixedPointScale(QualType Ty) const
TemplateName getAssumedTemplateName(DeclarationName Name) const
Retrieve a template name representing an unqualified-id that has been assumed to name a template for ...
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 getCommonSugaredType(QualType X, QualType Y, bool Unqualified=false) const
QualType isPromotableBitField(Expr *E) const
Whether this is a promotable bitfield reference according to C99 6.3.1.1p2, bullet 2 (and GCC extensi...
bool isSentinelNullExpr(const Expr *E)
uint64_t getCharWidth() const
Return the size of the character type, in bits.
QualType getBitIntType(bool Unsigned, unsigned NumBits) const
Return a bit-precise integer type with the specified signedness and bit count.
AddrLabelExpr - The GNU address of label extension, representing &&label.
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Wrapper for source info for arrays.
Represents an array type, per C99 6.7.5.2 - Array Declarators.
ArraySizeModifier getSizeModifier() const
QualType getElementType() const
AsTypeExpr - Clang builtin function __builtin_astype [OpenCL 6.2.4.2] This AST node provides support ...
Attr - This represents one attribute.
SourceRange getRange() const
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
A builtin binary operation expression such as "x + y" or "x <= y".
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)
Retrieve the overloaded operator kind that corresponds to the given binary opcode.
static bool isComparisonOp(Opcode Opc)
bool isComparisonOp() const
StringRef getOpcodeStr() const
bool isRelationalOp() const
SourceLocation getOperatorLoc() const
bool isCompoundAssignmentOp() const
bool isMultiplicativeOp() const
static StringRef getOpcodeStr(Opcode Op)
getOpcodeStr - Turn an Opcode enum value into the punctuation char it corresponds to,...
bool isEqualityOp() const
static BinaryOperator * Create(const ASTContext &C, Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy, ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc, FPOptionsOverride FPFeatures)
bool isAdditiveOp() const
static bool isNullPointerArithmeticExtension(ASTContext &Ctx, Opcode Opc, const Expr *LHS, const Expr *RHS)
Return true if a binary operator using the specified opcode and operands would match the 'p = (i8*)nu...
bool isAssignmentOp() const
static Opcode getOverloadedOpcode(OverloadedOperatorKind OO)
Retrieve the binary opcode that corresponds to the given overloaded operator.
static bool isBitwiseOp(Opcode Opc)
A binding in a decomposition declaration.
A class which contains all the information about a particular captured value.
Represents a block literal declaration, which is like an unnamed FunctionDecl.
void setParams(ArrayRef< ParmVarDecl * > NewParamInfo)
void setSignatureAsWritten(TypeSourceInfo *Sig)
void setBlockMissingReturnType(bool val=true)
void setIsVariadic(bool value)
SourceLocation getCaretLocation() const
void setBody(CompoundStmt *B)
ArrayRef< ParmVarDecl * > parameters() const
void setCaptures(ASTContext &Context, ArrayRef< Capture > Captures, bool CapturesCXXThis)
static BlockDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L)
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
This class is used for builtin types like 'int'.
bool hasPtrArgsOrResult(unsigned ID) const
Determines whether this builtin has a result or any arguments which are pointer types.
bool isImmediate(unsigned ID) const
Returns true if this is an immediate (consteval) function.
bool hasCustomTypechecking(unsigned ID) const
Determines whether this builtin has custom typechecking.
std::string getName(unsigned ID) const
Return the identifier name for the specified builtin, e.g.
bool isInStdNamespace(unsigned ID) const
Determines whether this builtin is a C++ standard library function that lives in (possibly-versioned)...
bool isDirectlyAddressable(unsigned ID) const
Determines whether this builtin can have its address taken with no special action required.
static CUDAKernelCallExpr * Create(const ASTContext &Ctx, Expr *Fn, CallExpr *Config, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation RP, FPOptionsOverride FPFeatures, unsigned MinNumArgs=0)
Represents a path from a specific derived class (which is not represented as part of the path) to a p...
BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases...
Represents a call to a C++ constructor.
Represents a C++ constructor within a class.
Represents a C++ conversion function within a class.
bool isLambdaToBlockPointerConversion() const
Determine whether this conversion function is a conversion from a lambda closure type to a block poin...
Represents a C++ base or member initializer.
A default argument (C++ [dcl.fct.default]).
static CXXDefaultArgExpr * Create(const ASTContext &C, SourceLocation Loc, ParmVarDecl *Param, Expr *RewrittenExpr, DeclContext *UsedContext)
A use of a default initializer in a constructor or in aggregate initialization.
static CXXDefaultInitExpr * Create(const ASTContext &Ctx, SourceLocation Loc, FieldDecl *Field, DeclContext *UsedContext, Expr *RewrittenInitExpr)
Field is the non-static data member whose default initializer is used by this expression.
static CXXDependentScopeMemberExpr * Create(const ASTContext &Ctx, Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs)
Represents a C++ destructor within a class.
Represents a static or instance method of a struct/union/class.
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
CXXMethodDecl * getDevirtualizedMethod(const Expr *Base, bool IsAppleKext)
If it's possible to devirtualize a call to this method, return the called function.
A call to an overloaded operator written using operator syntax.
SourceLocation getOperatorLoc() const
Returns the location of the operator symbol in the expression.
SourceRange getSourceRange() const
static CXXParenListInitExpr * Create(ASTContext &C, ArrayRef< Expr * > Args, QualType T, unsigned NumUserSpecifiedExprs, SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc)
Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
Represents a C++ struct/union/class.
bool isStandardLayout() const
Determine whether this class is standard-layout per C++ [class]p7.
bool hasAnyDependentBases() const
Determine whether this class has any dependent base classes which are not the current instantiation.
unsigned getNumBases() const
Retrieves the number of base classes of this class.
const CXXRecordDecl * getTemplateInstantiationPattern() const
Retrieve the record declaration from which this record could be instantiated.
bool hasDefinition() const
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
bool isDerivedFrom(const CXXRecordDecl *Base) const
Determine whether this class is derived from the class Base.
Represents a C++ nested-name-specifier or a global scope specifier.
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
bool isValid() const
A scope specifier is present, and it refers to a real scope.
void MakeTrivial(ASTContext &Context, NestedNameSpecifier Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
SourceRange getRange() const
SourceLocation getBeginLoc() const
bool isSet() const
Deprecated.
NestedNameSpecifier getScopeRep() const
Retrieve the representation of the nested-name-specifier.
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context.
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.
QualType withConst() const
Retrieves a version of this type with const applied.
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
const char * getCastKindName() const
CharLiteralParser - Perform interpretation and semantic analysis of a character literal.
Represents a character-granular source range.
static CharSourceRange getCharRange(SourceRange R)
static CharSourceRange getTokenRange(SourceRange R)
CharUnits - This is an opaque type for sizes expressed in character units.
bool isZero() const
isZero - Test whether the quantity equals zero.
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
static CharUnits One()
One - Construct a CharUnits quantity of one.
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
unsigned getValue() const
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
void mergeFrom(CleanupInfo Rhs)
void setExprNeedsCleanups(bool SideEffects)
bool cleanupsHaveSideEffects() const
bool exprNeedsCleanups() const
Complex values, per C99 6.2.5p11.
QualType getElementType() const
static CompoundAssignOperator * Create(const ASTContext &C, Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy, ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc, FPOptionsOverride FPFeatures, QualType CompLHSType=QualType(), QualType CompResultType=QualType())
CompoundLiteralExpr - [C99 6.5.2.5].
CompoundStmt - This represents a group of statements like { stmt stmt }.
Stmt * getStmtExprResult()
ConditionalOperator - The ?: ternary operator.
Represents the canonical version of C arrays with a specified constant size.
llvm::APInt getSize() const
Return the constant array size as an APInt.
uint64_t getZExtSize() const
Return the size zero-extended as a uint64_t.
ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluatin...
static ConstantResultStorageKind getStorageKind(const APValue &Value)
void MoveIntoResult(APValue &Value, const ASTContext &Context)
SourceLocation getBeginLoc() const LLVM_READONLY
static ConstantExpr * Create(const ASTContext &Context, Expr *E, const APValue &Result)
Represents a concrete matrix type with constant number of rows and columns.
unsigned getNumColumns() const
Returns the number of columns in the matrix.
unsigned getNumRows() const
Returns the number of rows in the matrix.
The result of a constraint satisfaction check, containing the necessary information to diagnose an un...
ConvertVectorExpr - Clang builtin function __builtin_convertvector This AST node provides support for...
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
void setTypoName(const IdentifierInfo *II)
void setTypoNNS(NestedNameSpecifier NNS)
Wrapper for source info for pointers decayed from arrays and functions.
A POD class for pairing a NamedDecl* with an access specifier.
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
The results of name lookup within a DeclContext.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC.
bool isRequiresExprBody() const
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
void addDecl(Decl *D)
Add the declaration D into this context.
bool containsDecl(Decl *D) const
Checks whether a declaration is in this context.
RecordDecl * getOuterLexicalRecordContext()
Retrieve the outermost lexically enclosing record context.
bool isFunctionOrMethod() const
DeclContext * getLookupParent()
Find the parent context of this context that will be used for unqualified name lookup.
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context semantically 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.
NestedNameSpecifier getQualifier() const
If the name was qualified, retrieves the nested-name-specifier that precedes the name.
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.
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 getBeginLoc() const
SourceLocation getLocation() const
Decl - This represents one declaration (or definition), e.g.
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
AvailabilityResult getAvailability(std::string *Message=nullptr, VersionTuple EnclosingVersion=VersionTuple(), StringRef *RealizedPlatform=nullptr) const
Determine the availability of the given declaration.
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
void markUsed(ASTContext &C)
Mark the declaration used, in the sense of odr-use.
bool isInvalidDecl() const
SourceLocation getLocation() const
void setReferenced(bool R=true)
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
DeclContext * getDeclContext()
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
The name of a declaration.
IdentifierInfo * getAsIdentifierInfo() const
Retrieve the IdentifierInfo * stored in this declaration name, or null if this declaration name isn't...
@ CXXConversionFunctionName
bool isIdentifier() const
Predicate functions for querying what type of name this is.
SourceLocation getBeginLoc() const LLVM_READONLY
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier (with source-location information) that qualifies the name of this...
TypeSourceInfo * getTypeSourceInfo() const
Information about one declarator, including the parsed type information and the identifier.
DeclaratorContext getContext() const
SourceLocation getBeginLoc() const LLVM_READONLY
const IdentifierInfo * getIdentifier() const
static DependentScopeDeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)
A little helper class used to produce diagnostics.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
bool getSuppressSystemWarnings() const
Recursive AST visitor that supports extension via dynamic dispatch.
virtual bool VisitStmt(MaybeConst< Stmt > *S)
virtual bool TraverseTemplateArgument(const TemplateArgument &Arg)
Recursively visit a template argument and dispatch to the appropriate method for the argument type.
Represents a reference to #emded data.
RAII object that enters a new expression evaluation context.
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
EnumDecl * getOriginalDecl() 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,...
bool isIntegerConstantExpr(const ASTContext &Ctx) const
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...
@ SE_AllowSideEffects
Allow any unmodeled side effect.
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.
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
std::optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx) const
isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.
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.
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.
bool refersToBitField() const
Returns true if this expression is a gl-value that potentially refers to a bit-field.
@ MLV_DuplicateVectorComponents
@ MLV_InvalidMessageExpression
@ MLV_ConstQualifiedField
@ MLV_SubObjCPropertySetting
bool isOrdinaryOrBitFieldObject() const
bool hasPlaceholderType() const
Returns whether this expression has a placeholder type.
static ExprValueKind getValueKindForType(QualType T)
getValueKindForType - Given a formal return or parameter type, give its value kind.
bool isKnownToHaveBooleanValue(bool Semantic=true) const
isKnownToHaveBooleanValue - Return true if this is an integer expression that is known to return 0 or...
ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the ...
ExtVectorType - Extended vector type.
Represents difference between two FPOptions values.
bool isFPConstrained() const
RoundingMode getRoundingMode() const
Represents a member of a struct/union/class.
bool isBitField() const
Determines whether this field is a bitfield.
bool hasInClassInitializer() const
Determine whether this member has a C++11 default member initializer.
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined.
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
static FixedPointLiteral * CreateFromRawInt(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l, unsigned Scale)
static FloatingLiteral * Create(const ASTContext &C, const llvm::APFloat &V, bool isexact, QualType Type, SourceLocation L)
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.
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, const AssociatedConstraint &TrailingRequiresClause={})
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.
bool isImmediateEscalating() const
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, init-capture pack, or binding pack that has been...
Represents a prototype with parameter type info, e.g.
ExtParameterInfo getExtParameterInfo(unsigned I) const
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
bool isParamConsumed(unsigned I) const
unsigned getNumParams() const
QualType getParamType(unsigned i) const
bool isVariadic() const
Whether this function prototype is variadic.
ExtProtoInfo getExtProtoInfo() const
ArrayRef< QualType > getParamTypes() const
ArrayRef< QualType > param_types() const
Declaration of a template function.
unsigned getNumParams() const
ParmVarDecl * getParam(unsigned i) const
SourceLocation getLocalRangeEnd() const
TypeLoc getReturnLoc() const
SourceLocation getLocalRangeBegin() const
A class which abstracts out some details necessary for making a call.
bool getCmseNSCall() const
ExtInfo withNoReturn(bool noReturn) const
ParameterABI getABI() const
Return the ABI treatment of this parameter.
FunctionType - C99 6.7.5.3 - Function Declarators.
ExtInfo getExtInfo() const
bool getNoReturnAttr() const
Determine whether this function type includes the GNU noreturn attribute.
bool getCFIUncheckedCalleeAttr() const
Determine whether this is a function prototype that includes the cfi_unchecked_callee 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.
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...
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.
@ CX_Promoted
Implementation of complex division using algebraic formulas at higher precision.
@ 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
bool allowArrayReturnTypes() const
unsigned getOpenCLCompatibleVersion() const
Return the OpenCL version that kernel language is compatible with.
static StringRef getSourceText(CharSourceRange Range, const SourceManager &SM, const LangOptions &LangOpts, bool *Invalid=nullptr)
Returns a string for the source that the range encompasses.
static SourceLocation AdvanceToTokenCharacter(SourceLocation TokStart, unsigned Characters, const SourceManager &SM, const LangOptions &LangOpts)
AdvanceToTokenCharacter - If the current SourceLocation specifies a location at the start of a token,...
static std::string Stringify(StringRef Str, bool Charify=false)
Stringify - Convert the specified string into a C string by i) escaping '\' and " characters and ii) ...
Represents the results of name lookup.
bool wasNotFoundInCurrentInstantiation() const
Determine whether no result was found because we could not search into dependent base classes of the ...
LLVM_ATTRIBUTE_REINITIALIZES void clear()
Clears out any current state.
DeclClass * getAsSingle() const
void addDecl(NamedDecl *D)
Add a declaration to these results with its natural access.
void setLookupName(DeclarationName Name)
Sets the name to look up.
bool empty() const
Return true if no decls were found.
void resolveKind()
Resolves the result kind of the lookup, possibly hiding decls.
SourceLocation getNameLoc() const
Gets the location of the identifier.
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
CXXRecordDecl * getNamingClass() const
Returns the 'naming class' for this lookup, i.e.
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
void setNamingClass(CXXRecordDecl *Record)
Sets the 'naming class' for this lookup.
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
DeclarationName getLookupName() const
Gets the name to look up.
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
MS property subscript expression.
Keeps track of the mangled names of lambda expressions and block literals within a particular context...
virtual unsigned getManglingNumber(const CXXMethodDecl *CallOperator)=0
Retrieve the mangling number of a new lambda expression with the given call operator within this cont...
MatrixSubscriptExpr - Matrix subscript expression for the MatrixType extension.
Represents a matrix type, as defined in the Matrix Types clang extensions.
QualType getElementType() const
Returns type of the elements being stored in the matrix.
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
SourceLocation getMemberLoc() const
getMemberLoc - Return the location of the "member", in X->F, it is the location of 'F'.
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
static MemberExpr * Create(const ASTContext &C, Expr *Base, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *MemberDecl, DeclAccessPair FoundDecl, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs, QualType T, ExprValueKind VK, ExprObjectKind OK, NonOdrUseReason NOUR)
bool performsVirtualDispatch(const LangOptions &LO) const
Returns true if virtual dispatch is performed.
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
This represents a decl that may have a name.
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
std::string getQualifiedNameAsString() const
bool isExternallyVisible() const
bool isCXXClassMember() const
Determine whether this declaration is a C++ class member.
Represent a C++ namespace.
A C++ nested-name-specifier augmented with source location information.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
CXXRecordDecl * getAsRecordDecl() const
Retrieve the record declaration stored in this nested name specifier, or null.
@ Type
A type, stored as a Type*.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
NumericLiteralParser - This performs strict semantic analysis of the content of a ppnumber,...
Represents an ObjC class declaration.
bool hasDefinition() const
Determine whether this class has been defined.
ivar_iterator ivar_begin() const
ObjCInterfaceDecl * getSuperClass() const
Interfaces are the core concept in Objective-C for object oriented design.
ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC 'id' type.
ObjCIvarDecl - Represents an ObjC instance variable.
ObjCIvarRefExpr - A reference to an ObjC instance variable.
SourceLocation getBeginLoc() const LLVM_READONLY
SourceLocation getLocation() const
SourceLocation getOpLoc() const
SourceLocation getEndLoc() const LLVM_READONLY
const Expr * getBase() const
An expression that sends a message to the given Objective-C object or class.
ObjCMethodDecl - Represents an instance or class method declaration.
ImplicitParamDecl * getSelfDecl() const
bool isClassMethod() const
Represents a pointer to an Objective C object.
const ObjCInterfaceType * getInterfaceType() const
If this pointer points to an Objective C @interface type, gets the type for that interface.
Represents a class type in Objective C.
Represents one property declaration in an Objective-C interface.
static ObjCPropertyDecl * findPropertyDecl(const DeclContext *DC, const IdentifierInfo *propertyID, ObjCPropertyQueryKind queryKind)
Lookup a property by name in the specified DeclContext.
Represents an Objective-C protocol declaration.
bool allowsSizeofAlignof() const
Does this runtime allow sizeof or alignof on object types?
bool allowsPointerArithmetic() const
Does this runtime allow pointer arithmetic on objects?
static OffsetOfExpr * Create(const ASTContext &C, QualType type, SourceLocation OperatorLoc, TypeSourceInfo *tsi, ArrayRef< OffsetOfNode > comps, ArrayRef< Expr * > exprs, SourceLocation RParenLoc)
Helper class for OffsetOfExpr.
void * getAsOpaquePtr() const
static OpaquePtr getFromOpaquePtr(void *P)
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
bool isAvailableOption(llvm::StringRef Ext, const LangOptions &LO) const
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13....
@ CSK_Normal
Normal lookup.
SmallVectorImpl< OverloadCandidate >::iterator iterator
OverloadingResult BestViableFunction(Sema &S, SourceLocation Loc, OverloadCandidateSet::iterator &Best)
Find the best viable function on this overload set, if it exists.
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr.
static FindResult find(Expr *E)
Finds the overloaded expression in the given expression E of OverloadTy.
ParenExpr - This represents a parenthesized expression, e.g.
SourceLocation getBeginLoc() const LLVM_READONLY
const Expr * getSubExpr() const
bool isProducedByFoldExpansion() const
Expr * getExpr(unsigned Init)
static ParenListExpr * Create(const ASTContext &Ctx, SourceLocation LParenLoc, ArrayRef< Expr * > Exprs, SourceLocation RParenLoc)
Create a paren list.
unsigned getNumExprs() const
Return the number of expressions in this paren list.
Represents a parameter to a function.
bool hasUnparsedDefaultArg() const
Determines whether this parameter has a default argument that has not yet been parsed.
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
bool hasUninstantiatedDefaultArg() const
QualType getOriginalType() const
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
bool hasDefaultArg() const
Determines whether this parameter has a default argument, either parsed or not.
bool isEquivalent(PointerAuthQualifier Other) const
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
static PredefinedExpr * Create(const ASTContext &Ctx, SourceLocation L, QualType FNTy, PredefinedIdentKind IK, bool IsTransparent, StringLiteral *SL)
Create a PredefinedExpr.
static std::string ComputeName(PredefinedIdentKind IK, const Decl *CurrentDecl, bool ForceElaboratedPrinting=false)
SourceLocation getLastFPEvalPragmaLocation() const
void CreateString(StringRef Str, Token &Tok, SourceLocation ExpansionLocStart=SourceLocation(), SourceLocation ExpansionLocEnd=SourceLocation())
Plop the specified string into a scratch buffer and set the specified token's location and length to ...
LangOptions::FPEvalMethodKind getCurrentFPEvalMethod() const
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
uint8_t getSpellingOfSingleCharacterNumericConstant(const Token &Tok, bool *Invalid=nullptr) const
Given a Token Tok that is a numeric constant with length 1, return the value of constant as an unsign...
SourceManager & getSourceManager() const
bool isMacroDefined(StringRef Id)
const TargetInfo & getTargetInfo() const
StringRef getSpelling(SourceLocation loc, SmallVectorImpl< char > &buffer, bool *invalid=nullptr) const
Return the 'spelling' of the token at the given location; does not go up to the spelling location or ...
bool isCodeCompletionEnabled() const
Determine if we are performing code completion.
IdentifierTable & getIdentifierTable()
const LangOptions & getLangOpts() const
DiagnosticsEngine & getDiagnostics() const
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Computes the source location just past the end of the token at this source location.
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const
Forwarding function for diagnostics.
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
bool hasQualifiers() const
Determine whether this type has any qualifiers.
bool hasNonTrivialToPrimitiveCopyCUnion() const
Check if this is or contains a C union that is non-trivial to copy, which is a union that has a membe...
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type.
bool isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const
bool isAddressSpaceOverlapping(QualType T, const ASTContext &Ctx) const
Returns true if address space qualifiers overlap with T address space qualifiers.
QualType withConst() const
void addConst()
Add the const type qualifier to this QualType.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
LangAS getAddressSpace() const
Return the address space of this type.
bool hasNonTrivialToPrimitiveDestructCUnion() const
Check if this is or contains a C union that is non-trivial to destruct, which is a union that has a m...
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
bool isCXX98PODType(const ASTContext &Context) const
Return true if this is a POD type according to the rules of the C++98 standard, regardless of the cur...
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
QualType getCanonicalType() const
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
bool isWebAssemblyReferenceType() const
Returns true if it is a WebAssembly Reference Type.
QualType withCVRQualifiers(unsigned CVR) const
bool isCForbiddenLValueType() const
Determine whether expressions of the given type are forbidden from being lvalues in C.
bool isConstQualified() const
Determine whether this type is const-qualified.
bool hasAddressSpace() const
Check if this type has any address space qualifier.
QualType getAtomicUnqualifiedType() const
Remove all qualifiers including _Atomic.
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after.
QualType getSingleStepDesugaredType(const ASTContext &Context) const
Return the specified type with one level of "sugar" removed from the type.
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
bool isAtLeastAsQualifiedAs(QualType Other, const ASTContext &Ctx) const
Determine whether this type is at least as qualified as the other given type, requiring exact equalit...
Qualifiers getLocalQualifiers() const
Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...
bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const
Check if this is or contains a C union that is non-trivial to default-initialize, which is a union th...
The collection of all-type qualifiers we support.
unsigned getCVRQualifiers() const
void removeCVRQualifiers(unsigned mask)
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
@ OCL_Weak
Reading or writing from this object requires a barrier call.
@ OCL_Autoreleasing
Assigning into this object requires a lifetime extension.
void removeObjCLifetime()
bool compatiblyIncludes(Qualifiers other, const ASTContext &Ctx) const
Determines if these qualifiers compatibly include another set.
static bool isAddressSpaceSupersetOf(LangAS A, LangAS B, const ASTContext &Ctx)
Returns true if address space A is equal to or a superset of B.
void removeAddressSpace()
void setAddressSpace(LangAS space)
PointerAuthQualifier getPointerAuth() const
ObjCLifetime getObjCLifetime() const
Qualifiers withoutObjCLifetime() const
Qualifiers withoutObjCGCAttr() const
LangAS getAddressSpace() const
bool compatiblyIncludesObjCLifetime(Qualifiers other) const
Determines if these qualifiers compatibly include another set of qualifiers from the narrow perspecti...
Represents a struct/union/class.
bool hasFlexibleArrayMember() const
field_range fields() const
RecordDecl * getDefinitionOrSelf() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
RecordDecl * getOriginalDecl() const
static RecoveryExpr * Create(ASTContext &Ctx, QualType T, SourceLocation BeginLoc, SourceLocation EndLoc, ArrayRef< Expr * > SubExprs)
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
Base for LValueReferenceType and RValueReferenceType.
Scope - A scope is a transient data structure that is used while parsing the program.
unsigned getFlags() const
getFlags - Return the flags for this scope.
@ ContinueScope
This is a while, do, for, which can have continue statements embedded into it.
@ ControlScope
The controlling scope in a if/switch/while/for statement.
@ BreakScope
This is a while, do, switch, for, etc that can have break statements embedded into it.
@ DeclScope
This is a scope that can contain a declaration.
Smart pointer class that efficiently represents Objective-C method names.
StringRef getNameForSlot(unsigned argIndex) const
Retrieve the name at a given position in the selector.
bool isUnarySelector() const
A generic diagnostic builder for errors which may or may not be deferred.
SemaDiagnosticBuilder DiagCompat(SourceLocation Loc, unsigned CompatDiagId, bool DeferHint=false)
Emit a compatibility diagnostic.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
void RecordImplicitHostDeviceFuncUsedByDevice(const FunctionDecl *FD)
Record FD if it is a CUDA/HIP implicit host device function used on device side in device compilation...
CUDAFunctionTarget IdentifyTarget(const FunctionDecl *D, bool IgnoreImplicitHDAttr=false)
Determines whether the given function is a CUDA device/host/kernel/etc.
bool CheckCall(SourceLocation Loc, FunctionDecl *Callee)
Check whether we're allowed to call Callee from the current context.
@ CVT_Host
Emitted on device side with a shadow variable on host side.
ExprResult ActOnOutParamExpr(ParmVarDecl *Param, Expr *Arg)
void emitLogicalOperatorFixIt(Expr *LHS, Expr *RHS, BinaryOperatorKind Opc)
QualType handleVectorBinOpConversion(ExprResult &LHS, ExprResult &RHS, QualType LHSType, QualType RHSType, bool IsCompAssign)
ObjCMethodDecl * LookupInstanceMethodInGlobalPool(Selector Sel, SourceRange R, bool receiverIdOrClass=false)
LookupInstanceMethodInGlobalPool - Returns the method and warns if there are multiple signatures.
ObjCLiteralKind CheckLiteralKind(Expr *FromE)
ObjCMethodDecl * LookupMethodInObjectType(Selector Sel, QualType Ty, bool IsInstance)
LookupMethodInType - Look up a method in an ObjCObjectType.
void CheckObjCBridgeRelatedCast(QualType castType, Expr *castExpr)
QualType FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
FindCompositeObjCPointerType - Helper method to find composite type of two objective-c pointer types ...
void CheckTollFreeBridgeCast(QualType castType, Expr *castExpr)
const DeclContext * getCurObjCLexicalContext() const
void checkRetainCycles(ObjCMessageExpr *msg)
checkRetainCycles - Check whether an Objective-C message send might create an obvious retain cycle.
void EmitRelatedResultTypeNote(const Expr *E)
If the given expression involves a message send to a method with a related result type,...
void EmitRelatedResultTypeNoteForReturn(QualType destType)
Given that we had incompatible pointer types in a return statement, check whether we're in a method w...
void diagnoseARCUnbridgedCast(Expr *e)
Given that we saw an expression with the ARCUnbridgedCastTy placeholder type, complain bitterly.
ObjCMethodDecl * LookupMethodInQualifiedType(Selector Sel, const ObjCObjectPointerType *OPT, bool IsInstance)
LookupMethodInQualifiedType - Lookups up a method in protocol qualifier list of a qualified objective...
ARCConversionResult CheckObjCConversion(SourceRange castRange, QualType castType, Expr *&op, CheckedConversionKind CCK, bool Diagnose=true, bool DiagnoseCFAudited=false, BinaryOperatorKind Opc=BO_PtrMemD, bool IsReinterpretCast=false)
Checks for invalid conversions and casts between retainable pointers and other pointer kinds for ARC ...
Expr * stripARCUnbridgedCast(Expr *e)
stripARCUnbridgedCast - Given an expression of ARCUnbridgedCast type, remove the placeholder cast.
ExprResult BuildObjCSubscriptExpression(SourceLocation RB, Expr *BaseExpr, Expr *IndexExpr, ObjCMethodDecl *getterMethod, ObjCMethodDecl *setterMethod)
Build an ObjC subscript pseudo-object expression, given that that's supported by the runtime.
std::unique_ptr< NSAPI > NSAPIObj
Caches identifiers/selectors for NSFoundation APIs.
void CheckDeclReference(SourceLocation Loc, Expr *E, Decl *D)
ExprResult ActOnArraySectionExpr(Expr *Base, SourceLocation LBLoc, Expr *LowerBound, SourceLocation ColonLocFirst, Expr *Length, SourceLocation RBLoc)
Checks and creates an Array Section used in an OpenACC construct/clause.
ExprResult ActOnOpenMPCall(ExprResult Call, Scope *Scope, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig)
Given the potential call expression Call, determine if there is a specialization via the OpenMP decla...
void tryCaptureOpenMPLambdas(ValueDecl *V)
Function tries to capture lambda's captured variables in the OpenMP region before the original lambda...
OpenMPClauseKind isOpenMPPrivateDecl(ValueDecl *D, unsigned Level, unsigned CapLevel) const
Check if the specified variable is used in 'private' clause.
VarDecl * isOpenMPCapturedDecl(ValueDecl *D, bool CheckScopeInfo=false, unsigned StopAt=0)
Check if the specified variable is used in one of the private clauses (private, firstprivate,...
ExprResult ActOnOMPArraySectionExpr(Expr *Base, SourceLocation LBLoc, Expr *LowerBound, SourceLocation ColonLocFirst, SourceLocation ColonLocSecond, Expr *Length, Expr *Stride, SourceLocation RBLoc)
bool isOpenMPCapturedByRef(const ValueDecl *D, unsigned Level, unsigned OpenMPCaptureLevel) const
Return true if the provided declaration VD should be captured by reference.
bool isOpenMPTargetCapturedDecl(const ValueDecl *D, unsigned Level, unsigned CaptureLevel) const
Check if the specified variable is captured by 'target' directive.
bool isOpenMPGlobalCapturedDecl(ValueDecl *D, unsigned Level, unsigned CaptureLevel) const
Check if the specified global variable must be captured by outer capture regions.
bool isInOpenMPDeclareTargetContext() const
Return true inside OpenMP declare target region.
void checkDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D, SourceLocation IdLoc=SourceLocation())
Check declaration inside target region.
const ValueDecl * getOpenMPDeclareMapperVarName() const
ExprResult checkAssignment(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opcode, Expr *LHS, Expr *RHS)
ExprResult checkIncDec(Scope *S, SourceLocation OpLoc, UnaryOperatorKind Opcode, Expr *Op)
Check an increment or decrement of a pseudo-object expression.
ExprResult checkRValue(Expr *E)
RAII object used to temporarily allow the C++ 'this' expression to be used, with the given qualifiers...
RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...
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...
bool TryFunctionConversion(QualType FromType, QualType ToType, QualType &ResultTy) const
Same as IsFunctionConversion, but if this would return true, it sets ResultTy to ToType.
void DefineImplicitLambdaToFunctionPointerConversion(SourceLocation CurrentLoc, CXXConversionDecl *Conv)
Define the "body" of the conversion from a lambda object to a function pointer.
ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo)
Package the given type and TSI into a ParsedType.
ExprResult ActOnCXXParenListInitExpr(ArrayRef< Expr * > Args, QualType T, unsigned NumUserSpecifiedExprs, SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc)
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.
Scope * getCurScope() const
Retrieve the parser's current scope.
ExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc, tok::TokenKind Op, Expr *Input, bool IsAfterAmp=false)
Unary Operators. 'Tok' is the token for the operator.
bool RequireCompleteSizedExprType(Expr *E, unsigned DiagID, const Ts &...Args)
ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *InputExpr, bool IsAfterAmp=false)
bool isAlwaysConstantEvaluatedContext() const
bool isExternalWithNoLinkageType(const ValueDecl *VD) const
Determine if VD, which must be a variable or function, is an external symbol that nonetheless can't b...
bool isAttrContext() const
void DiagnoseUnusedParameters(ArrayRef< ParmVarDecl * > Parameters)
Diagnose any unused parameters in the given sequence of ParmVarDecl pointers.
ExprResult IgnoredValueConversions(Expr *E)
IgnoredValueConversions - Given that an expression's result is syntactically ignored,...
bool RequireCompleteSizedType(SourceLocation Loc, QualType T, unsigned DiagID, const Ts &...Args)
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
@ LookupObjCImplicitSelfParam
Look up implicit 'self' parameter of an objective-c method.
@ LookupMemberName
Member name lookup, which finds the names of class/struct/union members.
void DiagnoseSentinelCalls(const NamedDecl *D, SourceLocation Loc, ArrayRef< Expr * > Args)
DiagnoseSentinelCalls - This routine checks whether a call or message-send is to a declaration with t...
ExprResult ActOnConstantExpression(ExprResult Res)
QualType CheckLogicalOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc)
ExprResult ActOnCompoundLiteral(SourceLocation LParenLoc, ParsedType Ty, SourceLocation RParenLoc, Expr *InitExpr)
bool LookupTemplateName(LookupResult &R, Scope *S, CXXScopeSpec &SS, QualType ObjectType, bool EnteringContext, RequiredTemplateKind RequiredTemplate=SourceLocation(), AssumedTemplateKind *ATK=nullptr, bool AllowTypoCorrection=true)
ImplicitConversionSequence TryImplicitConversion(Expr *From, QualType ToType, bool SuppressUserConversions, AllowedExplicit AllowExplicit, bool InOverloadResolution, bool CStyle, bool AllowObjCWritebackConversion)
ExprResult BuildLiteralOperatorCall(LookupResult &R, DeclarationNameInfo &SuffixInfo, ArrayRef< Expr * > Args, SourceLocation LitEndLoc, TemplateArgumentListInfo *ExplicitTemplateArgs=nullptr)
BuildLiteralOperatorCall - Build a UserDefinedLiteral by creating a call to a literal operator descri...
bool areVectorTypesSameSize(QualType srcType, QualType destType)
void DiagnoseAlwaysNonNullPointer(Expr *E, Expr::NullPointerConstantKind NullType, bool IsEqual, SourceRange Range)
Diagnose pointers that are always non-null.
void DefineImplicitMoveAssignment(SourceLocation CurrentLocation, CXXMethodDecl *MethodDecl)
Defines an implicitly-declared move assignment operator.
VariadicCallType getVariadicCallType(FunctionDecl *FDecl, const FunctionProtoType *Proto, Expr *Fn)
ExprResult CreateBuiltinBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr, bool ForFoldExpression=false)
CreateBuiltinBinOp - Creates a new built-in binary operation with operator Opc at location TokLoc.
void DecomposeUnqualifiedId(const UnqualifiedId &Id, TemplateArgumentListInfo &Buffer, DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *&TemplateArgs)
Decomposes the given name into a DeclarationNameInfo, its location, and possibly a list of template a...
bool InstantiateDefaultArgument(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param)
void ActOnStartStmtExpr()
ExprResult CreateOverloadedArraySubscriptExpr(SourceLocation LLoc, SourceLocation RLoc, Expr *Base, MultiExprArg Args)
void WarnOnPendingNoDerefs(ExpressionEvaluationContextRecord &Rec)
Emit a warning for all pending noderef expressions that we recorded.
void ActOnStmtExprError()
void MarkDeclarationsReferencedInExpr(Expr *E, bool SkipLocalVariables=false, ArrayRef< const Expr * > StopAt={})
Mark any declarations that appear within this expression or any potentially-evaluated subexpressions ...
bool BoundsSafetyCheckAssignmentToCountAttrPtr(QualType LHSTy, Expr *RHSExpr, AssignmentAction Action, SourceLocation Loc, const ValueDecl *Assignee, bool ShowFullyQualifiedAssigneeName)
Perform Bounds Safety Semantic checks for assigning to a __counted_by or __counted_by_or_null pointer...
QualType UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, ArithConvKind ACK)
UsualArithmeticConversions - Performs various conversions that are common to binary operators (C99 6....
void CheckFloatComparison(SourceLocation Loc, const Expr *LHS, const Expr *RHS, BinaryOperatorKind Opcode)
Check for comparisons of floating-point values using == and !=.
void CheckPtrComparisonWithNullChar(ExprResult &E, ExprResult &NullE)
NamedDecl * ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II, Scope *S)
ImplicitlyDefineFunction - An undeclared identifier was used in a function call, forming a call to an...
unsigned CapturingFunctionScopes
Track the number of currently active capturing scopes.
void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl=nullptr, ExpressionEvaluationContextRecord::ExpressionKind Type=ExpressionEvaluationContextRecord::EK_Other)
ExprResult CheckBooleanCondition(SourceLocation Loc, Expr *E, bool IsConstexpr=false)
CheckBooleanCondition - Diagnose problems involving the use of the given expression as a boolean cond...
@ Boolean
A boolean condition, from 'if', 'while', 'for', or 'do'.
@ Switch
An integral condition for a 'switch' statement.
@ ConstexprIf
A constant boolean condition from 'if constexpr'.
ExprResult ActOnIdExpression(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, UnqualifiedId &Id, bool HasTrailingLParen, bool IsAddressOfOperand, CorrectionCandidateCallback *CCC=nullptr, bool IsInlineAsmIdentifier=false, Token *KeywordReplacement=nullptr)
bool needsRebuildOfDefaultArgOrInit() const
bool GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl, const FunctionProtoType *Proto, unsigned FirstParam, ArrayRef< Expr * > Args, SmallVectorImpl< Expr * > &AllArgs, VariadicCallType CallType=VariadicCallType::DoesNotApply, bool AllowExplicit=false, bool IsListInitialization=false)
GatherArgumentsForCall - Collector argument expressions for various form of call prototypes.
SourceLocation LocationOfExcessPrecisionNotSatisfied
SmallVector< sema::FunctionScopeInfo *, 4 > FunctionScopes
Stack containing information about each of the nested function, block, and method scopes that are cur...
PoppedFunctionScopePtr PopFunctionScopeInfo(const sema::AnalysisBasedWarnings::Policy *WP=nullptr, const Decl *D=nullptr, QualType BlockType=QualType())
Pop a function (or block or lambda or captured region) scope from the stack.
Preprocessor & getPreprocessor() const
const ExpressionEvaluationContextRecord & currentEvaluationContext() const
Scope * getScopeForContext(DeclContext *Ctx)
Determines the active Scope associated with the given declaration context.
QualType GetSignedSizelessVectorType(QualType V)
bool CheckCXXThisCapture(SourceLocation Loc, bool Explicit=false, bool BuildAndDiagnose=true, const unsigned *const FunctionScopeIndexToStopAt=nullptr, bool ByCopy=false)
Make sure the value of 'this' is actually available in the current context, if it is a potentially ev...
llvm::SmallPtrSet< ConstantExpr *, 4 > FailedImmediateInvocations
ExprResult ActOnCharacterConstant(const Token &Tok, Scope *UDLScope=nullptr)
DefaultedComparisonKind getDefaultedComparisonKind(const FunctionDecl *FD)
ExprResult MaybeBindToTemporary(Expr *E)
MaybeBindToTemporary - If the passed in expression has a record type with a non-trivial destructor,...
void CheckCompleteDestructorVariant(SourceLocation CurrentLocation, CXXDestructorDecl *Dtor)
Do semantic checks to allow the complete destructor variant to be emitted when the destructor is defi...
void MarkCaptureUsedInEnclosingContext(ValueDecl *Capture, SourceLocation Loc, unsigned CapturingScopeIndex)
Expr * BuildBuiltinCallExpr(SourceLocation Loc, Builtin::ID Id, MultiExprArg CallArgs)
BuildBuiltinCallExpr - Create a call to a builtin function specified by Id.
QualType CheckVectorOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign, bool AllowBothBool, bool AllowBoolConversion, bool AllowBoolOperation, bool ReportInvalid)
type checking for vector binary operators.
LiteralOperatorLookupResult LookupLiteralOperator(Scope *S, LookupResult &R, ArrayRef< QualType > ArgTys, bool AllowRaw, bool AllowTemplate, bool AllowStringTemplate, bool DiagnoseMissing, StringLiteral *StringLit=nullptr)
LookupLiteralOperator - Determine which literal operator should be used for a user-defined literal,...
FPOptionsOverride CurFPFeatureOverrides()
bool isValidSveBitcast(QualType srcType, QualType destType)
Are the two types SVE-bitcast-compatible types? I.e.
ExprResult ActOnDependentIdExpression(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, bool isAddressOfOperand, const TemplateArgumentListInfo *TemplateArgs)
ActOnDependentIdExpression - Handle a dependent id-expression that was just parsed.
ExprResult BuildStmtExpr(SourceLocation LPLoc, Stmt *SubStmt, SourceLocation RPLoc, unsigned TemplateDepth)
ExprResult BuildCallToMemberFunction(Scope *S, Expr *MemExpr, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false, bool AllowRecovery=false)
BuildCallToMemberFunction - Build a call to a member function.
NamedDecl * LookupSingleName(Scope *S, DeclarationName Name, SourceLocation Loc, LookupNameKind NameKind, RedeclarationKind Redecl=RedeclarationKind::NotForRedeclaration)
Look up a name, looking for a single declaration.
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.
ExprResult BuildVAArgExpr(SourceLocation BuiltinLoc, Expr *E, TypeSourceInfo *TInfo, SourceLocation RPLoc)
ExpressionEvaluationContextRecord & parentEvaluationContext()
FunctionDecl * getCurFunctionDecl(bool AllowLambda=false) const
Returns a pointer to the innermost enclosing function, or nullptr if the current context is not insid...
ExprResult PerformContextualImplicitConversion(SourceLocation Loc, Expr *FromE, ContextualImplicitConverter &Converter)
Perform a contextual implicit conversion.
bool CheckConceptUseInDefinition(NamedDecl *Concept, SourceLocation Loc)
ExprResult UsualUnaryConversions(Expr *E)
UsualUnaryConversions - Performs various conversions that are common to most operators (C99 6....
bool checkPointerAuthEnabled(SourceLocation Loc, SourceRange Range)
ExprResult CheckUnevaluatedOperand(Expr *E)
ExprResult DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT, FunctionDecl *FDecl)
void DiagnoseCommaOperator(const Expr *LHS, SourceLocation Loc)
Look for instances where it is likely the comma operator is confused with another operator.
ExprResult tryConvertExprToType(Expr *E, QualType Ty)
Try to convert an expression E to type Ty.
QualType CheckTemplateIdType(ElaboratedTypeKeyword Keyword, TemplateName Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs)
bool DeduceReturnType(FunctionDecl *FD, SourceLocation Loc, bool Diagnose=true)
std::vector< Token > ExpandFunctionLocalPredefinedMacros(ArrayRef< Token > Toks)
bool CheckMatrixCast(SourceRange R, QualType DestTy, QualType SrcTy, CastKind &Kind)
QualType CheckAddressOfOperand(ExprResult &Operand, SourceLocation OpLoc)
CheckAddressOfOperand - The operand of & must be either a function designator or an lvalue designatin...
ParmVarDecl * BuildParmVarDeclForTypedef(DeclContext *DC, SourceLocation Loc, QualType T)
Synthesizes a variable for a parameter arising from a typedef.
ExprResult CheckSwitchCondition(SourceLocation SwitchLoc, Expr *Cond)
static bool TooManyArguments(size_t NumParams, size_t NumArgs, bool PartialOverloading=false)
To be used for checking whether the arguments being passed to function exceeds the number of paramete...
bool ShouldSplatAltivecScalarInCast(const VectorType *VecTy)
QualType CheckVectorLogicalOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc)
QualType InvalidOperands(SourceLocation Loc, ExprResult &LHS, ExprResult &RHS)
the following "Check" methods will return a valid/converted QualType or a null QualType (indicating a...
bool DiagIfReachable(SourceLocation Loc, ArrayRef< const Stmt * > Stmts, const PartialDiagnostic &PD)
Conditionally issue a diagnostic based on the statements's reachability analysis.
bool BoundsSafetyCheckUseOfCountAttrPtr(const Expr *E)
Perform Bounds Safety semantic checks for uses of invalid uses counted_by or counted_by_or_null point...
QualType CheckShiftOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc, bool IsCompAssign=false)
DiagnosticsEngine & getDiagnostics() const
ExprResult MaybeConvertParenListExprToParenExpr(Scope *S, Expr *ME)
This is not an AltiVec-style cast or or C++ direct-initialization, so turn the ParenListExpr into a s...
bool checkAddressOfFunctionIsAvailable(const FunctionDecl *Function, bool Complain=false, SourceLocation Loc=SourceLocation())
Returns whether the given function's address can be taken or not, optionally emitting a diagnostic if...
bool CheckCaseExpression(Expr *E)
QualType CheckMatrixElementwiseOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign)
Type checking for matrix binary operators.
bool tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD, bool ForceComplain=false, bool(*IsPlausibleResult)(QualType)=nullptr)
Try to recover by turning the given expression into a call.
FunctionDecl * ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr, QualType TargetType, bool Complain, DeclAccessPair &Found, bool *pHadMultipleCandidates=nullptr)
ResolveAddressOfOverloadedFunction - Try to resolve the address of an overloaded function (C++ [over....
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
void LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S, UnresolvedSetImpl &Functions)
void checkSpecializationReachability(SourceLocation Loc, NamedDecl *Spec)
void CleanupVarDeclMarking()
ExprResult DefaultFunctionArrayLvalueConversion(Expr *E, bool Diagnose=true)
bool isImmediateFunctionContext() const
ASTContext & getASTContext() const
ExprResult CallExprUnaryConversions(Expr *E)
CallExprUnaryConversions - a special case of an unary conversion performed on a function designator o...
void translateTemplateArguments(const ASTTemplateArgsPtr &In, TemplateArgumentListInfo &Out)
Translates template arguments as provided by the parser into template arguments used by semantic anal...
ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *Input, bool IsAfterAmp=false)
bool tryCaptureVariable(ValueDecl *Var, SourceLocation Loc, TryCaptureKind Kind, SourceLocation EllipsisLoc, bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType, const unsigned *const FunctionScopeIndexToStopAt)
Try to capture the given variable.
void MarkVariableReferenced(SourceLocation Loc, VarDecl *Var)
Mark a variable referenced, and check whether it is odr-used (C++ [basic.def.odr]p2,...
void LookupBinOp(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opc, UnresolvedSetImpl &Functions)
ExprResult BuildTemplateIdExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, bool RequiresADL, const TemplateArgumentListInfo *TemplateArgs)
void DiagnoseUnguardedAvailabilityViolations(Decl *FD)
Issue any -Wunguarded-availability warnings in FD.
void PopExpressionEvaluationContext()
ExprResult CreateOverloadedBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *LHS, Expr *RHS, bool RequiresADL=true, bool AllowRewrittenCandidates=true, FunctionDecl *DefaultedFn=nullptr)
Create a binary operation that may resolve to an overloaded operator.
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
ExprResult DefaultArgumentPromotion(Expr *E)
DefaultArgumentPromotion (C99 6.5.2.2p6).
ExprResult BuildPredefinedExpr(SourceLocation Loc, PredefinedIdentKind IK)
bool CheckArgsForPlaceholders(MultiExprArg args)
Check an argument list for placeholders that we won't try to handle later.
bool UseArgumentDependentLookup(const CXXScopeSpec &SS, const LookupResult &R, bool HasTrailingLParen)
void InstantiateVariableDefinition(SourceLocation PointOfInstantiation, VarDecl *Var, bool Recursive=false, bool DefinitionRequired=false, bool AtEndOfTU=false)
Instantiate the definition of the given variable from its template.
ExprResult BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo, SourceLocation RParenLoc, Expr *LiteralExpr)
ExprResult ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc, LabelDecl *TheDecl)
ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
QualType CheckSubtractionOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc, QualType *CompLHSTy=nullptr)
DefaultedComparisonKind
Kinds of defaulted comparison operator functions.
@ None
This is not a defaultable comparison operator.
ExprResult ActOnParenListExpr(SourceLocation L, SourceLocation R, MultiExprArg Val)
QualType CheckMatrixMultiplyOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign)
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
ObjCMethodDecl * getCurMethodDecl()
getCurMethodDecl - If inside of a method body, this returns a pointer to the method decl for the meth...
DeclRefExpr * BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, SourceLocation Loc, const CXXScopeSpec *SS=nullptr)
void DefineImplicitMoveConstructor(SourceLocation CurrentLocation, CXXConstructorDecl *Constructor)
DefineImplicitMoveConstructor - Checks for feasibility of defining this constructor as the move const...
ExprResult ActOnChooseExpr(SourceLocation BuiltinLoc, Expr *CondExpr, Expr *LHSExpr, Expr *RHSExpr, SourceLocation RPLoc)
ExprResult CreateGenericSelectionExpr(SourceLocation KeyLoc, SourceLocation DefaultLoc, SourceLocation RParenLoc, bool PredicateIsExpr, void *ControllingExprOrType, ArrayRef< TypeSourceInfo * > Types, ArrayRef< Expr * > Exprs)
ControllingExprOrType is either a TypeSourceInfo * or an Expr *.
ExprResult ActOnUnevaluatedStringLiteral(ArrayRef< Token > StringToks)
void DiagnoseSelfMove(const Expr *LHSExpr, const Expr *RHSExpr, SourceLocation OpLoc)
DiagnoseSelfMove - Emits a warning if a value is moved to itself.
SourceRange getExprRange(Expr *E) const
void AddTemplateOverloadCandidate(FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=true, ADLCallKind IsADLCandidate=ADLCallKind::NotADL, OverloadCandidateParamOrder PO={}, bool AggregateCandidateDeduction=false)
Add a C++ function template specialization as a candidate in the candidate set, using template argume...
std::unique_ptr< sema::FunctionScopeInfo, PoppedFunctionScopeDeleter > PoppedFunctionScopePtr
void DefineImplicitCopyConstructor(SourceLocation CurrentLocation, CXXConstructorDecl *Constructor)
DefineImplicitCopyConstructor - Checks for feasibility of defining this constructor as the copy const...
std::optional< ExpressionEvaluationContextRecord::InitializationContext > OutermostDeclarationWithDelayedImmediateInvocations() const
void DiagnoseUnusedExprResult(const Stmt *S, unsigned DiagID)
DiagnoseUnusedExprResult - If the statement passed in is an expression whose result is unused,...
FPOptions & getCurFPFeatures()
RecordDecl * StdSourceLocationImplDecl
The C++ "std::source_location::__impl" struct, defined in <source_location>.
ConditionResult ActOnCondition(Scope *S, SourceLocation Loc, Expr *SubExpr, ConditionKind CK, bool MissingOK=false)
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
@ UPPC_Block
Block expression.
const LangOptions & getLangOpts() const
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, CorrectionCandidateCallback &CCC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr, bool RecordFailure=true)
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
QualType CheckComparisonCategoryType(ComparisonCategoryType Kind, SourceLocation Loc, ComparisonCategoryUsage Usage)
Lookup the specified comparison category types in the standard library, an check the VarDecls possibl...
void DiagnoseInvalidJumps(Stmt *Body)
QualType CheckCompareOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc)
CastKind PrepareScalarCast(ExprResult &src, QualType destType)
Prepares for a scalar cast, performing all the necessary stages except the final cast and returning t...
bool tryToFixVariablyModifiedVarType(TypeSourceInfo *&TInfo, QualType &T, SourceLocation Loc, unsigned FailedFoldDiagID)
Attempt to fold a variable-sized type to a constant-sized type, returning true if we were successful.
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
void MarkExpressionAsImmediateEscalating(Expr *E)
NonOdrUseReason getNonOdrUseReasonInCurrentContext(ValueDecl *D)
If D cannot be odr-used in the current expression evaluation context, return a reason explaining why.
void DefineDefaultedComparison(SourceLocation Loc, FunctionDecl *FD, DefaultedComparisonKind DCK)
void diagnoseUnavailableAlignedAllocation(const FunctionDecl &FD, SourceLocation Loc)
Produce diagnostics if FD is an aligned allocation or deallocation function that is unavailable.
bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS, QualType ObjectType, bool AllowBuiltinCreation=false, bool EnteringContext=false)
Performs name lookup for a name that was parsed in the source code, and may contain a C++ scope speci...
void MarkFunctionParmPackReferenced(FunctionParmPackExpr *E)
Perform reference-marking and odr-use handling for a FunctionParmPackExpr.
bool DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R, CorrectionCandidateCallback &CCC, TemplateArgumentListInfo *ExplicitTemplateArgs=nullptr, ArrayRef< Expr * > Args={}, DeclContext *LookupCtx=nullptr)
Diagnose an empty lookup.
QualType CheckAdditionOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc, QualType *CompLHSTy=nullptr)
bool isPotentialImplicitMemberAccess(const CXXScopeSpec &SS, LookupResult &R, bool IsAddressOfOperand)
Check whether an expression might be an implicit class member access.
ExprResult BuildCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false, bool AllowRecovery=false)
BuildCallExpr - Handle a call to Fn with the specified array of arguments.
bool CheckUseOfCXXMethodAsAddressOfOperand(SourceLocation OpLoc, const Expr *Op, const CXXMethodDecl *MD)
ExprResult BuildSourceLocExpr(SourceLocIdentKind Kind, QualType ResultTy, SourceLocation BuiltinLoc, SourceLocation RPLoc, DeclContext *ParentContext)
bool ActOnAlignasTypeArgument(StringRef KWName, ParsedType Ty, SourceLocation OpLoc, SourceRange R)
ActOnAlignasTypeArgument - Handle alignas(type-id) and _Alignas(type-name) .
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
void checkTypeSupport(QualType Ty, SourceLocation Loc, ValueDecl *D=nullptr)
Check if the type is allowed to be used for the current target.
bool areMatrixTypesOfTheSameDimension(QualType srcTy, QualType destTy)
Are the two types matrix types and do they have the same dimensions i.e.
void CheckExtraCXXDefaultArguments(Declarator &D)
CheckExtraCXXDefaultArguments - Check for any extra default arguments in the declarator,...
bool hasCStrMethod(const Expr *E)
Check to see if a given expression could have '.c_str()' called on it.
AssignConvertType CheckAssignmentConstraints(SourceLocation Loc, QualType LHSType, QualType RHSType)
CheckAssignmentConstraints - Perform type checking for assignment, argument passing,...
void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=true, bool AllowExplicitConversion=false, ADLCallKind IsADLCandidate=ADLCallKind::NotADL, ConversionSequenceList EarlyConversions={}, OverloadCandidateParamOrder PO={}, bool AggregateCandidateDeduction=false, bool StrictPackMatch=false)
AddOverloadCandidate - Adds the given function to the set of candidate functions, using the given fun...
const LangOptions & LangOpts
void PushExpressionEvaluationContextForFunction(ExpressionEvaluationContext NewContext, FunctionDecl *FD)
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.
VarArgKind isValidVarArgType(const QualType &Ty)
Determine the degree of POD-ness for an expression.
NamedDeclSetType UnusedPrivateFields
Set containing all declared private fields that are not used.
void DefineInheritingConstructor(SourceLocation UseLoc, CXXConstructorDecl *Constructor)
Define the specified inheriting constructor.
void CheckUnusedVolatileAssignment(Expr *E)
Check whether E, which is either a discarded-value expression or an unevaluated operand,...
void maybeAddDeclWithEffects(FuncOrBlockDecl *D)
Inline checks from the start of maybeAddDeclWithEffects, to minimize performance impact on code not u...
void MaybeSuggestAddingStaticToDecl(const FunctionDecl *D)
@ OperatorInExpression
The '<=>' operator was used in an expression and a builtin operator was selected.
bool CanUseDecl(NamedDecl *D, bool TreatUnavailableAsInvalid)
Determine whether the use of this declaration is valid, without emitting diagnostics.
void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse)
Perform marking for a reference to an arbitrary declaration.
void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class, bool DefinitionRequired=false)
Note that the vtable for the given class was used at the given location.
QualType InvalidLogicalVectorOperands(SourceLocation Loc, ExprResult &LHS, ExprResult &RHS)
Diagnose cases where a scalar was implicitly converted to a vector and diagnose the underlying types.
bool diagnoseArgIndependentDiagnoseIfAttrs(const NamedDecl *ND, SourceLocation Loc)
Emit diagnostics for the diagnose_if attributes on Function, ignoring any ArgDependent DiagnoseIfAttr...
CleanupInfo Cleanup
Used to control the generation of ExprWithCleanups.
llvm::DenseMap< ParmVarDecl *, SourceLocation > UnparsedDefaultArgLocs
NamedDecl * getCurFunctionOrMethodDecl() const
getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method or C function we're in,...
QualType CheckMultiplyDivideOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc)
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
bool isQualifiedMemberAccess(Expr *E)
Determine whether the given expression is a qualified member access expression, of a form that could ...
static CastKind ScalarTypeToBooleanCastKind(QualType ScalarTy)
ScalarTypeToBooleanCastKind - Returns the cast kind corresponding to the conversion from scalar type ...
void DefineImplicitLambdaToBlockPointerConversion(SourceLocation CurrentLoc, CXXConversionDecl *Conv)
Define the "body" of the conversion from a lambda object to a block pointer.
void DefineImplicitDestructor(SourceLocation CurrentLocation, CXXDestructorDecl *Destructor)
DefineImplicitDestructor - Checks for feasibility of defining this destructor as the default destruct...
ExprResult BuildCStyleCastExpr(SourceLocation LParenLoc, TypeSourceInfo *Ty, SourceLocation RParenLoc, Expr *Op)
void DiagnoseMisalignedMembers()
Diagnoses the current set of gathered accesses.
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 ActOnEmbedExpr(SourceLocation EmbedKeywordLoc, StringLiteral *BinaryData, StringRef FileName)
bool CheckLoopHintExpr(Expr *E, SourceLocation Loc, bool AllowZero)
QualType CheckSizelessVectorOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign, ArithConvKind OperationKind)
void DiagnoseAssignmentEnum(QualType DstType, QualType SrcType, Expr *SrcExpr)
DiagnoseAssignmentEnum - Warn if assignment to enum is a constant integer not in the range of enum va...
llvm::DenseMap< const VarDecl *, int > RefsMinusAssignments
Increment when we find a reference; decrement when we find an ignored assignment.
ExprResult CreateOverloadedUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *input, bool RequiresADL=true)
Create a unary operation that may resolve to an overloaded operator.
std::optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
bool findMacroSpelling(SourceLocation &loc, StringRef name)
Looks through the macro-expansion chain for the given location, looking for a macro expansion with th...
void DefineImplicitDefaultConstructor(SourceLocation CurrentLocation, CXXConstructorDecl *Constructor)
DefineImplicitDefaultConstructor - Checks for feasibility of defining this constructor as the default...
void AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool PartialOverloading=false)
Add the overload candidates named by callee and/or found by argument dependent lookup to the given ov...
ExprResult DefaultLvalueConversion(Expr *E)
ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)
bool CheckDerivedToBaseConversion(QualType Derived, QualType Base, SourceLocation Loc, SourceRange Range, CXXCastPath *BasePath=nullptr, bool IgnoreAccess=false)
bool isInLifetimeExtendingContext() const
AssignConvertType CheckTransparentUnionArgumentConstraints(QualType ArgType, ExprResult &RHS)
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.
bool IsAssignConvertCompatible(AssignConvertType ConvTy)
sema::BlockScopeInfo * getCurBlock()
Retrieve the current block, if any.
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
MaterializeTemporaryExpr * CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary, bool BoundToLvalueReference)
ExprResult checkUnknownAnyCast(SourceRange TypeRange, QualType CastType, Expr *CastExpr, CastKind &CastKind, ExprValueKind &VK, CXXCastPath &Path)
Check a cast of an unknown-any type.
MultiLevelTemplateArgumentList getTemplateInstantiationArgs(const NamedDecl *D, const DeclContext *DC=nullptr, bool Final=false, std::optional< ArrayRef< TemplateArgument > > Innermost=std::nullopt, bool RelativeToPrimary=false, const FunctionDecl *Pattern=nullptr, bool ForConstraintInstantiation=false, bool SkipForSpecialization=false, bool ForDefaultArgumentSubstitution=false)
Retrieve the template argument list(s) that should be used to instantiate the definition of the given...
SuppressedDiagnosticsMap SuppressedDiagnostics
DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name)
Retrieves the declaration name from a parsed unqualified-id.
std::deque< PendingImplicitInstantiation > PendingLocalImplicitInstantiations
The queue of implicit template instantiations that are required and must be performed within the curr...
ExprResult ActOnGNUNullExpr(SourceLocation TokenLoc)
ExprResult PerformContextuallyConvertToBool(Expr *From)
PerformContextuallyConvertToBool - Perform a contextual conversion of the expression From to bool (C+...
void DefineImplicitCopyAssignment(SourceLocation CurrentLocation, CXXMethodDecl *MethodDecl)
Defines an implicitly-declared copy assignment operator.
bool DiagnoseConditionalForNull(const Expr *LHSExpr, const Expr *RHSExpr, SourceLocation QuestionLoc)
Emit a specialized diagnostic when one expression is a null pointer constant and the other is not a p...
bool CheckFunctionConstraints(const FunctionDecl *FD, ConstraintSatisfaction &Satisfaction, SourceLocation UsageLoc=SourceLocation(), bool ForOverloadResolution=false)
Check whether the given function decl's trailing requires clause is satisfied, if any.
bool IsDerivedFrom(SourceLocation Loc, CXXRecordDecl *Derived, CXXRecordDecl *Base, CXXBasePaths &Paths)
Determine whether the type Derived is a C++ class that is derived from the type Base.
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.
FunctionDecl * ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl, bool Complain=false, DeclAccessPair *Found=nullptr, TemplateSpecCandidateSet *FailedTSC=nullptr, bool ForTypeDeduction=false)
Given an expression that refers to an overloaded function, try to resolve that overloaded function ex...
void CheckShadowingDeclModification(Expr *E, SourceLocation Loc)
Warn if 'E', which is an expression that is about to be modified, refers to a shadowing declaration.
void MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base=nullptr)
Perform reference-marking and odr-use handling for a DeclRefExpr.
ExprResult BuildQualifiedDeclarationNameExpr(CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, bool IsAddressOfOperand, TypeSourceInfo **RecoveryTSI=nullptr)
BuildQualifiedDeclarationNameExpr - Build a C++ qualified declaration name, generally during template...
ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E)
ExprResult ActOnSourceLocExpr(SourceLocIdentKind Kind, SourceLocation BuiltinLoc, SourceLocation RPLoc)
llvm::PointerIntPair< ConstantExpr *, 1 > ImmediateInvocationCandidate
ExprResult CheckPlaceholderExpr(Expr *E)
Check for operands with placeholder types and complain if found.
ExprResult TransformToPotentiallyEvaluated(Expr *E)
EnableIfAttr * CheckEnableIf(FunctionDecl *Function, SourceLocation CallLoc, ArrayRef< Expr * > Args, bool MissingImplicitThis=false)
Check the enable_if expressions on the given function.
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
SourceManager & getSourceManager() const
ExprResult BuildAsTypeExpr(Expr *E, QualType DestTy, SourceLocation BuiltinLoc, SourceLocation RParenLoc)
Create a new AsTypeExpr node (bitcast) from the arguments.
bool CheckVecStepExpr(Expr *E)
ExprResult FixOverloadedFunctionReference(Expr *E, DeclAccessPair FoundDecl, FunctionDecl *Fn)
FixOverloadedFunctionReference - E is an expression that refers to a C++ overloaded function (possibl...
ExprResult ActOnConditionalOp(SourceLocation QuestionLoc, SourceLocation ColonLoc, Expr *CondExpr, Expr *LHSExpr, Expr *RHSExpr)
ActOnConditionalOp - Parse a ?: operation.
bool IsFunctionConversion(QualType FromType, QualType ToType, bool *DiscardingCFIUncheckedCallee=nullptr, bool *AddingCFIUncheckedCallee=nullptr) const
Determine whether the conversion from FromType to ToType is a valid conversion that strips "noexcept"...
QualType CheckVectorCompareOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc)
CheckVectorCompareOperands - vector comparisons are a clang extension that operates on extended vecto...
ExprResult CheckCXXBooleanCondition(Expr *CondExpr, bool IsConstexpr=false)
CheckCXXBooleanCondition - Returns true if conversion to bool is invalid.
ExprResult CheckLValueToRValueConversionOperand(Expr *E)
QualType CheckAssignmentOperands(Expr *LHSExpr, ExprResult &RHS, SourceLocation Loc, QualType CompoundType, BinaryOperatorKind Opc)
void DiscardMisalignedMemberAddress(const Type *T, Expr *E)
This function checks if the expression is in the sef of potentially misaligned members and it is conv...
ExprResult BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, const TemplateArgumentListInfo *TemplateArgs, const Scope *S)
Builds an expression which might be an implicit member expression.
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
bool resolveAndFixAddressOfSingleOverloadCandidate(ExprResult &SrcExpr, bool DoFunctionPointerConversion=false)
Given an overloaded function, tries to turn it into a non-overloaded function reference using resolve...
void DiagnoseAvailabilityOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass, bool ObjCPropertyAccess, bool AvoidPartialAvailabilityChecks, ObjCInterfaceDecl *ClassReceiver)
QualType CheckPointerToMemberOperands(ExprResult &LHS, ExprResult &RHS, ExprValueKind &VK, SourceLocation OpLoc, bool isIndirect)
std::vector< std::pair< QualType, unsigned > > ExcessPrecisionNotSatisfied
bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement, const PartialDiagnostic &PD)
Conditionally issue a diagnostic based on the current evaluation context.
ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param, Expr *Init=nullptr)
BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating the default expr if needed.
bool anyAltivecTypes(QualType srcType, QualType destType)
bool isLaxVectorConversion(QualType srcType, QualType destType)
Is this a legal conversion between two types, one of which is known to be a vector type?
void PushBlockScope(Scope *BlockScope, BlockDecl *Block)
ExprResult BuildOverloadedCallExpr(Scope *S, Expr *Fn, UnresolvedLookupExpr *ULE, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc, Expr *ExecConfig, bool AllowTypoCorrection=true, bool CalleesAddressIsTaken=false)
BuildOverloadedCallExpr - Given the call expression that calls Fn (which eventually refers to the dec...
QualType CXXCheckConditionalOperands(ExprResult &cond, ExprResult &lhs, ExprResult &rhs, ExprValueKind &VK, ExprObjectKind &OK, SourceLocation questionLoc)
Check the operands of ?: under C++ semantics.
ExprResult BuildAnonymousStructUnionMemberReference(const CXXScopeSpec &SS, SourceLocation nameLoc, IndirectFieldDecl *indirectField, DeclAccessPair FoundDecl=DeclAccessPair::make(nullptr, AS_none), Expr *baseObjectExpr=nullptr, SourceLocation opLoc=SourceLocation())
MaybeODRUseExprSet MaybeODRUseExprs
ExprResult PerformImplicitConversion(Expr *From, QualType ToType, const ImplicitConversionSequence &ICS, AssignmentAction Action, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
PerformImplicitConversion - Perform an implicit conversion of the expression From to the type ToType ...
bool InstantiateInClassInitializer(SourceLocation PointOfInstantiation, FieldDecl *Instantiation, FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs)
Instantiate the definition of a field from the given pattern.
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReciever=nullptr, bool SkipTrailingRequiresClause=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics.
bool CheckParmsForFunctionDef(ArrayRef< ParmVarDecl * > Parameters, bool CheckParameterNames)
CheckParmsForFunctionDef - Check that the parameters of the given function are appropriate for the de...
void CheckShadow(NamedDecl *D, NamedDecl *ShadowedDecl, const LookupResult &R)
Diagnose variable or built-in function shadowing.
ExprResult BuildCallToObjectOfClassType(Scope *S, Expr *Object, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc)
BuildCallToObjectOfClassType - Build a call to an object of class type (C++ [over....
ExprResult ActOnStringLiteral(ArrayRef< Token > StringToks, Scope *UDLScope=nullptr)
ActOnStringLiteral - The specified tokens were lexed as pasted string fragments (e....
bool isCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind=CompleteTypeKind::Default)
ExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc, tok::TokenKind Kind, Expr *LHSExpr, Expr *RHSExpr)
Binary Operators. 'Tok' is the token for the operator.
void checkUnusedDeclAttributes(Declarator &D)
checkUnusedDeclAttributes - Given a declarator which is not being used to build a declaration,...
ExprResult CheckExtVectorCast(SourceRange R, QualType DestTy, Expr *CastExpr, CastKind &Kind)
void setFunctionHasBranchProtectedScope()
bool isConstantEvaluatedContext() const
void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation, FunctionDecl *Function, bool Recursive=false, bool DefinitionRequired=false, bool AtEndOfTU=false)
Instantiate the definition of the given function from its template.
void FinalizeVarWithDestructor(VarDecl *VD, CXXRecordDecl *DeclInit)
FinalizeVarWithDestructor - Prepare for calling destructor on the constructed variable.
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, AllowFoldKind CanFold=AllowFoldKind::No)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
bool CheckForConstantInitializer(Expr *Init, unsigned DiagID=diag::err_init_element_not_constant)
type checking declaration initializers (C99 6.7.8)
llvm::SmallPtrSet< const Decl *, 4 > ParsingInitForAutoVars
ParsingInitForAutoVars - a set of declarations with auto types for which we are currently parsing the...
bool CheckPointerConversion(Expr *From, QualType ToType, CastKind &Kind, CXXCastPath &BasePath, bool IgnoreBaseAccess, bool Diagnose=true)
CheckPointerConversion - Check the pointer conversion from the expression From to the type ToType.
SmallVector< ExprWithCleanups::CleanupObject, 8 > ExprCleanupObjects
ExprCleanupObjects - This is the stack of objects requiring cleanup that are created by the current f...
void NoteDeletedFunction(FunctionDecl *FD)
Emit a note explaining that this function is deleted.
sema::AnalysisBasedWarnings AnalysisWarnings
Worker object for performing CFG-based warnings.
std::deque< PendingImplicitInstantiation > PendingInstantiations
The queue of implicit template instantiations that are required but have not yet been performed.
ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc, Expr *Idx, SourceLocation RLoc)
void NoteAllOverloadCandidates(Expr *E, QualType DestType=QualType(), bool TakingAddress=false)
ExprResult ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind)
QualType GetSignedVectorType(QualType V)
Return a signed ext_vector_type that is of identical size and number of elements.
QualType CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS, ExprResult &RHS, ExprValueKind &VK, ExprObjectKind &OK, SourceLocation QuestionLoc)
Note that LHS is not null here, even if this is the gnu "x ?: y" extension.
ExpressionEvaluationContext
Describes how the expressions currently being parsed are evaluated at run-time, if at all.
@ UnevaluatedAbstract
The current expression occurs within an unevaluated operand that unconditionally permits abstract ref...
@ UnevaluatedList
The current expression occurs within a braced-init-list within an unevaluated operand.
@ ConstantEvaluated
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
@ DiscardedStatement
The current expression occurs within a discarded statement.
@ PotentiallyEvaluated
The current expression is potentially evaluated at run time, which means that code may be generated t...
@ Unevaluated
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7),...
@ ImmediateFunctionContext
In addition of being constant evaluated, the current expression occurs in an immediate function conte...
@ PotentiallyEvaluatedIfUsed
The current expression is potentially evaluated, but any declarations referenced inside that expressi...
void CheckCompatibleReinterpretCast(QualType SrcType, QualType DestType, bool IsDereference, SourceRange Range)
ExprResult BuildDependentDeclRefExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)
ExprResult ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy, SourceLocation BuiltinLoc, SourceLocation RParenLoc)
Parse a __builtin_astype expression.
ExprResult CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo, SourceLocation OpLoc, UnaryExprOrTypeTrait ExprKind, SourceRange R)
Build a sizeof or alignof expression given a type operand.
TypeSourceInfo * GetTypeForDeclarator(Declarator &D)
GetTypeForDeclarator - Convert the type for the specified declarator to Type instances.
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
bool CheckCallReturnType(QualType ReturnType, SourceLocation Loc, CallExpr *CE, FunctionDecl *FD)
CheckCallReturnType - Checks that a call expression's return type is complete.
bool CheckUnaryExprOrTypeTraitOperand(Expr *E, UnaryExprOrTypeTrait ExprKind)
Check the constraints on expression operands to unary type expression and type traits.
ExprResult ActOnVAArg(SourceLocation BuiltinLoc, Expr *E, ParsedType Ty, SourceLocation RPLoc)
TypeSourceInfo * GetTypeForDeclaratorCast(Declarator &D, QualType FromTy)
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
ExprResult forceUnknownAnyToType(Expr *E, QualType ToType)
Force an expression with unknown-type to an expression of the given type.
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
void NoteDeletedInheritingConstructor(CXXConstructorDecl *CD)
QualType getCapturedDeclRefType(ValueDecl *Var, SourceLocation Loc)
Given a variable, determine the type that a reference to that variable will have in the given scope.
ExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc, Declarator &D, ParsedType &Ty, SourceLocation RParenLoc, Expr *CastExpr)
ExprResult PerformObjectMemberConversion(Expr *From, NestedNameSpecifier Qualifier, NamedDecl *FoundDecl, NamedDecl *Member)
Cast a base object to a member's actual type.
Expr * MaybeCreateExprWithCleanups(Expr *SubExpr)
MaybeCreateExprWithCleanups - If the current full-expression requires any cleanups,...
bool RebuildingImmediateInvocation
Whether the AST is currently being rebuilt to correct immediate invocations.
void 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)
QualType getCompletedType(Expr *E)
Get the type of expression E, triggering instantiation to complete the type if necessary – that is,...
void mergeDeclAttributes(NamedDecl *New, Decl *Old, AvailabilityMergeKind AMK=AvailabilityMergeKind::Redeclaration)
mergeDeclAttributes - Copy attributes from the Old decl to the New one.
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.
ExprResult UsualUnaryFPConversions(Expr *E)
UsualUnaryFPConversions - Promotes floating-point types according to the current language semantics.
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 BuildBinOp(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr, bool ForFoldExpression=false)
ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)
void diagnoseMissingTemplateArguments(TemplateName Name, SourceLocation Loc)
ExprResult ActOnIntegerConstant(SourceLocation Loc, int64_t Val)
ExprResult BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field)
void DiagnoseAssignmentAsCondition(Expr *E)
DiagnoseAssignmentAsCondition - Given that an expression is being used as a boolean condition,...
void checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec)
We've found a use of a templated declaration that would trigger an implicit instantiation.
QualType CheckBitwiseOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc)
llvm::MapVector< NamedDecl *, SourceLocation > UndefinedButUsed
UndefinedInternals - all the used, undefined objects which require a definition in this translation u...
ExprResult ActOnStmtExpr(Scope *S, SourceLocation LPLoc, Stmt *SubStmt, SourceLocation RPLoc)
bool ResolveAndFixSingleFunctionTemplateSpecialization(ExprResult &SrcExpr, bool DoFunctionPointerConversion=false, bool Complain=false, SourceRange OpRangeForComplaining=SourceRange(), QualType DestTypeForComplaining=QualType(), unsigned DiagIDForComplaining=0)
ExprResult ConvertParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg, SourceLocation EqualLoc)
void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD)
ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in it, apply them to D.
void checkVariadicArgument(const Expr *E, VariadicCallType CT)
Check to see if the given expression is a valid argument to a variadic function, issuing a diagnostic...
void CheckStaticArrayArgument(SourceLocation CallLoc, ParmVarDecl *Param, const Expr *ArgExpr)
CheckStaticArrayArgument - If the given argument corresponds to a static array parameter,...
QualType CheckSizelessVectorCompareOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc)
ExprResult ConvertMemberDefaultInitExpression(FieldDecl *FD, Expr *InitExpr, SourceLocation InitLoc)
bool IsInvalidSMECallConversion(QualType FromType, QualType ToType)
void checkNonTrivialCUnionInInitializer(const Expr *Init, SourceLocation Loc)
Emit diagnostics if the initializer or any of its explicit or implicitly-generated subexpressions req...
ExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc, Stmt *Body, Scope *CurScope)
ActOnBlockStmtExpr - This is called when the body of a block statement literal was successfully compl...
void DiagnoseDeletedDefaultedFunction(FunctionDecl *FD)
Produce notes explaining why a defaulted function was defined as deleted.
void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)
Run some code with "sufficient" stack space.
void MarkMemberReferenced(MemberExpr *E)
Perform reference-marking and odr-use handling for a MemberExpr.
bool DiagnoseAssignmentResult(AssignConvertType ConvTy, SourceLocation Loc, QualType DstType, QualType SrcType, Expr *SrcExpr, AssignmentAction Action, bool *Complained=nullptr)
DiagnoseAssignmentResult - Emit a diagnostic, if required, for the assignment conversion type specifi...
void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, bool MightBeOdrUse=true)
Mark a function referenced, and check whether it is odr-used (C++ [basic.def.odr]p2,...
ExprResult ActOnStmtExprResult(ExprResult E)
ExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc, tok::TokenKind Kind, Expr *Input)
std::tuple< MangleNumberingContext *, Decl * > getCurrentMangleNumberContext(const DeclContext *DC)
Compute the mangling number context for a lambda expression or block literal.
void DiagnoseEqualityWithExtraParens(ParenExpr *ParenE)
Redundant parentheses over an equality comparison can indicate that the user intended an assignment u...
SemaDiagnosticBuilder targetDiag(SourceLocation Loc, unsigned DiagID, const FunctionDecl *FD=nullptr)
ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End, ArrayRef< Expr * > SubExprs, QualType T=QualType())
Attempts to produce a RecoveryExpr after some AST node cannot be created.
ExprResult ActOnNumericConstant(const Token &Tok, Scope *UDLScope=nullptr)
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)
void DiagnoseUnsatisfiedConstraint(const ConstraintSatisfaction &Satisfaction, bool First=true)
Emit diagnostics explaining why a constraint expression was deemed unsatisfied.
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
@ 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.
void checkEnumArithmeticConversions(Expr *LHS, Expr *RHS, SourceLocation Loc, ArithConvKind ACK)
Check that the usual arithmetic conversions can be performed on this pair of expressions that might b...
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType)
Helper function to determine whether this is the (deprecated) C++ conversion from a string literal to...
void computeNRVO(Stmt *Body, sema::FunctionScopeInfo *Scope)
Given the set of return statements within a function body, compute the variables that are subject to ...
void checkNonTrivialCUnion(QualType QT, SourceLocation Loc, NonTrivialCUnionContext UseContext, unsigned NonTrivialKind)
Emit diagnostics if a non-trivial C union type or a struct that contains a non-trivial C union is use...
static ConditionResult ConditionError()
ExprResult ActOnConvertVectorExpr(Expr *E, ParsedType ParsedDestTy, SourceLocation BuiltinLoc, SourceLocation RParenLoc)
ActOnConvertVectorExpr - create a new convert-vector expression from the provided arguments.
void HandleFunctionTypeMismatch(PartialDiagnostic &PDiag, QualType FromType, QualType ToType)
HandleFunctionTypeMismatch - Gives diagnostic information for differeing function types.
ExprResult checkUnknownAnyArg(SourceLocation callLoc, Expr *result, QualType ¶mType)
Type-check an expression that's being passed to an __unknown_anytype parameter.
bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn, FunctionDecl *FDecl, const FunctionProtoType *Proto, ArrayRef< Expr * > Args, SourceLocation RParenLoc, bool ExecConfig=false)
ConvertArgumentsForCall - Converts the arguments specified in Args/NumArgs to the parameter types of ...
ExprResult ActOnBuiltinOffsetOf(Scope *S, SourceLocation BuiltinLoc, SourceLocation TypeLoc, ParsedType ParsedArgTy, ArrayRef< OffsetOfComponent > Components, SourceLocation RParenLoc)
SemaPseudoObject & PseudoObject()
bool hasAnyUnrecoverableErrorsInThisFunction() const
Determine whether any errors occurred within this function/method/ block.
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.
void DiagnoseImmediateEscalatingReason(FunctionDecl *FD)
ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)
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
static StringLiteral * Create(const ASTContext &Ctx, StringRef Str, StringLiteralKind Kind, bool Pascal, QualType Ty, ArrayRef< SourceLocation > Locs)
This is the "fully general" constructor that allows representation of strings formed from one or more...
uint32_t getCodeUnit(size_t i) const
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?
void setElaboratedKeywordLoc(SourceLocation Loc)
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Exposes information about the current target.
virtual bool hasLongDoubleType() const
Determine whether the long double type is supported on this target.
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
@ CharPtrBuiltinVaList
typedef char* __builtin_va_list;
virtual size_t getMaxBitIntWidth() const
virtual bool useFP16ConversionIntrinsics() const
Check whether llvm intrinsics such as llvm.convert.to.fp16 should be used to convert to and from __fp...
unsigned getTypeWidth(IntType T) const
Return the width (in bits) of the specified integer type enum.
uint64_t getPointerWidth(LangAS AddrSpace) const
Return the width of pointers on this target, for the specified address space.
virtual bool hasInt128Type() const
Determine whether the __int128 type is supported on this target.
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.
bool shouldUseMicrosoftCCforMangling() const
Should the Microsoft mangling scheme be used for C Calling Convention.
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.
bool isDependent() const
Whether this template argument is dependent on a template parameter such that its result can change f...
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 startToken()
Reset all flags to cleared.
Represents a declaration of a type.
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.
bool isFixedPointOrIntegerType() const
Return true if this is a fixed point or integer type.
bool isBlockPointerType() const
bool isBooleanType() const
bool isFunctionReferenceType() const
bool isObjCBuiltinType() const
bool isMFloat8Type() const
bool hasAttr(attr::Kind AK) const
Determine whether this type had the specified attribute applied to it (looking through top-level type...
const Type * getPointeeOrArrayElementType() const
If this is a pointer type, return the pointee type.
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
bool isIncompleteArrayType() const
bool isPlaceholderType() const
Test for a type which does not represent an actual type-system type but is instead used as a placehol...
bool isComplexType() const
isComplexType() does not include complex integers (a GCC extension).
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool canDecayToPointerType() const
Determines whether this type can decay to a pointer type.
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
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 isChar16Type() const
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 isChar32Type() const
EnumDecl * castAsEnumDecl() 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...
EnumDecl * getAsEnumDecl() const
Retrieves the EnumDecl this type refers to.
bool isDoubleType() const
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isFunctionType() const
bool isObjCObjectPointerType() const
bool hasFloatingRepresentation() const
Determine whether this type has a floating-point representation of some sort, e.g....
bool isMemberFunctionPointerType() const
bool isUnsignedFixedPointType() const
Return true if this is a fixed point type that is unsigned according to ISO/IEC JTC1 SC22 WG14 N1169.
bool isVectorType() const
bool isObjCQualifiedClassType() const
bool isObjCClassType() const
bool isRealFloatingType() const
Floating point categories.
bool isRVVSizelessBuiltinType() const
Returns true for RVV scalable vector types.
const T * getAsCanonical() const
If this type is canonically the specified type, return its canonical type cast to that specified type...
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...
const T * castAsCanonical() const
Return this type's canonical type cast to the specified type.
bool isAnyPointerType() const
TypeClass getTypeClass() const
bool isSubscriptableVectorType() const
const T * getAs() const
Member-template getAs<specific type>'.
bool isNullPtrType() const
bool isRecordType() const
std::optional< NullabilityKind > getNullability() const
Determine the nullability of the given type.
bool isSizelessVectorType() const
Returns true for all scalable vector types.
bool isScopedEnumeralType() const
Determine whether this type is a scoped enumeration type.
bool isUnicodeCharacterType() const
Wrapper for source info for typedefs.
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.
bool isOverloaded() const
NestedNameSpecifier getCorrectionSpecifier() const
Gets the NestedNameSpecifier needed to use the typo correction.
NamedDecl * getFoundDecl() const
Get the correction declaration found by name lookup (before we looked through using shadow declaratio...
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand.
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
SourceLocation getOperatorLoc() const
getOperatorLoc - Return the location of the operator.
Expr * getSubExpr() const
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)
Retrieve the overloaded operator kind that corresponds to the given unary opcode.
static UnaryOperator * Create(const ASTContext &C, Expr *input, Opcode opc, QualType type, ExprValueKind VK, ExprObjectKind OK, SourceLocation l, bool CanOverflow, FPOptionsOverride FPFeatures)
bool isIncrementDecrementOp() const
An artificial decl, representing a global anonymous constant value which is uniquified by value withi...
Represents a C++ unqualified-id that has been parsed.
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
static UnresolvedLookupExpr * Create(const ASTContext &Context, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool RequiresADL, UnresolvedSetIterator Begin, UnresolvedSetIterator End, bool KnownDependent, bool KnownInstantiationDependent)
Represents a C++ member access expression for which lookup produced a set of overloaded functions.
CXXRecordDecl * getNamingClass()
Retrieve the naming class of this lookup.
bool isImplicitAccess() const
True if this is an implicit access, i.e., one in which the member being accessed was not written in t...
A set of unresolved declarations.
A set of unresolved declarations.
A call to a literal operator (C++11 [over.literal]) written as a user-defined literal (C++11 [lit....
Represents a call to the builtin function __builtin_va_arg.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
void setType(QualType newType)
VarDecl * getPotentiallyDecomposedVarDecl()
Represents a variable declaration or definition.
VarDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
bool isStaticDataMember() const
Determines whether this is a static data member.
bool hasGlobalStorage() const
Returns true for all variables that do not have local storage.
bool mightBeUsableInConstantExpressions(const ASTContext &C) const
Determine whether this variable's value might be usable in a constant expression, according to the re...
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
For a static data member that was instantiated from a static data member of a class template,...
bool isInline() const
Whether this variable is (C++1z) inline.
const Expr * getInit() const
bool hasExternalStorage() const
Returns true if a variable has extern or private_extern storage.
bool hasLocalStorage() const
Returns true if a variable with function scope is a non-static local variable.
@ TLS_None
Not a TLS variable.
@ DeclarationOnly
This declaration is only a declaration.
DefinitionKind hasDefinition(ASTContext &) const
Check whether this variable is defined in this translation unit.
bool isUsableInConstantExpressions(const ASTContext &C) const
Determine whether this variable's value can be used in a constant expression, according to the releva...
SourceLocation getPointOfInstantiation() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
bool isLocalVarDeclOrParm() const
Similar to isLocalVarDecl but also includes parameters.
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this variable is an instantiation of a static data member of a class template specialization,...
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 getPolicyInEffectAt(SourceLocation Loc)
Retains information about a block that is currently being parsed.
Scope * TheScope
TheScope - This is the scope for the block itself, which contains arguments etc.
QualType FunctionType
BlockType - The function type of the block, if one was given.
ValueDecl * getVariable() const
bool isBlockCapture() const
SourceLocation getLocation() const
Retrieve the location at which this variable was captured.
void markUsed(bool IsODRUse)
bool isThisCapture() const
QualType getCaptureType() const
Retrieve the capture type for this capture, which is effectively the type of the non-static data memb...
bool isCopyCapture() const
Retains information about a captured region.
unsigned short OpenMPLevel
unsigned short CapRegionKind
The kind of captured region.
unsigned short OpenMPCaptureLevel
void addVLATypeCapture(SourceLocation Loc, const VariableArrayType *VLAType, QualType CaptureType)
QualType ReturnType
ReturnType - The target type of return statements in this context, or null if unknown.
bool ContainsUnexpandedParameterPack
Whether this contains an unexpanded parameter pack.
SmallVector< Capture, 4 > Captures
Captures - The captures.
ImplicitCaptureStyle ImpCaptureStyle
unsigned CXXThisCaptureIndex
CXXThisCaptureIndex - The (index+1) of the capture of 'this'; zero if 'this' is not captured.
bool HasImplicitReturnType
Capture & getCXXThisCapture()
Retrieve the capture of C++ 'this', if it has been captured.
llvm::DenseMap< ValueDecl *, unsigned > CaptureMap
CaptureMap - A map of captured variables to (index+1) into Captures.
bool isCXXThisCaptured() const
Determine whether the C++ 'this' is captured.
bool isVLATypeCaptured(const VariableArrayType *VAT) const
Determine whether the given variable-array type has been captured.
void addCapture(ValueDecl *Var, bool isBlock, bool isByref, bool isNested, SourceLocation Loc, SourceLocation EllipsisLoc, QualType CaptureType, bool Invalid)
Capture & getCapture(ValueDecl *Var)
Retrieve the capture of the given variable, if it has been captured already.
Retains information about a function, method, or block that is currently being parsed.
void recordUseOfWeak(const ExprT *E, bool IsRead=true)
Record that a weak object was accessed.
void markSafeWeakUse(const Expr *E)
Record that a given expression is a "safe" access of a weak object (e.g.
void addBlock(const BlockDecl *BD)
void setHasBranchProtectedScope()
llvm::SmallVector< AddrLabelExpr *, 4 > AddrLabels
The set of GNU address of label extension "&&label".
bool HasOMPDeclareReductionCombiner
True if current scope is for OpenMP declare reduction combiner.
SourceRange IntroducerRange
Source range covering the lambda introducer [...].
bool lambdaCaptureShouldBeConst() const
void addPotentialCapture(Expr *VarExpr)
Add a variable that might potentially be captured by the lambda and therefore the enclosing lambdas.
void addPotentialThisCapture(SourceLocation Loc)
llvm::SmallPtrSet< VarDecl *, 4 > CUDAPotentialODRUsedVars
Variables that are potentially ODR-used in CUDA/HIP.
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.
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
void checkAssignmentLifetime(Sema &SemaRef, const AssignedEntity &Entity, Expr *Init)
Check that the lifetime of the given expr (and its subobjects) is sufficient for assigning to the ent...
bool isStringLiteral(TokenKind K)
Return true if this is a C or C++ string-literal (or C++11 user-defined-string-literal) token.
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
The JSON file list parser is used to communicate input to InstallAPI.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
@ OO_None
Not an overloaded operator.
bool isa(CodeGen::Address addr)
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))
@ OR_Success
Overload resolution succeeded.
bool isTargetAddressSpace(LangAS AS)
DeclContext * getLambdaAwareParentOfDeclContext(DeclContext *DC)
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
ArithConvKind
Context in which we're performing a usual arithmetic conversion.
@ BitwiseOp
A bitwise operation.
@ Arithmetic
An arithmetic operation.
@ Conditional
A conditional (?:) operator.
@ CompAssign
A compound assignment expression.
@ Comparison
A comparison.
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.
std::string FormatUTFCodeUnitAsCodepoint(unsigned Value, QualType T)
@ Vector
'vector' clause, allowed on 'loop', Combined, and 'routine' directives.
@ Self
'self' clause, allowed on Compute and Combined Constructs, plus 'update'.
@ IK_ImplicitSelfParam
An implicit 'self' parameter.
@ IK_TemplateId
A template-id, e.g., f<int>.
llvm::omp::Clause OpenMPClauseKind
OpenMP clauses.
std::optional< ComparisonCategoryType > getComparisonCategoryForBuiltinCmp(QualType T)
Get the comparison category that should be used when comparing values of type T.
@ Dependent
Parse the block as a dependent block, which may be used in some template instantiations but not other...
UnaryExprOrTypeTrait
Names for the "expression or type" traits.
unsigned toTargetAddressSpace(LangAS AS)
@ Internal
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
TemplateDecl * getAsTypeTemplateDecl(Decl *D)
bool isLambdaCallOperator(const CXXMethodDecl *MD)
@ Result
The result type of a method or function.
ImplicitConversionKind
ImplicitConversionKind - The kind of implicit conversion used to convert an argument to a parameter's...
@ ICK_Complex_Conversion
Complex conversions (C99 6.3.1.6)
@ ICK_Integral_Conversion
Integral conversions (C++ [conv.integral])
@ ICK_Floating_Integral
Floating-integral conversions (C++ [conv.fpint])
@ ICK_HLSL_Array_RValue
HLSL non-decaying array rvalue cast.
@ ICK_Array_To_Pointer
Array-to-pointer conversion (C++ [conv.array])
@ ICK_Identity
Identity conversion (no conversion)
@ ICK_Lvalue_To_Rvalue
Lvalue-to-rvalue conversion (C++ [conv.lval])
@ ICK_Floating_Conversion
Floating point conversions (C++ [conv.double].
@ ICK_Complex_Real
Complex-real conversions (C99 6.3.1.7)
@ ICK_Function_To_Pointer
Function-to-pointer (C++ [conv.array])
AssignConvertType
AssignConvertType - All of the 'assignment' semantic checks return this enum to indicate whether the ...
@ IncompatiblePointer
IncompatiblePointer - The assignment is between two pointers types that are not compatible,...
@ Incompatible
Incompatible - We reject this conversion outright, it is invalid to represent it in the AST.
@ IntToPointer
IntToPointer - The assignment converts an int to a pointer, which we accept as an extension.
@ IncompatibleVectors
IncompatibleVectors - The assignment is between two vector types that have the same size,...
@ IncompatibleNestedPointerAddressSpaceMismatch
IncompatibleNestedPointerAddressSpaceMismatch - The assignment changes address spaces in nested point...
@ IncompatibleObjCWeakRef
IncompatibleObjCWeakRef - Assigning a weak-unavailable object to an object with __weak qualifier.
@ IntToBlockPointer
IntToBlockPointer - The assignment converts an int to a block pointer.
@ CompatibleVoidPtrToNonVoidPtr
CompatibleVoidPtrToNonVoidPtr - The types are compatible in C because a void * can implicitly convert...
@ IncompatiblePointerDiscardsQualifiers
IncompatiblePointerDiscardsQualifiers - The assignment discards qualifiers that we don't permit to be...
@ CompatiblePointerDiscardsQualifiers
CompatiblePointerDiscardsQualifiers - The assignment discards c/v/r qualifiers, which we accept as an...
@ IncompatibleObjCQualifiedId
IncompatibleObjCQualifiedId - The assignment is between a qualified id type and something else (that ...
@ Compatible
Compatible - the types are compatible according to the standard.
@ IncompatibleFunctionPointerStrict
IncompatibleFunctionPointerStrict - The assignment is between two function pointer types that are not...
@ PointerToInt
PointerToInt - The assignment converts a pointer to an int, which we accept as an extension.
@ FunctionVoidPointer
FunctionVoidPointer - The assignment is between a function pointer and void*, which the standard does...
@ IncompatibleNestedPointerQualifiers
IncompatibleNestedPointerQualifiers - The assignment is between two nested pointer types,...
@ 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 ...
@ IncompatibleBlockPointer
IncompatibleBlockPointer - The assignment is between two block pointers types that are not compatible...
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.
bool isLambdaConversionOperator(CXXConversionDecl *C)
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.
@ TNK_Concept_template
The name refers to a concept.
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.
for(const auto &A :T->param_types())
const FunctionProtoType * T
@ NK_Not_Narrowing
Not a narrowing conversion.
@ NK_Constant_Narrowing
A narrowing conversion, because a constant expression got narrowed.
@ NK_Dependent_Narrowing
Cannot tell whether this is a narrowing conversion because the expression is value-dependent.
@ NK_Type_Narrowing
A narrowing conversion by virtue of the source and destination types.
@ NK_Variable_Narrowing
A narrowing conversion, because a non-constant-expression variable might have got narrowed.
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
@ TSK_ExplicitInstantiationDeclaration
This template specialization was instantiated from a template due to an explicit instantiation declar...
@ TSK_ImplicitInstantiation
This template specialization was implicitly instantiated from a template.
@ TSK_Undeclared
This template specialization was formed from a template-id but has not yet been declared,...
CallingConv
CallingConv - Specifies the calling convention that a function uses.
@ AltiVecBool
is AltiVec 'vector bool ...'
@ SveFixedLengthData
is AArch64 SVE fixed-length data vector
@ AltiVecVector
is AltiVec vector
@ AltiVecPixel
is AltiVec 'vector Pixel'
@ Generic
not a target-specific vector type
@ RVVFixedLengthData
is RISC-V RVV fixed-length data vector
@ RVVFixedLengthMask
is RISC-V RVV fixed-length mask vector
@ SveFixedLengthPredicate
is AArch64 SVE fixed-length predicate vector
@ None
No keyword precedes the qualified type name.
bool isLambdaMethod(const DeclContext *DC)
@ 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.
SourceRange getSourceRange() const LLVM_READONLY
getSourceRange - The range of the declaration name.
SourceLocation getEndLoc() const LLVM_READONLY
Stores data related to a single #embed directive.
EvalResult is a struct with detailed info about an evaluated expression.
APValue Val
Val - This is the value the expression can be folded to.
SmallVectorImpl< PartialDiagnosticAt > * Diag
Diag - If this is non-null, it will be filled in with a stack of notes indicating why evaluation fail...
bool HasUndefinedBehavior
Whether the evaluation hit undefined behavior.
bool HasSideEffects
Whether the evaluated expression has side effects.
Extra information about a function prototype.
FunctionType::ExtInfo ExtInfo
bool IsAddressOfOperandWithParen
bool HasFormOfMemberPointer
OverloadExpr * Expression
@ DefaultFunctionArgumentInstantiation
We are instantiating a default argument for a function.
Data structure used to record current or nested expression evaluation contexts.
llvm::SmallPtrSet< const Expr *, 8 > PossibleDerefs
bool InLifetimeExtendingContext
Whether we are currently in a context in which all temporaries must be lifetime-extended,...
Decl * ManglingContextDecl
The declaration that provides context for lambda expressions and block literals if the normal declara...
SmallVector< Expr *, 2 > VolatileAssignmentLHSs
Expressions appearing as the LHS of a volatile assignment in this context.
bool isUnevaluated() const
llvm::SmallPtrSet< DeclRefExpr *, 4 > ReferenceToConsteval
Set of DeclRefExprs referencing a consteval function when used in a context not already known to be i...
llvm::SmallVector< ImmediateInvocationCandidate, 4 > ImmediateInvocationCandidates
Set of candidates for starting an immediate invocation.
bool isImmediateFunctionContext() const
SmallVector< MaterializeTemporaryExpr *, 8 > ForRangeLifetimeExtendTemps
P2718R0 - Lifetime extension in range-based for loops.
enum clang::Sema::ExpressionEvaluationContextRecord::ExpressionKind ExprContext
SmallVector< LambdaExpr *, 2 > Lambdas
The lambdas that are present within this context, if it is indeed an unevaluated context.
ExpressionKind
Describes whether we are in an expression constext which we have to handle differently.
MaybeODRUseExprSet SavedMaybeODRUseExprs
CleanupInfo ParentCleanup
Whether the enclosing context needed a cleanup.
bool isConstantEvaluated() const
bool isDiscardedStatementContext() const
ExpressionEvaluationContext Context
The expression evaluation context.
bool InImmediateEscalatingFunctionContext
unsigned NumCleanupObjects
The number of active cleanup objects when we entered this expression evaluation context.
Abstract class used to diagnose incomplete types.
Location information for a TemplateArgument.
Describes an entity that is being assigned.