48#include "llvm/ADT/APInt.h"
49#include "llvm/ADT/STLExtras.h"
50#include "llvm/ADT/STLForwardCompat.h"
51#include "llvm/ADT/StringExtras.h"
52#include "llvm/Support/ErrorHandling.h"
53#include "llvm/Support/TypeSize.h"
83 llvm_unreachable(
"Nested name specifier is not a type for inheriting ctor");
97 "not a constructor name");
119 auto *RD = dyn_cast<CXXRecordDecl>(ND);
120 if (RD && RD->isInjectedClassName()) {
121 InjectedClassName = RD;
125 if (!InjectedClassName) {
130 diag::err_incomplete_nested_name_spec) << CurClass << SS.
getRange();
145 bool EnteringContext) {
191 auto IsAcceptableResult = [&](
NamedDecl *
D) ->
bool {
192 auto *
Type = dyn_cast<TypeDecl>(
D->getUnderlyingDecl());
203 unsigned NumAcceptableResults = 0;
205 if (IsAcceptableResult(
D))
206 ++NumAcceptableResults;
211 if (
auto *RD = dyn_cast<CXXRecordDecl>(
D))
212 if (RD->isInjectedClassName())
213 D = cast<NamedDecl>(RD->getParent());
215 if (FoundDeclSet.insert(
D).second)
216 FoundDecls.push_back(
D);
224 if (
Found.isAmbiguous() && NumAcceptableResults == 1) {
225 Diag(NameLoc, diag::ext_dtor_name_ambiguous);
229 if (
auto *TD = dyn_cast<TypeDecl>(
D->getUnderlyingDecl()))
235 if (!IsAcceptableResult(
D))
241 if (
Found.isAmbiguous())
245 if (IsAcceptableResult(
Type)) {
257 bool IsDependent =
false;
259 auto LookupInObjectType = [&]() ->
ParsedType {
260 if (Failed || SearchType.
isNull())
270 return CheckLookupResult(
Found);
288 return CheckLookupResult(
Found);
297 return CheckLookupResult(
Found);
344 if (
ParsedType T = LookupInNestedNameSpec(PrefixSS))
374 unsigned NumNonExtensionDecls = FoundDecls.size();
398 Diag(SS.
getEndLoc(), diag::ext_qualified_dtor_named_in_lexical_scope)
400 Diag(FoundDecls.back()->getLocation(), diag::note_destructor_type_here)
411 FoundDecls.resize(NumNonExtensionDecls);
414 std::stable_sort(FoundDecls.begin(), FoundDecls.end(),
416 return isa<TypeDecl>(A->getUnderlyingDecl()) >
417 isa<TypeDecl>(B->getUnderlyingDecl());
421 auto MakeFixItHint = [&]{
427 Destroyed = dyn_cast_or_null<CXXRecordDecl>(S->getEntity());
434 if (FoundDecls.empty()) {
436 Diag(NameLoc, diag::err_undeclared_destructor_name)
437 << &II << MakeFixItHint();
438 }
else if (!SearchType.
isNull() && FoundDecls.size() == 1) {
439 if (
auto *TD = dyn_cast<TypeDecl>(FoundDecls[0]->getUnderlyingDecl())) {
440 assert(!SearchType.
isNull() &&
441 "should only reject a type result if we have a search type");
443 Diag(NameLoc, diag::err_destructor_expr_type_mismatch)
444 <<
T << SearchType << MakeFixItHint();
446 Diag(NameLoc, diag::err_destructor_expr_nontype)
447 << &II << MakeFixItHint();
450 Diag(NameLoc, SearchType.
isNull() ? diag::err_destructor_name_nontype
451 : diag::err_destructor_expr_mismatch)
452 << &II << SearchType << MakeFixItHint();
456 if (
auto *TD = dyn_cast<TypeDecl>(FoundD->getUnderlyingDecl()))
457 Diag(FoundD->getLocation(), diag::note_destructor_type_here)
460 Diag(FoundD->getLocation(), diag::note_destructor_nontype_here)
478 "unexpected type in getDestructorType");
507 Name.getSourceRange(),
508 (StringRef(
"operator\"\"") + II->
getName()).str());
510 Diag(
Loc, diag::warn_reserved_extern_symbol)
511 << II << static_cast<int>(Status) << Hint;
513 Diag(
Loc, diag::warn_deprecated_literal_operator_id) << II << Hint;
529 Diag(Name.getBeginLoc(), diag::err_literal_operator_id_outside_namespace)
540 llvm_unreachable(
"unknown nested name specifier kind");
561 return ExprError(
Diag(TypeidLoc, diag::err_variably_modified_typeid) <<
T);
574 bool WasEvaluated =
false;
584 CXXRecordDecl *RecordD = cast<CXXRecordDecl>(RecordT->getDecl());
630 return ExprError(
Diag(TypeidLoc, diag::err_variably_modified_typeid)
637 ? diag::warn_side_effects_typeid
638 : diag::warn_side_effects_unevaluated_context);
651 return ExprError(
Diag(OpLoc, diag::err_openclcxx_not_supported)
657 return ExprError(
Diag(OpLoc, diag::err_need_header_before_typeid));
671 return ExprError(
Diag(OpLoc, diag::err_need_header_before_typeid));
675 return ExprError(
Diag(OpLoc, diag::err_no_typeid_with_fno_rtti));
699 if (
auto *CTE = dyn_cast<CXXTypeidExpr>(
Result.get()))
700 if (CTE->isPotentiallyEvaluated() && !CTE->isMostDerived(
Context))
701 Diag(OpLoc, diag::warn_no_typeid_with_rtti_disabled)
723 if (
const auto *Uuid = TD->getMostRecentDecl()->getAttr<UuidAttr>()) {
724 UuidAttrs.insert(Uuid);
729 if (
const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(TD)) {
732 const UuidAttr *UuidForTA =
nullptr;
739 UuidAttrs.insert(UuidForTA);
749 if (!Operand->getType()->isDependentType()) {
752 if (UuidAttrs.empty())
753 return ExprError(
Diag(TypeidLoc, diag::err_uuidof_without_guid));
754 if (UuidAttrs.size() > 1)
755 return ExprError(
Diag(TypeidLoc, diag::err_uuidof_with_multiple_guids));
756 Guid = UuidAttrs.back()->getGuidDecl();
773 if (UuidAttrs.empty())
774 return ExprError(
Diag(TypeidLoc, diag::err_uuidof_without_guid));
775 if (UuidAttrs.size() > 1)
776 return ExprError(
Diag(TypeidLoc, diag::err_uuidof_with_multiple_guids));
777 Guid = UuidAttrs.back()->getGuidDecl();
812 assert((Kind == tok::kw_true || Kind == tok::kw_false) &&
813 "Unknown C++ Boolean value!");
825 bool IsThrownVarInScope =
false;
838 if (
const auto *DRE = dyn_cast<DeclRefExpr>(Ex->
IgnoreParens()))
839 if (
const auto *Var = dyn_cast<VarDecl>(DRE->getDecl());
840 Var && Var->hasLocalStorage() &&
841 !Var->getType().isVolatileQualified()) {
842 for (; S; S = S->getParent()) {
843 if (S->isDeclScope(Var)) {
844 IsThrownVarInScope =
true;
861 bool IsThrownVarInScope) {
863 const bool IsOpenMPGPUTarget =
864 getLangOpts().OpenMPIsTargetDevice && (
T.isNVPTX() ||
T.isAMDGCN());
867 if (!IsOpenMPGPUTarget && !
getLangOpts().CXXExceptions &&
870 targetDiag(OpLoc, diag::err_exceptions_disabled) <<
"throw";
874 if (IsOpenMPGPUTarget)
875 targetDiag(OpLoc, diag::warn_throw_not_valid_on_target) <<
T.str();
880 <<
"throw" << llvm::to_underlying(
CUDA().CurrentTarget());
883 Diag(OpLoc, diag::err_omp_simd_region_cannot_use_stmt) <<
"throw";
888 Diag(OpLoc, diag::err_acc_branch_in_out_compute_construct)
932 llvm::DenseMap<CXXRecordDecl *, unsigned> &SubobjectsSeen,
933 llvm::SmallPtrSetImpl<CXXRecordDecl *> &VBases,
934 llvm::SetVector<CXXRecordDecl *> &PublicSubobjectsSeen,
935 bool ParentIsPublic) {
937 CXXRecordDecl *BaseDecl = BS.getType()->getAsCXXRecordDecl();
942 NewSubobject = VBases.insert(BaseDecl).second;
947 ++SubobjectsSeen[BaseDecl];
950 bool PublicPath = ParentIsPublic && BS.getAccessSpecifier() ==
AS_public;
952 PublicSubobjectsSeen.insert(BaseDecl);
962 llvm::DenseMap<CXXRecordDecl *, unsigned> SubobjectsSeen;
963 llvm::SmallSet<CXXRecordDecl *, 2> VBases;
964 llvm::SetVector<CXXRecordDecl *> PublicSubobjectsSeen;
965 SubobjectsSeen[RD] = 1;
966 PublicSubobjectsSeen.insert(RD);
970 for (
CXXRecordDecl *PublicSubobject : PublicSubobjectsSeen) {
972 if (SubobjectsSeen[PublicSubobject] > 1)
975 Objects.push_back(PublicSubobject);
984 bool isPointer =
false;
1004 isPointer ? diag::err_throw_incomplete_ptr
1005 : diag::err_throw_incomplete,
1015 diag::err_throw_abstract_type,
E))
1037 PDiag(diag::err_access_dtor_exception) << Ty);
1053 for (
CXXRecordDecl *Subobject : UnambiguousPublicSubobjects) {
1094 if (ExnObjAlign < TypeAlign) {
1095 Diag(ThrowLoc, diag::warn_throw_underaligned_obj);
1096 Diag(ThrowLoc, diag::note_throw_underaligned_obj)
1101 if (!isPointer &&
getLangOpts().AssumeNothrowExceptionDtor) {
1103 auto Ty = Dtor->getType();
1107 Diag(ThrowLoc, diag::err_throw_object_throwing_dtor) << RD;
1159 for (
int I = FunctionScopes.size();
1160 I-- && isa<LambdaScopeInfo>(FunctionScopes[I]) &&
1162 cast<LambdaScopeInfo>(FunctionScopes[I])->CallOperator);
1164 CurLSI = cast<LambdaScopeInfo>(FunctionScopes[I]);
1171 if (
C.isCopyCapture()) {
1183 "While computing 'this' capture-type for a generic lambda, when we "
1184 "run out of enclosing LSI's, yet the enclosing DC is a "
1185 "lambda-call-operator we must be (i.e. Current LSI) in a generic "
1186 "lambda call oeprator");
1189 auto IsThisCaptured =
1194 if (
C.capturesThis()) {
1205 bool IsByCopyCapture =
false;
1206 bool IsConstCapture =
false;
1209 IsThisCaptured(Closure, IsByCopyCapture, IsConstCapture)) {
1210 if (IsByCopyCapture) {
1228 if (method && method->isImplicitObjectMemberFunction())
1229 ThisTy = method->getThisType().getNonReferenceType();
1257 : S(S), OldCXXThisTypeOverride(S.CXXThisTypeOverride), Enabled(
false)
1259 if (!Enabled || !ContextDecl)
1264 Record = Template->getTemplatedDecl();
1266 Record = cast<CXXRecordDecl>(ContextDecl);
1274 this->Enabled =
true;
1291 Sema.
Diag(DiagLoc, diag::note_lambda_this_capture_fixit)
1297 bool BuildAndDiagnose,
const unsigned *
const FunctionScopeIndexToStopAt,
1298 const bool ByCopy) {
1303 assert((!ByCopy || Explicit) &&
"cannot implicitly capture *this by value");
1305 const int MaxFunctionScopesIndex = FunctionScopeIndexToStopAt
1306 ? *FunctionScopeIndexToStopAt
1332 unsigned NumCapturingClosures = 0;
1333 for (
int idx = MaxFunctionScopesIndex; idx >= 0; idx--) {
1336 if (CSI->CXXThisCaptureIndex != 0) {
1338 CSI->Captures[CSI->CXXThisCaptureIndex - 1].markUsed(BuildAndDiagnose);
1344 if (BuildAndDiagnose) {
1346 Diag(
Loc, diag::err_this_capture)
1347 << (Explicit && idx == MaxFunctionScopesIndex);
1357 (Explicit && idx == MaxFunctionScopesIndex)) {
1363 NumCapturingClosures++;
1367 if (BuildAndDiagnose) {
1369 Diag(
Loc, diag::err_this_capture)
1370 << (Explicit && idx == MaxFunctionScopesIndex);
1378 if (!BuildAndDiagnose)
return false;
1391 "Only a lambda can capture the enclosing object (referred to by "
1394 for (
int idx = MaxFunctionScopesIndex; NumCapturingClosures;
1395 --idx, --NumCapturingClosures) {
1402 bool isNested = NumCapturingClosures > 1;
1436 const auto *Method = dyn_cast<CXXMethodDecl>(DC);
1437 if (Method && Method->isExplicitObjectMemberFunction()) {
1438 Diag(
Loc, diag::err_invalid_this_use) << 1;
1440 Diag(
Loc, diag::err_invalid_this_use) << 1;
1442 Diag(
Loc, diag::err_invalid_this_use) << 0;
1456 if (This->isTypeDependent())
1461 auto IsDependent = [&]() {
1463 auto *LSI = dyn_cast<sema::LambdaScopeInfo>(
Scope);
1467 if (LSI->Lambda && !LSI->Lambda->Encloses(
CurContext) &&
1468 LSI->AfterParameterList)
1475 if (LSI->isCXXThisCaptured()) {
1476 if (!LSI->getCXXThisCapture().isCopyCapture())
1479 const auto *MD = LSI->CallOperator;
1480 if (MD->getType().isNull())
1484 return Ty && MD->isExplicitObjectMemberFunction() &&
1491 This->setCapturedByCopyInLambdaWithExplicitObjectParameter(IsDependent);
1511 bool ListInitialization) {
1521 RParenOrBraceLoc, ListInitialization);
1525 if (!
Result.isInvalid() &&
Result.get()->isInstantiationDependent() &&
1526 !
Result.get()->isTypeDependent())
1528 else if (
Result.isInvalid())
1530 RParenOrBraceLoc, exprs, Ty);
1539 bool ListInitialization) {
1543 assert((!ListInitialization || Exprs.size() == 1) &&
1544 "List initialization must have exactly one expression.");
1551 ? ListInitialization
1553 TyBeginLoc, LParenOrBraceLoc, RParenOrBraceLoc)
1567 isa<DeducedTemplateSpecializationType>(Deduced)) {
1573 }
else if (Deduced && !Deduced->
isDeduced()) {
1575 if (ListInitialization) {
1576 auto *ILE = cast<InitListExpr>(Exprs[0]);
1577 Inits =
MultiExprArg(ILE->getInits(), ILE->getNumInits());
1581 return ExprError(
Diag(TyBeginLoc, diag::err_auto_expr_init_no_expression)
1582 << Ty << FullRange);
1583 if (Inits.size() > 1) {
1584 Expr *FirstBad = Inits[1];
1586 diag::err_auto_expr_init_multiple_expressions)
1587 << Ty << FullRange);
1591 Diag(TyBeginLoc, diag::warn_cxx20_compat_auto_expr) << FullRange;
1593 Expr *Deduce = Inits[0];
1594 if (isa<InitListExpr>(Deduce))
1597 << ListInitialization << Ty << FullRange);
1604 return ExprError(
Diag(TyBeginLoc, diag::err_auto_expr_deduction_failure)
1605 << Ty << Deduce->
getType() << FullRange
1619 RParenOrBraceLoc, ListInitialization);
1625 if (Exprs.size() == 1 && !ListInitialization &&
1626 !isa<InitListExpr>(Exprs[0])) {
1627 Expr *Arg = Exprs[0];
1635 if (!ListInitialization)
1636 return ExprError(
Diag(TyBeginLoc, diag::err_value_init_for_array_type)
1646 return ExprError(
Diag(TyBeginLoc, diag::err_init_for_function_type)
1647 << Ty << FullRange);
1656 if (ListInitialization &&
1657 cast<InitListExpr>(Exprs[0])->getNumInits() == 0) {
1661 Exprs[0]->getBeginLoc(), Exprs[0]->getEndLoc());
1664 diag::err_invalid_incomplete_type_use,
1678 Inner = BTE->getSubExpr();
1679 if (
auto *CE = dyn_cast<ConstantExpr>(Inner);
1680 CE && CE->isImmediateInvocation())
1681 Inner = CE->getSubExpr();
1682 if (!isa<CXXTemporaryObjectExpr>(Inner) &&
1683 !isa<CXXScalarValueInitExpr>(Inner)) {
1695 :
SourceRange(LParenOrBraceLoc, RParenOrBraceLoc);
1717 for (
const auto *
D : R) {
1718 if (
const auto *FD = dyn_cast<FunctionDecl>(
D)) {
1735 return llvm::none_of(PreventedBy, [&](
const FunctionDecl *FD) {
1737 "Only single-operand functions should be in PreventedBy");
1752 unsigned UsualParams = 1;
1754 if (S.
getLangOpts().SizedDeallocation && UsualParams < FD->getNumParams() &&
1760 if (S.
getLangOpts().AlignedAllocation && UsualParams < FD->getNumParams() &&
1770 struct UsualDeallocFnInfo {
1771 UsualDeallocFnInfo() :
Found(), FD(nullptr) {}
1779 unsigned NumBaseParams = 1;
1780 if (FD->isDestroyingOperatorDelete()) {
1785 if (NumBaseParams < FD->getNumParams() &&
1787 FD->getParamDecl(NumBaseParams)->getType(),
1793 if (NumBaseParams < FD->getNumParams() &&
1794 FD->getParamDecl(NumBaseParams)->getType()->isAlignValT()) {
1796 HasAlignValT =
true;
1805 explicit operator bool()
const {
return FD; }
1807 bool isBetterThan(
const UsualDeallocFnInfo &
Other,
bool WantSize,
1808 bool WantAlign)
const {
1812 if (Destroying !=
Other.Destroying)
1819 if (HasAlignValT !=
Other.HasAlignValT)
1820 return HasAlignValT == WantAlign;
1822 if (HasSizeT !=
Other.HasSizeT)
1823 return HasSizeT == WantSize;
1826 return CUDAPref >
Other.CUDAPref;
1831 bool Destroying, HasSizeT, HasAlignValT;
1851 UsualDeallocFnInfo Best;
1853 for (
auto I = R.
begin(),
E = R.
end(); I !=
E; ++I) {
1854 UsualDeallocFnInfo Info(S, I.getPair());
1862 BestFns->push_back(Info);
1866 if (Best.isBetterThan(Info, WantSize, WantAlign))
1871 if (BestFns && Info.isBetterThan(Best, WantSize, WantAlign))
1876 BestFns->push_back(Info);
1890 if (!record)
return false;
1903 if (ops.
empty())
return false;
1915 return Best && Best.HasSizeT;
1923 std::optional<Expr *> ArraySize;
1925 if (
D.getNumTypeObjects() > 0 &&
1928 if (
D.getDeclSpec().hasAutoTypeSpec())
1939 D.DropFirstTypeObject();
1944 for (
unsigned I = 0, N =
D.getNumTypeObjects(); I < N; ++I) {
1949 if (
Expr *NumElts = (
Expr *)Array.NumElts) {
1950 if (!NumElts->isTypeDependent() && !NumElts->isValueDependent()) {
1965 NumElts,
nullptr, diag::err_new_array_nonconst,
AllowFold)
1977 if (
D.isInvalidType())
1982 DirectInitRange = List->getSourceRange();
1985 PlacementLParen, PlacementArgs, PlacementRParen,
1986 TypeIdParens, AllocType, TInfo, ArraySize, DirectInitRange,
1995 return IsCPlusPlus20 || PLE->getNumExprs() == 0;
1996 if (isa<ImplicitValueInitExpr>(
Init))
1999 return !CCE->isListInitialization() &&
2000 CCE->getConstructor()->isDefaultConstructor();
2002 assert(isa<InitListExpr>(
Init) &&
2003 "Shouldn't create list CXXConstructExprs for arrays.");
2015 std::optional<unsigned> AlignmentParam;
2028 StringRef OSName = AvailabilityAttr::getPlatformNameSourceSpelling(
2033 bool IsDelete = Kind == OO_Delete || Kind == OO_Array_Delete;
2034 Diag(
Loc, diag::err_aligned_allocation_unavailable)
2036 << OSVersion.getAsString() << OSVersion.empty();
2037 Diag(
Loc, diag::note_silence_aligned_allocation_unavailable);
2047 std::optional<Expr *> ArraySize,
2053 if (DirectInitRange.
isValid()) {
2054 assert(
Initializer &&
"Have parens but no initializer.");
2056 }
else if (isa_and_nonnull<InitListExpr>(
Initializer))
2061 "Initializer expression that cannot have been implicitly created.");
2068 "paren init for non-call init");
2069 Exprs =
MultiExprArg(List->getExprs(), List->getNumExprs());
2076 switch (InitStyle) {
2087 DirectInitRange.
getEnd());
2093 llvm_unreachable(
"Unknown initialization kind");
2098 if (Deduced && !Deduced->isDeduced() &&
2099 isa<DeducedTemplateSpecializationType>(Deduced)) {
2102 Diag(*ArraySize ? (*ArraySize)->getExprLoc() : TypeRange.
getBegin(),
2103 diag::err_deduced_class_template_compound_type)
2105 << (*ArraySize ? (*ArraySize)->getSourceRange() : TypeRange));
2110 AllocTypeInfo, Entity, Kind, Exprs);
2113 }
else if (Deduced && !Deduced->isDeduced()) {
2117 auto *ILE = cast<InitListExpr>(Exprs[0]);
2118 Inits =
MultiExprArg(ILE->getInits(), ILE->getNumInits());
2122 return ExprError(
Diag(StartLoc, diag::err_auto_new_requires_ctor_arg)
2123 << AllocType << TypeRange);
2124 if (Inits.size() > 1) {
2125 Expr *FirstBad = Inits[1];
2127 diag::err_auto_new_ctor_multiple_expressions)
2128 << AllocType << TypeRange);
2132 << AllocType << TypeRange;
2133 Expr *Deduce = Inits[0];
2134 if (isa<InitListExpr>(Deduce))
2137 << Braced << AllocType << TypeRange);
2144 return ExprError(
Diag(StartLoc, diag::err_auto_new_deduction_failure)
2145 << AllocType << Deduce->
getType() << TypeRange
2162 AllocType = Array->getElementType();
2182 if (ArraySize && *ArraySize &&
2183 (*ArraySize)->getType()->isNonOverloadPlaceholderType()) {
2186 ArraySize = result.
get();
2195 std::optional<uint64_t> KnownArraySize;
2196 if (ArraySize && *ArraySize && !(*ArraySize)->isTypeDependent()) {
2205 (*ArraySize)->getType()->getAs<
RecordType>())
2207 Diag(StartLoc, diag::warn_cxx98_compat_array_size_conversion)
2208 << (*ArraySize)->getType() << 0 <<
"'size_t'";
2215 SizeConvertDiagnoser(
Expr *ArraySize)
2217 ArraySize(ArraySize) {}
2221 return S.
Diag(
Loc, diag::err_array_size_not_integral)
2227 return S.
Diag(
Loc, diag::err_array_size_incomplete_type)
2233 return S.
Diag(
Loc, diag::err_array_size_explicit_conversion) <<
T << ConvTy;
2244 return S.
Diag(
Loc, diag::err_array_size_ambiguous_conversion) <<
T;
2258 ? diag::warn_cxx98_compat_array_size_conversion
2259 : diag::ext_array_size_conversion)
2262 } SizeDiagnoser(*ArraySize);
2270 ArraySize = ConvertedSize.
get();
2271 QualType SizeType = (*ArraySize)->getType();
2289 if (std::optional<llvm::APSInt>
Value =
2290 (*ArraySize)->getIntegerConstantExpr(
Context)) {
2291 if (
Value->isSigned() &&
Value->isNegative()) {
2293 diag::err_typecheck_negative_array_size)
2294 << (*ArraySize)->getSourceRange());
2298 unsigned ActiveSizeBits =
2302 Diag((*ArraySize)->getBeginLoc(), diag::err_array_too_large)
2306 KnownArraySize =
Value->getZExtValue();
2307 }
else if (TypeIdParens.
isValid()) {
2309 Diag((*ArraySize)->getBeginLoc(), diag::ext_new_paren_array_nonconst)
2310 << (*ArraySize)->getSourceRange()
2323 unsigned Alignment =
2326 bool PassAlignment =
getLangOpts().AlignedAllocation &&
2327 Alignment > NewAlignment;
2337 AllocType, ArraySize.has_value(), PassAlignment, PlacementArgs,
2338 OperatorNew, OperatorDelete))
2343 bool UsualArrayDeleteWantsSize =
false;
2345 UsualArrayDeleteWantsSize =
2358 unsigned NumImplicitArgs = PassAlignment ? 2 : 1;
2360 NumImplicitArgs, PlacementArgs, AllPlaceArgs,
2364 if (!AllPlaceArgs.empty())
2365 PlacementArgs = AllPlaceArgs;
2375 llvm::APInt SingleEltSize(
2379 std::optional<llvm::APInt> AllocationSize;
2382 AllocationSize = SingleEltSize;
2386 AllocationSize = llvm::APInt(SizeTyWidth, *KnownArraySize)
2387 .umul_ov(SingleEltSize, Overflow);
2391 "Expected that all the overflows would have been handled already.");
2395 Context, AllocationSize.value_or(llvm::APInt::getZero(SizeTyWidth)),
2414 CK_IntegralCast, &AlignmentLiteral,
2419 CallArgs.reserve(NumImplicitArgs + PlacementArgs.size());
2420 CallArgs.emplace_back(AllocationSize
2421 ?
static_cast<Expr *
>(&AllocationSizeLiteral)
2422 : &OpaqueAllocationSize);
2424 CallArgs.emplace_back(&DesiredAlignment);
2425 CallArgs.insert(CallArgs.end(), PlacementArgs.begin(), PlacementArgs.end());
2429 checkCall(OperatorNew, Proto,
nullptr, CallArgs,
2430 false, StartLoc,
Range, CallType);
2434 if (PlacementArgs.empty() && !PassAlignment &&
2438 if (Alignment > NewAlignment)
2439 Diag(StartLoc, diag::warn_overaligned_type)
2451 SourceRange InitRange(Exprs.front()->getBeginLoc(),
2452 Exprs.back()->getEndLoc());
2453 Diag(StartLoc, diag::err_new_array_init_args) << InitRange;
2473 InitType = AllocType;
2486 dyn_cast_or_null<CXXBindTemporaryExpr>(FullInit.
get()))
2487 FullInit = Binder->getSubExpr();
2494 if (ArraySize && !*ArraySize) {
2502 Diag(TypeRange.
getEnd(), diag::err_new_array_size_unknown_from_init)
2514 if (OperatorDelete) {
2521 PassAlignment, UsualArrayDeleteWantsSize,
2522 PlacementArgs, TypeIdParens, ArraySize, InitStyle,
2532 return Diag(
Loc, diag::err_bad_new_type)
2533 << AllocType << 0 << R;
2535 return Diag(
Loc, diag::err_bad_new_type)
2536 << AllocType << 1 << R;
2539 Loc, AllocType, diag::err_new_incomplete_or_sizeless_type, R))
2542 diag::err_allocation_of_abstract_type))
2545 return Diag(
Loc, diag::err_variably_modified_new_type)
2549 return Diag(
Loc, diag::err_address_space_qualified_new)
2557 return Diag(
Loc, diag::err_arc_new_array_without_ownership)
2572 Alloc != AllocEnd; ++Alloc) {
2575 NamedDecl *
D = (*Alloc)->getUnderlyingDecl();
2609 if (PassAlignment) {
2610 PassAlignment =
false;
2612 Args.erase(Args.begin() + 1);
2614 Operator, &Candidates, AlignArg,
2640 (Args[1]->getType()->isObjectPointerType() ||
2641 Args[1]->getType()->isArrayType())) {
2642 S.
Diag(R.
getNameLoc(), diag::err_need_header_before_placement_new)
2657 if (AlignedCandidates) {
2659 return C.Function->getNumParams() > 1 &&
2660 C.Function->getParamDecl(1)->getType()->isAlignValT();
2664 AlignedArgs.reserve(Args.size() + 1);
2665 AlignedArgs.push_back(Args[0]);
2666 AlignedArgs.push_back(AlignArg);
2667 AlignedArgs.append(Args.begin() + 1, Args.end());
2680 if (AlignedCandidates)
2681 AlignedCandidates->
NoteCandidates(S, AlignedArgs, AlignedCands,
"",
2691 S.
PDiag(diag::err_ovl_ambiguous_call)
2700 Candidates, Best->Function, Args);
2704 llvm_unreachable(
"Unreachable, bad result from BestViableFunction");
2726 AllocArgs.reserve((PassAlignment ? 2 : 1) + PlaceArgs.size());
2736 AllocArgs.push_back(&Size);
2739 if (PassAlignment) {
2745 AllocArgs.push_back(&Align);
2747 AllocArgs.insert(AllocArgs.end(), PlaceArgs.begin(), PlaceArgs.end());
2756 IsArray ? OO_Array_New : OO_New);
2788 if (PlaceArgs.empty()) {
2789 Diag(StartLoc, diag::err_openclcxx_not_supported) <<
"default new";
2791 Diag(StartLoc, diag::err_openclcxx_placement_new);
2796 assert(!R.
empty() &&
"implicitly declared allocation functions not found");
2797 assert(!R.
isAmbiguous() &&
"global allocation functions are ambiguous");
2803 OperatorNew,
nullptr,
2810 OperatorDelete =
nullptr;
2845 while (Filter.hasNext()) {
2846 auto *FD = dyn_cast<FunctionDecl>(Filter.next()->getUnderlyingDecl());
2847 if (FD && FD->isDestroyingOperatorDelete())
2853 bool FoundGlobalDelete = FoundDelete.
empty();
2854 if (FoundDelete.
empty()) {
2881 bool isPlacementNew = !PlaceArgs.empty() || OperatorNew->
param_size() != 1 ||
2884 if (isPlacementNew) {
2901 for (
unsigned I = 1, N = Proto->getNumParams(); I < N; ++I)
2902 ArgTypes.push_back(Proto->getParamType(I));
2906 EPI.
Variadic = Proto->isVariadic();
2908 ExpectedFunctionType
2913 DEnd = FoundDelete.
end();
2917 dyn_cast<FunctionTemplateDecl>((*D)->getUnderlyingDecl())) {
2925 Fn = cast<FunctionDecl>((*D)->getUnderlyingDecl());
2928 ExpectedFunctionType,
2930 ExpectedFunctionType))
2931 Matches.push_back(std::make_pair(
D.getPair(), Fn));
2947 *
this, FoundDelete, FoundGlobalDelete,
2951 Matches.push_back(std::make_pair(Selected.Found, Selected.FD));
2955 for (
auto Fn : BestDeallocFns)
2956 Matches.push_back(std::make_pair(Fn.Found, Fn.FD));
2964 if (Matches.size() == 1) {
2965 OperatorDelete = Matches[0].second;
2975 UsualDeallocFnInfo Info(*
this,
2981 bool IsSizedDelete = Info.HasSizeT;
2982 if (IsSizedDelete && !FoundGlobalDelete) {
2983 auto NonSizedDelete =
2986 if (NonSizedDelete && !NonSizedDelete.HasSizeT &&
2987 NonSizedDelete.HasAlignValT == Info.HasAlignValT)
2988 IsSizedDelete =
false;
2991 if (IsSizedDelete) {
2995 PlaceArgs.back()->getEndLoc());
2996 Diag(StartLoc, diag::err_placement_new_non_placement_delete) << R;
3005 }
else if (!Matches.empty()) {
3009 Diag(StartLoc, diag::warn_ambiguous_suitable_delete_function_found)
3010 << DeleteName << AllocElemType;
3012 for (
auto &Match : Matches)
3013 Diag(Match.second->getLocation(),
3014 diag::note_member_declared_here) << DeleteName;
3078 if (TheGlobalModuleFragment) {
3093 if (TheGlobalModuleFragment) {
3094 AlignValT->setModuleOwnershipKind(
3096 AlignValT->setLocalOwningModule(TheGlobalModuleFragment);
3101 AlignValT->setImplicit(
true);
3114 Params.push_back(Param);
3117 bool HasSizedVariant =
getLangOpts().SizedDeallocation &&
3118 (Kind == OO_Delete || Kind == OO_Array_Delete);
3119 bool HasAlignedVariant =
getLangOpts().AlignedAllocation;
3121 int NumSizeVariants = (HasSizedVariant ? 2 : 1);
3122 int NumAlignVariants = (HasAlignedVariant ? 2 : 1);
3123 for (
int Sized = 0; Sized < NumSizeVariants; ++Sized) {
3125 Params.push_back(SizeT);
3127 for (
int Aligned = 0; Aligned < NumAlignVariants; ++Aligned) {
3140 DeclareGlobalAllocationFunctions(OO_New, VoidPtr, SizeT);
3141 DeclareGlobalAllocationFunctions(OO_Array_New, VoidPtr, SizeT);
3142 DeclareGlobalAllocationFunctions(OO_Delete,
Context.
VoidTy, VoidPtr);
3143 DeclareGlobalAllocationFunctions(OO_Array_Delete,
Context.
VoidTy, VoidPtr);
3146 PopGlobalModuleFragment();
3159 Alloc != AllocEnd; ++Alloc) {
3163 if (
Func->getNumParams() == Params.size()) {
3165 for (
auto *
P :
Func->parameters())
3166 FuncParams.push_back(
3172 Func->setVisibleDespiteOwningModule();
3180 false,
false,
true));
3183 bool HasBadAllocExceptionSpec
3184 = (Name.getCXXOverloadedOperator() == OO_New ||
3185 Name.getCXXOverloadedOperator() == OO_Array_New);
3186 if (HasBadAllocExceptionSpec) {
3189 assert(
StdBadAlloc &&
"Must have std::bad_alloc declared");
3201 auto CreateAllocationFunctionDecl = [&](
Attr *ExtraAttr) {
3207 Alloc->setImplicit();
3209 Alloc->setVisibleDespiteOwningModule();
3211 if (HasBadAllocExceptionSpec &&
getLangOpts().NewInfallible &&
3214 ReturnsNonNullAttr::CreateImplicit(
Context, Alloc->getLocation()));
3226 if (TheGlobalModuleFragment) {
3227 Alloc->setModuleOwnershipKind(
3229 Alloc->setLocalOwningModule(TheGlobalModuleFragment);
3233 Alloc->addAttr(VisibilityAttr::CreateImplicit(
3235 ? VisibilityAttr::Hidden
3237 ? VisibilityAttr::Protected
3238 : VisibilityAttr::Default));
3245 ParamDecls.back()->setImplicit();
3247 Alloc->setParams(ParamDecls);
3249 Alloc->addAttr(ExtraAttr);
3256 CreateAllocationFunctionDecl(
nullptr);
3260 CreateAllocationFunctionDecl(CUDAHostAttr::CreateImplicit(
Context));
3261 CreateAllocationFunctionDecl(CUDADeviceAttr::CreateImplicit(
Context));
3266 bool CanProvideSize,
3280 assert(
Result.FD &&
"operator delete missing from global scope?");
3292 return OperatorDelete;
3304 bool WantSize,
bool WantAligned) {
3309 if (
Found.isAmbiguous())
3312 Found.suppressDiagnostics();
3322 Overaligned, &Matches);
3325 if (Matches.size() == 1) {
3326 Operator = cast<CXXMethodDecl>(Matches[0].FD);
3332 Diag(StartLoc, diag::err_deleted_function_use)
3333 << (Msg !=
nullptr) << (Msg ? Msg->
getString() : StringRef());
3349 if (!Matches.empty()) {
3351 Diag(StartLoc, diag::err_ambiguous_suitable_delete_member_function_found)
3353 for (
auto &Match : Matches)
3354 Diag(Match.FD->getLocation(), diag::note_member_declared_here) << Name;
3361 if (!
Found.empty()) {
3363 Diag(StartLoc, diag::err_no_suitable_delete_member_function_found)
3368 diag::note_member_declared_here) << Name;
3380class MismatchingNewDeleteDetector {
3382 enum MismatchResult {
3388 MemberInitMismatches,
3397 explicit MismatchingNewDeleteDetector(
bool EndOfTU)
3398 : Field(nullptr), IsArrayForm(
false), EndOfTU(EndOfTU),
3399 HasUndefinedConstructors(
false) {}
3416 MismatchResult analyzeField(
FieldDecl *Field,
bool DeleteWasArrayForm);
3426 bool HasUndefinedConstructors;
3438 MismatchResult analyzeMemberExpr(
const MemberExpr *ME);
3461 MismatchResult analyzeInClassInitializer();
3465MismatchingNewDeleteDetector::MismatchResult
3466MismatchingNewDeleteDetector::analyzeDeleteExpr(
const CXXDeleteExpr *DE) {
3468 assert(DE &&
"Expected delete-expression");
3471 if (
const MemberExpr *ME = dyn_cast<const MemberExpr>(
E)) {
3472 return analyzeMemberExpr(ME);
3473 }
else if (
const DeclRefExpr *
D = dyn_cast<const DeclRefExpr>(
E)) {
3474 if (!hasMatchingVarInit(
D))
3475 return VarInitMismatches;
3481MismatchingNewDeleteDetector::getNewExprFromInitListOrExpr(
const Expr *
E) {
3482 assert(
E !=
nullptr &&
"Expected a valid initializer expression");
3484 if (
const InitListExpr *ILE = dyn_cast<const InitListExpr>(
E)) {
3485 if (ILE->getNumInits() == 1)
3486 E = dyn_cast<const CXXNewExpr>(ILE->getInit(0)->IgnoreParenImpCasts());
3489 return dyn_cast_or_null<const CXXNewExpr>(
E);
3492bool MismatchingNewDeleteDetector::hasMatchingNewInCtorInit(
3496 (NE = getNewExprFromInitListOrExpr(CI->
getInit()))) {
3497 if (
NE->isArray() == IsArrayForm)
3500 NewExprs.push_back(NE);
3505bool MismatchingNewDeleteDetector::hasMatchingNewInCtor(
3511 HasUndefinedConstructors =
true;
3514 for (
const auto *CI : cast<const CXXConstructorDecl>(
Definition)->inits()) {
3515 if (hasMatchingNewInCtorInit(CI))
3521MismatchingNewDeleteDetector::MismatchResult
3522MismatchingNewDeleteDetector::analyzeInClassInitializer() {
3523 assert(Field !=
nullptr &&
"This should be called only for members");
3524 const Expr *InitExpr =
Field->getInClassInitializer();
3526 return EndOfTU ? NoMismatch : AnalyzeLater;
3527 if (
const CXXNewExpr *NE = getNewExprFromInitListOrExpr(InitExpr)) {
3528 if (
NE->isArray() != IsArrayForm) {
3529 NewExprs.push_back(NE);
3530 return MemberInitMismatches;
3536MismatchingNewDeleteDetector::MismatchResult
3537MismatchingNewDeleteDetector::analyzeField(
FieldDecl *Field,
3538 bool DeleteWasArrayForm) {
3539 assert(Field !=
nullptr &&
"Analysis requires a valid class member.");
3540 this->Field =
Field;
3541 IsArrayForm = DeleteWasArrayForm;
3543 for (
const auto *CD : RD->
ctors()) {
3544 if (hasMatchingNewInCtor(CD))
3547 if (HasUndefinedConstructors)
3548 return EndOfTU ? NoMismatch : AnalyzeLater;
3549 if (!NewExprs.empty())
3550 return MemberInitMismatches;
3551 return Field->hasInClassInitializer() ? analyzeInClassInitializer()
3555MismatchingNewDeleteDetector::MismatchResult
3556MismatchingNewDeleteDetector::analyzeMemberExpr(
const MemberExpr *ME) {
3557 assert(ME !=
nullptr &&
"Expected a member expression");
3559 return analyzeField(F, IsArrayForm);
3563bool MismatchingNewDeleteDetector::hasMatchingVarInit(
const DeclRefExpr *
D) {
3565 if (
const VarDecl *VD = dyn_cast<const VarDecl>(
D->getDecl())) {
3566 if (VD->hasInit() && (NE = getNewExprFromInitListOrExpr(VD->getInit())) &&
3567 NE->isArray() != IsArrayForm) {
3568 NewExprs.push_back(NE);
3571 return NewExprs.empty();
3576 const MismatchingNewDeleteDetector &Detector) {
3579 if (!Detector.IsArrayForm)
3588 SemaRef.
Diag(DeleteLoc, diag::warn_mismatched_delete_new)
3589 << Detector.IsArrayForm << H;
3591 for (
const auto *NE : Detector.NewExprs)
3592 SemaRef.
Diag(NE->getExprLoc(), diag::note_allocated_here)
3593 << Detector.IsArrayForm;
3596void Sema::AnalyzeDeleteExprMismatch(
const CXXDeleteExpr *DE) {
3599 MismatchingNewDeleteDetector Detector(
false);
3600 switch (Detector.analyzeDeleteExpr(DE)) {
3601 case MismatchingNewDeleteDetector::VarInitMismatches:
3602 case MismatchingNewDeleteDetector::MemberInitMismatches: {
3606 case MismatchingNewDeleteDetector::AnalyzeLater: {
3611 case MismatchingNewDeleteDetector::NoMismatch:
3617 bool DeleteWasArrayForm) {
3618 MismatchingNewDeleteDetector Detector(
true);
3619 switch (Detector.analyzeField(Field, DeleteWasArrayForm)) {
3620 case MismatchingNewDeleteDetector::VarInitMismatches:
3621 llvm_unreachable(
"This analysis should have been done for class members.");
3622 case MismatchingNewDeleteDetector::AnalyzeLater:
3623 llvm_unreachable(
"Analysis cannot be postponed any point beyond end of "
3624 "translation unit.");
3625 case MismatchingNewDeleteDetector::MemberInitMismatches:
3628 case MismatchingNewDeleteDetector::NoMismatch:
3635 bool ArrayForm,
Expr *ExE) {
3645 bool ArrayFormAsWritten = ArrayForm;
3646 bool UsualArrayDeleteWantsSize =
false;
3664 if (ConvPtrType->getPointeeType()->isIncompleteOrObjectType())
3671 return S.
Diag(
Loc, diag::err_delete_operand) <<
T;
3676 return S.
Diag(
Loc, diag::err_delete_incomplete_class_type) <<
T;
3682 return S.
Diag(
Loc, diag::err_delete_explicit_conversion) <<
T << ConvTy;
3693 return S.
Diag(
Loc, diag::err_ambiguous_delete_operand) <<
T;
3705 llvm_unreachable(
"conversion functions are permitted");
3713 if (!Converter.match(
Type))
3724 diag::err_address_space_qualified_delete)
3734 Diag(StartLoc,
LangOpts.CPlusPlus26 ? diag::err_delete_incomplete
3735 : diag::ext_delete_void_ptr_operand)
3747 ? diag::err_delete_incomplete
3748 : diag::warn_delete_incomplete,
3751 PointeeRD = cast<CXXRecordDecl>(RT->getDecl());
3756 Diag(StartLoc, diag::warn_delete_array_type)
3763 ArrayForm ? OO_Array_Delete : OO_Delete);
3777 UsualArrayDeleteWantsSize =
3782 else if (isa_and_nonnull<CXXMethodDecl>(OperatorDelete))
3783 UsualArrayDeleteWantsSize =
3784 UsualDeallocFnInfo(*
this,
3803 if (!OperatorDelete) {
3805 Diag(StartLoc, diag::err_openclcxx_not_supported) <<
"default delete";
3810 bool CanProvideSize =
3811 IsComplete && (!ArrayForm || UsualArrayDeleteWantsSize ||
3817 Overaligned, DeleteName);
3827 bool IsVirtualDelete =
false;
3831 PDiag(diag::err_access_dtor) << PointeeElem);
3832 IsVirtualDelete = Dtor->isVirtual();
3861 UsualArrayDeleteWantsSize, OperatorDelete, Ex.
get(), StartLoc);
3862 AnalyzeDeleteExprMismatch(
Result);
3871 IsDelete ? OO_Delete : OO_New);
3875 assert(!R.
empty() &&
"implicitly declared allocation functions not found");
3876 assert(!R.
isAmbiguous() &&
"global allocation functions are ambiguous");
3885 FnOvl != FnOvlEnd; ++FnOvl) {
3888 NamedDecl *
D = (*FnOvl)->getUnderlyingDecl();
3912 "class members should not be considered");
3915 S.
Diag(R.
getNameLoc(), diag::err_builtin_operator_new_delete_not_usual)
3916 << (IsDelete ? 1 : 0) <<
Range;
3917 S.
Diag(FnDecl->
getLocation(), diag::note_non_usual_function_declared_here)
3929 S.
PDiag(diag::err_ovl_no_viable_function_in_call)
3937 S.
PDiag(diag::err_ovl_ambiguous_call)
3944 Candidates, Best->Function, Args);
3947 llvm_unreachable(
"Unreachable, bad result from BestViableFunction");
3952 CallExpr *TheCall = cast<CallExpr>(TheCallResult.
get());
3955 << (IsDelete ?
"__builtin_operator_delete" :
"__builtin_operator_new")
3965 OperatorNewOrDelete))
3967 assert(OperatorNewOrDelete &&
"should be found");
3973 for (
unsigned i = 0; i != TheCall->
getNumArgs(); ++i) {
3984 assert(Callee &&
Callee->getCastKind() == CK_BuiltinFnToFnPtr &&
3985 "Callee expected to be implicit cast to a builtin function pointer");
3988 return TheCallResult;
3992 bool IsDelete,
bool CallCanBeVirtual,
3993 bool WarnOnNonAbstractTypes,
4020 Diag(
Loc, diag::warn_delete_abstract_non_virtual_dtor) << (IsDelete ? 0 : 1)
4022 }
else if (WarnOnNonAbstractTypes) {
4025 Diag(
Loc, diag::warn_delete_non_virtual_dtor) << (IsDelete ? 0 : 1)
4029 std::string TypeStr;
4031 Diag(DtorLoc, diag::note_delete_non_virtual)
4059 diag::err_invalid_use_of_function_type)
4063 diag::err_invalid_use_of_array_type)
4081 llvm_unreachable(
"unexpected condition kind");
4107 diag::err_constexpr_if_condition_expression_is_not_constant);
4115 From = Cast->getSubExpr();
4127 if (!ToPtrType->getPointeeType().hasQualifiers()) {
4128 switch (StrLit->getKind()) {
4135 return (ToPointeeType->getKind() == BuiltinType::Char_U ||
4136 ToPointeeType->getKind() == BuiltinType::Char_S);
4141 assert(
false &&
"Unevaluated string literal in expression");
4156 bool HadMultipleCandidates,
4159 default: llvm_unreachable(
"Unhandled cast kind!");
4160 case CK_ConstructorConversion: {
4165 diag::err_allocation_of_abstract_type))
4178 CastLoc, Ty, FoundDecl, cast<CXXConstructorDecl>(Method),
4179 ConstructorArgs, HadMultipleCandidates,
4180 false,
false,
false,
4188 case CK_UserDefinedConversion: {
4198 HadMultipleCandidates);
4203 CK_UserDefinedConversion,
Result.get(),
4204 nullptr,
Result.get()->getValueKind(),
4237 assert(FD &&
"no conversion function for user-defined conversion seq");
4239 CastKind = CK_UserDefinedConversion;
4247 CastKind = CK_ConstructorConversion;
4275 From = CastArg.
get();
4289 PDiag(diag::err_typecheck_ambiguous_condition)
4295 llvm_unreachable(
"bad conversion");
4302 ToType, From->
getType(), From, Action);
4303 assert(Diagnosed &&
"failed to diagnose bad conversion"); (void)Diagnosed;
4316 QualType ElType = ToVec->getElementType();
4352 false,
false,
false,
4359 false,
false,
false,
4392 ToAtomicType = ToType;
4393 ToType = ToAtomic->getValueType();
4396 QualType InitialFromType = FromType;
4398 switch (SCS.
First) {
4401 FromType = FromAtomic->getValueType().getUnqualifiedType();
4414 From = FromRes.
get();
4441 llvm_unreachable(
"Improper first standard conversion");
4482 "only enums with fixed underlying type can promote to bool");
4512 CK = CK_FloatingComplexCast;
4514 CK = CK_FloatingComplexToIntegralComplex;
4516 CK = CK_IntegralComplexToFloatingComplex;
4518 CK = CK_IntegralComplexCast;
4544 "Attempting implicit fixed point conversion without a fixed "
4549 nullptr, CCK).
get();
4553 nullptr, CCK).
get();
4557 nullptr, CCK).
get();
4561 nullptr, CCK).
get();
4565 nullptr, CCK).
get();
4569 nullptr, CCK).
get();
4574 nullptr, CCK).
get();
4583 diag::ext_typecheck_convert_incompatible_pointer)
4588 diag::ext_typecheck_convert_incompatible_pointer)
4595 }
else if (
getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
4596 !
ObjC().CheckObjCARCUnavailableWeakConversion(ToType,
4601 Diag(From->
getBeginLoc(), diag::err_arc_convesion_of_weak_unavailable)
4630 if (Kind == CK_BlockPointerToObjCPointerCast) {
4692 &BasePath, CCK).
get();
4721 QualType ElType = ToComplex->getElementType();
4729 isFloatingComplex ? CK_FloatingCast : CK_FloatingToIntegral).
get();
4733 isFloatingComplex ? CK_IntegralToFloating : CK_IntegralCast).
get();
4737 isFloatingComplex ? CK_FloatingRealToComplex
4738 : CK_IntegralRealToComplex).
get();
4743 QualType ElType = FromComplex->getElementType();
4748 isFloatingComplex ? CK_FloatingComplexToReal
4749 : CK_IntegralComplexToReal,
4758 isFloatingComplex ? CK_FloatingCast
4759 : CK_IntegralToFloating,
4765 isFloatingComplex ? CK_FloatingToIntegral
4781 AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion : CK_BitCast;
4794 From = FromRes.
get();
4796 "Improper transparent union conversion");
4804 CK_ZeroToOCLOpaqueType,
4819 llvm_unreachable(
"Improper second standard conversion");
4828 "Dimension conversion for matrix types is not implemented yet.");
4830 "Dimension conversion is only supported for vector types.");
4845 "HLSL vector truncation should only apply to ExtVectors");
4848 QualType ElType = FromVec->getElementType();
4858 llvm_unreachable(
"Improper element standard conversion");
4862 switch (SCS.
Third) {
4885 CK = CK_AddressSpaceConversion;
4890 CK = CK_AddressSpaceConversion;
4896 << InitialFromType << ToType;
4907 ? diag::ext_deprecated_string_literal_conversion
4908 : diag::warn_deprecated_string_literal_conversion)
4916 llvm_unreachable(
"Improper third standard conversion");
4921 if (!ToAtomicType.
isNull()) {
4957 S.
Diag(
T->getTypeLoc().getBeginLoc(), diag::err_vla_unsupported)
4958 << 1 << TypeTraitID;
4971 S.
Diag(
T->getTypeLoc().getBeginLoc(), diag::err_atomic_unsupported)
4995 default: llvm_unreachable(
"not a UTT");
4997 case UTT_IsCompleteType:
5005 case UTT_IsIntegral:
5006 case UTT_IsFloatingPoint:
5008 case UTT_IsBoundedArray:
5010 case UTT_IsReferenceable:
5011 case UTT_IsLvalueReference:
5012 case UTT_IsRvalueReference:
5013 case UTT_IsMemberFunctionPointer:
5014 case UTT_IsMemberObjectPointer:
5016 case UTT_IsScopedEnum:
5019 case UTT_IsFunction:
5020 case UTT_IsReference:
5021 case UTT_IsArithmetic:
5022 case UTT_IsFundamental:
5025 case UTT_IsCompound:
5026 case UTT_IsMemberPointer:
5035 case UTT_IsVolatile:
5037 case UTT_IsUnboundedArray:
5038 case UTT_IsUnsigned:
5041 case UTT_IsInterfaceClass:
5047 case UTT_IsPolymorphic:
5048 case UTT_IsAbstract:
5052 Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
5061 Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
5065 case UTT_IsAggregate:
5066 case UTT_IsImplicitLifetime:
5071 Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
5076 case UTT_IsTriviallyCopyable:
5077 case UTT_IsStandardLayout:
5080 case UTT_IsBitwiseCloneable:
5083 case UTT_IsTriviallyRelocatable:
5084 case UTT_IsTriviallyEqualityComparable:
5085 case UTT_CanPassInRegs:
5089 case UTT_HasNothrowAssign:
5090 case UTT_HasNothrowMoveAssign:
5091 case UTT_HasNothrowConstructor:
5092 case UTT_HasNothrowCopy:
5093 case UTT_HasTrivialAssign:
5094 case UTT_HasTrivialMoveAssign:
5095 case UTT_HasTrivialDefaultConstructor:
5096 case UTT_HasTrivialMoveConstructor:
5097 case UTT_HasTrivialCopy:
5098 case UTT_HasTrivialDestructor:
5099 case UTT_HasVirtualDestructor:
5103 case UTT_HasUniqueObjectRepresentations:
5109 case UTT_IsDestructible:
5110 case UTT_IsNothrowDestructible:
5111 case UTT_IsTriviallyDestructible:
5116 Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
5127 if ((RD->*HasTrivial)() && !(RD->*HasNonTrivial)())
5133 if (
Self.LookupQualifiedName(Res, RD)) {
5134 bool FoundOperator =
false;
5137 Op != OpEnd; ++Op) {
5138 if (isa<FunctionTemplateDecl>(*Op))
5142 if((Operator->*IsDesiredOp)()) {
5143 FoundOperator =
true;
5145 CPT =
Self.ResolveExceptionSpec(KeyLoc, CPT);
5150 return FoundOperator;
5158 if (
Decl->isUnion())
5160 if (
Decl->isLambda())
5161 return Decl->isCapturelessLambda();
5171 {},
Decl->getTypeForDecl()->getCanonicalTypeUnqualified().withConst(),
5178 Functions, &Operand, &Operand);
5182 const auto *
CallExpr = dyn_cast<CXXOperatorCallExpr>(
Result.get());
5186 auto ParamT = Callee->getParamDecl(0)->getType();
5187 if (!Callee->isDefaulted())
5189 if (!ParamT->isReferenceType() && !
Decl->isTriviallyCopyable())
5191 if (ParamT.getNonReferenceType()->getUnqualifiedDesugaredType() !=
5192 Decl->getTypeForDecl())
5196 return llvm::all_of(
Decl->bases(),
5198 if (const auto *RD = BS.getType()->getAsCXXRecordDecl())
5199 return HasNonDeletedDefaultedEqualityComparison(
5204 auto Type = FD->getType();
5205 if (Type->isArrayType())
5206 Type = Type->getBaseElementTypeUnsafe()
5207 ->getCanonicalTypeUnqualified();
5209 if (Type->isReferenceType() || Type->isEnumeralType())
5211 if (const auto *RD = Type->getAsCXXRecordDecl())
5212 return HasNonDeletedDefaultedEqualityComparison(S, RD, KeyLoc);
5229 CanonicalType,
false);
5236 assert(!
T->
isDependentType() &&
"Cannot evaluate traits of dependent type");
5240 default: llvm_unreachable(
"not a UTT");
5245 case UTT_IsIntegral:
5247 case UTT_IsFloatingPoint:
5252 if (
const auto *CAT =
C.getAsConstantArrayType(
T))
5253 return CAT->getSize() != 0;
5255 case UTT_IsBoundedArray:
5260 if (
const auto *CAT =
C.getAsConstantArrayType(
T))
5261 return CAT->getSize() != 0;
5263 case UTT_IsUnboundedArray:
5269 case UTT_IsLvalueReference:
5271 case UTT_IsRvalueReference:
5273 case UTT_IsMemberFunctionPointer:
5275 case UTT_IsMemberObjectPointer:
5279 case UTT_IsScopedEnum:
5285 case UTT_IsFunction:
5290 case UTT_IsReference:
5292 case UTT_IsArithmetic:
5294 case UTT_IsFundamental:
5304 switch (
T.getObjCLifetime()) {
5317 case UTT_IsCompound:
5319 case UTT_IsMemberPointer:
5325 return T.isConstQualified();
5326 case UTT_IsVolatile:
5327 return T.isVolatileQualified();
5329 return T.isTrivialType(
C);
5330 case UTT_IsTriviallyCopyable:
5331 return T.isTriviallyCopyableType(
C);
5332 case UTT_IsStandardLayout:
5335 return T.isPODType(
C);
5342 case UTT_IsPolymorphic:
5346 case UTT_IsAbstract:
5350 case UTT_IsAggregate:
5359 case UTT_IsInterfaceClass:
5364 return RD->
hasAttr<FinalAttr>();
5371 case UTT_IsUnsigned:
5390 case UTT_HasTrivialDefaultConstructor:
5397 if (
CXXRecordDecl *RD =
C.getBaseElementType(
T)->getAsCXXRecordDecl())
5401 case UTT_HasTrivialMoveConstructor:
5407 if (
CXXRecordDecl *RD =
C.getBaseElementType(
T)->getAsCXXRecordDecl())
5410 case UTT_HasTrivialCopy:
5422 case UTT_HasTrivialMoveAssign:
5428 if (
CXXRecordDecl *RD =
C.getBaseElementType(
T)->getAsCXXRecordDecl())
5431 case UTT_HasTrivialAssign:
5444 if (
T.isConstQualified())
5452 case UTT_IsDestructible:
5453 case UTT_IsTriviallyDestructible:
5454 case UTT_IsNothrowDestructible:
5473 if (UTT == UTT_IsTriviallyDestructible &&
T.isDestructedType())
5480 if (
auto *RD =
C.getBaseElementType(
T)->getAsCXXRecordDecl()) {
5491 if (UTT == UTT_IsNothrowDestructible) {
5493 CPT =
Self.ResolveExceptionSpec(KeyLoc, CPT);
5500 case UTT_HasTrivialDestructor:
5515 if (
CXXRecordDecl *RD =
C.getBaseElementType(
T)->getAsCXXRecordDecl())
5519 case UTT_HasNothrowAssign:
5527 if (
C.getBaseElementType(
T).isConstQualified())
5540 case UTT_HasNothrowMoveAssign:
5553 case UTT_HasNothrowCopy:
5566 bool FoundConstructor =
false;
5568 for (
const auto *ND :
Self.LookupConstructors(RD)) {
5572 if (isa<FunctionTemplateDecl>(ND->getUnderlyingDecl()))
5575 if (isa<UsingDecl>(ND))
5577 auto *Constructor = cast<CXXConstructorDecl>(ND->getUnderlyingDecl());
5578 if (Constructor->isCopyConstructor(FoundTQs)) {
5579 FoundConstructor =
true;
5581 CPT =
Self.ResolveExceptionSpec(KeyLoc, CPT);
5591 return FoundConstructor;
5594 case UTT_HasNothrowConstructor:
5602 if (
CXXRecordDecl *RD =
C.getBaseElementType(
T)->getAsCXXRecordDecl()) {
5607 bool FoundConstructor =
false;
5608 for (
const auto *ND :
Self.LookupConstructors(RD)) {
5610 if (isa<FunctionTemplateDecl>(ND->getUnderlyingDecl()))
5613 if (isa<UsingDecl>(ND))
5615 auto *Constructor = cast<CXXConstructorDecl>(ND->getUnderlyingDecl());
5616 if (Constructor->isDefaultConstructor()) {
5617 FoundConstructor =
true;
5619 CPT =
Self.ResolveExceptionSpec(KeyLoc, CPT);
5628 return FoundConstructor;
5631 case UTT_HasVirtualDestructor:
5643 case UTT_IsCompleteType:
5648 case UTT_HasUniqueObjectRepresentations:
5649 return C.hasUniqueObjectRepresentations(
T);
5650 case UTT_IsTriviallyRelocatable:
5651 return T.isTriviallyRelocatableType(
C);
5652 case UTT_IsBitwiseCloneable:
5653 return T.isBitwiseCloneableType(
C);
5654 case UTT_IsReferenceable:
5655 return T.isReferenceable();
5656 case UTT_CanPassInRegs:
5659 Self.Diag(KeyLoc, diag::err_builtin_pass_in_regs_non_class) <<
T;
5661 case UTT_IsTriviallyEqualityComparable:
5663 case UTT_IsImplicitLifetime: {
5665 tok::kw___builtin_is_implicit_lifetime);
5667 tok::kw___builtin_is_implicit_lifetime);
5705 SourceLocation KeyLoc, llvm::BumpPtrAllocator &OpaqueExprAllocator) {
5746 LhsT =
Self.Context.getRValueReferenceType(LhsT);
5786 if (Kind <=
BTT_Last && Kind != BTT_ReferenceBindsToTemporary &&
5787 Kind != BTT_ReferenceConstructsFromTemporary &&
5788 Kind != BTT_ReferenceConvertsFromTemporary)
5790 Args[1], RParenLoc);
5793 case clang::BTT_ReferenceBindsToTemporary:
5794 case clang::BTT_ReferenceConstructsFromTemporary:
5795 case clang::BTT_ReferenceConvertsFromTemporary:
5796 case clang::TT_IsConstructible:
5797 case clang::TT_IsNothrowConstructible:
5798 case clang::TT_IsTriviallyConstructible: {
5812 assert(!Args.empty());
5817 for (
const auto *TSI : Args) {
5823 diag::err_incomplete_type_used_in_type_trait_expr))
5837 llvm::BumpPtrAllocator OpaqueExprAllocator;
5839 ArgExprs.reserve(Args.size() - 1);
5840 for (
unsigned I = 1, N = Args.size(); I != N; ++I) {
5841 QualType ArgTy = Args[I]->getType();
5860 Kind == clang::BTT_ReferenceConvertsFromTemporary
5871 if (Kind == clang::TT_IsConstructible)
5874 if (Kind == clang::BTT_ReferenceBindsToTemporary ||
5875 Kind == clang::BTT_ReferenceConstructsFromTemporary ||
5876 Kind == clang::BTT_ReferenceConvertsFromTemporary) {
5880 if (!
Init.isDirectReferenceBinding())
5883 if (Kind == clang::BTT_ReferenceBindsToTemporary)
5887 if (
U->isReferenceType())
5895 OpaqueExprAllocator)
5899 if (Kind == clang::TT_IsNothrowConstructible)
5902 if (Kind == clang::TT_IsTriviallyConstructible) {
5905 if (
T.getNonReferenceType().hasNonTrivialObjCLifetime())
5913 llvm_unreachable(
"unhandled type trait");
5916 default: llvm_unreachable(
"not a TT");
5927 case UTT_HasNothrowAssign:
5928 case UTT_HasNothrowMoveAssign:
5929 Replacement = BTT_IsNothrowAssignable;
5931 case UTT_HasNothrowCopy:
5932 case UTT_HasNothrowConstructor:
5933 Replacement = TT_IsNothrowConstructible;
5935 case UTT_HasTrivialAssign:
5936 case UTT_HasTrivialMoveAssign:
5937 Replacement = BTT_IsTriviallyAssignable;
5939 case UTT_HasTrivialCopy:
5940 Replacement = UTT_IsTriviallyCopyable;
5942 case UTT_HasTrivialDefaultConstructor:
5943 case UTT_HasTrivialMoveConstructor:
5944 Replacement = TT_IsTriviallyConstructible;
5946 case UTT_HasTrivialDestructor:
5947 Replacement = UTT_IsTriviallyDestructible;
5952 S.
Diag(KWLoc, diag::warn_deprecated_builtin)
5958 if (Arity && N != Arity) {
5959 Diag(
Loc, diag::err_type_trait_arity)
5964 if (!Arity && N == 0) {
5965 Diag(
Loc, diag::err_type_trait_arity)
5977 return TypeTraitReturnType::Bool;
5987 *
this, Kind, KWLoc, Args[0]->getType()))
5990 DiagnoseBuiltinDeprecation(*
this, Kind, KWLoc);
5993 for (
unsigned I = 0, N = Args.size(); I != N; ++I) {
5994 if (Args[I]->getType()->isDependentType()) {
6001 case TypeTraitReturnType::Bool: {
6005 KWLoc, Kind, Args, RParenLoc,
Result);
6008 llvm_unreachable(
"unhandled type trait return type");
6015 ConvertedArgs.reserve(Args.size());
6017 for (
unsigned I = 0, N = Args.size(); I != N; ++I) {
6023 ConvertedArgs.push_back(TInfo);
6035 "Cannot evaluate traits of dependent types");
6038 case BTT_IsBaseOf: {
6046 if (!rhsRecord || !lhsRecord) {
6049 if (!LHSObjTy || !RHSObjTy)
6054 if (!BaseInterface || !DerivedInterface)
6057 if (
Self.RequireCompleteType(
6059 diag::err_incomplete_type_used_in_type_trait_expr))
6065 assert(
Self.Context.hasSameUnqualifiedType(LhsT, RhsT)
6066 == (lhsRecord == rhsRecord));
6072 if (rhsRecord && rhsRecord->getDecl()->isUnion())
6075 if (lhsRecord == rhsRecord)
6082 if (
Self.RequireCompleteType(
6084 diag::err_incomplete_type_used_in_type_trait_expr))
6087 return cast<CXXRecordDecl>(rhsRecord->getDecl())
6088 ->isDerivedFrom(cast<CXXRecordDecl>(lhsRecord->
getDecl()));
6090 case BTT_IsVirtualBaseOf: {
6094 if (!BaseRecord || !DerivedRecord) {
6096 tok::kw___builtin_is_virtual_base_of);
6098 tok::kw___builtin_is_virtual_base_of);
6102 if (BaseRecord->
isUnionType() || DerivedRecord->isUnionType())
6106 !DerivedRecord->isStructureOrClassType())
6110 diag::err_incomplete_type))
6113 return cast<CXXRecordDecl>(DerivedRecord->getDecl())
6114 ->isVirtuallyDerivedFrom(cast<CXXRecordDecl>(BaseRecord->
getDecl()));
6117 return Self.Context.hasSameType(LhsT, RhsT);
6118 case BTT_TypeCompatible: {
6121 QualType Lhs =
Self.getASTContext().getUnqualifiedArrayType(LhsT, LhsQuals);
6122 QualType Rhs =
Self.getASTContext().getUnqualifiedArrayType(RhsT, RhsQuals);
6123 return Self.Context.typesAreCompatible(Lhs, Rhs);
6125 case BTT_IsConvertible:
6126 case BTT_IsConvertibleTo:
6127 case BTT_IsNothrowConvertible: {
6130 llvm::BumpPtrAllocator OpaqueExprAllocator;
6132 OpaqueExprAllocator);
6136 if (BTT != BTT_IsNothrowConvertible)
6142 case BTT_IsAssignable:
6143 case BTT_IsNothrowAssignable:
6144 case BTT_IsTriviallyAssignable: {
6157 Self.RequireCompleteType(
6159 diag::err_incomplete_type_used_in_type_trait_expr))
6162 Self.RequireCompleteType(
6164 diag::err_incomplete_type_used_in_type_trait_expr))
6174 LhsT =
Self.Context.getRValueReferenceType(LhsT);
6176 RhsT =
Self.Context.getRValueReferenceType(RhsT);
6194 Self.CheckUnusedVolatileAssignment(
Result.get());
6199 if (BTT == BTT_IsAssignable)
6202 if (BTT == BTT_IsNothrowAssignable)
6205 if (BTT == BTT_IsTriviallyAssignable) {
6211 return !
Result.get()->hasNonTrivialCall(
Self.Context);
6214 llvm_unreachable(
"unhandled type trait");
6217 case BTT_IsLayoutCompatible: {
6220 diag::err_incomplete_type);
6223 diag::err_incomplete_type);
6228 return Self.IsLayoutCompatible(LhsT, RhsT);
6230 case BTT_IsPointerInterconvertibleBaseOf: {
6232 !
Self.getASTContext().hasSameUnqualifiedType(LhsT, RhsT)) {
6234 diag::err_incomplete_type);
6238 tok::kw___is_pointer_interconvertible_base_of);
6240 tok::kw___is_pointer_interconvertible_base_of);
6242 return Self.IsPointerInterconvertibleBaseOf(Lhs, Rhs);
6244 case BTT_IsDeducible: {
6245 const auto *TSTToBeDeduced = cast<DeducedTemplateSpecializationType>(LhsT);
6247 return Self.DeduceTemplateArgumentsFromType(
6248 TSTToBeDeduced->getTemplateName().getAsTemplateDecl(), RhsT,
6252 llvm_unreachable(
"not a BTT");
6254 llvm_unreachable(
"Unknown type trait or not implemented");
6273 assert(!
T->
isDependentType() &&
"Cannot evaluate traits of dependent type");
6281 T = AT->getElementType();
6287 case ATT_ArrayExtent: {
6290 if (
Self.VerifyIntegerConstantExpression(
6291 DimExpr, &
Value, diag::err_dimension_expr_not_constant_integer)
6294 if (
Value.isSigned() &&
Value.isNegative()) {
6295 Self.Diag(KeyLoc, diag::err_dimension_expr_not_constant_integer)
6299 Dim =
Value.getLimitedValue();
6303 bool Matched =
false;
6310 T = AT->getElementType();
6315 return CAT->getLimitedSize();
6321 llvm_unreachable(
"Unknown type trait or not implemented");
6361 case ET_IsLValueExpr:
return E->
isLValue();
6362 case ET_IsRValueExpr:
6365 llvm_unreachable(
"Expression trait not covered by switch");
6391 "placeholders should have been weeded out by now");
6406 const char *OpSpelling = isIndirect ?
"->*" :
".*";
6414 Diag(
Loc, diag::err_bad_memptr_rhs)
6436 Diag(
Loc, diag::err_bad_memptr_lhs)
6437 << OpSpelling << 1 << LHSType
6446 OpSpelling, (
int)isIndirect)) {
6451 Diag(
Loc, diag::err_bad_memptr_lhs) << OpSpelling
6475 Diag(
Loc, diag::err_pointer_to_member_type) << isIndirect;
6494 switch (Proto->getRefQualifier()) {
6503 if (Proto->isConst() && !Proto->isVolatile())
6505 ? diag::warn_cxx17_compat_pointer_to_const_ref_member_on_rvalue
6506 : diag::ext_pointer_to_const_ref_member_on_rvalue);
6508 Diag(
Loc, diag::err_pointer_to_member_oper_value_classify)
6515 Diag(
Loc, diag::err_pointer_to_member_oper_value_classify)
6528 if (
Result->isFunctionType()) {
6531 }
else if (isIndirect) {
6549 bool &HaveConversion,
6551 HaveConversion =
false;
6574 HaveConversion =
true;
6589 bool FDerivedFromT = FRec && TRec && FRec != TRec &&
6590 Self.IsDerivedFrom(QuestionLoc, FTy, TTy);
6591 if (FRec && TRec && (FRec == TRec || FDerivedFromT ||
6592 Self.IsDerivedFrom(QuestionLoc, TTy, FTy))) {
6596 if (FRec == TRec || FDerivedFromT) {
6601 HaveConversion =
true;
6624 HaveConversion = !InitSeq.
Failed();
6642 Self.AddBuiltinOperatorCandidates(OO_Conditional, QuestionLoc, Args,
6650 LHS.
get(), Best->BuiltinParamTypes[0], Best->Conversions[0],
6657 RHS.
get(), Best->BuiltinParamTypes[1], Best->Conversions[1],
6663 Self.MarkFunctionReferenced(QuestionLoc, Best->Function);
6672 if (
Self.DiagnoseConditionalForNull(LHS.
get(), RHS.
get(), QuestionLoc))
6675 Self.Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
6681 Self.Diag(QuestionLoc, diag::err_conditional_ambiguous_ovl)
6689 llvm_unreachable(
"Conditional operator has only built-in overloads");
6700 Expr *Arg =
E.get();
6718 assert(!EltTy->
isEnumeralType() &&
"Vectors cant be enum types");
6728 assert(!EltTy->
isEnumeralType() &&
"Vectors cant be enum types");
6740 QualType CondElementTy = CondVT->getElementType();
6741 unsigned CondElementCount = CondVT->getNumElements();
6750 if (LHSVT && RHSVT) {
6751 if (isa<ExtVectorType>(CondVT) != isa<ExtVectorType>(LHSVT)) {
6752 Diag(QuestionLoc, diag::err_conditional_vector_cond_result_mismatch)
6753 << isa<ExtVectorType>(CondVT);
6759 Diag(QuestionLoc, diag::err_conditional_vector_mismatched)
6760 << LHSType << RHSType;
6764 }
else if (LHSVT || RHSVT) {
6766 LHS, RHS, QuestionLoc,
false,
true,
6770 if (ResultType.isNull())
6783 Diag(QuestionLoc, diag::err_conditional_vector_operand_type)
6798 assert(!ResultType.isNull() && ResultType->isVectorType() &&
6800 "Result should have been a vector type");
6801 auto *ResultVectorTy = ResultType->castAs<
VectorType>();
6802 QualType ResultElementTy = ResultVectorTy->getElementType();
6803 unsigned ResultElementCount = ResultVectorTy->getNumElements();
6805 if (ResultElementCount != CondElementCount) {
6806 Diag(QuestionLoc, diag::err_conditional_vector_size) << CondType
6813 Diag(QuestionLoc, diag::err_conditional_vector_element_size) << CondType
6831 llvm::ElementCount CondElementCount =
6843 if (LHSBT && RHSBT) {
6846 Diag(QuestionLoc, diag::err_conditional_vector_mismatched)
6847 << LHSType << RHSType;
6850 ResultType = LHSType;
6851 }
else if (LHSBT || RHSBT) {
6854 if (ResultType.isNull())
6863 ResultElementTy = LHSType;
6869 Diag(QuestionLoc, diag::err_conditional_vector_operand_type)
6875 ResultElementTy, CondElementCount.getKnownMinValue());
6881 assert(!ResultType.isNull() && ResultType->isSveVLSBuiltinType() &&
6882 "Result should have been a vector type");
6883 auto *ResultBuiltinTy = ResultType->castAs<
BuiltinType>();
6885 llvm::ElementCount ResultElementCount =
6888 if (ResultElementCount != CondElementCount) {
6889 Diag(QuestionLoc, diag::err_conditional_vector_size)
6890 << CondType << ResultType;
6896 Diag(QuestionLoc, diag::err_conditional_vector_element_size)
6897 << CondType << ResultType;
6914 bool IsVectorConditional =
6917 bool IsSizelessVectorConditional =
6924 ExprResult CondRes = IsVectorConditional || IsSizelessVectorConditional
6950 if (LVoid || RVoid) {
6959 if (IsVectorConditional) {
6962 bool IsThrow = LVoid ? LThrow : RThrow;
6963 Diag(DiagLoc.
getBegin(), diag::err_conditional_vector_has_void)
6964 << DiagLoc << IsThrow;
6968 if (LThrow != RThrow) {
6969 Expr *NonThrow = LThrow ? RHS.
get() : LHS.
get();
6983 Diag(QuestionLoc, diag::err_conditional_void_nonvoid)
6984 << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1)
6990 if (IsVectorConditional)
6993 if (IsSizelessVectorConditional)
6998 Diag(QuestionLoc, diag::err_wasm_table_conditional_expression)
7011 bool HaveL2R, HaveR2L;
7018 if (HaveL2R && HaveR2L) {
7019 Diag(QuestionLoc, diag::err_conditional_ambiguous)
7031 }
else if (HaveR2L) {
7055 ReferenceConversions::Qualification |
7056 ReferenceConversions::NestedQualification |
7057 ReferenceConversions::Function;
7062 !(RefConv & ~AllowedConversions) &&
7070 !(RefConv & ~AllowedConversions) &&
7086 if (Same && LVK == RVK && LVK !=
VK_PRValue &&
7160 diag::err_typecheck_cond_incompatible_operands) << LTy << RTy
7198 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
7218 bool T2IsPointerLike = T2->isAnyPointerType() || T2->isMemberPointerType() ||
7219 T2->isNullPtrType();
7220 if (!T1IsPointerLike && !T2IsPointerLike)
7228 if (T1IsPointerLike &&
7232 ? CK_NullToMemberPointer
7233 : CK_NullToPointer).
get();
7236 if (T2IsPointerLike &&
7240 ? CK_NullToMemberPointer
7241 : CK_NullToPointer).
get();
7246 if (!T1IsPointerLike || !T2IsPointerLike)
7249 "nullptr_t should be a null pointer constant");
7252 enum Kind {
Pointer, ObjCPointer, MemberPointer, Array } K;
7257 const Type *ClassOrBound;
7259 Step(
Kind K,
const Type *ClassOrBound =
nullptr)
7260 : K(K), ClassOrBound(ClassOrBound) {}
7271 if (
auto *CAT = cast_or_null<ConstantArrayType>(ClassOrBound))
7273 ArraySizeModifier::Normal, 0);
7277 llvm_unreachable(
"unknown step kind");
7299 unsigned NeedConstBefore = 0;
7308 if (!Steps.empty()) {
7318 }
else if (Steps.size() == 1) {
7321 if (MaybeQ1 == MaybeQ2) {
7340 assert(Steps.size() == 1);
7348 assert(Steps.size() == 1);
7352 Steps.back().Quals = Quals;
7353 if (Q1 != Quals || Q2 != Quals)
7354 NeedConstBefore = Steps.size() - 1;
7362 auto *CAT1 = dyn_cast<ConstantArrayType>(Arr1);
7363 auto *CAT2 = dyn_cast<ConstantArrayType>(Arr2);
7364 if (CAT1 && CAT2 && CAT1->getSize() == CAT2->getSize()) {
7367 Steps.emplace_back(Step::Array, CAT1);
7370 bool IAT1 = isa<IncompleteArrayType>(Arr1);
7371 bool IAT2 = isa<IncompleteArrayType>(Arr2);
7372 if ((IAT1 && IAT2) ||
7374 ((
bool)CAT1 != (
bool)CAT2) &&
7375 (Steps.empty() || Steps.back().K != Step::Array))) {
7381 Steps.emplace_back(Step::Array);
7383 NeedConstBefore = Steps.size();
7393 Steps.emplace_back(Step::Pointer);
7402 Steps.emplace_back(Step::ObjCPointer);
7426 else if (Steps.empty())
7432 Steps.emplace_back(Step::MemberPointer,
Class);
7444 Steps.emplace_back(Step::Pointer);
7482 if (Steps.size() == 1) {
7501 FPT1->getParamTypes(), EPI1);
7503 FPT2->getParamTypes(), EPI2);
7509 if (Steps.size() == 1 && Steps.front().K == Step::Pointer &&
7515 Composite2 = Composite1;
7517 Composite1 = Composite2;
7526 Composite1 = Composite2;
7528 Composite2 = Composite1;
7538 for (
unsigned I = 0; I != NeedConstBefore; ++I)
7539 Steps[I].Quals.addConst();
7543 for (
auto &S : llvm::reverse(Steps))
7544 Composite = S.rebuild(
Context, Composite);
7565 E1 = E1Result.
get();
7570 E2 = E2Result.
get();
7580 assert(!isa<CXXBindTemporaryExpr>(
E) &&
"Double-bound temporary?");
7591 bool ReturnsRetained;
7596 Expr *Callee =
Call->getCallee()->IgnoreParens();
7602 T = BinOp->getRHS()->getType();
7603 else if (
MemberExpr *Mem = dyn_cast<MemberExpr>(Callee))
7604 T = Mem->getMemberDecl()->getType();
7619 }
else if (isa<StmtExpr>(
E)) {
7620 ReturnsRetained =
true;
7624 }
else if (isa<CastExpr>(
E) &&
7625 isa<BlockExpr>(cast<CastExpr>(
E)->getSubExpr())) {
7634 D = Send->getMethodDecl();
7635 }
else if (
ObjCBoxedExpr *BoxedExpr = dyn_cast<ObjCBoxedExpr>(
E)) {
7636 D = BoxedExpr->getBoxingMethod();
7640 if (ArrayLit->getNumElements() == 0 &&
7644 D = ArrayLit->getArrayWithObjectsMethod();
7646 = dyn_cast<ObjCDictionaryLiteral>(
E)) {
7649 if (DictLit->getNumElements() == 0 &&
7653 D = DictLit->getDictWithObjectsMethod();
7656 ReturnsRetained = (
D &&
D->
hasAttr<NSReturnsRetainedAttr>());
7661 if (!ReturnsRetained &&
7672 CastKind ck = (ReturnsRetained ? CK_ARCConsumeObject
7673 : CK_ARCReclaimReturnedObject);
7691 RT = cast<RecordType>(
T);
7693 case Type::ConstantArray:
7694 case Type::IncompleteArray:
7695 case Type::VariableArray:
7696 case Type::DependentSizedArray:
7697 T = cast<ArrayType>(
T)->getElementType().getTypePtr();
7717 PDiag(diag::err_access_dtor_temp)
7748 assert(SubExpr &&
"subexpression can't be null!");
7770 assert(SubStmt &&
"sub-statement can't be null!");
7793 "not in a decltype expression");
7810 if (
ParenExpr *PE = dyn_cast<ParenExpr>(
E)) {
7814 if (SubExpr.
get() == PE->getSubExpr())
7819 if (BO->getOpcode() == BO_Comma) {
7823 if (RHS.
get() == BO->getRHS())
7826 BO->
getType(), BO->getValueKind(),
7827 BO->getObjectKind(), BO->getOperatorLoc(),
7828 BO->getFPFeatures());
7855 for (
unsigned I = 0, N =
ExprEvalContexts.back().DelayedDecltypeCalls.size();
7858 if (
Call == TopCall)
7868 for (
unsigned I = 0, N =
ExprEvalContexts.back().DelayedDecltypeBinds.size();
7872 if (
Bind == TopBind)
7878 Bind->getType()->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
7884 PDiag(diag::err_access_dtor_temp)
7885 <<
Bind->getType());
7900 unsigned SkipStart = OperatorArrows.size(), SkipCount = 0;
7903 if (OperatorArrows.size() > Limit) {
7905 SkipStart = (Limit - 1) / 2 + (Limit - 1) % 2;
7906 SkipCount = OperatorArrows.size() - (Limit - 1);
7909 for (
unsigned I = 0; I < OperatorArrows.size(); ) {
7910 if (I == SkipStart) {
7911 S.
Diag(OperatorArrows[I]->getLocation(),
7912 diag::note_operator_arrows_suppressed)
7916 S.
Diag(OperatorArrows[I]->getLocation(), diag::note_operator_arrow_here)
7917 << OperatorArrows[I]->getCallResultType();
7927 bool &MayBePseudoDestructor) {
7938 MayBePseudoDestructor =
false;
7943 if (OpKind == tok::arrow)
7948 MayBePseudoDestructor =
true;
7955 if (OpKind == tok::arrow) {
7957 bool NoArrowOperatorFound =
false;
7958 bool FirstIteration =
true;
7966 if (OperatorArrows.size() >=
getLangOpts().ArrowDepth) {
7967 Diag(OpLoc, diag::err_operator_arrow_depth_exceeded)
7968 << StartingType <<
getLangOpts().ArrowDepth <<
Base->getSourceRange();
7970 Diag(OpLoc, diag::note_operator_arrow_depth)
7983 : &NoArrowOperatorFound);
7984 if (
Result.isInvalid()) {
7985 if (NoArrowOperatorFound) {
7986 if (FirstIteration) {
7987 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
7988 << BaseType << 1 <<
Base->getSourceRange()
7990 OpKind = tok::period;
7993 Diag(OpLoc, diag::err_typecheck_member_reference_arrow)
7994 << BaseType <<
Base->getSourceRange();
7998 diag::note_member_reference_arrow_from_operator_arrow);
8005 OperatorArrows.push_back(OpCall->getDirectCallee());
8006 BaseType =
Base->getType();
8008 if (!CTypes.insert(CBaseType).second) {
8009 Diag(OpLoc, diag::err_operator_arrow_circular) << StartingType;
8013 FirstIteration =
false;
8016 if (OpKind == tok::arrow) {
8020 BaseType = AT->getElementType();
8042 MayBePseudoDestructor =
true;
8054 diag::err_incomplete_member_access)) {
8069 if (
Base->hasPlaceholderType()) {
8074 ObjectType =
Base->getType();
8082 if (OpKind == tok::arrow) {
8092 ObjectType =
Base->getType();
8097 }
else if (!
Base->isTypeDependent()) {
8099 S.
Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
8100 << ObjectType <<
true
8105 OpKind = tok::period;
8147 Diag(OpLoc, diag::ext_pseudo_dtor_on_void) <<
Base->getSourceRange();
8149 Diag(OpLoc, diag::err_pseudo_dtor_base_not_scalar)
8150 << ObjectType <<
Base->getSourceRange();
8158 if (DestructedTypeInfo) {
8171 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
8172 << ObjectType << 0 <<
Base->getSourceRange();
8176 *
this, DestructedType))
8181 ObjectType = DestructedType;
8182 OpKind = tok::arrow;
8184 Diag(DestructedTypeStart, diag::err_pseudo_dtor_type_mismatch)
8185 << ObjectType << DestructedType <<
Base->getSourceRange()
8189 DestructedType = ObjectType;
8190 DestructedTypeInfo =
8201 Diag(DestructedTypeStart, diag::err_arc_pseudo_dtor_inconstant_quals)
8202 << ObjectType << DestructedType <<
Base->getSourceRange()
8207 DestructedType = ObjectType;
8209 DestructedTypeStart);
8222 if (ScopeTypeInfo) {
8224 if (!ScopeType->isDependentType() && !ObjectType->
isDependentType() &&
8228 diag::err_pseudo_dtor_type_mismatch)
8229 << ObjectType << ScopeType <<
Base->getSourceRange()
8233 ScopeTypeInfo =
nullptr;
8239 OpKind == tok::arrow, OpLoc,
8259 "Invalid first type name in pseudo-destructor");
8262 "Invalid second type name in pseudo-destructor");
8286 S, &SS,
true,
false, ObjectTypePtrForLookup,
8299 diag::err_pseudo_dtor_destructor_non_type)
8305 DestructedType = ObjectType;
8323 if (
T.isInvalid() || !
T.get()) {
8325 DestructedType = ObjectType;
8332 if (!DestructedType.
isNull()) {
8333 if (!DestructedTypeInfo)
8347 S, &SS,
true,
false, ObjectTypePtrForLookup,
8351 diag::err_pseudo_dtor_destructor_non_type)
8376 if (
T.isInvalid() || !
T.get()) {
8384 if (!ScopeType.isNull() && !ScopeTypeInfo)
8390 ScopeTypeInfo, CCLoc, TildeLoc,
8421 cast<PackIndexingType>(
T.getTypePtr())->getPattern(),
8428 llvm_unreachable(
"Unsupported type in pseudo destructor");
8454 Operand->HasSideEffects(
Context,
false)) {
8457 Diag(Operand->getExprLoc(), diag::warn_side_effects_unevaluated_context);
8473 bool IsCompoundAssign =
false;
8474 bool isIncrementDecrementUnaryOp =
false;
8476 if (BO->getLHS()->getType()->isDependentType() ||
8477 BO->getRHS()->getType()->isDependentType()) {
8478 if (BO->getOpcode() != BO_Assign)
8480 }
else if (!BO->isAssignmentOp())
8483 IsCompoundAssign = BO->isCompoundAssignmentOp();
8484 LHS = dyn_cast<DeclRefExpr>(BO->getLHS());
8486 if (COCE->getOperator() != OO_Equal)
8488 LHS = dyn_cast<DeclRefExpr>(COCE->getArg(0));
8490 if (!UO->isIncrementDecrementOp())
8492 isIncrementDecrementUnaryOp =
true;
8493 LHS = dyn_cast<DeclRefExpr>(UO->getSubExpr());
8503 if ((IsCompoundAssign || isIncrementDecrementUnaryOp) &&
8509 iter->getSecond()--;
8574 if (!
T->getDecl()->isComplete()) {
8588 diag::err_incomplete_type);
8614 if (isa<ParmVarDecl>(Var))
return true;
8615 const VarDecl *DefVD =
nullptr;
8649 while (isa_and_nonnull<CapturedDecl>(DC))
8653 "The current call operator must be synchronized with Sema's CurContext");
8674 !IsFullExprInstantiationDependent)
8683 if (
const std::optional<unsigned> Index =
8687 const bool IsVarNeverAConstantExpression =
8689 if (!IsFullExprInstantiationDependent || IsVarNeverAConstantExpression) {
8701 DeclRefType,
nullptr)) {
8707 DeclRefType,
nullptr);
8716 if (
const std::optional<unsigned> Index =
8719 const unsigned FunctionScopeIndexOfCapturableLambda = *Index;
8722 &FunctionScopeIndexOfCapturableLambda);
8734 Consumer.getLookupResult().getLookupKind());
8747 if (ND->isCXXClassMember()) {
8751 Record = NNS->getAsType()->getAsCXXRecordDecl();
8754 dyn_cast<CXXRecordDecl>(ND->getDeclContext()->getRedeclContext());
8761 NewSS, R,
Consumer.isAddressOfOperand()))
8765 }
else if (
auto *Ivar = dyn_cast<ObjCIvarDecl>(ND)) {
8767 Ivar->getIdentifier());
8781 : TypoExprs(TypoExprs) {}
8783 TypoExprs.insert(TE);
8788class TransformTypos :
public TreeTransform<TransformTypos> {
8795 llvm::SmallDenseMap<TypoExpr *, ExprResult, 2> TransformCache;
8796 llvm::SmallDenseMap<OverloadExpr *, Expr *, 4> OverloadResolution;
8808 void EmitAllDiagnostics(
bool IsAmbiguous) {
8810 auto &State = SemaRef.getTypoExprState(TE);
8811 if (State.DiagHandler) {
8822 Replacement.isInvalid() ?
nullptr : Replacement.get()))
8825 State.DiagHandler(TC);
8827 SemaRef.clearDelayedTypo(TE);
8845 bool CheckAndAdvanceTypoExprCorrectionStreams() {
8846 for (
auto *TE : TypoExprs) {
8847 auto &State = SemaRef.getTypoExprState(TE);
8848 TransformCache.erase(TE);
8849 if (!State.Consumer->hasMadeAnyCorrectionProgress())
8851 if (!State.Consumer->finished())
8853 State.Consumer->resetCorrectionStream();
8859 if (
auto *OE = dyn_cast_or_null<OverloadExpr>(
E))
8860 E = OverloadResolution[OE];
8864 if (
auto *DRE = dyn_cast<DeclRefExpr>(
E))
8865 return DRE->getFoundDecl();
8866 if (
auto *ME = dyn_cast<MemberExpr>(
E))
8877 if (Trap.hasErrorOccurred() || Res.
isInvalid())
8880 return ExprFilter(Res.
get());
8894 auto SavedTypoExprs = std::move(TypoExprs);
8895 auto SavedAmbiguousTypoExprs = std::move(AmbiguousTypoExprs);
8897 AmbiguousTypoExprs.clear();
8899 FindTypoExprs(TypoExprs).TraverseStmt(FixedExpr);
8900 if (!TypoExprs.empty()) {
8904 RecursiveTransformLoop(FixedExpr, IsAmbiguous);
8912 auto &SemaTypoExprs = SemaRef.TypoExprs;
8913 for (
auto *TE : TypoExprs) {
8914 TransformCache.erase(TE);
8915 SemaRef.clearDelayedTypo(TE);
8917 auto SI = find(SemaTypoExprs, TE);
8918 if (SI != SemaTypoExprs.end()) {
8919 SemaTypoExprs.erase(SI);
8926 SavedTypoExprs.set_union(TypoExprs);
8930 TypoExprs = std::move(SavedTypoExprs);
8931 AmbiguousTypoExprs = std::move(SavedAmbiguousTypoExprs);
8943 auto SavedTypoExprs = std::move(SemaRef.TypoExprs);
8944 SemaRef.TypoExprs.clear();
8947 Res = CheckForRecursiveTypos(TryTransform(
E), IsAmbiguous);
8961 if (!CheckAndAdvanceTypoExprCorrectionStreams())
8966 if (!IsAmbiguous && !Res.
isInvalid() && !AmbiguousTypoExprs.empty()) {
8967 auto SavedTransformCache =
8968 llvm::SmallDenseMap<TypoExpr *, ExprResult, 2>(TransformCache);
8972 while (!AmbiguousTypoExprs.empty()) {
8973 auto TE = AmbiguousTypoExprs.back();
8977 SemaRef.getTypoExprState(TE).Consumer->saveCurrentPosition();
8979 TypoCorrection TC = SemaRef.getTypoExprState(TE).Consumer->peekNextCorrection();
8985 TransformCache.erase(TE);
8986 ExprResult AmbigRes = CheckForRecursiveTypos(TryTransform(
E), IsAmbiguous);
8988 if (!AmbigRes.
isInvalid() || IsAmbiguous) {
8989 SemaRef.getTypoExprState(TE).Consumer->resetCorrectionStream();
8990 SavedTransformCache.erase(TE);
8995 }
while ((Next = SemaRef.getTypoExprState(TE).Consumer->peekNextCorrection()) &&
9001 AmbiguousTypoExprs.remove(TE);
9002 SemaRef.getTypoExprState(TE).Consumer->restoreSavedPosition();
9003 TransformCache[TE] = SavedTransformCache[TE];
9005 TransformCache = std::move(SavedTransformCache);
9012 auto &SemaTypoExprs = SemaRef.TypoExprs;
9013 for (
auto Iterator = SemaTypoExprs.begin(); Iterator != SemaTypoExprs.end();) {
9014 auto TE = *Iterator;
9015 auto FI = find(TypoExprs, TE);
9016 if (FI != TypoExprs.end()) {
9020 SemaRef.clearDelayedTypo(TE);
9021 Iterator = SemaTypoExprs.erase(Iterator);
9023 SemaRef.TypoExprs = std::move(SavedTypoExprs);
9030 : BaseTransform(SemaRef), InitDecl(InitDecl), ExprFilter(
Filter) {}
9035 Expr *ExecConfig =
nullptr) {
9036 auto Result = BaseTransform::RebuildCallExpr(Callee, LParenLoc, Args,
9037 RParenLoc, ExecConfig);
9038 if (
auto *OE = dyn_cast<OverloadExpr>(Callee)) {
9039 if (Result.isUsable()) {
9040 Expr *ResultCall = Result.get();
9041 if (
auto *BE = dyn_cast<CXXBindTemporaryExpr>(ResultCall))
9042 ResultCall = BE->getSubExpr();
9043 if (
auto *CE = dyn_cast<CallExpr>(ResultCall))
9044 OverloadResolution[OE] = CE->getCallee();
9055 bool IsAmbiguous =
false;
9056 ExprResult Res = RecursiveTransformLoop(
E, IsAmbiguous);
9059 FindTypoExprs(TypoExprs).TraverseStmt(
E);
9061 EmitAllDiagnostics(IsAmbiguous);
9070 auto &CacheEntry = TransformCache[
E];
9071 if (!TypoExprs.insert(
E) && !CacheEntry.isUnset()) {
9076 assert(State.Consumer &&
"Cannot transform a cleared TypoExpr");
9080 while (
TypoCorrection TC = State.Consumer->getNextCorrection()) {
9086 State.RecoveryHandler(SemaRef,
E, TC) :
9088 if (!
NE.isInvalid()) {
9093 if ((Next = State.Consumer->peekNextCorrection()) &&
9095 AmbiguousTypoExprs.insert(
E);
9097 AmbiguousTypoExprs.remove(
E);
9099 assert(!
NE.isUnset() &&
9100 "Typo was transformed into a valid-but-null ExprResult");
9101 return CacheEntry =
NE;
9111 bool RecoverUncorrectedTypos,
9119 auto TyposResolved = DelayedTypos.size();
9120 auto Result = TransformTypos(*
this, InitDecl, Filter).Transform(
E);
9121 TyposResolved -= DelayedTypos.size();
9124 if (
Result.isInvalid() && RecoverUncorrectedTypos) {
9132 return TT.TransformExpr(
E);
9136 assert(TyposResolved == 0 &&
"Corrected typo but got same Expr back?");
9142 bool DiscardedValue,
bool IsConstexpr,
9143 bool IsTemplateArgument) {
9152 if (DiscardedValue) {
9177 CheckCompletedExpr(
FullExpr.get(), CC, IsConstexpr);
9226 while (isa_and_nonnull<CapturedDecl>(DC))
9229 if (IsInLambdaDeclContext && CurrentLSI &&
9256 RedeclarationKind::NotForRedeclaration);
9274 llvm_unreachable(
"Invalid LookupResult Kind!");
9302 "Exactly one of TypeName and TemplateId must be specified.");
9370 E,
false, NoexceptLoc,
9398 auto *Param = cast<TemplateTypeParmDecl>(TPL->
getParam(0));
9403 assert(TC &&
"Type Constraint cannot be null here");
9405 assert(IDC &&
"ImmediatelyDeclaredConstraint can't be null here.");
9410 [&](llvm::raw_ostream &
OS) {
9411 IDC->printPretty(OS, nullptr,
9412 getPrintingPolicy());
9414 IsSimple, NoexceptLoc, ReturnTypeRequirement);
9416 SubstitutedConstraintExpr =
9417 cast<ConceptSpecializationExpr>(Constraint.
get());
9422 ReturnTypeRequirement, Status,
9423 SubstitutedConstraintExpr);
9432 IsSimple, NoexceptLoc,
9433 ReturnTypeRequirement);
9466 InvalidConstraintEntity,
9482 if (Param->hasDefaultArg())
9486 Diag(Param->getDefaultArgRange().getBegin(),
9487 diag::err_requires_expr_local_parameter_default_argument);
9490 Param->setDeclContext(Body);
9492 if (Param->getIdentifier()) {
9501 assert(
CurContext &&
"DeclContext imbalance!");
9503 assert(
CurContext &&
"Popped translation unit!");
9512 LocalParameters, RParenLoc, Requirements,
Defines the clang::ASTContext interface.
This file provides some common utility functions for processing Lambda related AST Constructs.
Defines a function that returns the minimum OS versions supporting C++17's aligned allocation functio...
static bool CanThrow(Expr *E, ASTContext &Ctx)
static CanQualType GetReturnType(QualType RetTy)
Returns the "extra-canonicalized" return type, which discards qualifiers on the return type.
enum clang::sema::@1656::IndirectLocalPathEntry::EntryKind Kind
static const char * getPlatformName(Darwin::DarwinPlatformKind Platform, Darwin::DarwinEnvironmentKind Environment)
Defines the clang::Expr interface and subclasses for C++ expressions.
Defines Expressions and AST nodes for C++2a concepts.
llvm::MachO::Record Record
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.
Defines the clang::Preprocessor interface.
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
This file declares semantic analysis for CUDA constructs.
static void collectPublicBases(CXXRecordDecl *RD, llvm::DenseMap< CXXRecordDecl *, unsigned > &SubobjectsSeen, llvm::SmallPtrSetImpl< CXXRecordDecl * > &VBases, llvm::SetVector< CXXRecordDecl * > &PublicSubobjectsSeen, bool ParentIsPublic)
static bool EvaluateBinaryTypeTrait(Sema &Self, TypeTrait BTT, const TypeSourceInfo *Lhs, const TypeSourceInfo *Rhs, SourceLocation KeyLoc)
static bool HasNonDeletedDefaultedEqualityComparison(Sema &S, const CXXRecordDecl *Decl, SourceLocation KeyLoc)
static bool DiagnoseVLAInCXXTypeTrait(Sema &S, const TypeSourceInfo *T, clang::tok::TokenKind TypeTraitID)
Checks that type T is not a VLA.
static bool ConvertForConditional(Sema &Self, ExprResult &E, QualType T)
Perform an "extended" implicit conversion as returned by TryClassUnification.
static void MaybeDecrementCount(Expr *E, llvm::DenseMap< const VarDecl *, int > &RefsMinusAssignments)
static ExprResult attemptRecovery(Sema &SemaRef, const TypoCorrectionConsumer &Consumer, const TypoCorrection &TC)
static void DiagnoseMismatchedNewDelete(Sema &SemaRef, SourceLocation DeleteLoc, const MismatchingNewDeleteDetector &Detector)
static void getUnambiguousPublicSubobjects(CXXRecordDecl *RD, llvm::SmallVectorImpl< CXXRecordDecl * > &Objects)
static bool isLegalArrayNewInitializer(CXXNewInitializationStyle Style, Expr *Init, bool IsCPlusPlus20)
static QualType adjustVectorType(ASTContext &Context, QualType FromTy, QualType ToType, QualType *ElTy=nullptr)
static void CheckIfAnyEnclosingLambdasMustCaptureAnyPotentialCaptures(Expr *const FE, LambdaScopeInfo *const CurrentLSI, Sema &S)
Check if the current lambda has any potential captures that must be captured by any of its enclosing ...
static void getUuidAttrOfType(Sema &SemaRef, QualType QT, llvm::SmallSetVector< const UuidAttr *, 1 > &UuidAttrs)
Grabs __declspec(uuid()) off a type, or returns 0 if we cannot resolve to a single GUID.
static bool resolveAllocationOverload(Sema &S, LookupResult &R, SourceRange Range, SmallVectorImpl< Expr * > &Args, bool &PassAlignment, FunctionDecl *&Operator, OverloadCandidateSet *AlignedCandidates, Expr *AlignArg, bool Diagnose)
static QualType adjustCVQualifiersForCXXThisWithinLambda(ArrayRef< FunctionScopeInfo * > FunctionScopes, QualType ThisTy, DeclContext *CurSemaContext, ASTContext &ASTCtx)
static bool DiagnoseAtomicInCXXTypeTrait(Sema &S, const TypeSourceInfo *T, clang::tok::TokenKind TypeTraitID)
Checks that type T is not an atomic type (_Atomic).
static bool FindConditionalOverload(Sema &Self, ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
Try to find a common type for two according to C++0x 5.16p5.
static bool TryClassUnification(Sema &Self, Expr *From, Expr *To, SourceLocation QuestionLoc, bool &HaveConversion, QualType &ToType)
Try to convert a type to another according to C++11 5.16p3.
static bool HasNoThrowOperator(const RecordType *RT, OverloadedOperatorKind Op, Sema &Self, SourceLocation KeyLoc, ASTContext &C, bool(CXXRecordDecl::*HasTrivial)() const, bool(CXXRecordDecl::*HasNonTrivial)() const, bool(CXXMethodDecl::*IsDesiredOp)() const)
static bool EvaluateExpressionTrait(ExpressionTrait ET, Expr *E)
static UsualDeallocFnInfo resolveDeallocationOverload(Sema &S, LookupResult &R, bool WantSize, bool WantAlign, llvm::SmallVectorImpl< UsualDeallocFnInfo > *BestFns=nullptr)
Select the correct "usual" deallocation function to use from a selection of deallocation functions (e...
static bool hasNewExtendedAlignment(Sema &S, QualType AllocType)
Determine whether a type has new-extended alignment.
static ExprResult BuildCXXCastArgument(Sema &S, SourceLocation CastLoc, QualType Ty, CastKind Kind, CXXMethodDecl *Method, DeclAccessPair FoundDecl, bool HadMultipleCandidates, Expr *From)
static bool VariableCanNeverBeAConstantExpression(VarDecl *Var, ASTContext &Context)
static bool canRecoverDotPseudoDestructorCallsOnPointerObjects(Sema &SemaRef, QualType DestructedType)
Check if it's ok to try and recover dot pseudo destructor calls on pointer objects.
static bool CheckArrow(Sema &S, QualType &ObjectType, Expr *&Base, tok::TokenKind &OpKind, SourceLocation OpLoc)
static bool resolveBuiltinNewDeleteOverload(Sema &S, CallExpr *TheCall, bool IsDelete, FunctionDecl *&Operator)
static bool doesUsualArrayDeleteWantSize(Sema &S, SourceLocation loc, QualType allocType)
Determine whether a given type is a class for which 'delete[]' would call a member 'operator delete[]...
static bool EvaluateUnaryTypeTrait(Sema &Self, TypeTrait UTT, SourceLocation KeyLoc, TypeSourceInfo *TInfo)
static uint64_t EvaluateArrayTypeTrait(Sema &Self, ArrayTypeTrait ATT, QualType T, Expr *DimExpr, SourceLocation KeyLoc)
static bool isValidVectorForConditionalCondition(ASTContext &Ctx, QualType CondTy)
static bool CheckUnaryTypeTraitTypeCompleteness(Sema &S, TypeTrait UTT, SourceLocation Loc, QualType ArgTy)
Check the completeness of a type in a unary type trait.
static void noteOperatorArrows(Sema &S, ArrayRef< FunctionDecl * > OperatorArrows)
Note a set of 'operator->' functions that were used for a member access.
static bool isValidSizelessVectorForConditionalCondition(ASTContext &Ctx, QualType CondTy)
static void buildLambdaThisCaptureFixit(Sema &Sema, LambdaScopeInfo *LSI)
static ExprResult CheckConvertibilityForTypeTraits(Sema &Self, const TypeSourceInfo *Lhs, const TypeSourceInfo *Rhs, SourceLocation KeyLoc, llvm::BumpPtrAllocator &OpaqueExprAllocator)
static bool EvaluateBooleanTypeTrait(Sema &S, TypeTrait Kind, SourceLocation KWLoc, ArrayRef< TypeSourceInfo * > Args, SourceLocation RParenLoc, bool IsDependent)
static bool isTriviallyEqualityComparableType(Sema &S, QualType Type, SourceLocation KeyLoc)
static bool isNonPlacementDeallocationFunction(Sema &S, FunctionDecl *FD)
Determine whether the given function is a non-placement deallocation function.
static NamedDecl * getDeclFromExpr(Expr *E)
This file provides some common utility functions for processing Lambdas.
This file declares semantic analysis for Objective-C.
This file declares semantic analysis functions specific to PowerPC.
static QualType getPointeeType(const MemRegion *R)
Defines the clang::TokenKind enum and support functions.
Defines the clang::TypeLoc interface and its subclasses.
Defines enumerations for the type traits support.
C Language Family Type Representation.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
MSGuidDecl * getMSGuidDecl(MSGuidDeclParts Parts) const
Return a declaration for the global GUID object representing the given GUID value.
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
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type.
unsigned getIntWidth(QualType T) const
QualType getBlockPointerType(QualType T) const
Return the uniqued reference to the type for a block of the specified type.
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.
QualType getMemberPointerType(QualType T, const Type *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
DeclarationNameTable DeclarationNames
QualType getRecordType(const RecordDecl *Decl) const
QualType getScalableVectorType(QualType EltTy, unsigned NumElts, unsigned NumFields=1) const
Return the unique reference to a scalable vector type of the specified element type and scalable numb...
QualType getArrayParameterType(QualType Ty) const
Return the uniqued reference to a specified array parameter type from the original array type.
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.
CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod, bool IsBuiltin=false) const
Retrieves the default calling convention for the current target.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
QualType getMSGuidType() const
Retrieve the implicitly-predeclared 'struct _GUID' type.
QualType getReferenceQualifiedType(const Expr *e) const
getReferenceQualifiedType - Given an expr, will return the type for that expression,...
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, const Expr *SizeExpr, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type.
const LangOptions & getLangOpts() const
bool hasUniqueObjectRepresentations(QualType Ty, bool CheckIfTriviallyCopyable=true) const
Return true if the specified type has unique object representations according to (C++17 [meta....
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
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 ...
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType, TagDecl *OwnedTagDecl=nullptr) const
CharUnits getExnObjectAlignment() const
Return the alignment (in bytes) of the thrown exception object.
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
QualType getObjCIdType() const
Represents the Objective-CC id type.
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
FunctionProtoType::ExceptionSpecInfo mergeExceptionSpecs(FunctionProtoType::ExceptionSpecInfo ESI1, FunctionProtoType::ExceptionSpecInfo ESI2, SmallVectorImpl< QualType > &ExceptionTypeStorage, bool AcceptDependent)
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const
Allocate an uninitialized TypeSourceInfo.
QualType getExceptionObjectType(QualType T) const
QualType getCommonSugaredType(QualType X, QualType Y, bool Unqualified=false)
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
unsigned getTypeAlignIfKnown(QualType T, bool NeedsPreferredAlignment=false) const
Return the alignment of a type, in bits, or 0 if the type is incomplete and we cannot determine the a...
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
void addCopyConstructorForExceptionObject(CXXRecordDecl *RD, CXXConstructorDecl *CD)
QualType getCVRQualifiedType(QualType T, unsigned CVR) const
Return a type with additional const, volatile, or restrict qualifiers.
QualType getExtVectorType(QualType VectorType, unsigned NumElts) const
Return the unique reference to an extended vector type of the specified element type and size.
const TargetInfo & getTargetInfo() const
QualType getLifetimeQualifiedType(QualType type, Qualifiers::ObjCLifetime lifetime)
Return a type with the given lifetime qualifier.
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 getWideCharType() const
Return the type of wide characters.
QualType getLogicalOperationType() const
The result type of logical operations, '<', '>', '!=', etc.
QualType getIncompleteArrayType(QualType EltTy, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return a unique reference to the type for an incomplete array of the specified element type.
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals) const
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals.
unsigned getTypeAlign(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in bits.
uint64_t getCharWidth() const
Return the size of the character type, in bits.
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent.
Represents an array type, per C99 6.7.5.2 - Array Declarators.
QualType getElementType() const
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
Attr - This represents one attribute.
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
A builtin binary operation expression such as "x + y" or "x <= y".
static BinaryOperator * Create(const ASTContext &C, Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy, ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc, FPOptionsOverride FPFeatures)
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
This class is used for builtin types like 'int'.
Represents a base class of a C++ class.
Represents binding an expression to a temporary.
static CXXBindTemporaryExpr * Create(const ASTContext &C, CXXTemporary *Temp, Expr *SubExpr)
const Expr * getSubExpr() const
A boolean literal, per ([C++ lex.bool] Boolean literals).
Represents a call to a C++ constructor.
Represents a C++ constructor within a class.
Represents a C++ conversion function within a class.
Represents a C++ base or member initializer.
FieldDecl * getMember() const
If this is a member initializer, returns the declaration of the non-static data member being initiali...
Expr * getInit() const
Get the initializer.
Represents a delete expression for memory deallocation and destructor calls, e.g.
SourceLocation getBeginLoc() const
Represents a C++ destructor within a class.
static CXXFunctionalCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, TypeSourceInfo *Written, CastKind Kind, Expr *Op, const CXXCastPath *Path, FPOptionsOverride FPO, SourceLocation LPLoc, SourceLocation RPLoc)
Represents a static or instance method of a struct/union/class.
bool isUsualDeallocationFunction(SmallVectorImpl< const FunctionDecl * > &PreventedBy) const
Determine whether this is a usual deallocation function (C++ [basic.stc.dynamic.deallocation]p2),...
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
bool isMoveAssignmentOperator() const
Determine whether this is a move assignment operator.
QualType getFunctionObjectParameterType() const
bool isCopyAssignmentOperator() const
Determine whether this is a copy-assignment operator, regardless of whether it was declared implicitl...
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
static CXXNewExpr * Create(const ASTContext &Ctx, bool IsGlobalNew, FunctionDecl *OperatorNew, FunctionDecl *OperatorDelete, bool ShouldPassAlignment, bool UsualArrayDeleteWantsSize, ArrayRef< Expr * > PlacementArgs, SourceRange TypeIdParens, std::optional< Expr * > ArraySize, CXXNewInitializationStyle InitializationStyle, Expr *Initializer, QualType Ty, TypeSourceInfo *AllocatedTypeInfo, SourceRange Range, SourceRange DirectInitRange)
Create a c++ new expression.
Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
The null pointer literal (C++11 [lex.nullptr])
A call to an overloaded operator written using operator syntax.
Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
Represents a C++ struct/union/class.
bool hasTrivialMoveAssignment() const
Determine whether this class has a trivial move assignment operator (C++11 [class....
bool hasNonTrivialCopyAssignment() const
Determine whether this class has a non-trivial copy assignment operator (C++ [class....
bool hasTrivialDefaultConstructor() const
Determine whether this class has a trivial default constructor (C++11 [class.ctor]p5).
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
bool hasTrivialMoveConstructor() const
Determine whether this class has a trivial move constructor (C++11 [class.copy]p12)
bool hasTrivialCopyConstructor() const
Determine whether this class has a trivial copy constructor (C++ [class.copy]p6, C++11 [class....
bool isPolymorphic() const
Whether this class is polymorphic (C++ [class.virtual]), which means that the class contains or inher...
static CXXRecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, CXXRecordDecl *PrevDecl=nullptr, bool DelayTypeCreation=false)
bool hasTrivialCopyAssignment() const
Determine whether this class has a trivial copy assignment operator (C++ [class.copy]p11,...
capture_const_range captures() const
bool isAbstract() const
Determine whether this class has a pure virtual function.
bool hasIrrelevantDestructor() const
Determine whether this class has a destructor which has no semantic effect.
bool hasNonTrivialMoveConstructor() const
Determine whether this class has a non-trivial move constructor (C++11 [class.copy]p12)
bool hasDefinition() const
bool isEmpty() const
Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
bool hasNonTrivialMoveAssignment() const
Determine whether this class has a non-trivial move assignment operator (C++11 [class....
bool hasNonTrivialDefaultConstructor() const
Determine whether this class has a non-trivial default constructor (C++11 [class.ctor]p5).
bool hasNonTrivialCopyConstructor() const
Determine whether this class has a non-trivial copy constructor (C++ [class.copy]p6,...
CXXMethodDecl * getLambdaCallOperator() const
Retrieve the lambda call operator of the closure type if this is a closure type.
An expression "T()" which creates an rvalue of a non-class type T.
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.
char * location_data() const
Retrieve the data associated with the source-location information.
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.
SourceLocation getLastQualifierNameLoc() const
Retrieve the location of the name in the last qualifier in this nested name specifier.
SourceLocation getEndLoc() const
SourceRange getRange() const
bool isSet() const
Deprecated.
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context.
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
bool isInvalid() const
An error occurred during parsing of the scope specifier.
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
Represents a C++ temporary.
void setDestructor(const CXXDestructorDecl *Dtor)
static CXXTemporary * Create(const ASTContext &C, const CXXDestructorDecl *Destructor)
Represents the this expression in C++.
static CXXThisExpr * Create(const ASTContext &Ctx, SourceLocation L, QualType Ty, bool IsImplicit)
A C++ throw-expression (C++ [except.throw]).
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
static CXXUnresolvedConstructExpr * Create(const ASTContext &Context, QualType T, TypeSourceInfo *TSI, SourceLocation LParenLoc, ArrayRef< Expr * > Args, SourceLocation RParenLoc, bool IsListInit)
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
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.
SourceLocation getBeginLoc() const LLVM_READONLY
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return null.
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
CharUnits - This is an opaque type for sizes expressed in character units.
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Declaration of a class template.
void setExprNeedsCleanups(bool SideEffects)
bool cleanupsHaveSideEffects() const
bool exprNeedsCleanups() const
Complex values, per C99 6.2.5p11.
CompoundStmt - This represents a group of statements like { stmt stmt }.
static CompoundStmt * Create(const ASTContext &C, ArrayRef< Stmt * > Stmts, FPOptionsOverride FPFeatures, SourceLocation LB, SourceLocation RB)
Represents the specialization of a concept - evaluates to a prvalue of type bool.
bool isSatisfied() const
Whether or not the concept with the given arguments was satisfied when the expression was created.
Represents the canonical version of C arrays with a specified constant size.
static unsigned getNumAddressingBits(const ASTContext &Context, QualType ElementType, const llvm::APInt &NumElements)
Determine the number of bits required to address a member of.
static unsigned getMaxSizeBits(const ASTContext &Context)
Determine the maximum number of active bits that an array's size can require, which limits the maximu...
The result of a constraint satisfaction check, containing the necessary information to diagnose an un...
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 isDependentContext() const
Determines whether this context is dependent on a template parameter.
DeclContext * getLexicalParent()
getLexicalParent - Returns the containing lexical DeclContext.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
void addDecl(Decl *D)
Add the declaration D into this context.
A reference to a declared variable, function, enum, etc.
Captures information about "declaration specifiers".
Expr * getPackIndexingExpr() const
TST getTypeSpecType() const
SourceLocation getBeginLoc() const LLVM_READONLY
static const TST TST_typename_pack_indexing
ParsedType getRepAsType() const
SourceLocation getEllipsisLoc() const
Expr * getRepAsExpr() const
static const TST TST_decltype
SourceLocation getTypeSpecTypeLoc() const
static const TST TST_decltype_auto
static const TST TST_error
SourceRange getTypeofParensRange() const
Decl - This represents one declaration (or definition), e.g.
SourceLocation getEndLoc() const LLVM_READONLY
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Kind
Lists the kind of concrete classes of Decl.
bool isInvalidDecl() const
SourceLocation getLocation() const
void setLocalOwningModule(Module *M)
void setImplicit(bool I=true)
DeclContext * getDeclContext()
@ ReachableWhenImported
This declaration has an owning module, and is visible to lookups that occurs within that module.
void setModuleOwnershipKind(ModuleOwnershipKind MOK)
Set whether this declaration is hidden from name lookup.
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
The name of a declaration.
bool isDependentName() const
Determines whether the name itself is dependent, e.g., because it involves a C++ type that is itself ...
OverloadedOperatorKind getCXXOverloadedOperator() const
If this name is the name of an overloadable operator in C++ (e.g., operator+), retrieve the kind of o...
SourceLocation getBeginLoc() const LLVM_READONLY
Information about one declarator, including the parsed type information and the identifier.
void setRParenLoc(SourceLocation Loc)
void setDecltypeLoc(SourceLocation Loc)
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
DiagnosticOptions & getDiagnosticOptions() const
Retrieve the diagnostic options.
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
RAII object that enters a new expression evaluation context.
static EnumDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, EnumDecl *PrevDecl, bool IsScoped, bool IsScopedUsingClassTag, bool IsFixed)
bool isFixed() const
Returns true if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying...
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
EnumDecl * getDecl() const
static ExprWithCleanups * Create(const ASTContext &C, EmptyShell empty, unsigned numObjects)
This represents one expression.
bool isReadIfDiscardedInCPlusPlus11() const
Determine whether an lvalue-to-rvalue conversion should implicitly be applied to this expression if i...
bool isValueDependent() const
Determines whether the value of this expression depends on.
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
bool refersToVectorElement() const
Returns whether this expression refers to a vector element.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language.
static bool hasAnyTypeDependentArguments(ArrayRef< Expr * > Exprs)
hasAnyTypeDependentArguments - Determines if any of the expressions in Exprs is type-dependent.
@ NPC_ValueDependentIsNull
Specifies that a value-dependent expression of integral or dependent type should be considered a null...
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
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 isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on.
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
bool refersToBitField() const
Returns true if this expression is a gl-value that potentially refers to a bit-field.
Classification Classify(ASTContext &Ctx) const
Classify - Classify this expression according to the C++11 expression taxonomy.
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.
An expression trait intrinsic.
Represents difference between two FPOptions values.
Represents a member of a struct/union/class.
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.
FullExpr - Represents a "full-expression" node.
Represents a function declaration or definition.
const ParmVarDecl * getParamDecl(unsigned i) const
bool isFunctionTemplateSpecialization() const
Determine whether this function is a function template specialization.
bool isThisDeclarationADefinition() const
Returns whether this specific declaration of the function is also a definition that does not contain ...
StringLiteral * getDeletedMessage() const
Get the message that indicates why this function was deleted.
QualType getReturnType() const
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
bool isVariadic() const
Whether this function is variadic.
bool isDeleted() const
Whether this function has been deleted.
bool isReplaceableGlobalAllocationFunction(std::optional< unsigned > *AlignmentParam=nullptr, bool *IsNothrow=nullptr) const
Determines whether this function is one of the replaceable global allocation functions: void *operato...
static FunctionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation NLoc, DeclarationName N, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin=false, bool isInlineSpecified=false, bool hasWrittenPrototype=true, ConstexprSpecKind ConstexprKind=ConstexprSpecKind::Unspecified, Expr *TrailingRequiresClause=nullptr)
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any.
bool isUserProvided() const
True if this method is user-declared and was not deleted or defaulted on its first declaration.
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
size_t param_size() const
bool isDefined(const FunctionDecl *&Definition, bool CheckForPendingFriendDefinition=false) const
Returns true if the function has a definition that does not need to be instantiated.
Represents a prototype with parameter type info, e.g.
unsigned getNumParams() const
QualType getParamType(unsigned i) const
bool isVariadic() const
Whether this function prototype is variadic.
bool isNothrow(bool ResultIfDependent=false) const
Determine whether this function type has a non-throwing exception specification.
Declaration of a template function.
ExtInfo withNoReturn(bool noReturn) const
bool getProducesResult() const
FunctionType - C99 6.7.5.3 - Function Declarators.
ExtInfo getExtInfo() const
One of these records is kept for each identifier that is lexed.
ReservedIdentifierStatus isReserved(const LangOptions &LangOpts) const
Determine whether this is a name reserved for the implementation (C99 7.1.3, C++ [lib....
StringRef getName() const
Return the actual identifier string.
bool tryAddTopLevelDecl(NamedDecl *D, DeclarationName Name)
Try to add the given declaration to the top level scope, if it (or a redeclaration of it) hasn't alre...
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
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...
@ StaticObjectArgumentConversion
StandardConversionSequence Standard
When ConversionKind == StandardConversion, provides the details of the standard conversion sequence.
UserDefinedConversionSequence UserDefined
When ConversionKind == UserDefinedConversion, provides the details of the user-defined conversion seq...
void DiagnoseAmbiguousConversion(Sema &S, SourceLocation CaretLoc, const PartialDiagnostic &PDiag) const
Diagnoses an ambiguous conversion.
Describes an C or C++ initializer list.
Describes the kind of initialization being performed, along with location information for tokens rela...
static InitializationKind CreateDefault(SourceLocation InitLoc)
Create a default initialization.
static InitializationKind CreateDirect(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc)
Create a direct initialization.
static InitializationKind CreateCopy(SourceLocation InitLoc, SourceLocation EqualLoc, bool AllowExplicitConvs=false)
Create a copy initialization.
static InitializationKind CreateDirectList(SourceLocation InitLoc)
static InitializationKind CreateValue(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc, bool isImplicit=false)
Create a value initialization.
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.
bool isAmbiguous() const
Determine whether this initialization failed due to an ambiguity.
bool Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef< Expr * > Args)
Diagnose an potentially-invalid initialization sequence.
bool Failed() const
Determine whether the initialization sequence is invalid.
bool isDirectReferenceBinding() const
Determine whether this initialization is a direct reference binding (C++ [dcl.init....
Describes an entity that is being initialized.
static InitializedEntity InitializeException(SourceLocation ThrowLoc, QualType Type)
Create the initialization entity for an exception object.
static InitializedEntity InitializeTemporary(QualType Type)
Create the initialization entity for a temporary.
static InitializedEntity InitializeNew(SourceLocation NewLoc, QualType Type)
Create the initialization entity for an object allocated via new.
static InitializedEntity InitializeParameter(ASTContext &Context, ParmVarDecl *Parm)
Create the initialization entity for a parameter.
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'.
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
clang::ObjCRuntime ObjCRuntime
bool hasGlobalAllocationFunctionVisibility() const
bool allowsNonTrivialObjCLifetimeQualifiers() const
True if any ObjC types may have non-trivial lifetime qualifiers.
bool hasHiddenGlobalAllocationFunctionVisibility() const
bool hasProtectedGlobalAllocationFunctionVisibility() const
static SourceLocation findLocationAfterToken(SourceLocation loc, tok::TokenKind TKind, const SourceManager &SM, const LangOptions &LangOpts, bool SkipTrailingWhitespaceAndNewLine)
Checks that the given token is the first token that occurs after the given location (this excludes co...
A class for iterating through a result set and possibly filtering out results.
void erase()
Erase the last element returned from this iterator.
Represents the results of name lookup.
@ FoundOverloaded
Name lookup found a set of overloaded functions that met the criteria.
@ FoundUnresolvedValue
Name lookup found an unresolvable value declaration and cannot yet complete.
@ Ambiguous
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
@ NotFound
No entity found met the criteria.
@ NotFoundInCurrentInstantiation
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
@ Found
Name lookup found a single declaration that met the criteria.
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.
SourceLocation getNameLoc() const
Gets the location of the identifier.
Filter makeFilter()
Create a filter for this result set.
CXXRecordDecl * getNamingClass() const
Returns the 'naming class' for this lookup, i.e.
bool isClassLookup() const
Returns whether these results arose from performing a lookup into a class.
void setNamingClass(CXXRecordDecl *Record)
Sets the 'naming class' for this lookup.
LookupResultKind getResultKind() const
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
DeclarationName getLookupName() const
Gets the name to look up.
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
DeclAccessPair getFoundDecl() const
Retrieves the declaration found by lookup.
A pointer to member type per C++ 8.3.3 - Pointers to members.
QualType getPointeeType() const
const Type * getClass() const
Data structure that captures multiple levels of template argument lists for use in template instantia...
void addOuterRetainedLevels(unsigned Num)
This represents a decl that may have a name.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
std::string getNameAsString() const
Get a human-readable name for the declaration, even if it is one of the special kinds of names (C++ c...
A C++ nested-name-specifier augmented with source location information.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
IdentifierInfo * getAsIdentifier() const
Retrieve the identifier stored in this nested name specifier.
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
@ NamespaceAlias
A namespace alias, stored as a NamespaceAliasDecl*.
@ TypeSpec
A type, stored as a Type*.
@ TypeSpecWithTemplate
A type that was preceded by the 'template' keyword, stored as a Type*.
@ Super
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in.
@ Identifier
An identifier, stored as an IdentifierInfo*.
@ Global
The global specifier '::'. There is no stored value.
@ Namespace
A namespace, stored as a NamespaceDecl*.
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp,...
ObjCBoxedExpr - used for generalized expression boxing.
ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserN...
Represents an ObjC class declaration.
bool isSuperClassOf(const ObjCInterfaceDecl *I) const
isSuperClassOf - Return true if this class is the specified class or is a super class of the specifie...
An expression that sends a message to the given Objective-C object or class.
ObjCMethodDecl - Represents an instance or class method declaration.
Represents a pointer to an Objective C object.
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
Represents a class type in Objective C.
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface.
bool hasEmptyCollections() const
Are the empty collection symbols available?
static OpaquePtr getFromOpaquePtr(void *P)
static OpaquePtr make(QualType P)
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13....
@ CSK_Normal
Normal lookup.
@ CSK_Operator
C++ [over.match.oper]: Lookup of operator function candidates in a call using operator syntax.
SmallVectorImpl< OverloadCandidate >::iterator iterator
void NoteCandidates(PartialDiagnosticAt PA, Sema &S, OverloadCandidateDisplayKind OCD, ArrayRef< Expr * > Args, StringRef Opc="", SourceLocation Loc=SourceLocation(), llvm::function_ref< bool(OverloadCandidate &)> Filter=[](OverloadCandidate &) { return true;})
When overload resolution fails, prints diagnostic messages containing the candidates in the candidate...
OverloadingResult BestViableFunction(Sema &S, SourceLocation Loc, OverloadCandidateSet::iterator &Best)
Find the best viable function on this overload set, if it exists.
SmallVector< OverloadCandidate *, 32 > CompleteCandidates(Sema &S, OverloadCandidateDisplayKind OCD, ArrayRef< Expr * > Args, SourceLocation OpLoc=SourceLocation(), llvm::function_ref< bool(OverloadCandidate &)> Filter=[](OverloadCandidate &) { return true;})
void setEllipsisLoc(SourceLocation Loc)
ParenExpr - This represents a parenthesized expression, e.g.
Represents a parameter to a function.
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
SourceManager & getSourceManager() const
IdentifierTable & getIdentifierTable()
const LangOptions & getLangOpts() const
Stores the type being destroyed by a pseudo-destructor expression.
TypeSourceInfo * getTypeSourceInfo() const
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type.
QualType withConst() const
void addConst()
Add the const type qualifier to this QualType.
bool isAtLeastAsQualifiedAs(QualType Other) const
Determine whether this type is at least as qualified as the other given type, requiring exact equalit...
bool isNull() const
Return true if this QualType doesn't point to a type yet.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
LangAS getAddressSpace() const
Return the address space of this type.
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
void getAsStringInternal(std::string &Str, const PrintingPolicy &Policy) const
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.
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after.
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
bool hasNonTrivialObjCLifetime() const
The collection of all-type qualifiers we support.
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_ExplicitNone
This object can be modified without requiring retains or releases.
@ OCL_None
There is no lifetime qualification on this type.
@ OCL_Weak
Reading or writing from this object requires a barrier call.
@ OCL_Autoreleasing
Assigning into this object requires a lifetime extension.
bool hasCVRQualifiers() const
bool hasUnaligned() const
unsigned getAddressSpaceAttributePrintValue() const
Get the address space attribute value to be printed by diagnostics.
void setAddressSpace(LangAS space)
static bool isAddressSpaceSupersetOf(LangAS A, LangAS B)
Returns true if address space A is equal to or a superset of B.
unsigned getCVRUQualifiers() const
void setObjCGCAttr(GC type)
ObjCLifetime getObjCLifetime() const
static Qualifiers fromCVRUMask(unsigned CVRU)
LangAS getAddressSpace() const
void setObjCLifetime(ObjCLifetime type)
Represents a struct/union/class.
bool canPassInRegisters() const
Determine whether this class can be passed in registers.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
RecordDecl * getDecl() const
A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...
Represents the body of a requires-expression.
static RequiresExprBodyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc)
static RequiresExpr * Create(ASTContext &C, SourceLocation RequiresKWLoc, RequiresExprBodyDecl *Body, SourceLocation LParenLoc, ArrayRef< ParmVarDecl * > LocalParameters, SourceLocation RParenLoc, ArrayRef< concepts::Requirement * > Requirements, SourceLocation RBraceLoc)
Scope - A scope is a transient data structure that is used while parsing the program.
@ BlockScope
This is a scope that corresponds to a block/closure object.
@ ClassScope
The scope of a struct/union/class definition.
@ TryScope
This is the scope of a C++ try statement.
@ FnScope
This indicates that the scope corresponds to a function, which means that labels are set here.
@ ObjCMethodScope
This scope corresponds to an Objective-C method body.
A generic diagnostic builder for errors which may or may not be deferred.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
SemaDiagnosticBuilder DiagIfDeviceCode(SourceLocation Loc, unsigned DiagID)
Creates a SemaDiagnosticBuilder that emits the diagnostic if the current context is "used as device c...
void EraseUnwantedMatches(const FunctionDecl *Caller, llvm::SmallVectorImpl< std::pair< DeclAccessPair, FunctionDecl * > > &Matches)
Finds a function in Matches with highest calling priority from Caller context and erases all function...
CUDAFunctionPreference IdentifyPreference(const FunctionDecl *Caller, const FunctionDecl *Callee)
Identifies relative preference of a given Caller/Callee combination, based on their host/device attri...
ARCConversionResult CheckObjCConversion(SourceRange castRange, QualType castType, Expr *&op, CheckedConversionKind CCK, bool Diagnose=true, bool DiagnoseCFAudited=false, BinaryOperatorKind Opc=BO_PtrMemD)
Checks for invalid conversions and casts between retainable pointers and other pointer kinds for ARC ...
QualType FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
FindCompositeObjCPointerType - Helper method to find composite type of two objective-c pointer types ...
ExprResult LookupInObjCMethod(LookupResult &LookUp, Scope *S, IdentifierInfo *II, bool AllowBuiltinCreation=false)
The parser has read a name in, and Sema has detected that we're currently inside an ObjC method.
void EmitRelatedResultTypeNote(const Expr *E)
If the given expression involves a message send to a method with a related result type,...
CastKind PrepareCastToObjCObjectPointer(ExprResult &E)
Prepare a conversion of the given expression to an ObjC object pointer type.
bool CheckPPCMMAType(QualType Type, SourceLocation TypeLoc)
CXXThisScopeRAII(Sema &S, Decl *ContextDecl, Qualifiers CXXThisTypeQuals, bool Enabled=true)
Introduce a new scope where 'this' may be allowed (when enabled), using the given declaration (which ...
Abstract base class used to perform a contextual implicit conversion from an expression to any type p...
RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...
bool hasErrorOccurred() const
Determine whether any SFINAE errors have been trapped.
Sema - This implements semantic analysis and AST building for C.
FunctionDecl * FindUsualDeallocationFunction(SourceLocation StartLoc, bool CanProvideSize, bool Overaligned, DeclarationName Name)
void DeclareGlobalNewDelete()
DeclareGlobalNewDelete - Declare the global forms of operator new and delete.
QualType CheckSizelessVectorConditionalTypes(ExprResult &Cond, ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo)
Package the given type and TSI into a ParsedType.
ExprResult ActOnCXXTypeid(SourceLocation OpLoc, SourceLocation LParenLoc, bool isType, void *TyOrExpr, SourceLocation RParenLoc)
ActOnCXXTypeid - Parse typeid( something ).
QualType getCurrentThisType()
Try to retrieve the type of the 'this' pointer.
ExprResult ActOnCXXUuidof(SourceLocation OpLoc, SourceLocation LParenLoc, bool isType, void *TyOrExpr, SourceLocation RParenLoc)
ActOnCXXUuidof - Parse __uuidof( something ).
Scope * getCurScope() const
Retrieve the parser's current scope.
QualType CheckVectorConditionalTypes(ExprResult &Cond, ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
bool checkArrayElementAlignment(QualType EltTy, SourceLocation Loc)
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....
@ LookupDestructorName
Look up a name following ~ in a destructor name.
@ LookupTagName
Tag name lookup, which finds the names of enums, classes, structs, and unions.
@ LookupAnyName
Look up any declaration with any name.
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 ActOnNoexceptExpr(SourceLocation KeyLoc, SourceLocation LParen, Expr *Operand, SourceLocation RParen)
bool BuildTypeConstraint(const CXXScopeSpec &SS, TemplateIdAnnotation *TypeConstraint, TemplateTypeParmDecl *ConstrainedParameter, SourceLocation EllipsisLoc, bool AllowUnexpandedPack)
bool CheckCXXThisType(SourceLocation Loc, QualType Type)
Check whether the type of 'this' is valid in the current context.
TypeResult ActOnTemplateIdType(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, TemplateTy Template, const IdentifierInfo *TemplateII, SourceLocation TemplateIILoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgs, SourceLocation RAngleLoc, bool IsCtorOrDtorName=false, bool IsClassName=false, ImplicitTypenameContext AllowImplicitTypename=ImplicitTypenameContext::No)
IfExistsResult
Describes the result of an "if-exists" condition check.
@ IER_DoesNotExist
The symbol does not exist.
@ IER_Dependent
The name is a dependent name, so the results will differ from one instantiation to the next.
@ IER_Error
An error occurred.
@ IER_Exists
The symbol exists.
QualType UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, ArithConvKind ACK)
UsualArithmeticConversions - Performs various conversions that are common to binary operators (C99 6....
ExprResult ActOnExpressionTrait(ExpressionTrait OET, SourceLocation KWLoc, Expr *Queried, SourceLocation RParen)
ActOnExpressionTrait - Parsed one of the unary type trait support pseudo-functions.
bool CompleteConstructorCall(CXXConstructorDecl *Constructor, QualType DeclInitType, MultiExprArg ArgsPtr, SourceLocation Loc, SmallVectorImpl< Expr * > &ConvertedArgs, bool AllowExplicit=false, bool IsListInitialization=false)
Given a constructor and the set of arguments provided for the constructor, convert the arguments and ...
ExprResult CheckBooleanCondition(SourceLocation Loc, Expr *E, bool IsConstexpr=false)
CheckBooleanCondition - Diagnose problems involving the use of the given expression as a boolean cond...
@ Boolean
A boolean condition, from 'if', 'while', 'for', or 'do'.
@ Switch
An integral condition for a 'switch' statement.
@ ConstexprIf
A constant boolean condition from 'if constexpr'.
bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC)
Require that the context specified by SS be complete.
SmallVector< sema::FunctionScopeInfo *, 4 > FunctionScopes
Stack containing information about each of the nested function, block, and method scopes that are cur...
@ Ref_Compatible
Ref_Compatible - The two types are reference-compatible.
ExprResult BuildCXXFunctionalCastExpr(TypeSourceInfo *TInfo, QualType Type, SourceLocation LParenLoc, Expr *CastExpr, SourceLocation RParenLoc)
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...
ExprResult MaybeBindToTemporary(Expr *E)
MaybeBindToTemporary - If the passed in expression has a record type with a non-trivial destructor,...
void MarkCaptureUsedInEnclosingContext(ValueDecl *Capture, SourceLocation Loc, unsigned CapturingScopeIndex)
ExprResult ActOnStartCXXMemberReference(Scope *S, Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, ParsedType &ObjectType, bool &MayBePseudoDestructor)
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, AllowFoldKind CanFold=NoFold)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
QualType CheckVectorOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign, bool AllowBothBool, bool AllowBoolConversion, bool AllowBoolOperation, bool ReportInvalid)
type checking for vector binary operators.
concepts::Requirement * ActOnSimpleRequirement(Expr *E)
FPOptionsOverride CurFPFeatureOverrides()
concepts::Requirement * ActOnCompoundRequirement(Expr *E, SourceLocation NoexceptLoc)
ExprResult BuildOverloadedArrowExpr(Scope *S, Expr *Base, SourceLocation OpLoc, bool *NoArrowOperatorFound=nullptr)
BuildOverloadedArrowExpr - Build a call to an overloaded operator-> (if one exists),...
FunctionDecl * getCurFunctionDecl(bool AllowLambda=false) const
Returns a pointer to the innermost enclosing function, or nullptr if the current context is not insid...
ExprResult PerformContextualImplicitConversion(SourceLocation Loc, Expr *FromE, ContextualImplicitConverter &Converter)
Perform a contextual implicit conversion.
ExprResult CheckUnevaluatedOperand(Expr *E)
ExprResult ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal, bool ArrayForm, Expr *Operand)
ActOnCXXDelete - Parsed a C++ 'delete' expression (C++ 5.3.5), as in:
ExprResult CheckSwitchCondition(SourceLocation SwitchLoc, Expr *Cond)
void diagnoseNullableToNonnullConversion(QualType DstType, QualType SrcType, SourceLocation Loc)
Warn if we're implicitly casting from a _Nullable pointer type to a _Nonnull one.
ExprResult ActOnCXXNullPtrLiteral(SourceLocation Loc)
ActOnCXXNullPtrLiteral - Parse 'nullptr'.
ExprResult BuildCXXTypeId(QualType TypeInfoType, SourceLocation TypeidLoc, TypeSourceInfo *Operand, SourceLocation RParenLoc)
Build a C++ typeid expression with a type operand.
ExprResult SubstExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs)
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...
concepts::TypeRequirement * BuildTypeRequirement(TypeSourceInfo *Type)
AccessResult CheckDestructorAccess(SourceLocation Loc, CXXDestructorDecl *Dtor, const PartialDiagnostic &PDiag, QualType objectType=QualType())
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.
ParsedType getDestructorName(const IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec &SS, ParsedType ObjectType, bool EnteringContext)
void CleanupVarDeclMarking()
ExprResult DefaultFunctionArrayLvalueConversion(Expr *E, bool Diagnose=true)
ASTContext & getASTContext() const
void DeclareGlobalAllocationFunction(DeclarationName Name, QualType Return, ArrayRef< QualType > Params)
DeclareGlobalAllocationFunction - Declares a single implicit global allocation function if it doesn't...
bool DiagnoseUnexpandedParameterPackInRequiresExpr(RequiresExpr *RE)
If the given requirees-expression contains an unexpanded reference to one of its own parameter packs,...
CXXDestructorDecl * LookupDestructor(CXXRecordDecl *Class)
Look for the destructor of the given class.
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 LookupBinOp(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opc, UnresolvedSetImpl &Functions)
AssignConvertType CheckTransparentUnionArgumentConstraints(QualType ArgType, ExprResult &RHS)
NamespaceDecl * getOrCreateStdNamespace()
Retrieve the special "std" namespace, which may require us to implicitly define the namespace.
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.
bool CheckTypeTraitArity(unsigned Arity, SourceLocation Loc, size_t N)
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 ActOnPseudoDestructorExpr(Scope *S, Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, CXXScopeSpec &SS, UnqualifiedId &FirstTypeName, SourceLocation CCLoc, SourceLocation TildeLoc, UnqualifiedId &SecondTypeName)
bool CheckArgsForPlaceholders(MultiExprArg args)
Check an argument list for placeholders that we won't try to handle later.
AccessResult CheckAllocationAccess(SourceLocation OperatorLoc, SourceRange PlacementRange, CXXRecordDecl *NamingClass, DeclAccessPair FoundDecl, bool Diagnose=true)
Checks access to an overloaded operator new or delete.
AccessResult CheckMemberOperatorAccess(SourceLocation Loc, Expr *ObjectExpr, const SourceRange &, DeclAccessPair FoundDecl)
ExprResult ActOnArrayTypeTrait(ArrayTypeTrait ATT, SourceLocation KWLoc, ParsedType LhsTy, Expr *DimExpr, SourceLocation RParen)
ActOnArrayTypeTrait - Parsed one of the binary type trait support pseudo-functions.
void ActOnFinishRequiresExpr()
ExprResult BuildCXXNew(SourceRange Range, bool UseGlobal, SourceLocation PlacementLParen, MultiExprArg PlacementArgs, SourceLocation PlacementRParen, SourceRange TypeIdParens, QualType AllocType, TypeSourceInfo *AllocTypeInfo, std::optional< Expr * > ArraySize, SourceRange DirectInitRange, Expr *Initializer)
void DiagnoseUseOfDeletedFunction(SourceLocation Loc, SourceRange Range, DeclarationName Name, OverloadCandidateSet &CandidateSet, FunctionDecl *Fn, MultiExprArg Args, bool IsMember=false)
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
ExprResult ActOnCXXThrow(Scope *S, SourceLocation OpLoc, Expr *expr)
DeclRefExpr * BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, SourceLocation Loc, const CXXScopeSpec *SS=nullptr)
ExprResult CheckConvertedConstantExpression(Expr *From, QualType T, llvm::APSInt &Value, CCEKind CCE)
EnumDecl * getStdAlignValT() const
LazyDeclPtr StdBadAlloc
The C++ "std::bad_alloc" class, which is defined by the C++ standard library.
NamedReturnInfo getNamedReturnInfo(Expr *&E, SimplerImplicitMoveMode Mode=SimplerImplicitMoveMode::Normal)
Determine whether the given expression might be move-eligible or copy-elidable in either a (co_)retur...
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...
bool CheckMemberPointerConversion(Expr *From, QualType ToType, CastKind &Kind, CXXCastPath &BasePath, bool IgnoreBaseAccess)
CheckMemberPointerConversion - Check the member pointer conversion from the expression From to the ty...
bool checkLiteralOperatorId(const CXXScopeSpec &SS, const UnqualifiedId &Id, bool IsUDSuffix)
void DiagnoseUnusedExprResult(const Stmt *S, unsigned DiagID)
DiagnoseUnusedExprResult - If the statement passed in is an expression whose result is unused,...
FPOptions & getCurFPFeatures()
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
@ UPPC_IfExists
Microsoft __if_exists.
@ UPPC_IfNotExists
Microsoft __if_not_exists.
const LangOptions & getLangOpts() const
StmtResult ActOnFinishFullStmt(Stmt *Stmt)
CastKind PrepareScalarCast(ExprResult &src, QualType destType)
Prepares for a scalar cast, performing all the necessary stages except the final cast and returning t...
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...
bool isPotentialImplicitMemberAccess(const CXXScopeSpec &SS, LookupResult &R, bool IsAddressOfOperand)
Check whether an expression might be an implicit class member access.
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
ExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind)
ActOnCXXBoolLiteral - Parse {true,false} literals.
ExprResult BuildCXXTypeConstructExpr(TypeSourceInfo *Type, SourceLocation LParenLoc, MultiExprArg Exprs, SourceLocation RParenLoc, bool ListInitialization)
bool CheckConstraintSatisfaction(const NamedDecl *Template, ArrayRef< const Expr * > ConstraintExprs, const MultiLevelTemplateArgumentList &TemplateArgLists, SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction)
Check whether the given list of constraint expressions are satisfied (as if in a 'conjunction') given...
const LangOptions & LangOpts
bool FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range, AllocationFunctionScope NewScope, AllocationFunctionScope DeleteScope, QualType AllocType, bool IsArray, bool &PassAlignment, MultiExprArg PlaceArgs, FunctionDecl *&OperatorNew, FunctionDecl *&OperatorDelete, bool Diagnose=true)
Finds the overloads of operator new and delete that are appropriate for the allocation.
sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)
Retrieve the current lambda scope info, if any.
ExprResult BuildCXXMemberCallExpr(Expr *Exp, NamedDecl *FoundDecl, CXXConversionDecl *Method, bool HadMultipleCandidates)
ExprResult CheckConditionVariable(VarDecl *ConditionVar, SourceLocation StmtLoc, ConditionKind CK)
Check the use of the given variable as a C++ condition in an if, while, do-while, or switch statement...
ExprResult TemporaryMaterializationConversion(Expr *E)
If E is a prvalue denoting an unmaterialized temporary, materialize it as an xvalue.
CXXRecordDecl * getStdBadAlloc() const
ExprResult ActOnCXXTypeConstructExpr(ParsedType TypeRep, SourceLocation LParenOrBraceLoc, MultiExprArg Exprs, SourceLocation RParenOrBraceLoc, bool ListInitialization)
ActOnCXXTypeConstructExpr - Parse construction of a specified type.
void CheckUnusedVolatileAssignment(Expr *E)
Check whether E, which is either a discarded-value expression or an unevaluated operand,...
QualType CheckTypenameType(ElaboratedTypeKeyword Keyword, SourceLocation KeywordLoc, NestedNameSpecifierLoc QualifierLoc, const IdentifierInfo &II, SourceLocation IILoc, TypeSourceInfo **TSI, bool DeducedTSTContext)
bool CanUseDecl(NamedDecl *D, bool TreatUnavailableAsInvalid)
Determine whether the use of this declaration is valid, without emitting diagnostics.
ConditionResult ActOnConditionVariable(Decl *ConditionVar, SourceLocation StmtLoc, ConditionKind CK)
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.
bool CheckAllocatedType(QualType AllocType, SourceLocation Loc, SourceRange R)
Checks that a type is suitable as the allocated type in a new-expression.
CleanupInfo Cleanup
Used to control the generation of ExprWithCleanups.
ExprResult BuildTypeTrait(TypeTrait Kind, SourceLocation KWLoc, ArrayRef< TypeSourceInfo * > Args, SourceLocation RParenLoc)
ExprResult ActOnRequiresExpr(SourceLocation RequiresKWLoc, RequiresExprBodyDecl *Body, SourceLocation LParenLoc, ArrayRef< ParmVarDecl * > LocalParameters, SourceLocation RParenLoc, ArrayRef< concepts::Requirement * > Requirements, SourceLocation ClosingBraceLoc)
QualType FindCompositePointerType(SourceLocation Loc, Expr *&E1, Expr *&E2, bool ConvertArgs=true)
Find a merged pointer type and convert the two expressions to it.
ExprResult BuildExpressionTrait(ExpressionTrait OET, SourceLocation KWLoc, Expr *Queried, SourceLocation RParen)
static CastKind ScalarTypeToBooleanCastKind(QualType ScalarTy)
ScalarTypeToBooleanCastKind - Returns the cast kind corresponding to the conversion from scalar type ...
CXXRecordDecl * getCurrentClass(Scope *S, const CXXScopeSpec *SS)
Get the class that is directly named by the current context.
ExprResult BuildCXXUuidof(QualType TypeInfoType, SourceLocation TypeidLoc, TypeSourceInfo *Operand, SourceLocation RParenLoc)
Build a Microsoft __uuidof expression with a type operand.
Expr * BuildCXXThisExpr(SourceLocation Loc, QualType Type, bool IsImplicit)
Build a CXXThisExpr and mark it referenced in the current context.
QualType CheckSizelessVectorOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign, ArithConvKind OperationKind)
llvm::DenseMap< const VarDecl *, int > RefsMinusAssignments
Increment when we find a reference; decrement when we find an ignored assignment.
std::optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
QualType DeduceTemplateSpecializationFromInitializer(TypeSourceInfo *TInfo, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Init)
void MarkThisReferenced(CXXThisExpr *This)
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
Module * getCurrentModule() const
Get the module unit whose scope we are currently within.
static bool isCast(CheckedConversionKind CCK)
ExprResult prepareVectorSplat(QualType VectorTy, Expr *SplattedExpr)
Prepare SplattedExpr for a vector splat operation, adding implicit casts if necessary.
IfExistsResult CheckMicrosoftIfExistsSymbol(Scope *S, CXXScopeSpec &SS, const DeclarationNameInfo &TargetNameInfo)
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
bool FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD, DeclarationName Name, FunctionDecl *&Operator, bool Diagnose=true, bool WantSize=false, bool WantAligned=false)
DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name)
Retrieves the declaration name from a parsed unqualified-id.
ExprResult PerformContextuallyConvertToBool(Expr *From)
PerformContextuallyConvertToBool - Perform a contextual conversion of the expression From to bool (C+...
AccessResult CheckConstructorAccess(SourceLocation Loc, CXXConstructorDecl *D, DeclAccessPair FoundDecl, const InitializedEntity &Entity, bool IsCopyBindingRefToTemp=false)
Checks access to a constructor.
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...
ParsedType getDestructorTypeForDecltype(const DeclSpec &DS, ParsedType ObjectType)
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.
Stmt * MaybeCreateStmtWithCleanups(Stmt *SubStmt)
AssignConvertType
AssignConvertType - All of the 'assignment' semantic checks return this enum to indicate whether the ...
@ Compatible
Compatible - the types are compatible according to the standard.
@ Incompatible
Incompatible - We reject this conversion outright, it is invalid to represent it in the AST.
ExprResult ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal, SourceLocation PlacementLParen, MultiExprArg PlacementArgs, SourceLocation PlacementRParen, SourceRange TypeIdParens, Declarator &D, Expr *Initializer)
Parsed a C++ 'new' expression (C++ 5.3.4).
@ ACK_Conditional
A conditional (?:) operator.
ExprResult BuildCXXNoexceptExpr(SourceLocation KeyLoc, Expr *Operand, SourceLocation RParen)
bool GlobalNewDeleteDeclared
A flag to remember whether the implicit forms of operator new and delete have been declared.
ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E)
ExprResult CheckPlaceholderExpr(Expr *E)
Check for operands with placeholder types and complain if found.
ExprResult TransformToPotentiallyEvaluated(Expr *E)
ExprResult BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType, NamedDecl *FoundDecl, CXXConstructorDecl *Constructor, MultiExprArg Exprs, bool HadMultipleCandidates, bool IsListInitialization, bool IsStdInitListInitialization, bool RequiresZeroInit, CXXConstructionKind ConstructKind, SourceRange ParenRange)
BuildCXXConstructExpr - Creates a complete call to a constructor, including handling of its default a...
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
SourceManager & getSourceManager() const
QualType CXXThisTypeOverride
When non-NULL, the C++ 'this' expression is allowed despite the current context not being a non-stati...
ExprResult FixOverloadedFunctionReference(Expr *E, DeclAccessPair FoundDecl, FunctionDecl *Fn)
FixOverloadedFunctionReference - E is an expression that refers to a C++ overloaded function (possibl...
ExprResult PerformMoveOrCopyInitialization(const InitializedEntity &Entity, const NamedReturnInfo &NRInfo, Expr *Value, bool SupressSimplerImplicitMoves=false)
Perform the initialization of a potentially-movable value, which is the result of return value.
ExprResult CheckCXXBooleanCondition(Expr *CondExpr, bool IsConstexpr=false)
CheckCXXBooleanCondition - Returns true if conversion to bool is invalid.
CanThrowResult canThrow(const Stmt *E)
bool isThisOutsideMemberFunctionBody(QualType BaseType)
Determine whether the given type is the type of *this that is used outside of the body of a member fu...
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.
QualType CheckPointerToMemberOperands(ExprResult &LHS, ExprResult &RHS, ExprValueKind &VK, SourceLocation OpLoc, bool isIndirect)
concepts::ExprRequirement * BuildExprRequirement(Expr *E, bool IsSatisfied, SourceLocation NoexceptLoc, concepts::ExprRequirement::ReturnTypeRequirement ReturnTypeRequirement)
void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=true, bool AllowExplicitConversion=false, ADLCallKind IsADLCandidate=ADLCallKind::NotADL, ConversionSequenceList EarlyConversions=std::nullopt, OverloadCandidateParamOrder PO={}, bool AggregateCandidateDeduction=false)
AddOverloadCandidate - Adds the given function to the set of candidate functions, using the given fun...
QualType CXXCheckConditionalOperands(ExprResult &cond, ExprResult &lhs, ExprResult &rhs, ExprValueKind &VK, ExprObjectKind &OK, SourceLocation questionLoc)
Check the operands of ?: under C++ semantics.
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 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.
concepts::Requirement * ActOnTypeRequirement(SourceLocation TypenameKWLoc, CXXScopeSpec &SS, SourceLocation NameLoc, const IdentifierInfo *TypeName, TemplateIdAnnotation *TemplateId)
void CheckShadow(NamedDecl *D, NamedDecl *ShadowedDecl, const LookupResult &R)
Diagnose variable or built-in function shadowing.
ParsedType getInheritingConstructorName(CXXScopeSpec &SS, SourceLocation NameLoc, const IdentifierInfo &Name)
Handle the result of the special case name lookup for inheriting constructor declarations.
TypeResult ActOnTypenameType(Scope *S, SourceLocation TypenameLoc, const CXXScopeSpec &SS, const IdentifierInfo &II, SourceLocation IdLoc, ImplicitTypenameContext IsImplicitTypename=ImplicitTypenameContext::No)
Called when the parser has parsed a C++ typename specifier, e.g., "typename T::type".
bool isCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind=CompleteTypeKind::Default)
ExprResult BuildPseudoDestructorExpr(Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, const CXXScopeSpec &SS, TypeSourceInfo *ScopeType, SourceLocation CCLoc, SourceLocation TildeLoc, PseudoDestructorTypeStorage DestroyedType)
RecordDecl * CXXTypeInfoDecl
The C++ "type_info" declaration, which is defined in <typeinfo>.
@ CCEK_ArrayBound
Array bound in array declarator or new-expression.
CXXConstructorDecl * LookupCopyingConstructor(CXXRecordDecl *Class, unsigned Quals)
Look up the copying constructor for the given class.
ParsedType getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec *SS=nullptr, bool isClassName=false, bool HasTrailingDot=false, ParsedType ObjectType=nullptr, bool IsCtorOrDtorName=false, bool WantNontrivialTypeSourceInfo=false, bool IsClassTemplateDeductionContext=true, ImplicitTypenameContext AllowImplicitTypename=ImplicitTypenameContext::No, IdentifierInfo **CorrectedII=nullptr)
If the identifier refers to a type name within this scope, return the declaration of that type.
RequiresExprBodyDecl * ActOnStartRequiresExpr(SourceLocation RequiresKWLoc, ArrayRef< ParmVarDecl * > LocalParameters, Scope *BodyScope)
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.
void AddKnownFunctionAttributesForReplaceableGlobalAllocationFunction(FunctionDecl *FD)
If this function is a C++ replaceable global allocation function (C++2a [basic.stc....
@ Unevaluated
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7),...
QualType BuildDecltypeType(Expr *E, bool AsUnevaluated=true)
If AsUnevaluated is false, E is treated as though it were an evaluated context, such as when building...
TypeSourceInfo * GetTypeForDeclarator(Declarator &D)
GetTypeForDeclarator - Convert the type for the specified declarator to Type instances.
bool CheckCallReturnType(QualType ReturnType, SourceLocation Loc, CallExpr *CE, FunctionDecl *FD)
CheckCallReturnType - Checks that a call expression's return type is complete.
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...
ReferenceCompareResult CompareReferenceRelationship(SourceLocation Loc, QualType T1, QualType T2, ReferenceConversions *Conv=nullptr)
CompareReferenceRelationship - Compare the two types T1 and T2 to determine whether they are referenc...
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.
llvm::MapVector< FieldDecl *, DeleteLocs > DeleteExprs
Delete-expressions to be analyzed at the end of translation unit.
Expr * MaybeCreateExprWithCleanups(Expr *SubExpr)
MaybeCreateExprWithCleanups - If the current full-expression requires any cleanups,...
void DiscardCleanupsInEvaluationContext()
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 isDependentScopeSpecifier(const CXXScopeSpec &SS)
bool isUnavailableAlignedAllocationFunction(const FunctionDecl &FD) const
Determine whether FD is an aligned allocation or deallocation function that is unavailable.
DiagnosticsEngine & Diags
NamespaceDecl * getStdNamespace() const
ExprResult BuildCXXThrow(SourceLocation OpLoc, Expr *Ex, bool IsThrownVarInScope)
ExprResult DefaultFunctionArrayConversion(Expr *E, bool Diagnose=true)
DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).
ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)
ExprResult ActOnTypeTrait(TypeTrait Kind, SourceLocation KWLoc, ArrayRef< ParsedType > Args, SourceLocation RParenLoc)
Parsed one of the type trait support pseudo-functions.
bool CheckQualifiedFunctionForTypeId(QualType T, SourceLocation Loc)
concepts::NestedRequirement * BuildNestedRequirement(Expr *E)
FunctionDecl * FindDeallocationFunctionForDestructor(SourceLocation StartLoc, CXXRecordDecl *RD)
TemplateDeductionResult DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, ArrayRef< TemplateArgument > TemplateArgs, sema::TemplateDeductionInfo &Info)
QualType ActOnPackIndexingType(QualType Pattern, Expr *IndexExpr, SourceLocation Loc, SourceLocation EllipsisLoc)
bool isUsualDeallocationFunction(const CXXMethodDecl *FD)
ExprResult BuildArrayTypeTrait(ArrayTypeTrait ATT, SourceLocation KWLoc, TypeSourceInfo *TSInfo, Expr *DimExpr, SourceLocation RParen)
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,...
bool GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl, const FunctionProtoType *Proto, unsigned FirstParam, ArrayRef< Expr * > Args, SmallVectorImpl< Expr * > &AllArgs, VariadicCallType CallType=VariadicDoesNotApply, bool AllowExplicit=false, bool IsListInitialization=false)
GatherArgumentsForCall - Collector argument expressions for various form of call prototypes.
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.
ParsedType getConstructorName(const IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec &SS, bool EnteringContext)
LazyDeclPtr StdAlignValT
The C++ "std::align_val_t" enum class, which is defined by the C++ standard library.
AssignConvertType CheckAssignmentConstraints(SourceLocation Loc, QualType LHSType, QualType RHSType)
CheckAssignmentConstraints - Perform type checking for assignment, argument passing,...
bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base)
Determine whether the type Derived is a C++ class that is derived from the type Base.
@ Diagnose
Diagnose issues that are non-constant or that are extensions.
bool CheckCXXThrowOperand(SourceLocation ThrowLoc, QualType ThrowTy, Expr *E)
CheckCXXThrowOperand - Validate the operand of a throw.
TemplateDeductionResult DeduceAutoType(TypeLoc AutoTypeLoc, Expr *Initializer, QualType &Result, sema::TemplateDeductionInfo &Info, bool DependentDeduction=false, bool IgnoreConstraints=false, TemplateSpecCandidateSet *FailedTSC=nullptr)
Deduce the type for an auto type-specifier (C++11 [dcl.spec.auto]p6)
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false, bool ForceNoCPlusPlus=false)
Perform unqualified name lookup starting from a given scope.
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
concepts::Requirement * ActOnNestedRequirement(Expr *Constraint)
QualType adjustCCAndNoReturn(QualType ArgFunctionType, QualType FunctionType, bool AdjustExceptionSpec=false)
Adjust the type ArgFunctionType to match the calling convention, noreturn, and optionally the excepti...
bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType)
Helper function to determine whether this is the (deprecated) C++ conversion from a string literal to...
bool CheckExceptionSpecCompatibility(Expr *From, QualType ToType)
static ConditionResult ConditionError()
IdentifierResolver IdResolver
const TypoExprState & getTypoExprState(TypoExpr *TE) const
FullExprArg MakeFullExpr(Expr *Arg)
ExprResult ActOnCXXThis(SourceLocation Loc)
ExprResult ActOnDecltypeExpression(Expr *E)
Process the expression contained within a decltype.
AllocationFunctionScope
The scope in which to find allocation functions.
@ AFS_Both
Look for allocation functions in both the global scope and in the scope of the allocated class.
@ AFS_Class
Only look for allocation functions in the scope of the allocated class.
@ AFS_Global
Only look for allocation functions in the global scope.
bool CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param, Expr *Init=nullptr, bool SkipImmediateInvocations=true)
Instantiate or parse a C++ default argument expression as necessary.
ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, bool RecoverUncorrectedTypos=false, llvm::function_ref< ExprResult(Expr *)> Filter=[](Expr *E) -> ExprResult { return E;})
Process any TypoExprs in the given Expr and its children, generating diagnostics as appropriate and r...
void CheckVirtualDtorCall(CXXDestructorDecl *dtor, SourceLocation Loc, bool IsDelete, bool CallCanBeVirtual, bool WarnOnNonAbstractTypes, SourceLocation DtorLoc)
ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)
void checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto, const Expr *ThisArg, ArrayRef< const Expr * > Args, bool IsMemberFunction, SourceLocation Loc, SourceRange Range, VariadicCallType CallType)
Handles the checks for format strings, non-POD arguments to vararg functions, NULL arguments passed t...
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is 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....
DeclAccessPair FoundCopyConstructor
ImplicitConversionKind Second
Second - The second conversion can be an integral promotion, floating point promotion,...
ImplicitConversionKind First
First – The first conversion can be an lvalue-to-rvalue conversion, array-to-pointer conversion,...
unsigned DeprecatedStringLiteralToCharPtr
Whether this is the deprecated conversion of a string literal to a pointer to non-const character dat...
CXXConstructorDecl * CopyConstructor
CopyConstructor - The copy constructor that is used to perform this conversion, when the conversion i...
unsigned IncompatibleObjC
IncompatibleObjC - Whether this is an Objective-C conversion that we should warn about (if we actuall...
ImplicitConversionKind Third
Third - The third conversion can be a qualification conversion or a function conversion.
ImplicitConversionKind Dimension
Dimension - Between the second and third conversion a vector or matrix dimension conversion may occur...
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
Stmt - This represents one statement.
SourceLocation getEndLoc() const LLVM_READONLY
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
StringLiteral - This represents a string literal expression, e.g.
StringRef getString() const
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
bool isItaniumFamily() const
Does this ABI generally fall into the Itanium family of ABIs?
unsigned getNewAlign() const
Return the largest alignment for which a suitably-sized allocation with '::operator new(size_t)' is g...
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
unsigned getIntWidth() const
getIntWidth/Align - Return the size of 'signed int' and 'unsigned int' for this target,...
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
A template argument list.
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
Represents a template argument.
@ Declaration
The template argument is a declaration that was provided for a pointer, reference,...
@ Type
The template argument is a type.
Stores a list of template parameters for a TemplateDecl and its derived classes.
NamedDecl * getParam(unsigned Idx)
unsigned getDepth() const
Get the depth of this template parameter list in the set of template parameter lists.
static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl * > Params, SourceLocation RAngleLoc, Expr *RequiresClause)
static TemplateTypeParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation KeyLoc, SourceLocation NameLoc, unsigned D, unsigned P, IdentifierInfo *Id, bool Typename, bool ParameterPack, bool HasTypeConstraint=false, std::optional< unsigned > NumExpanded=std::nullopt)
Models the abbreviated syntax to constrain a template type parameter: template <convertible_to<string...
Expr * getImmediatelyDeclaredConstraint() const
Get the immediately-declared constraint expression introduced by this type-constraint,...
Represents a declaration of a type.
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
TypeSourceInfo * getTypeSourceInfo(ASTContext &Context, QualType T)
Creates a TypeSourceInfo for the given type.
void pushTrivial(ASTContext &Context, QualType T, SourceLocation Loc)
Pushes 'T' with all locations pointing to 'Loc'.
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
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.
static TypeTraitExpr * Create(const ASTContext &C, QualType T, SourceLocation Loc, TypeTrait Kind, ArrayRef< TypeSourceInfo * > Args, SourceLocation RParenLoc, bool Value)
Create a new type trait expression.
The base class of the type hierarchy.
bool isSizelessType() const
As an extension, we classify types as one of "sized" or "sizeless"; every type is one or the other.
bool isStructureType() const
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isBlockPointerType() const
bool isBooleanType() const
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
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 isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char,...
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
bool isRValueReferenceType() const
bool isFundamentalType() const
Tests whether the type is categorized as a fundamental type.
bool isVoidPointerType() const
bool isArithmeticType() const
bool isPointerType() const
CanQualType getCanonicalTypeUnqualified() const
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
bool isEnumeralType() const
bool isScalarType() const
bool isInterfaceType() const
bool isVariableArrayType() 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.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isExtVectorType() const
QualType getSveEltType(const ASTContext &Ctx) const
Returns the representative type for the element of an SVE builtin type.
bool isMemberDataPointerType() const
bool isLValueReferenceType() const
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool isAggregateType() const
Determines whether the type is a C++ aggregate type or C aggregate or union type.
bool isAnyComplexType() const
bool isFixedPointType() const
Return true if this is a fixed point type according to ISO/IEC JTC1 SC22 WG14 N1169.
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type.
bool isWebAssemblyTableType() const
Returns true if this is a WebAssembly table type: either an array of reference types,...
bool isCompoundType() const
Tests whether the type is categorized as a compound type.
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
bool isMemberPointerType() const
bool isAtomicType() const
bool isMatrixType() const
bool isStandardLayoutType() const
Test if this type is a standard-layout type.
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
bool isObjectType() const
Determine whether this type is an object type.
bool isPointerOrReferenceType() const
Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const
Return the implicit lifetime for this type, which must not be dependent.
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 isStructureOrClassType() const
bool isMemberFunctionPointerType() const
bool isVectorType() const
bool isRealFloatingType() const
Floating point categories.
bool isFloatingType() const
bool isUnsignedIntegerType() const
Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...
bool isAnyPointerType() const
TypeClass getTypeClass() const
const T * getAs() const
Member-template getAs<specific type>'.
bool isObjCARCImplicitlyUnretainedType() const
Determines if this type, which must satisfy isObjCLifetimeType(), is implicitly __unsafe_unretained r...
bool isNullPtrType() const
bool isRecordType() const
bool isObjCRetainableType() const
TagDecl * getAsTagDecl() const
Retrieves the TagDecl that this type refers to, either because the type is a TagType or because it is...
bool isScopedEnumeralType() const
Determine whether this type is a scoped enumeration type.
Simple class containing the result of Sema::CorrectTypo.
SourceRange getCorrectionRange() const
void WillReplaceSpecifier(bool ForceReplacement)
unsigned getEditDistance(bool Normalized=true) const
Gets the "edit distance" of the typo correction from the typo.
NestedNameSpecifier * getCorrectionSpecifier() const
Gets the NestedNameSpecifier needed to use the typo correction.
void setCorrectionDecl(NamedDecl *CDecl)
Clears the list of NamedDecls before adding the new one.
NamedDecl * getFoundDecl() const
Get the correction declaration found by name lookup (before we looked through using shadow declaratio...
TypoExpr - Internal placeholder for expressions where typo correction still needs to be performed and...
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Represents a C++ unqualified-id that has been parsed.
SourceLocation StartLocation
The location of the first token that describes this unqualified-id, which will be the location of the...
const IdentifierInfo * Identifier
When Kind == IK_Identifier, the parsed identifier, or when Kind == IK_UserLiteralId,...
UnqualifiedIdKind getKind() const
Determine what kind of name we have.
TemplateIdAnnotation * TemplateId
When Kind == IK_TemplateId or IK_ConstructorTemplateId, the template-id annotation that contains the ...
The iterator over UnresolvedSets.
A set of unresolved declarations.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
bool isWeak() const
Determine whether this symbol is weakly-imported, or declared with the weak or weak-ref attr.
VarDecl * getPotentiallyDecomposedVarDecl()
Represents a variable declaration or definition.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
bool isUsableInConstantExpressions(const ASTContext &C) const
Determine whether this variable's value can be used in a constant expression, according to the releva...
const Expr * getAnyInitializer() const
Get the initializer for this variable, no matter which declaration it is attached to.
Represents a GCC generic vector type.
unsigned getNumElements() const
bool isTypeConstraint() const
TemplateParameterList * getTypeConstraintTemplateParameterList() const
bool isSubstitutionFailure() const
A requires-expression requirement which queries the validity and properties of an expression ('simple...
@ SS_ConstraintsNotSatisfied
@ SS_TypeRequirementSubstitutionFailure
A requires-expression requirement which is satisfied when a general constraint expression is satisfie...
A static requirement that can be used in a requires-expression to check properties of types and expre...
A requires-expression requirement which queries the existence of a type name or type template special...
ImplicitCaptureStyle ImpCaptureStyle
Capture & getCXXThisCapture()
Retrieve the capture of C++ 'this', if it has been captured.
bool isCXXThisCaptured() const
Determine whether the C++ 'this' is captured.
void addThisCapture(bool isNested, SourceLocation Loc, QualType CaptureType, bool ByCopy)
SourceLocation PotentialThisCaptureLocation
bool hasPotentialThisCapture() const
SourceRange IntroducerRange
Source range covering the lambda introducer [...].
bool lambdaCaptureShouldBeConst() const
void clearPotentialCaptures()
bool hasPotentialCaptures() const
bool isVariableExprMarkedAsNonODRUsed(Expr *CapturingVarExpr) const
CXXRecordDecl * Lambda
The class that describes the lambda.
void visitPotentialCaptures(llvm::function_ref< void(ValueDecl *, Expr *)> Callback) const
unsigned NumExplicitCaptures
The number of captures in the Captures list that are explicit captures.
CXXMethodDecl * CallOperator
The lambda's compiler-generated operator().
Provides information about an attempted template argument deduction, whose success or failure was des...
Defines the clang::TargetInfo interface.
SmallVector< BoundNodes, 1 > match(MatcherT Matcher, const NodeT &Node, ASTContext &Context)
Returns the results of matching Matcher on Node.
Requirement::SubstitutionDiagnostic * createSubstDiagAt(Sema &S, SourceLocation Location, EntityPrinter Printer)
create a Requirement::SubstitutionDiagnostic with only a SubstitutedEntity and DiagLoc using Sema's a...
bool NE(InterpState &S, CodePtr OpPC)
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
The JSON file list parser is used to communicate input to InstallAPI.
@ Bind
'bind' clause, allowed on routine constructs.
@ Self
'self' clause, allowed on Compute and Combined Constructs, plus 'update'.
bool isLambdaCallWithImplicitObjectParameter(const DeclContext *DC)
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
ArrayTypeTrait
Names for the array type traits.
unsigned getTypeTraitArity(TypeTrait T) LLVM_READONLY
Return the arity of the type trait T.
if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))
@ OR_Deleted
Succeeded, but refers to a deleted function.
@ OR_Success
Overload resolution succeeded.
@ OR_Ambiguous
Ambiguous candidates found.
@ OR_No_Viable_Function
No viable function found.
CanThrowResult
Possible results from evaluation of a noexcept expression.
DeclContext * getLambdaAwareParentOfDeclContext(DeclContext *DC)
std::optional< unsigned > getStackIndexOfNearestEnclosingCaptureCapableLambda(ArrayRef< const sema::FunctionScopeInfo * > FunctionScopes, ValueDecl *VarToCapture, Sema &S)
Examines the FunctionScopeInfo stack to determine the nearest enclosing lambda (to the current lambda...
bool isReservedInAllContexts(ReservedIdentifierStatus Status)
Determine whether an identifier is reserved in all contexts.
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
@ RQ_None
No ref-qualifier was provided.
@ RQ_LValue
An lvalue ref-qualifier was provided (&).
@ RQ_RValue
An rvalue ref-qualifier was provided (&&).
@ OCD_AmbiguousCandidates
Requests that only tied-for-best candidates be shown.
@ OCD_AllCandidates
Requests that all candidates be shown.
ExprObjectKind
A further classification of the kind of object referenced by an l-value or x-value.
@ 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.
@ LCK_StarThis
Capturing the *this object by copy.
@ IK_TemplateId
A template-id, e.g., f<int>.
@ IK_LiteralOperatorId
A user-defined literal name, e.g., operator "" _i.
@ IK_Identifier
An identifier.
bool isLambdaCallWithExplicitObjectParameter(const DeclContext *DC)
bool isLambdaCallOperator(const CXXMethodDecl *MD)
@ Result
The result type of a method or function.
@ ICK_Complex_Conversion
Complex conversions (C99 6.3.1.6)
@ ICK_Floating_Promotion
Floating point promotions (C++ [conv.fpprom])
@ ICK_Boolean_Conversion
Boolean conversions (C++ [conv.bool])
@ ICK_Integral_Conversion
Integral conversions (C++ [conv.integral])
@ ICK_Fixed_Point_Conversion
Fixed point type conversions according to N1169.
@ ICK_Vector_Conversion
Vector conversions.
@ ICK_Block_Pointer_Conversion
Block Pointer conversions.
@ ICK_Pointer_Member
Pointer-to-member conversions (C++ [conv.mem])
@ ICK_Floating_Integral
Floating-integral conversions (C++ [conv.fpint])
@ ICK_HLSL_Array_RValue
HLSL non-decaying array rvalue cast.
@ ICK_SVE_Vector_Conversion
Arm SVE Vector conversions.
@ ICK_HLSL_Vector_Truncation
HLSL vector truncation.
@ ICK_Incompatible_Pointer_Conversion
C-only conversion between pointers with incompatible types.
@ ICK_Array_To_Pointer
Array-to-pointer conversion (C++ [conv.array])
@ ICK_RVV_Vector_Conversion
RISC-V RVV Vector conversions.
@ ICK_Complex_Promotion
Complex promotions (Clang extension)
@ ICK_Num_Conversion_Kinds
The number of conversion kinds.
@ ICK_Function_Conversion
Function pointer conversion (C++17 [conv.fctptr])
@ ICK_Vector_Splat
A vector splat from an arithmetic type.
@ ICK_Zero_Queue_Conversion
Zero constant to queue.
@ ICK_Identity
Identity conversion (no conversion)
@ ICK_Derived_To_Base
Derived-to-base (C++ [over.best.ics])
@ ICK_Lvalue_To_Rvalue
Lvalue-to-rvalue conversion (C++ [conv.lval])
@ ICK_Qualification
Qualification conversions (C++ [conv.qual])
@ ICK_Pointer_Conversion
Pointer conversions (C++ [conv.ptr])
@ ICK_TransparentUnionConversion
Transparent Union Conversions.
@ ICK_Integral_Promotion
Integral promotions (C++ [conv.prom])
@ ICK_Floating_Conversion
Floating point conversions (C++ [conv.double].
@ ICK_Compatible_Conversion
Conversions between compatible types in C99.
@ ICK_C_Only_Conversion
Conversions allowed in C, but not C++.
@ ICK_Writeback_Conversion
Objective-C ARC writeback conversion.
@ ICK_Zero_Event_Conversion
Zero constant to event (OpenCL1.2 6.12.10)
@ ICK_Complex_Real
Complex-real conversions (C99 6.3.1.7)
@ ICK_Function_To_Pointer
Function-to-pointer (C++ [conv.array])
llvm::VersionTuple alignedAllocMinVersion(llvm::Triple::OSType OS)
ActionResult< Expr * > ExprResult
@ Class
The "class" keyword.
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 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_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.
OpaquePtr< QualType > ParsedType
An opaque type for threading parsed type information through the parser.
const FunctionProtoType * T
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
TemplateDeductionResult
Describes the result of template argument deduction.
@ Success
Template argument deduction was successful.
@ AlreadyDiagnosed
Some error which was already diagnosed.
@ Generic
not a target-specific vector type
@ None
No keyword precedes the qualified type name.
@ Class
The "class" keyword introduces the elaborated-type-specifier.
@ Typename
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
@ Other
Other implicit parameter.
TypeTrait
Names for traits that operate specifically on types.
CXXNewInitializationStyle
@ Parens
New-expression has a C++98 paren-delimited initializer.
@ None
New-expression has no initializer as written.
@ Braces
New-expression has a C++11 list-initializer.
@ EST_BasicNoexcept
noexcept
@ EST_Dynamic
throw(T1, T2)
CheckedConversionKind
The kind of conversion being performed.
@ CStyleCast
A C-style cast.
@ ForBuiltinOverloadedOp
A conversion for an operand of a builtin overloaded operator.
@ FunctionalCast
A functional-style cast.
bool isGenericLambdaCallOperatorSpecialization(const CXXMethodDecl *MD)
MutableArrayRef< Expr * > MultiExprArg
The result of a constraint satisfaction check, containing the necessary information to diagnose an un...
static ASTConstraintSatisfaction * Rebuild(const ASTContext &C, const ASTConstraintSatisfaction &Satisfaction)
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
DeclarationName getName() const
getName - Returns the embedded declaration name.
unsigned hasStatic
True if this dimension included the 'static' keyword.
Expr * NumElts
This is the size of the array, or null if [] or [*] was specified.
One instance of this struct is used for each type in a declarator that is parsed.
SourceLocation Loc
Loc - The place where this type was defined.
ExceptionSpecificationType Type
The kind of exception specification this is.
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
Extra information about a function prototype.
ExceptionSpecInfo ExceptionSpec
FunctionType::ExtInfo ExtInfo
Parts of a decomposed MSGuidDecl.
OverloadCandidate - A single candidate in an overload set (C++ 13.3).
ReferenceConversions
The conversions that would be performed on an lvalue of type T2 when binding a reference of type T1 t...
Information about a template-id annotation token.
const IdentifierInfo * Name
FIXME: Temporarily stores the name of a specialization.
unsigned NumArgs
NumArgs - The number of template arguments.
SourceLocation TemplateNameLoc
TemplateNameLoc - The location of the template name within the source.
ParsedTemplateArgument * getTemplateArgs()
Retrieves a pointer to the template arguments.
SourceLocation RAngleLoc
The location of the '>' after the template argument list.
SourceLocation LAngleLoc
The location of the '<' before the template argument list.
SourceLocation TemplateKWLoc
TemplateKWLoc - The location of the template keyword.
ParsedTemplateTy Template
The declaration of the template corresponding to the template-name.
StandardConversionSequence Before
Represents the standard conversion that occurs before the actual user-defined conversion.
FunctionDecl * ConversionFunction
ConversionFunction - The function that will perform the user-defined conversion.
bool HadMultipleCandidates
HadMultipleCandidates - When this is true, it means that the conversion function was resolved from an...
StandardConversionSequence After
After - Represents the standard conversion that occurs after the actual user-defined conversion.
bool EllipsisConversion
EllipsisConversion - When this is true, it means user-defined conversion sequence starts with a ....
DeclAccessPair FoundConversionFunction
The declaration that we found via name lookup, which might be the same as ConversionFunction or it mi...