38 #include "llvm/ADT/APInt.h" 39 #include "llvm/ADT/STLExtras.h" 40 #include "llvm/Support/ErrorHandling.h" 41 using namespace clang;
73 llvm_unreachable(
"Nested name specifier is not a type for inheriting ctor");
78 return CreateParsedType(Type,
85 bool EnteringContext) {
88 "not a constructor name");
98 if (SS.
isNotEmpty() && RequireCompleteDeclContext(SS, CurClass))
110 if (RD && RD->isInjectedClassName()) {
111 InjectedClassName = RD;
115 if (!InjectedClassName) {
120 diag::err_incomplete_nested_name_spec) << CurClass << SS.
getRange();
126 DiagnoseUseOfDecl(InjectedClassName, NameLoc);
127 MarkAnyDeclReferenced(NameLoc, InjectedClassName,
false);
137 bool EnteringContext) {
162 bool isDependent =
false;
163 bool LookInScope =
false;
172 SearchType = GetTypeFromParser(ObjectTypePtr);
177 bool AlreadySearched =
false;
178 bool LookAtPrefix =
true;
190 DeclContext *DC = computeDeclContext(SS, EnteringContext);
192 AlreadySearched =
true;
195 }
else if (DC && isa<CXXRecordDecl>(DC)) {
196 LookAtPrefix =
false;
202 if (AlreadySearched) {
204 }
else if (LookAtPrefix && (Prefix = NNS->
getPrefix())) {
207 LookupCtx = computeDeclContext(PrefixSS, EnteringContext);
208 isDependent = isDependentScopeSpecifier(PrefixSS);
209 }
else if (ObjectTypePtr) {
210 LookupCtx = computeDeclContext(SearchType);
213 LookupCtx = computeDeclContext(SS, EnteringContext);
216 }
else if (ObjectTypePtr) {
224 LookupCtx = computeDeclContext(SearchType);
227 "Caller should have completed object type");
235 TypeDecl *NonMatchingTypeDecl =
nullptr;
236 LookupResult Found(*
this, &II, NameLoc, LookupOrdinaryName);
242 if (
Step == 0 && LookupCtx) {
243 if (RequireCompleteDeclContext(SS, LookupCtx))
245 LookupQualifiedName(Found, LookupCtx);
246 }
else if (
Step == 1 && LookInScope && S) {
247 LookupName(Found, S);
258 MarkAnyDeclReferenced(
Type->getLocation(),
Type,
false);
264 return CreateParsedType(T,
269 NonMatchingTypeDecl =
Type;
281 if (
DeclContext *Ctx = computeDeclContext(SS, EnteringContext)) {
287 if (MemberOfType.
isNull())
288 MemberOfType = SearchType;
290 if (MemberOfType.
isNull())
298 = dyn_cast<ClassTemplateSpecializationDecl>(Record->getDecl())) {
299 if (Spec->getSpecializedTemplate()->getCanonicalDecl() ==
300 Template->getCanonicalDecl())
301 return CreateParsedType(
321 if (SpecTemplate->getCanonicalDecl() == Template->getCanonicalDecl())
322 return CreateParsedType(
333 if (DepTemplate->isIdentifier() &&
334 DepTemplate->getIdentifier() == Template->getIdentifier())
335 return CreateParsedType(
356 if (NonMatchingTypeDecl) {
358 Diag(NameLoc, diag::err_destructor_expr_type_mismatch)
360 Diag(NonMatchingTypeDecl->
getLocation(), diag::note_destructor_type_here)
362 }
else if (ObjectTypePtr)
363 Diag(NameLoc, diag::err_ident_in_dtor_not_a_type)
367 diag::err_destructor_class_name);
370 if (
const CXXRecordDecl *Class = dyn_cast_or_null<CXXRecordDecl>(Ctx))
372 Class->getNameAsString());
390 "unexpected type in getDestructorType");
395 QualType SearchType = GetTypeFromParser(ObjectType);
396 if (!SearchType.isNull() && !SearchType->isDependentType() &&
421 Diag(Name.
getBeginLoc(), diag::err_literal_operator_id_outside_namespace)
432 llvm_unreachable(
"unknown nested name specifier kind");
450 RequireCompleteType(TypeidLoc, T, diag::err_incomplete_typeid))
454 return ExprError(
Diag(TypeidLoc, diag::err_variably_modified_typeid) << T);
465 bool WasEvaluated =
false;
475 CXXRecordDecl *RecordD = cast<CXXRecordDecl>(RecordT->getDecl());
479 if (RequireCompleteType(TypeidLoc, T, diag::err_incomplete_typeid))
489 ExprResult Result = TransformToPotentiallyEvaluated(E);
494 MarkVTableUsed(TypeidLoc, RecordD);
508 E = ImpCastExprToType(E, UnqualT, CK_NoOp, E->
getValueKind()).
get();
513 return ExprError(
Diag(TypeidLoc, diag::err_variably_modified_typeid)
515 else if (!inTemplateInstantiation() &&
520 ? diag::warn_side_effects_typeid
521 : diag::warn_side_effects_unevaluated_context);
533 if (getLangOpts().OpenCLCPlusPlus) {
534 return ExprError(
Diag(OpLoc, diag::err_openclcxx_not_supported)
539 if (!getStdNamespace())
540 return ExprError(
Diag(OpLoc, diag::err_need_header_before_typeid));
542 if (!CXXTypeInfoDecl) {
543 IdentifierInfo *TypeInfoII = &PP.getIdentifierTable().get(
"type_info");
545 LookupQualifiedName(R, getStdNamespace());
549 if (!CXXTypeInfoDecl && LangOpts.MSVCCompat) {
553 if (!CXXTypeInfoDecl)
554 return ExprError(
Diag(OpLoc, diag::err_need_header_before_typeid));
557 if (!getLangOpts().RTTI) {
558 return ExprError(
Diag(OpLoc, diag::err_no_typeid_with_fno_rtti));
574 return BuildCXXTypeId(TypeInfoType, OpLoc, TInfo, RParenLoc);
578 return BuildCXXTypeId(TypeInfoType, OpLoc, (
Expr*)TyOrExpr, RParenLoc);
597 if (
const auto *Uuid = TD->getMostRecentDecl()->getAttr<UuidAttr>()) {
598 UuidAttrs.insert(Uuid);
603 if (
const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(TD)) {
606 const UuidAttr *UuidForTA =
nullptr;
613 UuidAttrs.insert(UuidForTA);
627 if (UuidAttrs.empty())
628 return ExprError(
Diag(TypeidLoc, diag::err_uuidof_without_guid));
629 if (UuidAttrs.size() > 1)
630 return ExprError(
Diag(TypeidLoc, diag::err_uuidof_with_multiple_guids));
631 UuidStr = UuidAttrs.back()->getGuid();
646 UuidStr =
"00000000-0000-0000-0000-000000000000";
650 if (UuidAttrs.empty())
651 return ExprError(
Diag(TypeidLoc, diag::err_uuidof_without_guid));
652 if (UuidAttrs.size() > 1)
653 return ExprError(
Diag(TypeidLoc, diag::err_uuidof_with_multiple_guids));
654 UuidStr = UuidAttrs.back()->getGuid();
673 return ExprError(
Diag(OpLoc, diag::err_need_header_before_ms_uuidof));
689 return BuildCXXUuidof(GuidType, OpLoc, TInfo, RParenLoc);
693 return BuildCXXUuidof(GuidType, OpLoc, (
Expr*)TyOrExpr, RParenLoc);
699 assert((Kind == tok::kw_true || Kind == tok::kw_false) &&
700 "Unknown C++ Boolean value!");
714 bool IsThrownVarInScope =
false;
728 if (
VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
729 if (Var->hasLocalStorage() && !Var->getType().isVolatileQualified()) {
732 IsThrownVarInScope =
true;
746 return BuildCXXThrow(OpLoc, Ex, IsThrownVarInScope);
750 bool IsThrownVarInScope) {
752 if (!getLangOpts().CXXExceptions &&
753 !getSourceManager().isInSystemHeader(OpLoc) && !getLangOpts().CUDA) {
755 targetDiag(OpLoc, diag::err_exceptions_disabled) <<
"throw";
759 if (getLangOpts().CUDA)
760 CUDADiagIfDeviceCode(OpLoc, diag::err_cuda_device_exceptions)
761 <<
"throw" << CurrentCUDATarget();
763 if (getCurScope() && getCurScope()->isOpenMPSimdDirectiveScope())
764 Diag(OpLoc, diag::err_omp_simd_region_cannot_use_stmt) <<
"throw";
768 if (CheckCXXThrowOperand(OpLoc, ExceptionObjectTy, Ex))
786 const VarDecl *NRVOVariable =
nullptr;
787 if (IsThrownVarInScope)
788 NRVOVariable = getCopyElisionCandidate(
QualType(), Ex, CES_Strict);
791 OpLoc, ExceptionObjectTy,
792 NRVOVariable !=
nullptr);
793 ExprResult Res = PerformMoveOrCopyInitialization(
794 Entity, NRVOVariable,
QualType(), Ex, IsThrownVarInScope);
806 llvm::DenseMap<CXXRecordDecl *, unsigned> &SubobjectsSeen,
807 llvm::SmallPtrSetImpl<CXXRecordDecl *> &VBases,
808 llvm::SetVector<CXXRecordDecl *> &PublicSubobjectsSeen,
809 bool ParentIsPublic) {
811 CXXRecordDecl *BaseDecl = BS.getType()->getAsCXXRecordDecl();
816 NewSubobject = VBases.insert(BaseDecl).second;
821 ++SubobjectsSeen[BaseDecl];
824 bool PublicPath = ParentIsPublic && BS.getAccessSpecifier() ==
AS_public;
826 PublicSubobjectsSeen.insert(BaseDecl);
836 llvm::DenseMap<CXXRecordDecl *, unsigned> SubobjectsSeen;
837 llvm::SmallSet<CXXRecordDecl *, 2> VBases;
838 llvm::SetVector<CXXRecordDecl *> PublicSubobjectsSeen;
839 SubobjectsSeen[RD] = 1;
840 PublicSubobjectsSeen.insert(RD);
844 for (
CXXRecordDecl *PublicSubobject : PublicSubobjectsSeen) {
846 if (SubobjectsSeen[PublicSubobject] > 1)
849 Objects.push_back(PublicSubobject);
859 bool isPointer =
false;
865 if (RequireCompleteType(ThrowLoc, Ty,
866 isPointer ? diag::err_throw_incomplete_ptr
867 : diag::err_throw_incomplete,
871 if (RequireNonAbstractType(ThrowLoc, ExceptionObjectTy,
872 diag::err_throw_abstract_type, E))
883 MarkVTableUsed(ThrowLoc, RD);
892 MarkFunctionReferenced(E->
getExprLoc(), Destructor);
893 CheckDestructorAccess(E->
getExprLoc(), Destructor,
894 PDiag(diag::err_access_dtor_exception) << Ty);
895 if (DiagnoseUseOfDecl(Destructor, E->
getExprLoc()))
910 for (
CXXRecordDecl *Subobject : UnambiguousPublicSubobjects) {
937 for (
unsigned I = 1, E = CD->
getNumParams(); I != E; ++I) {
938 if (CheckCXXDefaultArgExpr(ThrowLoc, CD, CD->
getParamDecl(I)))
951 if (ExnObjAlign < TypeAlign) {
952 Diag(ThrowLoc, diag::warn_throw_underaligned_obj);
953 Diag(ThrowLoc, diag::note_throw_underaligned_obj)
1006 for (
int I = FunctionScopes.size();
1007 I-- && isa<LambdaScopeInfo>(FunctionScopes[I]) &&
1009 cast<LambdaScopeInfo>(FunctionScopes[I])->CallOperator);
1011 CurLSI = cast<LambdaScopeInfo>(FunctionScopes[I]);
1018 if (C.isCopyCapture()) {
1029 assert(CurLSI &&
"While computing 'this' capture-type for a generic " 1030 "lambda, we must have a corresponding LambdaScopeInfo");
1032 "While computing 'this' capture-type for a generic lambda, when we " 1033 "run out of enclosing LSI's, yet the enclosing DC is a " 1034 "lambda-call-operator we must be (i.e. Current LSI) in a generic " 1035 "lambda call oeprator");
1038 auto IsThisCaptured =
1042 for (
auto &&C : Closure->
captures()) {
1043 if (C.capturesThis()) {
1054 bool IsByCopyCapture =
false;
1055 bool IsConstCapture =
false;
1058 IsThisCaptured(Closure, IsByCopyCapture, IsConstCapture)) {
1059 if (IsByCopyCapture) {
1075 QualType ThisTy = CXXThisTypeOverride;
1078 if (method && method->isInstance())
1079 ThisTy = method->getThisType();
1083 inTemplateInstantiation()) {
1085 assert(isa<CXXRecordDecl>(DC) &&
1086 "Trying to get 'this' type from static method?");
1103 CurContext, Context);
1111 : S(S), OldCXXThisTypeOverride(S.CXXThisTypeOverride), Enabled(
false)
1113 if (!Enabled || !ContextDecl)
1118 Record = Template->getTemplatedDecl();
1120 Record = cast<CXXRecordDecl>(ContextDecl);
1127 this->Enabled =
true;
1138 bool BuildAndDiagnose,
const unsigned *
const FunctionScopeIndexToStopAt,
1139 const bool ByCopy) {
1144 assert((!ByCopy || Explicit) &&
"cannot implicitly capture *this by value");
1146 const int MaxFunctionScopesIndex = FunctionScopeIndexToStopAt
1147 ? *FunctionScopeIndexToStopAt
1173 unsigned NumCapturingClosures = 0;
1174 for (
int idx = MaxFunctionScopesIndex; idx >= 0; idx--) {
1177 if (CSI->CXXThisCaptureIndex != 0) {
1179 CSI->Captures[CSI->CXXThisCaptureIndex - 1].markUsed(BuildAndDiagnose);
1185 if (BuildAndDiagnose)
1186 Diag(Loc, diag::err_this_capture)
1187 << (Explicit && idx == MaxFunctionScopesIndex);
1194 (Explicit && idx == MaxFunctionScopesIndex)) {
1200 NumCapturingClosures++;
1204 if (BuildAndDiagnose)
1205 Diag(Loc, diag::err_this_capture)
1206 << (Explicit && idx == MaxFunctionScopesIndex);
1211 if (!BuildAndDiagnose)
return false;
1223 dyn_cast<LambdaScopeInfo>(
FunctionScopes[MaxFunctionScopesIndex])) &&
1224 "Only a lambda can capture the enclosing object (referred to by " 1227 for (
int idx = MaxFunctionScopesIndex; NumCapturingClosures;
1228 --idx, --NumCapturingClosures) {
1243 bool isNested = NumCapturingClosures > 1;
1256 return Diag(Loc, diag::err_invalid_this_use);
1292 bool ListInitialization) {
1302 RParenOrBraceLoc, ListInitialization);
1306 if (!
Result.isInvalid() &&
Result.get()->isInstantiationDependent() &&
1307 !
Result.get()->isTypeDependent())
1317 bool ListInitialization) {
1326 : SourceRange(LParenOrBraceLoc, RParenOrBraceLoc);
1331 assert((!ListInitialization ||
1332 (Exprs.size() == 1 && isa<InitListExpr>(Exprs[0]))) &&
1333 "List initialization must have initializer list as expression.");
1339 ? ListInitialization
1341 TyBeginLoc, LParenOrBraceLoc, RParenOrBraceLoc)
1351 if (Deduced && isa<DeducedTemplateSpecializationType>(Deduced)) {
1363 if (Exprs.size() == 1 && !ListInitialization &&
1364 !isa<InitListExpr>(Exprs[0])) {
1365 Expr *Arg = Exprs[0];
1373 if (!ListInitialization)
1374 return ExprError(
Diag(TyBeginLoc, diag::err_value_init_for_array_type)
1382 return ExprError(
Diag(TyBeginLoc, diag::err_init_for_function_type)
1383 << Ty << FullRange);
1390 diag::err_invalid_incomplete_type_use, FullRange))
1403 Inner = BTE->getSubExpr();
1404 if (!isa<CXXTemporaryObjectExpr>(Inner) &&
1405 !isa<CXXScalarValueInitExpr>(Inner)) {
1417 : SourceRange(LParenOrBraceLoc, RParenOrBraceLoc);
1436 if (Result || !
getLangOpts().CUDA || PreventedBy.empty())
1441 return llvm::none_of(PreventedBy, [&](
const FunctionDecl *FD) {
1443 "Only single-operand functions should be in PreventedBy");
1458 unsigned UsualParams = 1;
1476 struct UsualDeallocFnInfo {
1477 UsualDeallocFnInfo() : Found(), FD(
nullptr) {}
1480 Destroying(
false), HasSizeT(
false), HasAlignValT(
false),
1485 unsigned NumBaseParams = 1;
1486 if (FD->isDestroyingOperatorDelete()) {
1491 if (NumBaseParams < FD->getNumParams() &&
1493 FD->getParamDecl(NumBaseParams)->getType(),
1499 if (NumBaseParams < FD->getNumParams() &&
1500 FD->getParamDecl(NumBaseParams)->getType()->isAlignValT()) {
1502 HasAlignValT =
true;
1507 if (
auto *Caller = dyn_cast<FunctionDecl>(S.
CurContext))
1511 explicit operator bool()
const {
return FD; }
1513 bool isBetterThan(
const UsualDeallocFnInfo &Other,
bool WantSize,
1514 bool WantAlign)
const {
1518 if (Destroying != Other.Destroying)
1525 if (HasAlignValT != Other.HasAlignValT)
1526 return HasAlignValT == WantAlign;
1528 if (HasSizeT != Other.HasSizeT)
1529 return HasSizeT == WantSize;
1532 return CUDAPref > Other.CUDAPref;
1537 bool Destroying, HasSizeT, HasAlignValT;
1557 UsualDeallocFnInfo Best;
1559 for (
auto I = R.
begin(), E = R.
end(); I != E; ++I) {
1560 UsualDeallocFnInfo Info(S, I.getPair());
1568 BestFns->push_back(Info);
1572 if (Best.isBetterThan(Info, WantSize, WantAlign))
1577 if (BestFns && Info.isBetterThan(Best, WantSize, WantAlign))
1582 BestFns->push_back(Info);
1596 if (!record)
return false;
1609 if (ops.
empty())
return false;
1621 return Best && Best.HasSizeT;
1672 if (!NumElts->isTypeDependent() && !NumElts->isValueDependent()) {
1678 assert(IntWidth &&
"Builtin type of size 0?");
1679 llvm::APSInt
Value(IntWidth);
1687 diag::err_new_array_nonconst)
1703 if (
ParenListExpr *List = dyn_cast_or_null<ParenListExpr>(Initializer))
1704 DirectInitRange = List->getSourceRange();
1707 PlacementLParen, PlacementArgs, PlacementRParen,
1708 TypeIdParens, AllocType, TInfo, ArraySize, DirectInitRange,
1717 return PLE->getNumExprs() == 0;
1718 if (isa<ImplicitValueInitExpr>(Init))
1721 return !CCE->isListInitialization() &&
1722 CCE->getConstructor()->isDefaultConstructor();
1724 assert(isa<InitListExpr>(Init) &&
1725 "Shouldn't create list CXXConstructExprs for arrays.");
1737 bool IsAligned =
false;
1749 StringRef OSName = AvailabilityAttr::getPlatformNameSourceSpelling(
1753 bool IsDelete = Kind == OO_Delete || Kind == OO_Array_Delete;
1754 Diag(Loc, diag::err_aligned_allocation_unavailable)
1757 Diag(Loc, diag::note_silence_aligned_allocation_unavailable);
1776 if (DirectInitRange.
isValid()) {
1777 assert(Initializer &&
"Have parens but no initializer.");
1779 }
else if (Initializer && isa<InitListExpr>(Initializer))
1782 assert((!Initializer || isa<ImplicitValueInitExpr>(Initializer) ||
1783 isa<CXXConstructExpr>(Initializer)) &&
1784 "Initializer expression that cannot have been implicitly created.");
1789 unsigned NumInits = Initializer ? 1 : 0;
1790 if (
ParenListExpr *List = dyn_cast_or_null<ParenListExpr>(Initializer)) {
1792 Inits = List->getExprs();
1793 NumInits = List->getNumExprs();
1814 DirectInitRange.
getEnd());
1818 if (Deduced && isa<DeducedTemplateSpecializationType>(Deduced)) {
1821 Diag(ArraySize ? (*ArraySize)->getExprLoc() : TypeRange.
getBegin(),
1822 diag::err_deduced_class_template_compound_type)
1824 << (ArraySize ? (*ArraySize)->getSourceRange() : TypeRange));
1829 AllocTypeInfo, Entity, Kind,
MultiExprArg(Inits, NumInits));
1832 }
else if (Deduced) {
1834 if (NumInits == 1) {
1835 if (
auto p = dyn_cast_or_null<InitListExpr>(Inits[0])) {
1836 Inits =
p->getInits();
1837 NumInits =
p->getNumInits();
1843 return ExprError(
Diag(StartLoc, diag::err_auto_new_requires_ctor_arg)
1844 << AllocType << TypeRange);
1846 Expr *FirstBad = Inits[1];
1848 diag::err_auto_new_ctor_multiple_expressions)
1849 << AllocType << TypeRange);
1853 << AllocType << TypeRange;
1854 Expr *Deduce = Inits[0];
1857 return ExprError(
Diag(StartLoc, diag::err_auto_new_deduction_failure)
1858 << AllocType << Deduce->getType()
1859 << TypeRange << Deduce->getSourceRange());
1860 if (DeducedType.
isNull())
1862 AllocType = DeducedType;
1873 AllocType = Array->getElementType();
1890 if (ArraySize && *ArraySize &&
1891 (*ArraySize)->getType()->isNonOverloadPlaceholderType()) {
1894 ArraySize = result.
get();
1904 if (ArraySize && *ArraySize && !(*ArraySize)->isTypeDependent()) {
1912 if (!ConvertedSize.isInvalid() &&
1913 (*ArraySize)->getType()->getAs<
RecordType>())
1915 Diag(StartLoc, diag::warn_cxx98_compat_array_size_conversion)
1916 << (*ArraySize)->getType() << 0 <<
"'size_t'";
1923 SizeConvertDiagnoser(
Expr *ArraySize)
1925 ArraySize(ArraySize) {}
1929 return S.
Diag(Loc, diag::err_array_size_not_integral)
1935 return S.
Diag(Loc, diag::err_array_size_incomplete_type)
1941 return S.
Diag(Loc, diag::err_array_size_explicit_conversion) << T << ConvTy;
1952 return S.
Diag(Loc, diag::err_array_size_ambiguous_conversion) << T;
1966 ? diag::warn_cxx98_compat_array_size_conversion
1967 : diag::ext_array_size_conversion)
1970 } SizeDiagnoser(*ArraySize);
1978 ArraySize = ConvertedSize.
get();
1979 QualType SizeType = (*ArraySize)->getType();
1991 if (!(*ArraySize)->isValueDependent()) {
1998 if ((*ArraySize)->isIntegerConstantExpr(Value,
Context)) {
1999 if (Value.isSigned() && Value.isNegative()) {
2001 diag::err_typecheck_negative_array_size)
2002 << (*ArraySize)->getSourceRange());
2006 unsigned ActiveSizeBits =
2010 Diag((*ArraySize)->getBeginLoc(), diag::err_array_too_large)
2011 << Value.toString(10) << (*ArraySize)->getSourceRange());
2014 KnownArraySize = Value.getZExtValue();
2015 }
else if (TypeIdParens.
isValid()) {
2017 Diag((*ArraySize)->getBeginLoc(), diag::ext_new_paren_array_nonconst)
2018 << (*ArraySize)->getSourceRange()
2032 unsigned Alignment =
2035 bool PassAlignment =
getLangOpts().AlignedAllocation &&
2036 Alignment > NewAlignment;
2042 StartLoc,
SourceRange(PlacementLParen, PlacementRParen), Scope, Scope,
2043 AllocType, ArraySize.hasValue(), PassAlignment, PlacementArgs,
2044 OperatorNew, OperatorDelete))
2049 bool UsualArrayDeleteWantsSize =
false;
2051 UsualArrayDeleteWantsSize =
2066 PassAlignment ? 2 : 1, PlacementArgs,
2067 AllPlaceArgs, CallType))
2070 if (!AllPlaceArgs.empty())
2071 PlacementArgs = AllPlaceArgs;
2080 if (PlacementArgs.empty() && !PassAlignment &&
2081 (OperatorNew->isImplicit() ||
2082 (OperatorNew->getBeginLoc().isValid() &&
2084 if (Alignment > NewAlignment)
2085 Diag(StartLoc, diag::warn_overaligned_type)
2097 Inits[NumInits - 1]->getEndLoc());
2098 Diag(StartLoc, diag::err_new_array_init_args) << InitRange;
2106 llvm::makeArrayRef(Inits, NumInits))) {
2118 InitType = AllocType;
2133 dyn_cast_or_null<CXXBindTemporaryExpr>(FullInit.
get()))
2134 FullInit = Binder->getSubExpr();
2136 Initializer = FullInit.
get();
2141 if (ArraySize && !*ArraySize) {
2149 Diag(TypeRange.
getEnd(), diag::err_new_array_size_unknown_from_init)
2161 if (OperatorDelete) {
2168 PassAlignment, UsualArrayDeleteWantsSize,
2169 PlacementArgs, TypeIdParens, ArraySize, initStyle,
2170 Initializer, ResultType, AllocTypeInfo, Range,
2181 return Diag(Loc, diag::err_bad_new_type)
2182 << AllocType << 0 << R;
2184 return Diag(Loc, diag::err_bad_new_type)
2185 << AllocType << 1 << R;
2190 diag::err_allocation_of_abstract_type))
2193 return Diag(Loc, diag::err_variably_modified_new_type)
2197 return Diag(Loc, diag::err_address_space_qualified_new)
2205 return Diag(Loc, diag::err_arc_new_array_without_ownership)
2220 Alloc != AllocEnd; ++Alloc) {
2240 switch (Candidates.BestViableFunction(S, R.
getNameLoc(), Best)) {
2257 if (PassAlignment) {
2258 PassAlignment =
false;
2260 Args.erase(Args.begin() + 1);
2262 Operator, &Candidates, AlignArg,
2290 if (AlignedCandidates) {
2292 return C.Function->getNumParams() > 1 &&
2293 C.Function->getParamDecl(1)->getType()->isAlignValT();
2299 Args.insert(Args.begin() + 1, AlignArg);
2302 Args.erase(Args.begin() + 1);
2313 Candidates.NoteCandidates(
2315 S.
PDiag(diag::err_ovl_ambiguous_call)
2323 Candidates.NoteCandidates(
2325 S.
PDiag(diag::err_ovl_deleted_call)
2332 llvm_unreachable(
"Unreachable, bad result from BestViableFunction");
2354 AllocArgs.reserve((PassAlignment ? 2 : 1) + PlaceArgs.size());
2364 AllocArgs.push_back(&Size);
2367 if (PassAlignment) {
2373 AllocArgs.push_back(&Align);
2375 AllocArgs.insert(AllocArgs.end(), PlaceArgs.begin(), PlaceArgs.end());
2384 IsArray ? OO_Array_New : OO_New);
2416 if (PlaceArgs.empty()) {
2417 Diag(StartLoc, diag::err_openclcxx_not_supported) <<
"default new";
2419 Diag(StartLoc, diag::err_openclcxx_placement_new);
2424 assert(!R.
empty() &&
"implicitly declared allocation functions not found");
2425 assert(!R.
isAmbiguous() &&
"global allocation functions are ambiguous");
2431 OperatorNew,
nullptr,
2438 OperatorDelete =
nullptr;
2467 bool FoundGlobalDelete = FoundDelete.
empty();
2468 if (FoundDelete.
empty()) {
2493 bool isPlacementNew = !PlaceArgs.empty() || OperatorNew->
param_size() != 1 ||
2496 if (isPlacementNew) {
2514 for (
unsigned I = 1, N = Proto->
getNumParams(); I < N; ++I)
2521 ExpectedFunctionType
2526 DEnd = FoundDelete.
end();
2530 dyn_cast<FunctionTemplateDecl>((*D)->getUnderlyingDecl())) {
2538 Fn = cast<FunctionDecl>((*D)->getUnderlyingDecl());
2541 ExpectedFunctionType,
2543 ExpectedFunctionType))
2544 Matches.push_back(std::make_pair(D.getPair(), Fn));
2559 *
this, FoundDelete, FoundGlobalDelete,
2563 Matches.push_back(std::make_pair(Selected.Found, Selected.FD));
2567 for (
auto Fn : BestDeallocFns)
2568 Matches.push_back(std::make_pair(Fn.Found, Fn.FD));
2576 if (Matches.size() == 1) {
2577 OperatorDelete = Matches[0].second;
2585 if (
getLangOpts().CPlusPlus11 && isPlacementNew &&
2587 UsualDeallocFnInfo Info(*
this,
2593 bool IsSizedDelete = Info.HasSizeT;
2594 if (IsSizedDelete && !FoundGlobalDelete) {
2595 auto NonSizedDelete =
2598 if (NonSizedDelete && !NonSizedDelete.HasSizeT &&
2599 NonSizedDelete.HasAlignValT == Info.HasAlignValT)
2600 IsSizedDelete =
false;
2603 if (IsSizedDelete) {
2607 PlaceArgs.back()->getEndLoc());
2608 Diag(StartLoc, diag::err_placement_new_non_placement_delete) << R;
2617 }
else if (!Matches.empty()) {
2621 Diag(StartLoc, diag::warn_ambiguous_suitable_delete_function_found)
2622 << DeleteName << AllocElemType;
2624 for (
auto &Match : Matches)
2625 Diag(Match.second->getLocation(),
2626 diag::note_member_declared_here) << DeleteName;
2712 AlignValT->setImplicit(
true);
2724 Params.push_back(Param);
2727 bool HasSizedVariant =
getLangOpts().SizedDeallocation &&
2728 (Kind == OO_Delete || Kind == OO_Array_Delete);
2729 bool HasAlignedVariant =
getLangOpts().AlignedAllocation;
2731 int NumSizeVariants = (HasSizedVariant ? 2 : 1);
2732 int NumAlignVariants = (HasAlignedVariant ? 2 : 1);
2733 for (
int Sized = 0; Sized < NumSizeVariants; ++Sized) {
2735 Params.push_back(SizeT);
2737 for (
int Aligned = 0; Aligned < NumAlignVariants; ++Aligned) {
2750 DeclareGlobalAllocationFunctions(OO_New, VoidPtr, SizeT);
2751 DeclareGlobalAllocationFunctions(OO_Array_New, VoidPtr, SizeT);
2752 DeclareGlobalAllocationFunctions(OO_Delete,
Context.
VoidTy, VoidPtr);
2753 DeclareGlobalAllocationFunctions(OO_Array_Delete,
Context.
VoidTy, VoidPtr);
2766 Alloc != AllocEnd; ++Alloc) {
2769 if (
FunctionDecl *Func = dyn_cast<FunctionDecl>(*Alloc)) {
2770 if (Func->getNumParams() == Params.size()) {
2772 for (
auto *
P : Func->parameters())
2773 FuncParams.push_back(
2775 if (llvm::makeArrayRef(FuncParams) == Params) {
2779 Func->setVisibleDespiteOwningModule();
2787 false,
false,
true));
2790 bool HasBadAllocExceptionSpec
2793 if (HasBadAllocExceptionSpec) {
2796 assert(
StdBadAlloc &&
"Must have std::bad_alloc declared");
2798 EPI.ExceptionSpec.Exceptions = llvm::makeArrayRef(BadAllocType);
2805 auto CreateAllocationFunctionDecl = [&](
Attr *ExtraAttr) {
2809 FnType,
nullptr,
SC_None,
false,
true);
2814 Alloc->
addAttr(VisibilityAttr::CreateImplicit(
2816 ? VisibilityAttr::Hidden
2824 ParamDecls.back()->setImplicit();
2826 Alloc->setParams(ParamDecls);
2834 CreateAllocationFunctionDecl(
nullptr);
2838 CreateAllocationFunctionDecl(CUDAHostAttr::CreateImplicit(
Context));
2839 CreateAllocationFunctionDecl(CUDADeviceAttr::CreateImplicit(
Context));
2844 bool CanProvideSize,
2858 assert(Result.FD &&
"operator delete missing from global scope?");
2870 return OperatorDelete;
2898 Overaligned, &Matches);
2901 if (Matches.size() == 1) {
2902 Operator = cast<CXXMethodDecl>(Matches[0].FD);
2907 Diag(StartLoc, diag::err_deleted_function_use);
2923 if (!Matches.empty()) {
2925 Diag(StartLoc, diag::err_ambiguous_suitable_delete_member_function_found)
2927 for (
auto &Match : Matches)
2928 Diag(Match.FD->getLocation(), diag::note_member_declared_here) << Name;
2935 if (!Found.
empty()) {
2937 Diag(StartLoc, diag::err_no_suitable_delete_member_function_found)
2941 Diag(D->getUnderlyingDecl()->getLocation(),
2942 diag::note_member_declared_here) << Name;
2954 class MismatchingNewDeleteDetector {
2956 enum MismatchResult {
2962 MemberInitMismatches,
2971 explicit MismatchingNewDeleteDetector(
bool EndOfTU)
2972 : Field(
nullptr), IsArrayForm(
false), EndOfTU(EndOfTU),
2973 HasUndefinedConstructors(
false) {}
2990 MismatchResult analyzeField(
FieldDecl *Field,
bool DeleteWasArrayForm);
3000 bool HasUndefinedConstructors;
3012 MismatchResult analyzeMemberExpr(
const MemberExpr *ME);
3035 MismatchResult analyzeInClassInitializer();
3039 MismatchingNewDeleteDetector::MismatchResult
3040 MismatchingNewDeleteDetector::analyzeDeleteExpr(
const CXXDeleteExpr *DE) {
3042 assert(DE &&
"Expected delete-expression");
3045 if (
const MemberExpr *ME = dyn_cast<const MemberExpr>(E)) {
3046 return analyzeMemberExpr(ME);
3047 }
else if (
const DeclRefExpr *D = dyn_cast<const DeclRefExpr>(E)) {
3048 if (!hasMatchingVarInit(D))
3049 return VarInitMismatches;
3055 MismatchingNewDeleteDetector::getNewExprFromInitListOrExpr(
const Expr *E) {
3056 assert(E !=
nullptr &&
"Expected a valid initializer expression");
3058 if (
const InitListExpr *ILE = dyn_cast<const InitListExpr>(E)) {
3059 if (ILE->getNumInits() == 1)
3060 E = dyn_cast<const CXXNewExpr>(ILE->getInit(0)->IgnoreParenImpCasts());
3063 return dyn_cast_or_null<const CXXNewExpr>(E);
3066 bool MismatchingNewDeleteDetector::hasMatchingNewInCtorInit(
3070 (NE = getNewExprFromInitListOrExpr(CI->
getInit()))) {
3071 if (NE->
isArray() == IsArrayForm)
3074 NewExprs.push_back(NE);
3079 bool MismatchingNewDeleteDetector::hasMatchingNewInCtor(
3085 HasUndefinedConstructors =
true;
3088 for (
const auto *CI : cast<const CXXConstructorDecl>(Definition)->inits()) {
3089 if (hasMatchingNewInCtorInit(CI))
3095 MismatchingNewDeleteDetector::MismatchResult
3096 MismatchingNewDeleteDetector::analyzeInClassInitializer() {
3097 assert(Field !=
nullptr &&
"This should be called only for members");
3098 const Expr *InitExpr = Field->getInClassInitializer();
3100 return EndOfTU ? NoMismatch : AnalyzeLater;
3101 if (
const CXXNewExpr *NE = getNewExprFromInitListOrExpr(InitExpr)) {
3102 if (NE->isArray() != IsArrayForm) {
3103 NewExprs.push_back(NE);
3104 return MemberInitMismatches;
3110 MismatchingNewDeleteDetector::MismatchResult
3111 MismatchingNewDeleteDetector::analyzeField(
FieldDecl *Field,
3112 bool DeleteWasArrayForm) {
3113 assert(Field !=
nullptr &&
"Analysis requires a valid class member.");
3114 this->Field = Field;
3115 IsArrayForm = DeleteWasArrayForm;
3117 for (
const auto *CD : RD->
ctors()) {
3118 if (hasMatchingNewInCtor(CD))
3121 if (HasUndefinedConstructors)
3122 return EndOfTU ? NoMismatch : AnalyzeLater;
3123 if (!NewExprs.empty())
3124 return MemberInitMismatches;
3129 MismatchingNewDeleteDetector::MismatchResult
3130 MismatchingNewDeleteDetector::analyzeMemberExpr(
const MemberExpr *ME) {
3131 assert(ME !=
nullptr &&
"Expected a member expression");
3133 return analyzeField(F, IsArrayForm);
3137 bool MismatchingNewDeleteDetector::hasMatchingVarInit(
const DeclRefExpr *D) {
3140 if (VD->hasInit() && (NE = getNewExprFromInitListOrExpr(VD->getInit())) &&
3141 NE->
isArray() != IsArrayForm) {
3142 NewExprs.push_back(NE);
3145 return NewExprs.empty();
3150 const MismatchingNewDeleteDetector &Detector) {
3153 if (!Detector.IsArrayForm)
3162 SemaRef.
Diag(DeleteLoc, diag::warn_mismatched_delete_new)
3163 << Detector.IsArrayForm << H;
3165 for (
const auto *NE : Detector.NewExprs)
3166 SemaRef.
Diag(NE->getExprLoc(), diag::note_allocated_here)
3167 << Detector.IsArrayForm;
3170 void Sema::AnalyzeDeleteExprMismatch(
const CXXDeleteExpr *DE) {
3173 MismatchingNewDeleteDetector Detector(
false);
3174 switch (Detector.analyzeDeleteExpr(DE)) {
3175 case MismatchingNewDeleteDetector::VarInitMismatches:
3176 case MismatchingNewDeleteDetector::MemberInitMismatches: {
3180 case MismatchingNewDeleteDetector::AnalyzeLater: {
3185 case MismatchingNewDeleteDetector::NoMismatch:
3191 bool DeleteWasArrayForm) {
3192 MismatchingNewDeleteDetector Detector(
true);
3193 switch (Detector.analyzeField(Field, DeleteWasArrayForm)) {
3194 case MismatchingNewDeleteDetector::VarInitMismatches:
3195 llvm_unreachable(
"This analysis should have been done for class members.");
3196 case MismatchingNewDeleteDetector::AnalyzeLater:
3197 llvm_unreachable(
"Analysis cannot be postponed any point beyond end of " 3198 "translation unit.");
3199 case MismatchingNewDeleteDetector::MemberInitMismatches:
3202 case MismatchingNewDeleteDetector::NoMismatch:
3213 bool ArrayForm,
Expr *ExE) {
3223 bool ArrayFormAsWritten = ArrayForm;
3224 bool UsualArrayDeleteWantsSize =
false;
3226 if (!Ex.
get()->isTypeDependent()) {
3242 if (ConvPtrType->getPointeeType()->isIncompleteOrObjectType())
3249 return S.
Diag(Loc, diag::err_delete_operand) << T;
3254 return S.
Diag(Loc, diag::err_delete_incomplete_class_type) << T;
3260 return S.
Diag(Loc, diag::err_delete_explicit_conversion) << T << ConvTy;
3271 return S.
Diag(Loc, diag::err_ambiguous_delete_operand) << T;
3283 llvm_unreachable(
"conversion functions are permitted");
3290 Type = Ex.
get()->getType();
3291 if (!Converter.match(Type))
3301 return Diag(Ex.
get()->getBeginLoc(),
3302 diag::err_address_space_qualified_delete)
3311 Diag(StartLoc, diag::ext_delete_void_ptr_operand)
3312 << Type << Ex.
get()->getSourceRange();
3315 << Type << Ex.
get()->getSourceRange());
3320 diag::warn_delete_incomplete, Ex.
get())) {
3322 PointeeRD = cast<CXXRecordDecl>(RT->getDecl());
3327 Diag(StartLoc, diag::warn_delete_array_type)
3328 << Type << Ex.
get()->getSourceRange()
3334 ArrayForm ? OO_Array_Delete : OO_Delete);
3348 UsualArrayDeleteWantsSize =
3353 else if (OperatorDelete && isa<CXXMethodDecl>(OperatorDelete))
3354 UsualArrayDeleteWantsSize =
3355 UsualDeallocFnInfo(*
this,
3363 const_cast<CXXDestructorDecl*>(Dtor));
3374 if (!OperatorDelete) {
3376 Diag(StartLoc, diag::err_openclcxx_not_supported) <<
"default delete";
3381 bool CanProvideSize =
3382 IsComplete && (!ArrayForm || UsualArrayDeleteWantsSize ||
3388 Overaligned, DeleteName);
3395 bool IsVirtualDelete =
false;
3399 PDiag(diag::err_access_dtor) << PointeeElem);
3400 IsVirtualDelete = Dtor->isVirtual();
3429 UsualArrayDeleteWantsSize, OperatorDelete, Ex.
get(), StartLoc);
3430 AnalyzeDeleteExprMismatch(Result);
3439 IsDelete ? OO_Delete : OO_New);
3443 assert(!R.empty() &&
"implicitly declared allocation functions not found");
3444 assert(!R.isAmbiguous() &&
"global allocation functions are ambiguous");
3447 R.suppressDiagnostics();
3453 FnOvl != FnOvlEnd; ++FnOvl) {
3456 NamedDecl *D = (*FnOvl)->getUnderlyingDecl();
3475 switch (Candidates.BestViableFunction(S, R.getNameLoc(), Best)) {
3479 assert(R.getNamingClass() ==
nullptr &&
3480 "class members should not be considered");
3483 S.
Diag(R.getNameLoc(), diag::err_builtin_operator_new_delete_not_usual)
3484 << (IsDelete ? 1 : 0) << Range;
3485 S.
Diag(FnDecl->
getLocation(), diag::note_non_usual_function_declared_here)
3495 Candidates.NoteCandidates(
3497 S.
PDiag(diag::err_ovl_no_viable_function_in_call)
3498 << R.getLookupName() << Range),
3503 Candidates.NoteCandidates(
3505 S.
PDiag(diag::err_ovl_ambiguous_call)
3506 << R.getLookupName() << Range),
3511 Candidates.NoteCandidates(
3513 << R.getLookupName() << Range),
3518 llvm_unreachable(
"Unreachable, bad result from BestViableFunction");
3522 Sema::SemaBuiltinOperatorNewDeleteOverloaded(
ExprResult TheCallResult,
3524 CallExpr *TheCall = cast<CallExpr>(TheCallResult.
get());
3527 << (IsDelete ?
"__builtin_operator_delete" :
"__builtin_operator_new")
3537 OperatorNewOrDelete))
3539 assert(OperatorNewOrDelete &&
"should be found");
3556 assert(Callee && Callee->getCastKind() == CK_BuiltinFnToFnPtr &&
3557 "Callee expected to be implicit cast to a builtin function pointer");
3560 return TheCallResult;
3564 bool IsDelete,
bool CallCanBeVirtual,
3565 bool WarnOnNonAbstractTypes,
3592 Diag(Loc, diag::warn_delete_abstract_non_virtual_dtor) << (IsDelete ? 0 : 1)
3594 }
else if (WarnOnNonAbstractTypes) {
3597 Diag(Loc, diag::warn_delete_non_virtual_dtor) << (IsDelete ? 0 : 1)
3601 std::string TypeStr;
3603 Diag(DtorLoc, diag::note_delete_non_virtual)
3633 diag::err_invalid_use_of_function_type)
3637 diag::err_invalid_use_of_array_type)
3655 llvm_unreachable(
"unexpected condition kind");
3669 llvm::APSInt
Value(1);
3684 From = Cast->getSubExpr();
3696 if (!ToPtrType->getPointeeType().hasQualifiers()) {
3697 switch (StrLit->getKind()) {
3704 return (ToPointeeType->getKind() == BuiltinType::Char_U ||
3705 ToPointeeType->getKind() == BuiltinType::Char_S);
3722 bool HadMultipleCandidates,
3725 default: llvm_unreachable(
"Unhandled cast kind!");
3726 case CK_ConstructorConversion: {
3731 diag::err_allocation_of_abstract_type))
3743 CastLoc, Ty, FoundDecl, cast<CXXConstructorDecl>(Method),
3744 ConstructorArgs, HadMultipleCandidates,
3745 false,
false,
false,
3753 case CK_UserDefinedConversion: {
3763 HadMultipleCandidates);
3764 if (Result.isInvalid())
3768 CK_UserDefinedConversion, Result.get(),
3769 nullptr, Result.get()->getValueKind());
3805 assert(FD &&
"no conversion function for user-defined conversion seq");
3807 CastKind = CK_UserDefinedConversion;
3815 CastKind = CK_ConstructorConversion;
3843 From = CastArg.
get();
3857 PDiag(diag::err_typecheck_ambiguous_condition)
3862 llvm_unreachable(
"Cannot perform an ellipsis conversion");
3867 From->
getType(), From, Action);
3868 assert(Diagnosed &&
"failed to diagnose bad conversion"); (void)Diagnosed;
3906 ConstructorArgs,
false,
3907 false,
false,
false,
3914 false,
false,
false,
3937 ToAtomicType = ToType;
3938 ToType = ToAtomic->getValueType();
3941 QualType InitialFromType = FromType;
3943 switch (SCS.
First) {
3946 FromType = FromAtomic->getValueType().getUnqualifiedType();
3955 assert(!FromRes.isInvalid() &&
"Can't perform deduced conversion?!");
3956 From = FromRes.get();
3957 FromType = From->getType();
3974 llvm_unreachable(
"Improper first standard conversion");
4011 "only enums with fixed underlying type can promote to bool");
4033 CK = CK_FloatingComplexCast;
4035 CK = CK_FloatingComplexToIntegralComplex;
4037 CK = CK_IntegralComplexToFloatingComplex;
4039 CK = CK_IntegralComplexCast;
4066 diag::ext_typecheck_convert_incompatible_pointer)
4071 diag::ext_typecheck_convert_incompatible_pointer)
4084 Diag(From->
getBeginLoc(), diag::err_arc_convesion_of_weak_unavailable)
4096 if (Kind == CK_BlockPointerToObjCPointerCast) {
4101 if (
getLangOpts().allowsNonTrivialObjCLifetimeQualifiers())
4149 &BasePath, CCK).
get();
4162 nullptr, CCK).
get();
4169 QualType ElType = ToComplex->getElementType();
4177 isFloatingComplex ? CK_FloatingCast : CK_FloatingToIntegral).
get();
4181 isFloatingComplex ? CK_IntegralToFloating : CK_IntegralCast).
get();
4185 isFloatingComplex ? CK_FloatingRealToComplex
4186 : CK_IntegralRealToComplex).
get();
4191 assert(FromComplex);
4198 isFloatingComplex ? CK_FloatingComplexToReal
4199 : CK_IntegralComplexToReal,
4207 isFloatingComplex ? CK_FloatingCast : CK_IntegralToFloating,
4212 isFloatingComplex ? CK_FloatingToIntegral : CK_IntegralCast,
4226 AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion : CK_BitCast;
4238 From = FromRes.
get();
4240 "Improper transparent union conversion");
4248 CK_ZeroToOCLOpaqueType,
4260 llvm_unreachable(
"Improper second standard conversion");
4263 switch (SCS.
Third) {
4289 CK = CK_AddressSpaceConversion;
4294 CK = CK_AddressSpaceConversion;
4304 ? diag::ext_deprecated_string_literal_conversion
4305 : diag::warn_deprecated_string_literal_conversion)
4313 llvm_unreachable(
"Improper third standard conversion");
4318 if (!ToAtomicType.
isNull()) {
4353 default: llvm_unreachable(
"not a UTT");
4406 Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
4415 Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
4453 Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
4464 if ((RD->*HasTrivial)() && !(RD->*HasNonTrivial)())
4471 bool FoundOperator =
false;
4474 Op != OpEnd; ++Op) {
4475 if (isa<FunctionTemplateDecl>(*Op))
4479 if((Operator->*IsDesiredOp)()) {
4480 FoundOperator =
true;
4488 return FoundOperator;
4495 assert(!T->
isDependentType() &&
"Cannot evaluate traits of dependent type");
4499 default: llvm_unreachable(
"not a UTT");
4581 return !RD->isUnion() && RD->isEmpty();
4585 return !RD->isUnion() && RD->isPolymorphic();
4589 return !RD->isUnion() && RD->isAbstract();
4605 return RD->hasAttr<FinalAttr>();
4634 if (
CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
4635 return RD->hasTrivialDefaultConstructor() &&
4636 !RD->hasNonTrivialDefaultConstructor();
4644 if (
CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
4645 return RD->hasTrivialMoveConstructor() && !RD->hasNonTrivialMoveConstructor();
4656 return RD->hasTrivialCopyConstructor() &&
4657 !RD->hasNonTrivialCopyConstructor();
4665 if (
CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
4666 return RD->hasTrivialMoveAssignment() && !RD->hasNonTrivialMoveAssignment();
4686 return RD->hasTrivialCopyAssignment() &&
4687 !RD->hasNonTrivialCopyAssignment();
4717 if (
auto *RD = C.getBaseElementType(T)->getAsCXXRecordDecl()) {
4753 if (
CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
4754 return RD->hasTrivialDestructor();
4765 if (C.getBaseElementType(T).isConstQualified())
4800 if (RD->hasTrivialCopyConstructor() &&
4801 !RD->hasNonTrivialCopyConstructor())
4804 bool FoundConstructor =
false;
4810 if (isa<FunctionTemplateDecl>(ND->getUnderlyingDecl()))
4813 if (isa<UsingDecl>(ND))
4815 auto *Constructor = cast<CXXConstructorDecl>(ND->getUnderlyingDecl());
4816 if (Constructor->isCopyConstructor(FoundTQs)) {
4817 FoundConstructor =
true;
4830 return FoundConstructor;
4841 if (
CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl()) {
4842 if (RD->hasTrivialDefaultConstructor() &&
4843 !RD->hasNonTrivialDefaultConstructor())
4846 bool FoundConstructor =
false;
4849 if (isa<FunctionTemplateDecl>(ND->getUnderlyingDecl()))
4852 if (isa<UsingDecl>(ND))
4854 auto *Constructor = cast<CXXConstructorDecl>(ND->getUnderlyingDecl());
4855 if (Constructor->isDefaultConstructor()) {
4856 FoundConstructor =
true;
4868 return FoundConstructor;
4877 return Destructor->isVirtual();
4889 return C.hasUniqueObjectRepresentations(T);
4906 Args[1]->getType(), RParenLoc);
4926 assert(!Args.empty());
4931 for (
const auto *TSI : Args) {
4937 diag::err_incomplete_type_used_in_type_trait_expr))
4953 ArgExprs.reserve(Args.size() - 1);
4954 for (
unsigned I = 1, N = Args.size(); I != N; ++I) {
4955 QualType ArgTy = Args[I]->getType();
4958 OpaqueArgExprs.push_back(
4963 for (
Expr &E : OpaqueArgExprs)
4964 ArgExprs.push_back(&E);
5004 return !Result.
get()->hasNonTrivialCall(S.
Context);
5007 llvm_unreachable(
"unhandled type trait");
5010 default: llvm_unreachable(
"not a TT");
5022 *
this, Kind, KWLoc, Args[0]->getType()))
5025 bool Dependent =
false;
5026 for (
unsigned I = 0, N = Args.size(); I != N; ++I) {
5027 if (Args[I]->getType()->isDependentType()) {
5045 ConvertedArgs.reserve(Args.size());
5047 for (
unsigned I = 0, N = Args.size(); I != N; ++I) {
5053 ConvertedArgs.push_back(TInfo);
5062 "Cannot evaluate traits of dependent types");
5073 if (!rhsRecord || !lhsRecord) {
5076 if (!LHSObjTy || !RHSObjTy)
5081 if (!BaseInterface || !DerivedInterface)
5085 KeyLoc, RhsT, diag::err_incomplete_type_used_in_type_trait_expr))
5092 == (lhsRecord == rhsRecord));
5098 if (rhsRecord && rhsRecord->getDecl()->isUnion())
5101 if (lhsRecord == rhsRecord)
5109 diag::err_incomplete_type_used_in_type_trait_expr))
5112 return cast<CXXRecordDecl>(rhsRecord->getDecl())
5113 ->isDerivedFrom(cast<CXXRecordDecl>(lhsRecord->
getDecl()));
5171 Expr *FromPtr = &From;
5205 diag::err_incomplete_type_used_in_type_trait_expr))
5209 diag::err_incomplete_type_used_in_type_trait_expr))
5250 return !Result.get()->hasNonTrivialCall(Self.
Context);
5253 llvm_unreachable(
"unhandled type trait");
5256 default: llvm_unreachable(
"not a BTT");
5258 llvm_unreachable(
"Unknown type trait or not implemented");
5277 assert(!T->
isDependentType() &&
"Cannot evaluate traits of dependent type");
5285 T = AT->getElementType();
5295 diag::err_dimension_expr_not_constant_integer,
5298 if (Value.isSigned() && Value.isNegative()) {
5299 Self.
Diag(KeyLoc, diag::err_dimension_expr_not_constant_integer)
5303 Dim = Value.getLimitedValue();
5307 bool Matched =
false;
5314 T = AT->getElementType();
5319 return CAT->getSize().getLimitedValue();
5325 llvm_unreachable(
"Unknown type trait or not implemented");
5368 llvm_unreachable(
"Expression trait not covered by switch");
5393 assert(!LHS.
get()->getType()->isPlaceholderType() &&
5394 !RHS.
get()->getType()->isPlaceholderType() &&
5395 "placeholders should have been weeded out by now");
5401 else if (LHS.
get()->isRValue())
5410 const char *OpSpelling = isIndirect ?
"->*" :
".*";
5418 Diag(Loc, diag::err_bad_memptr_rhs)
5419 << OpSpelling << RHSType << RHS.
get()->getSourceRange();
5438 LHSType = Ptr->getPointeeType();
5440 Diag(Loc, diag::err_bad_memptr_lhs)
5441 << OpSpelling << 1 << LHSType
5450 OpSpelling, (
int)isIndirect)) {
5455 Diag(Loc, diag::err_bad_memptr_lhs) << OpSpelling
5456 << (int)isIndirect << LHS.
get()->getType();
5462 LHSType, Class, Loc,
5476 if (isa<CXXScalarValueInitExpr>(RHS.
get()->IgnoreParens())) {
5479 Diag(Loc, diag::err_pointer_to_member_type) << isIndirect;
5498 switch (Proto->getRefQualifier()) {
5504 if (!isIndirect && !LHS.
get()->Classify(
Context).isLValue()) {
5507 if (Proto->isConst() && !Proto->isVolatile())
5509 ? diag::warn_cxx17_compat_pointer_to_const_ref_member_on_rvalue
5510 : diag::ext_pointer_to_const_ref_member_on_rvalue);
5512 Diag(Loc, diag::err_pointer_to_member_oper_value_classify)
5513 << RHSType << 1 << LHS.
get()->getSourceRange();
5518 if (isIndirect || !LHS.
get()->Classify(
Context).isRValue())
5519 Diag(Loc, diag::err_pointer_to_member_oper_value_classify)
5520 << RHSType << 0 << LHS.
get()->getSourceRange();
5535 }
else if (isIndirect) {
5538 VK = LHS.
get()->getValueKind();
5553 bool &HaveConversion,
5555 HaveConversion =
false;
5580 HaveConversion =
true;
5585 return InitSeq.
Diagnose(Self, Entity, Kind, From);
5595 bool FDerivedFromT = FRec && TRec && FRec != TRec &&
5597 if (FRec && TRec && (FRec == TRec || FDerivedFromT ||
5602 if (FRec == TRec || FDerivedFromT) {
5607 HaveConversion =
true;
5612 return InitSeq.
Diagnose(Self, Entity, Kind, From);
5630 HaveConversion = !InitSeq.
Failed();
5633 return InitSeq.
Diagnose(Self, Entity, Kind, From);
5656 LHS.
get(), Best->BuiltinParamTypes[0], Best->Conversions[0],
5663 RHS.
get(), Best->BuiltinParamTypes[1], Best->Conversions[1],
5681 Self.
Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
5682 << LHS.
get()->getType() << RHS.
get()->getType()
5683 << LHS.
get()->getSourceRange() << RHS.
get()->getSourceRange();
5687 Self.
Diag(QuestionLoc, diag::err_conditional_ambiguous_ovl)
5688 << LHS.
get()->getType() << RHS.
get()->getType()
5689 << LHS.
get()->getSourceRange() << RHS.
get()->getSourceRange();
5695 llvm_unreachable(
"Conditional operator has only built-in overloads");
5738 if (!Cond.
get()->isTypeDependent()) {
5750 if (LHS.
get()->isTypeDependent() || RHS.
get()->isTypeDependent())
5757 bool LVoid = LTy->isVoidType();
5759 if (LVoid || RVoid) {
5764 bool LThrow = isa<CXXThrowExpr>(LHS.
get()->IgnoreParenImpCasts());
5765 bool RThrow = isa<CXXThrowExpr>(RHS.
get()->IgnoreParenImpCasts());
5766 if (LThrow != RThrow) {
5767 Expr *NonThrow = LThrow ? RHS.
get() : LHS.
get();
5781 Diag(QuestionLoc, diag::err_conditional_void_nonvoid)
5782 << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1)
5783 << LHS.
get()->getSourceRange() << RHS.
get()->getSourceRange();
5797 bool HaveL2R, HaveR2L;
5804 if (HaveL2R && HaveR2L) {
5805 Diag(QuestionLoc, diag::err_conditional_ambiguous)
5806 << LTy << RTy << LHS.
get()->getSourceRange() << RHS.
get()->getSourceRange();
5816 LTy = LHS.
get()->getType();
5817 }
else if (HaveR2L) {
5820 RTy = RHS.
get()->getType();
5838 bool DerivedToBase, ObjCConversion, ObjCLifetimeConversion;
5840 QuestionLoc, LTy, RTy, DerivedToBase,
5842 !DerivedToBase && !ObjCConversion && !ObjCLifetimeConversion &&
5845 !RHS.
get()->refersToBitField() &&
5846 !RHS.
get()->refersToVectorElement()) {
5848 RTy = RHS.
get()->getType();
5850 QuestionLoc, RTy, LTy, DerivedToBase,
5852 !DerivedToBase && !ObjCConversion && !ObjCLifetimeConversion &&
5853 !LHS.
get()->refersToBitField() &&
5854 !LHS.
get()->refersToVectorElement()) {
5856 LTy = LHS.
get()->getType();
5868 if (Same && LVK == RVK && LVK !=
VK_RValue &&
5869 LHS.
get()->isOrdinaryOrBitFieldObject() &&
5870 RHS.
get()->isOrdinaryOrBitFieldObject()) {
5871 VK = LHS.
get()->getValueKind();
5878 if (LTy->isFunctionPointerType() || LTy->isMemberFunctionPointerType()) {
5884 assert(!LTy.isNull() &&
"failed to find composite pointer type for " 5885 "canonically equivalent function ptr types");
5895 if (!Same && (LTy->isRecordType() || RTy->
isRecordType())) {
5910 LTy = LHS.
get()->getType();
5911 RTy = RHS.get()->getType();
5920 if (LTy->isRecordType()) {
5942 if (LTy->isFunctionPointerType() || LTy->isMemberFunctionPointerType()) {
5944 assert(!LTy.isNull() &&
"failed to find composite pointer type for " 5945 "canonically equivalent function ptr types");
5966 diag::err_typecheck_cond_incompatible_operands) << LTy << RTy
5967 << LHS.
get()->getSourceRange() << RHS.get()->getSourceRange();
6002 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
6003 << LHS.
get()->getType() << RHS.get()->getType()
6004 << LHS.
get()->getSourceRange() << RHS.get()->getSourceRange();
6040 "computing composite pointer type of dependent types");
6055 llvm_unreachable(
"handled above");
6060 assert(EST2 ==
EST_Dynamic &&
"other cases should already be handled");
6061 llvm::SmallPtrSet<QualType, 8> Found;
6065 ExceptionTypeStorage.push_back(E);
6075 llvm_unreachable(
"shouldn't see unresolved exception specifications here");
6078 llvm_unreachable(
"invalid ExceptionSpecificationType");
6106 bool T2IsPointerLike = T2->isAnyPointerType() || T2->isMemberPointerType() ||
6107 T2->isNullPtrType();
6108 if (!T1IsPointerLike && !T2IsPointerLike)
6116 if (T1IsPointerLike &&
6120 ? CK_NullToMemberPointer
6121 : CK_NullToPointer).
get();
6124 if (T2IsPointerLike &&
6128 ? CK_NullToMemberPointer
6129 : CK_NullToPointer).
get();
6134 if (!T1IsPointerLike || !T2IsPointerLike)
6137 "nullptr_t should be a null pointer constant");
6177 unsigned NeedConstBefore = 0;
6188 NeedConstBefore = QualifierUnion.size();
6190 QualifierUnion.push_back(
6192 MemberOfClass.push_back(std::make_pair(
nullptr,
nullptr));
6205 NeedConstBefore = QualifierUnion.size();
6207 QualifierUnion.push_back(
6209 MemberOfClass.push_back(std::make_pair(MemPtr1->
getClass(),
6229 if (QualifierUnion.size() == 1) {
6245 ExceptionTypeStorage);
6248 FPT1->getParamTypes(), EPI1);
6250 FPT2->getParamTypes(), EPI2);
6255 if (NeedConstBefore) {
6259 for (
unsigned I = 0; I != NeedConstBefore; ++I)
6261 QualifierUnion[I] = QualifierUnion[I] | Qualifiers::Const;
6265 auto MOC = MemberOfClass.rbegin();
6266 for (
unsigned CVR : llvm::reverse(QualifierUnion)) {
6268 auto Classes = *MOC++;
6269 if (Classes.first && Classes.second) {
6295 : S(S), E1(E1), E2(E2), Composite(Composite),
6298 E1ToC(S, Entity, Kind, E1), E2ToC(S, Entity, Kind, E2),
6299 Viable(E1ToC && E2ToC) {}
6308 if (E2Result.isInvalid())
6310 E2 = E2Result.getAs<
Expr>();
6317 Conversion C1(*
this, Loc, E1, E2, Composite1);
6319 if (ConvertArgs && C1.perform())
6321 return C1.Composite;
6323 Conversion C2(*
this, Loc, E1, E2, Composite2);
6325 if (C1.Viable == C2.Viable) {
6333 if (ConvertArgs && (C1.Viable ? C1 : C2).perform())
6336 return C1.Viable ? C1.Composite : C2.Composite;
6343 assert(!isa<CXXBindTemporaryExpr>(E) &&
"Double-bound temporary?");
6354 bool ReturnsRetained;
6358 if (
CallExpr *Call = dyn_cast<CallExpr>(E)) {
6359 Expr *Callee = Call->getCallee()->IgnoreParens();
6365 T = BinOp->getRHS()->getType();
6366 else if (
MemberExpr *Mem = dyn_cast<MemberExpr>(Callee))
6367 T = Mem->getMemberDecl()->getType();
6378 assert(FTy &&
"call to value not of function type?");
6383 }
else if (isa<StmtExpr>(E)) {
6384 ReturnsRetained =
true;
6388 }
else if (isa<CastExpr>(E) &&
6389 isa<BlockExpr>(cast<CastExpr>(E)->getSubExpr())) {
6398 D = Send->getMethodDecl();
6399 }
else if (
ObjCBoxedExpr *BoxedExpr = dyn_cast<ObjCBoxedExpr>(E)) {
6400 D = BoxedExpr->getBoxingMethod();
6404 if (ArrayLit->getNumElements() == 0 &&
6408 D = ArrayLit->getArrayWithObjectsMethod();
6410 = dyn_cast<ObjCDictionaryLiteral>(E)) {
6413 if (DictLit->getNumElements() == 0 &&
6417 D = DictLit->getDictWithObjectsMethod();
6420 ReturnsRetained = (D && D->
hasAttr<NSReturnsRetainedAttr>());
6425 if (!ReturnsRetained &&
6436 CastKind ck = (ReturnsRetained ? CK_ARCConsumeObject
6437 : CK_ARCReclaimReturnedObject);
6452 RT = cast<RecordType>(T);
6454 case Type::ConstantArray:
6455 case Type::IncompleteArray:
6456 case Type::VariableArray:
6457 case Type::DependentSizedArray:
6458 T = cast<ArrayType>(T)->getElementType().getTypePtr();
6478 PDiag(diag::err_access_dtor_temp)
6509 assert(SubExpr &&
"subexpression can't be null!");
6531 assert(SubStmt &&
"sub-statement can't be null!");
6556 "not in a decltype expression");
6559 if (Result.isInvalid())
6573 if (
ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
6577 if (SubExpr.
get() == PE->getSubExpr())
6582 if (BO->getOpcode() == BO_Comma) {
6586 if (RHS.
get() == BO->getRHS())
6589 BO->getLHS(), RHS.
get(), BO_Comma, BO->getType(), BO->getValueKind(),
6590 BO->getObjectKind(), BO->getOperatorLoc(), BO->getFPFeatures());
6612 for (
unsigned I = 0, N =
ExprEvalContexts.back().DelayedDecltypeCalls.size();
6615 if (Call == TopCall)
6625 for (
unsigned I = 0, N =
ExprEvalContexts.back().DelayedDecltypeBinds.size();
6629 if (Bind == TopBind)
6641 PDiag(diag::err_access_dtor_temp)
6657 unsigned SkipStart = OperatorArrows.size(), SkipCount = 0;
6660 if (OperatorArrows.size() > Limit) {
6662 SkipStart = (Limit - 1) / 2 + (Limit - 1) % 2;
6663 SkipCount = OperatorArrows.size() - (Limit - 1);
6666 for (
unsigned I = 0; I < OperatorArrows.size(); ) {
6667 if (I == SkipStart) {
6668 S.
Diag(OperatorArrows[I]->getLocation(),
6669 diag::note_operator_arrows_suppressed)
6673 S.
Diag(OperatorArrows[I]->getLocation(), diag::note_operator_arrow_here)
6674 << OperatorArrows[I]->getCallResultType();
6684 bool &MayBePseudoDestructor) {
6688 Base = Result.
get();
6692 Base = Result.
get();
6695 MayBePseudoDestructor =
false;
6700 if (OpKind == tok::arrow)
6705 MayBePseudoDestructor =
true;
6712 if (OpKind == tok::arrow) {
6714 bool NoArrowOperatorFound =
false;
6715 bool FirstIteration =
true;
6718 llvm::SmallPtrSet<CanQualType,8> CTypes;
6723 if (OperatorArrows.size() >=
getLangOpts().ArrowDepth) {
6724 Diag(OpLoc, diag::err_operator_arrow_depth_exceeded)
6727 Diag(OpLoc, diag::note_operator_arrow_depth)
6740 : &NoArrowOperatorFound);
6742 if (NoArrowOperatorFound) {
6743 if (FirstIteration) {
6744 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
6747 OpKind = tok::period;
6750 Diag(OpLoc, diag::err_typecheck_member_reference_arrow)
6755 diag::note_member_reference_arrow_from_operator_arrow);
6760 Base = Result.
get();
6762 OperatorArrows.push_back(OpCall->getDirectCallee());
6765 if (!CTypes.insert(CBaseType).second) {
6766 Diag(OpLoc, diag::err_operator_arrow_circular) << StartingType;
6770 FirstIteration =
false;
6773 if (OpKind == tok::arrow) {
6777 BaseType = AT->getElementType();
6799 MayBePseudoDestructor =
true;
6827 Base = result.
get();
6837 if (OpKind == tok::arrow) {
6842 S.
Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
6843 << ObjectType <<
true 6848 OpKind = tok::period;
6862 if (RD->hasDefinition())
6884 if (
CheckArrow(*
this, ObjectType, Base, OpKind, OpLoc))
6892 Diag(OpLoc, diag::err_pseudo_dtor_base_not_scalar)
6901 if (DestructedTypeInfo) {
6914 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
6919 *
this, DestructedType))
6924 ObjectType = DestructedType;
6925 OpKind = tok::arrow;
6927 Diag(DestructedTypeStart, diag::err_pseudo_dtor_type_mismatch)
6932 DestructedType = ObjectType;
6933 DestructedTypeInfo =
6944 Diag(DestructedTypeStart, diag::err_arc_pseudo_dtor_inconstant_quals)
6950 DestructedType = ObjectType;
6952 DestructedTypeStart);
6965 if (ScopeTypeInfo) {
6971 diag::err_pseudo_dtor_type_mismatch)
6976 ScopeTypeInfo =
nullptr;
6982 OpKind == tok::arrow, OpLoc,
7002 "Invalid first type name in pseudo-destructor");
7005 "Invalid second type name in pseudo-destructor");
7008 if (
CheckArrow(*
this, ObjectType, Base, OpKind, OpLoc))
7029 S, &SS,
true,
false, ObjectTypePtrForLookup,
7042 diag::err_pseudo_dtor_destructor_non_type)
7048 DestructedType = ObjectType;
7066 if (T.isInvalid() || !T.get()) {
7068 DestructedType = ObjectType;
7075 if (!DestructedType.
isNull()) {
7076 if (!DestructedTypeInfo)
7090 S, &SS,
true,
false, ObjectTypePtrForLookup,
7094 diag::err_pseudo_dtor_destructor_non_type)
7119 if (T.isInvalid() || !T.get()) {
7127 if (!ScopeType.
isNull() && !ScopeTypeInfo)
7133 ScopeTypeInfo, CCLoc, TildeLoc,
7143 if (
CheckArrow(*
this, ObjectType, Base, OpKind, OpLoc))
7162 bool HadMultipleCandidates) {
7180 SubE = BE->getSubExpr();
7181 if (isa<LambdaExpr>(SubE)) {
7191 Exp.
get()->getExprLoc(), Exp.
get()->getExprLoc(), Method, Exp.
get());
7195 Diag(Exp.
get()->getExprLoc(), diag::note_lambda_to_block_conv);
7209 ResultType = ResultType.getNonLValueExprType(
Context);
7212 Context, ME, {}, ResultType, VK, Exp.
get()->getEndLoc());
7214 if (CheckFunctionCall(Method, CE,
7236 Diag(Operand->
getExprLoc(), diag::warn_side_effects_unevaluated_context);
7258 if (isa<DeclRefExpr>(E))
7262 if (isa<ArraySubscriptExpr>(E))
7266 if (isa<MemberExpr>(E))
7271 if (UO->getOpcode() == UO_Deref)
7276 if (BO->isPtrMemOp())
7280 if (BO->getOpcode() == BO_Comma)
7291 dyn_cast<BinaryConditionalOperator>(E)) {
7292 if (
OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(BCO->getTrueExpr()))
7298 if (isa<PseudoObjectExpr>(E) || isa<ObjCIvarRefExpr>(E))
7356 if (!T->getDecl()->isComplete()) {
7370 diag::err_incomplete_type);
7388 if (isa<ParmVarDecl>(Var))
return true;
7389 const VarDecl *DefVD =
nullptr;
7394 if (DefVD->
isWeak())
return false;
7423 while (DC && isa<CapturedDecl>(DC))
7427 "The current call operator must be synchronized with Sema's CurContext");
7448 !IsFullExprInstantiationDependent)
7458 const bool IsVarNeverAConstantExpression =
7460 if (!IsFullExprInstantiationDependent || IsVarNeverAConstantExpression) {
7472 DeclRefType,
nullptr)) {
7478 DeclRefType,
nullptr);
7490 const unsigned FunctionScopeIndexOfCapturableLambda = Index.getValue();
7493 &FunctionScopeIndexOfCapturableLambda);
7516 R.setLookupName(ND->getDeclName());
7518 if (ND->isCXXClassMember()) {
7522 Record = NNS->getAsType()->getAsCXXRecordDecl();
7525 dyn_cast<
CXXRecordDecl>(ND->getDeclContext()->getRedeclContext());
7527 R.setNamingClass(Record);
7531 bool MightBeImplicitMember;
7533 MightBeImplicitMember =
true;
7535 MightBeImplicitMember =
false;
7536 else if (R.isOverloadedResult())
7537 MightBeImplicitMember =
false;
7538 else if (R.isUnresolvableResult())
7539 MightBeImplicitMember =
true;
7541 MightBeImplicitMember = isa<FieldDecl>(ND) ||
7542 isa<IndirectFieldDecl>(ND) ||
7543 isa<MSPropertyDecl>(ND);
7545 if (MightBeImplicitMember)
7549 }
else if (
auto *Ivar = dyn_cast<ObjCIvarDecl>(ND)) {
7551 Ivar->getIdentifier());
7565 : TypoExprs(TypoExprs) {}
7567 TypoExprs.insert(TE);
7572 class TransformTypos :
public TreeTransform<TransformTypos> {
7577 llvm::function_ref<ExprResult(Expr *)> ExprFilter;
7579 llvm::SmallDenseMap<TypoExpr *, ExprResult, 2> TransformCache;
7580 llvm::SmallDenseMap<OverloadExpr *, Expr *, 4> OverloadResolution;
7586 void EmitAllDiagnostics() {
7588 auto &
State = SemaRef.getTypoExprState(TE);
7589 if (
State.DiagHandler) {
7599 Replacement.
isInvalid() ? nullptr : Replacement.
get()))
7602 State.DiagHandler(TC);
7604 SemaRef.clearDelayedTypo(TE);
7617 bool CheckAndAdvanceTypoExprCorrectionStreams() {
7618 for (
auto TE : TypoExprs) {
7619 auto &
State = SemaRef.getTypoExprState(TE);
7620 TransformCache.erase(TE);
7621 if (!
State.Consumer->finished())
7623 State.Consumer->resetCorrectionStream();
7629 if (
auto *OE = dyn_cast_or_null<OverloadExpr>(E))
7630 E = OverloadResolution[OE];
7634 if (
auto *DRE = dyn_cast<DeclRefExpr>(E))
7635 return DRE->getFoundDecl();
7636 if (
auto *ME = dyn_cast<MemberExpr>(E))
7650 return ExprFilter(Res.
get());
7655 : BaseTransform(SemaRef), InitDecl(InitDecl), ExprFilter(
Filter) {}
7660 Expr *ExecConfig =
nullptr) {
7661 auto Result = BaseTransform::RebuildCallExpr(Callee, LParenLoc, Args,
7662 RParenLoc, ExecConfig);
7663 if (
auto *OE = dyn_cast<OverloadExpr>(Callee)) {
7666 if (
auto *BE = dyn_cast<CXXBindTemporaryExpr>(ResultCall))
7667 ResultCall = BE->getSubExpr();
7668 if (
auto *CE = dyn_cast<CallExpr>(ResultCall))
7669 OverloadResolution[OE] = CE->getCallee();
7682 Res = TryTransform(E);
7687 !CheckAndAdvanceTypoExprCorrectionStreams())
7700 while (!AmbiguousTypoExprs.empty()) {
7701 auto TE = AmbiguousTypoExprs.back();
7702 auto Cached = TransformCache[TE];
7704 State.Consumer->saveCurrentPosition();
7705 TransformCache.erase(TE);
7707 State.Consumer->resetCorrectionStream();
7708 TransformCache.erase(TE);
7712 AmbiguousTypoExprs.remove(TE);
7713 State.Consumer->restoreSavedPosition();
7714 TransformCache[TE] = Cached;
7720 FindTypoExprs(TypoExprs).TraverseStmt(E);
7722 EmitAllDiagnostics();
7731 auto &CacheEntry = TransformCache[E];
7732 if (!TypoExprs.insert(E) && !CacheEntry.isUnset()) {
7737 assert(
State.Consumer &&
"Cannot transform a cleared TypoExpr");
7742 if (InitDecl && TC.getFoundDecl() == InitDecl)
7747 State.RecoveryHandler(SemaRef, E, TC) :
7754 if ((Next =
State.Consumer->peekNextCorrection()) &&
7756 AmbiguousTypoExprs.insert(E);
7758 AmbiguousTypoExprs.remove(E);
7761 "Typo was transformed into a valid-but-null ExprResult");
7762 return CacheEntry = NE;
7779 auto TyposResolved = DelayedTypos.size();
7780 auto Result = TransformTypos(*
this, InitDecl,
Filter).Transform(E);
7781 TyposResolved -= DelayedTypos.size();
7786 assert(TyposResolved == 0 &&
"Corrected typo but got same Expr back?");
7792 bool DiscardedValue,
7796 if (!FullExpr.
get())
7802 if (DiscardedValue) {
7823 if (FullExpr.isInvalid())
7826 CheckCompletedExpr(FullExpr.get(), CC, IsConstexpr);
7875 while (DC && isa<CapturedDecl>(DC))
7878 if (IsInLambdaDeclContext && CurrentLSI &&
7879 CurrentLSI->hasPotentialCaptures() && !FullExpr.isInvalid())
7923 llvm_unreachable(
"Invalid LookupResult Kind!");
static bool CheckArrow(Sema &S, QualType &ObjectType, Expr *&Base, tok::TokenKind &OpKind, SourceLocation OpLoc)
A call to an overloaded operator written using operator syntax.
Function pointer conversion (C++17 [conv.fctptr])
DeclAccessPair FoundConversionFunction
The declaration that we found via name lookup, which might be the same as ConversionFunction or it mi...
Defines the clang::ASTContext interface.
void diagnoseUnavailableAlignedAllocation(const FunctionDecl &FD, SourceLocation Loc)
Produce diagnostics if FD is an aligned allocation or deallocation function that is unavailable...
CanThrowResult canThrow(const Expr *E)
unsigned DeprecatedStringLiteralToCharPtr
Whether this is the deprecated conversion of a string literal to a pointer to non-const character dat...
QualType getCurrentThisType()
Try to retrieve the type of the 'this' pointer.
This is the scope of a C++ try statement.
ExprResult ActOnArrayTypeTrait(ArrayTypeTrait ATT, SourceLocation KWLoc, ParsedType LhsTy, Expr *DimExpr, SourceLocation RParen)
ActOnArrayTypeTrait - Parsed one of the binary type trait support pseudo-functions.
The null pointer literal (C++11 [lex.nullptr])
void clearPotentialCaptures()
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
void setImplicit(bool I=true)
Represents a function declaration or definition.
bool FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD, DeclarationName Name, FunctionDecl *&Operator, bool Diagnose=true)
Name lookup found a set of overloaded functions that met the criteria.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
bool EllipsisConversion
EllipsisConversion - When this is true, it means user-defined conversion sequence starts with a ...
Expr * getInit() const
Get the initializer.
static FunctionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation NLoc, DeclarationName N, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool isInlineSpecified=false, bool hasWrittenPrototype=true, ConstexprSpecKind ConstexprKind=CSK_unspecified)
static bool EvaluateExpressionTrait(ExpressionTrait ET, Expr *E)
SourceRange getCorrectionRange() const
ExprResult PerformContextuallyConvertToBool(Expr *From)
PerformContextuallyConvertToBool - Perform a contextual conversion of the expression From to bool (C+...
no exception specification
QualType getObjCIdType() const
Represents the Objective-CC id type.
SourceLocation getLastQualifierNameLoc() const
Retrieve the location of the name in the last qualifier in this nested name specifier.
void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl=nullptr, ExpressionEvaluationContextRecord::ExpressionKind Type=ExpressionEvaluationContextRecord::EK_Other)
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
Stores the type being destroyed by a pseudo-destructor expression.
A (possibly-)qualified type.
bool isBlockPointerType() const
This is a scope that corresponds to the parameters within a function prototype.
Simple class containing the result of Sema::CorrectTypo.
static bool IsSpecialDiscardedValue(Expr *E)
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
bool isMemberPointerType() const
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
ConditionResult ActOnConditionVariable(Decl *ConditionVar, SourceLocation StmtLoc, ConditionKind CK)
bool CheckExceptionSpecCompatibility(Expr *From, QualType ToType)
bool checkLiteralOperatorId(const CXXScopeSpec &SS, const UnqualifiedId &Id)
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
static InitializedEntity InitializeException(SourceLocation ThrowLoc, QualType Type, bool NRVO)
Create the initialization entity for an exception object.
bool isUnavailableAlignedAllocationFunction(const FunctionDecl &FD) const
Determine whether FD is an aligned allocation or deallocation function that is unavailable.
SourceLocation StartLocation
The location of the first token that describes this unqualified-id, which will be the location of the...
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
const DeclaratorChunk & getTypeObject(unsigned i) const
Return the specified TypeInfo from this declarator.
bool isMemberDataPointerType() const
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...
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
IdentifierInfo * Name
FIXME: Temporarily stores the name of a specialization.
void setLookupName(DeclarationName Name)
Sets the name to look up.
SourceLocation TemplateNameLoc
TemplateNameLoc - The location of the template name within the source.
static ConditionResult ConditionError()
QualType CXXThisTypeOverride
When non-NULL, the C++ 'this' expression is allowed despite the current context not being a non-stati...
bool isArithmeticType() const
Stmt - This represents one statement.
IdentifierInfo * Identifier
When Kind == IK_Identifier, the parsed identifier, or when Kind == IK_UserLiteralId, the identifier suffix.
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
bool isGenericLambdaCallOperatorSpecialization(const CXXMethodDecl *MD)
FunctionType - C99 6.7.5.3 - Function Declarators.
FullExprArg MakeFullExpr(Expr *Arg)
Provides information about an attempted template argument deduction, whose success or failure was des...
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 getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Microsoft __if_not_exists.
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
bool isRealFloatingType() const
Floating point categories.
bool hasPlaceholderType() const
Returns whether this expression has a placeholder type.
QualType getThisType() const
Return the type of the this pointer.
void addConst()
Add the const type qualifier to this QualType.
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in...
ExprResult BuildCXXTypeConstructExpr(TypeSourceInfo *Type, SourceLocation LParenLoc, MultiExprArg Exprs, SourceLocation RParenLoc, bool ListInitialization)
Complex conversions (C99 6.3.1.6)
bool isRecordType() const
unsigned getTypeAlignIfKnown(QualType T) const
Return the ABI-specified alignment of a type, in bits, or 0 if the type is incomplete and we cannot d...
bool isEmpty() const
No scope specifier.
static InitializedEntity InitializeParameter(ASTContext &Context, const ParmVarDecl *Parm)
Create the initialization entity for a parameter.
UserDefinedConversionSequence UserDefined
When ConversionKind == UserDefinedConversion, provides the details of the user-defined conversion seq...
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
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.
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type...
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
bool hasIrrelevantDestructor() const
Determine whether this class has a destructor which has no semantic effect.
bool DiagnoseConditionalForNull(Expr *LHSExpr, Expr *RHSExpr, SourceLocation QuestionLoc)
Emit a specialized diagnostic when one expression is a null pointer constant and the other is not a p...
Decl - This represents one declaration (or definition), e.g.
bool isVariadic() const
Whether this function prototype is variadic.
ExprResult ActOnNoexceptExpr(SourceLocation KeyLoc, SourceLocation LParen, Expr *Operand, SourceLocation RParen)
bool isExtVectorType() const
AssignConvertType
AssignConvertType - All of the 'assignment' semantic checks return this enum to indicate whether the ...
ExprResult PerformContextualImplicitConversion(SourceLocation Loc, Expr *FromE, ContextualImplicitConverter &Converter)
Perform a contextual implicit conversion.
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS, bool AllowBuiltinCreation=false, bool EnteringContext=false)
Performs name lookup for a name that was parsed in the source code, and may contain a C++ scope speci...
OverloadedOperatorKind getCXXOverloadedOperator() const
If this name is the name of an overloadable operator in C++ (e.g., operator+), retrieve the kind of o...
ExprResult BuildBlockForLambdaConversion(SourceLocation CurrentLocation, SourceLocation ConvLocation, CXXConversionDecl *Conv, Expr *Src)
ParenExpr - This represents a parethesized expression, e.g.
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
ExprResult forceUnknownAnyToType(Expr *E, QualType ToType)
Force an expression with unknown-type to an expression of the given type.
static InitializationKind CreateDirect(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc)
Create a direct initialization.
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined...
The base class of the type hierarchy.
This indicates that the scope corresponds to a function, which means that labels are set here...
unsigned IncompatibleObjC
IncompatibleObjC - Whether this is an Objective-C conversion that we should warn about (if we actuall...
One instance of this struct is used for each type in a declarator that is parsed. ...
Represents an array type, per C99 6.7.5.2 - Array Declarators.
The template argument is a declaration that was provided for a pointer, reference, or pointer to member non-type template parameter.
static InitializationKind CreateDefault(SourceLocation InitLoc)
Create a default initialization.
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 ...
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Represents a call to a C++ constructor.
static ExprValueKind getValueKindForType(QualType T)
getValueKindForType - Given a formal return or parameter type, give its value kind.
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent...
SourceLocation getEndLoc() const LLVM_READONLY
Ambiguous candidates found.
QualType withConst() const
Incompatible - We reject this conversion outright, it is invalid to represent it in the AST...
const TargetInfo & getTargetInfo() const
A container of type source information.
static bool evaluateTypeTrait(Sema &S, TypeTrait Kind, SourceLocation KWLoc, ArrayRef< TypeSourceInfo *> Args, SourceLocation RParenLoc)
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
QualType getLogicalOperationType() const
The result type of logical operations, '<', '>', '!=', etc.
capture_const_range captures() const
Conversions between compatible types in C99.
bool isDefined(const FunctionDecl *&Definition) const
Returns true if the function has a definition that does not need to be instantiated.
static CXXFunctionalCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, TypeSourceInfo *Written, CastKind Kind, Expr *Op, const CXXCastPath *Path, SourceLocation LPLoc, SourceLocation RPLoc)
ExprResult ActOnExpressionTrait(ExpressionTrait OET, SourceLocation KWLoc, Expr *Queried, SourceLocation RParen)
ActOnExpressionTrait - Parsed one of the unary type trait support pseudo-functions.
const Expr * getAnyInitializer() const
Get the initializer for this variable, no matter which declaration it is attached to...
QualType getConversionType() const
Returns the type that this conversion function is converting to.
Represents a C++ constructor within a class.
LLVM_ATTRIBUTE_REINITIALIZES void clear()
Clears out any current state.
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, C99 6.9p3)
bool isVariableExprMarkedAsNonODRUsed(Expr *CapturingVarExpr) const
bool hasInClassInitializer() const
Determine whether this member has a C++11 default member initializer.
size_t param_size() const
static InitializedEntity InitializeTemporary(QualType Type)
Create the initialization entity for a temporary.
unsigned getTypeAlign(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in bits.
bool isTrivialType(const ASTContext &Context) const
Return true if this is a trivial type per (C++0x [basic.types]p9)
bool DisableTypoCorrection
Tracks whether we are in a context where typo correction is disabled.
An identifier, stored as an IdentifierInfo*.
bool isUnsignedIntegerType() const
Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...
This file provides some common utility functions for processing Lambda related AST Constructs...
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
RAII object that enters a new expression evaluation context.
Represents a variable declaration or definition.
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
bool isStructureType() const
bool hasPotentialThisCapture() const
ExprResult PerformObjectArgumentInitialization(Expr *From, NestedNameSpecifier *Qualifier, NamedDecl *FoundDecl, CXXMethodDecl *Method)
PerformObjectArgumentInitialization - Perform initialization of the implicit object parameter for the...
static ExprResult attemptRecovery(Sema &SemaRef, const TypoCorrectionConsumer &Consumer, const TypoCorrection &TC)
IfExistsResult
Describes the result of an "if-exists" condition check.
CleanupInfo Cleanup
Used to control the generation of ExprWithCleanups.
DeclarationName getLookupName() const
Gets the name to look up.
Information about one declarator, including the parsed type information and the identifier.
QualType getReturnType() const
DiagnosticsEngine & Diags
static QualType adjustCVQualifiersForCXXThisWithinLambda(ArrayRef< FunctionScopeInfo *> FunctionScopes, QualType ThisTy, DeclContext *CurSemaContext, ASTContext &ASTCtx)
unsigned getNumParams() const
bool isEnumeralType() const
bool isFixed() const
Returns true if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying...
const T * getAs() const
Member-template getAs<specific type>'.
bool isDirectReferenceBinding() const
Determine whether this initialization is a direct reference binding (C++ [dcl.init.ref]).
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
Extra information about a function prototype.
AccessResult CheckDestructorAccess(SourceLocation Loc, CXXDestructorDecl *Dtor, const PartialDiagnostic &PDiag, QualType objectType=QualType())
LangAS
Defines the address space values used by the address space qualifier of QualType. ...
static bool hasNewExtendedAlignment(Sema &S, QualType AllocType)
Determine whether a type has new-extended alignment.
RAII class that determines when any errors have occurred between the time the instance was created an...
ObjCMethodDecl - Represents an instance or class method declaration.
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)
NestedNameSpecifier * getCorrectionSpecifier() const
Gets the NestedNameSpecifier needed to use the typo correction.
A namespace, stored as a NamespaceDecl*.
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 ...
bool HadMultipleCandidates
HadMultipleCandidates - When this is true, it means that the conversion function was resolved from an...
bool isInvalidDecl() const
static InitializationKind CreateDirectList(SourceLocation InitLoc)
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
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, IdentifierInfo **CorrectedII=nullptr)
If the identifier refers to a type name within this scope, return the declaration of that type...
bool tryCaptureVariable(VarDecl *Var, SourceLocation Loc, TryCaptureKind Kind, SourceLocation EllipsisLoc, bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType, const unsigned *const FunctionScopeIndexToStopAt)
Try to capture the given variable.
A C++ throw-expression (C++ [except.throw]).
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[]...
Defines the clang::Expr interface and subclasses for C++ expressions.
noexcept(expression), value-dependent
enum clang::DeclaratorChunk::@217 Kind
bool isStandardLayoutType() const
Test if this type is a standard-layout type.
The collection of all-type qualifiers we support.
Information about a template-id annotation token.
ExprResult PerformImplicitConversion(Expr *From, QualType ToType, AssignmentAction Action, bool AllowExplicit=false)
PerformImplicitConversion - Perform an implicit conversion of the expression From to the type ToType...
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
void setCorrectionDecl(NamedDecl *CDecl)
Clears the list of NamedDecls before adding the new one.
bool isMoveAssignmentOperator() const
Determine whether this is a move assignment operator.
static CXXUnresolvedConstructExpr * Create(const ASTContext &Context, TypeSourceInfo *Type, SourceLocation LParenLoc, ArrayRef< Expr *> Args, SourceLocation RParenLoc)
Expr * FixOverloadedFunctionReference(Expr *E, DeclAccessPair FoundDecl, FunctionDecl *Fn)
FixOverloadedFunctionReference - E is an expression that refers to a C++ overloaded function (possibl...
Represents a struct/union/class.
QualType adjustCCAndNoReturn(QualType ArgFunctionType, QualType FunctionType, bool AdjustExceptionSpec=false)
Adjust the type ArgFunctionType to match the calling convention, noreturn, and optionally the excepti...
QualType FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
FindCompositeObjCPointerType - Helper method to find composite type of two objective-c pointer types ...
static bool ConvertForConditional(Sema &Self, ExprResult &E, QualType T)
Perform an "extended" implicit conversion as returned by TryClassUnification.
uint64_t getPointerWidth(unsigned AddrSpace) const
Return the width of pointers on this target, for the specified address space.
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.
TemplateIdAnnotation * TemplateId
When Kind == IK_TemplateId or IK_ConstructorTemplateId, the template-id annotation that contains the ...
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Boolean conversions (C++ [conv.bool])
FunctionType::ExtInfo ExtInfo
Represents a class template specialization, which refers to a class template with a given set of temp...
One of these records is kept for each identifier that is lexed.
void setIntegerType(QualType T)
Set the underlying integer type.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
void visitPotentialCaptures(llvm::function_ref< void(VarDecl *, Expr *)> Callback) const
DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name)
Retrieves the declaration name from a parsed unqualified-id.
void DiagnoseUnusedExprResult(const Stmt *S)
DiagnoseUnusedExprResult - If the statement passed in is an expression whose result is unused...
bool isNothrow(bool ResultIfDependent=false) const
Determine whether this function type has a non-throwing exception specification.
Represents a class type in Objective C.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
void DropFirstTypeObject()
A C++ nested-name-specifier augmented with source location information.
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
Represents a dependent template name that cannot be resolved prior to template instantiation.
The results of name lookup within a DeclContext.
SourceLocation getTypeSpecTypeLoc() const
bool allowsNonTrivialObjCLifetimeQualifiers() const
True if any ObjC types may have non-trivial lifetime qualifiers.
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
FullExpr - Represents a "full-expression" node.
bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base)
Determine whether the type Derived is a C++ class that is derived from the type Base.
QualType getLifetimeQualifiedType(QualType type, Qualifiers::ObjCLifetime lifetime)
Return a type with the given lifetime qualifier.
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
SourceLocation getBeginLoc() const LLVM_READONLY
Represents a member of a struct/union/class.
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
The current expression is potentially evaluated at run time, which means that code may be generated t...
Identity conversion (no conversion)
unsigned getNewAlign() const
Return the largest alignment for which a suitably-sized allocation with '::operator new(size_t)' is g...
void setVisibleDespiteOwningModule()
Set that this declaration is globally visible, even if it came from a module that is not visible...
bool isAbstractType(SourceLocation Loc, QualType T)
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
bool hasAutoTypeSpec() const
Floating point conversions (C++ [conv.double].
bool isReferenceType() const
CXXRecordDecl * getStdBadAlloc() const
void setArg(unsigned Arg, Expr *ArgExpr)
setArg - Set the specified argument.
bool hasTrivialMoveAssignment() const
Determine whether this class has a trivial move assignment operator (C++11 [class.copy]p25)
The iterator over UnresolvedSets.
static const TST TST_error
ExprResult ActOnCXXUuidof(SourceLocation OpLoc, SourceLocation LParenLoc, bool isType, void *TyOrExpr, SourceLocation RParenLoc)
ActOnCXXUuidof - Parse __uuidof( something ).
ExprResult BuildArrayTypeTrait(ArrayTypeTrait ATT, SourceLocation KWLoc, TypeSourceInfo *TSInfo, Expr *DimExpr, SourceLocation RParen)
ExprResult ActOnCXXNullPtrLiteral(SourceLocation Loc)
ActOnCXXNullPtrLiteral - Parse 'nullptr'.
static bool resolveAllocationOverload(Sema &S, LookupResult &R, SourceRange Range, SmallVectorImpl< Expr *> &Args, bool &PassAlignment, FunctionDecl *&Operator, OverloadCandidateSet *AlignedCandidates, Expr *AlignArg, bool Diagnose)
OpaquePtr< QualType > ParsedType
An opaque type for threading parsed type information through the parser.
LookupResultKind getResultKind() const
ParsedType getDestructorName(SourceLocation TildeLoc, IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec &SS, ParsedType ObjectType, bool EnteringContext)
SourceLocation getBeginLoc() const LLVM_READONLY
ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp, [NSNumber numberWithInt:42]];.
ExprResult DefaultFunctionArrayConversion(Expr *E, bool Diagnose=true)
DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).
void PopExpressionEvaluationContext()
bool isAtLeastAsQualifiedAs(QualType Other) const
Determine whether this type is at least as qualified as the other given type, requiring exact equalit...
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
A user-defined literal name, e.g., operator "" _i.
Stmt * MaybeCreateStmtWithCleanups(Stmt *SubStmt)
void NoteDeletedFunction(FunctionDecl *FD)
Emit a note explaining that this function is deleted.
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
bool isInvalidType() const
bool isDependentName() const
Determines whether the name itself is dependent, e.g., because it involves a C++ type that is itself ...
bool getProducesResult() const
DeclClass * getAsSingle() const
Floating point promotions (C++ [conv.fpprom])
ExprResult ActOnStartCXXMemberReference(Scope *S, Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, ParsedType &ObjectType, bool &MayBePseudoDestructor)
ObjCMethodFamily getMethodFamily() const
Determines the family of this method.
bool isReplaceableGlobalAllocationFunction(bool *IsAligned=nullptr) const
Determines whether this function is one of the replaceable global allocation functions: void *operato...
Describes an C or C++ initializer list.
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
This is a scope that corresponds to a block/closure object.
ExprResult ActOnCXXThrow(Scope *S, SourceLocation OpLoc, Expr *expr)
ActOnCXXThrow - Parse throw expressions.
Represents a C++ unqualified-id that has been parsed.
bool CanUseDecl(NamedDecl *D, bool TreatUnavailableAsInvalid)
Determine whether the use of this declaration is valid, without emitting diagnostics.
bool isCompleteType(SourceLocation Loc, QualType T)
IdentifierInfo * getAsIdentifier() const
Retrieve the identifier stored in this nested name specifier.
void setNameLoc(SourceLocation Loc)
NamespaceDecl * getOrCreateStdNamespace()
Retrieve the special "std" namespace, which may require us to implicitly define the namespace...
Represents the results of name lookup.
void DeclareGlobalNewDelete()
DeclareGlobalNewDelete - Declare the global forms of operator new and delete.
An lvalue ref-qualifier was provided (&).
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
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...
CharUnits - This is an opaque type for sizes expressed in character units.
bool isItaniumFamily() const
Does this ABI generally fall into the Itanium family of ABIs?
DeclRefExpr * BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, SourceLocation Loc, const CXXScopeSpec *SS=nullptr)
Microsoft throw(...) extension.
ReferenceCompareResult CompareReferenceRelationship(SourceLocation Loc, QualType T1, QualType T2, bool &DerivedToBase, bool &ObjCConversion, bool &ObjCLifetimeConversion)
CompareReferenceRelationship - Compare the two types T1 and T2 to determine whether they are referenc...
Succeeded, but refers to a deleted function.
bool CheckCXXThrowOperand(SourceLocation ThrowLoc, QualType ThrowTy, Expr *E)
CheckCXXThrowOperand - Validate the operand of a throw.
Ref_Compatible - The two types are reference-compatible.
bool isTriviallyCopyableType(const ASTContext &Context) const
Return true if this is a trivially copyable type (C++0x [basic.types]p9)
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, 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...
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...
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
Represents a declaration of a type.
A builtin binary operation expression such as "x + y" or "x <= y".
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
static CompoundStmt * Create(const ASTContext &C, ArrayRef< Stmt *> Stmts, SourceLocation LB, SourceLocation RB)
ImplicitConversionKind Second
Second - The second conversion can be an integral promotion, floating point promotion, integral conversion, floating point conversion, floating-integral conversion, pointer conversion, pointer-to-member conversion, or boolean conversion.
QualType getExceptionObjectType(QualType T) const
A conversion for an operand of a builtin overloaded operator.
ParsedTemplateArgument * getTemplateArgs()
Retrieves a pointer to the template arguments.
static InitializationKind CreateValue(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc, bool isImplicit=false)
Create a value initialization.
const Type * getClass() const
bool isRValueReferenceType() const
CheckedConversionKind
The kind of conversion being performed.
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...
LazyDeclPtr StdBadAlloc
The C++ "std::bad_alloc" class, which is defined by the C++ standard library.
IfExistsResult CheckMicrosoftIfExistsSymbol(Scope *S, CXXScopeSpec &SS, const DeclarationNameInfo &TargetNameInfo)
bool isLambda() const
Determine whether this class describes a lambda function object.
DeclContext * getLambdaAwareParentOfDeclContext(DeclContext *DC)
Scope - A scope is a transient data structure that is used while parsing the program.
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...
QualType getCVRQualifiedType(QualType T, unsigned CVR) const
Return a type with additional const, volatile, or restrict qualifiers.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
New-expression has a C++98 paren-delimited initializer.
TypoExpr - Internal placeholder for expressions where typo correction still needs to be performed and...
Qualification conversions (C++ [conv.qual])
static unsigned getNumAddressingBits(const ASTContext &Context, QualType ElementType, const llvm::APInt &NumElements)
Determine the number of bits required to address a member of.
ExprResult ActOnCXXThis(SourceLocation loc)
Represents a C++ nested-name-specifier or a global scope specifier.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
ExprResult CheckSwitchCondition(SourceLocation SwitchLoc, Expr *Cond)
Represents binding an expression to a temporary.
ArrayTypeTrait
Names for the array type traits.
CXXTemporary * getTemporary()
AccessResult CheckConstructorAccess(SourceLocation Loc, CXXConstructorDecl *D, DeclAccessPair FoundDecl, const InitializedEntity &Entity, bool IsCopyBindingRefToTemp=false)
Checks access to a constructor.
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
const LangOptions & getLangOpts() const
static FunctionProtoType::ExceptionSpecInfo mergeExceptionSpecs(Sema &S, FunctionProtoType::ExceptionSpecInfo ESI1, FunctionProtoType::ExceptionSpecInfo ESI2, SmallVectorImpl< QualType > &ExceptionTypeStorage)
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'.
bool isTypeDependent() const
isTypeDependent - Determines whether this expression is type-dependent (C++ [temp.dep.expr]), which means that its type could change from one template instantiation to the next.
ExprResult DefaultFunctionArrayLvalueConversion(Expr *E, bool Diagnose=true)
bool isScalarType() const
An ordinary object is located at an address in memory.
bool isLambdaCallOperator(const CXXMethodDecl *MD)
SmallVector< BoundNodes, 1 > match(MatcherT Matcher, const NodeT &Node, ASTContext &Context)
Returns the results of matching Matcher on Node.
The number of conversion kinds.
A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5...
Represents an ObjC class declaration.
FieldDecl * getMember() const
If this is a member initializer, returns the declaration of the non-static data member being initiali...
CastKind PrepareScalarCast(ExprResult &src, QualType destType)
Prepares for a scalar cast, performing all the necessary stages except the final cast and returning t...
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface...
ImplicitConversionKind Third
Third - The third conversion can be a qualification conversion or a function conversion.
bool isAbstract() const
Determine whether this class has a pure virtual function.
ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context...
Integral promotions (C++ [conv.prom])
const LangOptions & LangOpts
bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType)
Helper function to determine whether this is the (deprecated) C++ conversion from a string literal to...
CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod, bool IsBuiltin=false) const
Retrieves the default calling convention for the current target.
This object can be modified without requiring retains or releases.
SourceLocation TemplateKWLoc
TemplateKWLoc - The location of the template keyword.
Represents the this expression in C++.
C-only conversion between pointers with incompatible types.
New-expression has no initializer as written.
static InitializedEntity InitializeNew(SourceLocation NewLoc, QualType Type)
Create the initialization entity for an object allocated via new.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
TypeTrait
Names for traits that operate specifically on types.
SourceLocation LAngleLoc
The location of the '<' before the template argument list.
RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
bool isAmbiguous() const
Determine whether this initialization failed due to an ambiguity.
ExprResult TemporaryMaterializationConversion(Expr *E)
If E is a prvalue denoting an unmaterialized temporary, materialize it as an xvalue.
unsigned getFlags() const
getFlags - Return the flags for this scope.
ConditionalOperator - The ?: ternary operator.
Sema - This implements semantic analysis and AST building for C.
NamedDecl * getFoundDecl() const
Get the correction declaration found by name lookup (before we looked through using shadow declaratio...
Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
CompoundStmt - This represents a group of statements like { stmt stmt }.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Represents a prototype with parameter type info, e.g.
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
bool isUsableInConstantExpressions(ASTContext &C) const
Determine whether this variable's value can be used in a constant expression, according to the releva...
static NamedDecl * getDeclFromExpr(Expr *E)
SourceLocation getBeginLoc() const LLVM_READONLY
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any...
Transparent Union Conversions.
CastKind
CastKind - The kind of operation required for a conversion.
SourceRange getLocalSourceRange() const
Get the local source range.
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat)
DeclarationNameTable DeclarationNames
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...
Defines a function that returns the minimum OS versions supporting C++17's aligned allocation functio...
SourceRange getRange() const
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
SourceLocation PotentialThisCaptureLocation
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location, which defaults to the empty location.
unsigned getEditDistance(bool Normalized=true) const
Gets the "edit distance" of the typo correction from the typo.
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...
TST getTypeSpecType() const
bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const
HasSideEffects - This routine returns true for all those expressions which have any effect other than...
An Objective-C property is a logical field of an Objective-C object which is read and written via Obj...
bool isUsualDeallocationFunction(const CXXMethodDecl *FD)
unsigned hasStatic
True if this dimension included the 'static' keyword.
SourceLocation getBeginLoc() const
Get the begin source location.
An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type...
CXXMethodDecl * CallOperator
The lambda's compiler-generated operator().
QualType getElementType() const
bool isWeak() const
Determine whether this symbol is weakly-imported, or declared with the weak or weak-ref attr...
DeclAccessPair getFoundDecl() const
Retrieves the declaration found by lookup.
This represents one expression.
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.
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
static ExprResult BuildCXXCastArgument(Sema &S, SourceLocation CastLoc, QualType Ty, CastKind Kind, CXXMethodDecl *Method, DeclAccessPair FoundDecl, bool HadMultipleCandidates, Expr *From)
bool isVariadic() const
Whether this function is variadic.
llvm::StringRef getAsString(SyncScope S)
bool isDeclScope(Decl *D)
isDeclScope - Return true if this is the scope that the specified decl is declared in...
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
unsigned getIntWidth() const
getIntWidth/Align - Return the size of 'signed int' and 'unsigned int' for this target, in bits.
bool isObjCARCImplicitlyUnretainedType() const
Determines if this type, which must satisfy isObjCLifetimeType(), is implicitly __unsafe_unretained r...
ParsedType getDestructorTypeForDecltype(const DeclSpec &DS, ParsedType ObjectType)
static bool EvaluateUnaryTypeTrait(Sema &Self, TypeTrait UTT, SourceLocation KeyLoc, QualType T)
DeclContext * getEntity() 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...
StandardConversionSequence After
After - Represents the standard conversion that occurs after the actual user-defined conversion...
This file defines the classes used to store parsed information about declaration-specifiers and decla...
const T * castAs() const
Member-template castAs<specific type>.
bool isObjCRetainableType() const
QualType FindCompositePointerType(SourceLocation Loc, Expr *&E1, Expr *&E2, bool ConvertArgs=true)
Find a merged pointer type and convert the two expressions to it.
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Represents a C++ destructor within a class.
New-expression has a C++11 list-initializer.
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...
const CXXScopeSpec * getSS() const
bool isThisDeclarationADefinition() const
Returns whether this specific declaration of the function is also a definition that does not contain ...
ExprResult ActOnPseudoDestructorExpr(Scope *S, Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, CXXScopeSpec &SS, UnqualifiedId &FirstTypeName, SourceLocation CCLoc, SourceLocation TildeLoc, UnqualifiedId &SecondTypeName)
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl...
Defines the clang::Preprocessor interface.
bool isNullPtrType() const
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, bool AllowFold=true)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
bool isFileContext() const
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
CXXConstructorDecl * CopyConstructor
CopyConstructor - The copy constructor that is used to perform this conversion, when the conversion i...
ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserN...
DeclContext * getDeclContext()
Overload resolution succeeded.
bool isAnyComplexType() const
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...
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
ExprResult CheckPlaceholderExpr(Expr *E)
Check for operands with placeholder types and complain if found.
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return null.
Represents a C++ template name within the type system.
void getAsStringInternal(std::string &Str, const PrintingPolicy &Policy) const
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Defines the clang::TypeLoc interface and its subclasses.
A namespace alias, stored as a NamespaceAliasDecl*.
Floating-integral conversions (C++ [conv.fpint])
UnqualifiedIdKind getKind() const
Determine what kind of name we have.
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7)...
void DiscardCleanupsInEvaluationContext()
bool isFunctionTemplateSpecialization() const
Determine whether this function is a function template specialization.
Specifies that a value-dependent expression of integral or dependent type should be considered a null...
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char, signed char, short, int, long..], or an enum decl which has a signed representation.
bool isPolymorphic() const
Whether this class is polymorphic (C++ [class.virtual]), which means that the class contains or inher...
static bool EvaluateBinaryTypeTrait(Sema &Self, TypeTrait BTT, QualType LhsT, QualType RhsT, SourceLocation KeyLoc)
ExprResult ActOnTypeTrait(TypeTrait Kind, SourceLocation KWLoc, ArrayRef< ParsedType > Args, SourceLocation RParenLoc)
Parsed one of the type trait support pseudo-functions.
TagDecl * getAsTagDecl() const
Retrieves the TagDecl that this type refers to, either because the type is a TagType or because it is...
ExprResult BuildCXXUuidof(QualType TypeInfoType, SourceLocation TypeidLoc, TypeSourceInfo *Operand, SourceLocation RParenLoc)
Build a Microsoft __uuidof expression with a type operand.
SmallVector< sema::FunctionScopeInfo *, 4 > FunctionScopes
Stack containing information about each of the nested function, block, and method scopes that are cur...
SourceLocation Loc
Loc - The place where this type was defined.
StandardConversionSequence Standard
When ConversionKind == StandardConversion, provides the details of the standard conversion sequence...
clang::ObjCRuntime ObjCRuntime
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
void DiagnoseAmbiguousConversion(Sema &S, SourceLocation CaretLoc, const PartialDiagnostic &PDiag) const
Diagnoses an ambiguous conversion.
static void collectPublicBases(CXXRecordDecl *RD, llvm::DenseMap< CXXRecordDecl *, unsigned > &SubobjectsSeen, llvm::SmallPtrSetImpl< CXXRecordDecl *> &VBases, llvm::SetVector< CXXRecordDecl *> &PublicSubobjectsSeen, bool ParentIsPublic)
A boolean condition, from 'if', 'while', 'for', or 'do'.
An expression that sends a message to the given Objective-C object or class.
QualType getRecordType(const RecordDecl *Decl) const
SourceLocation getEnd() const
UnaryOperator - This represents the unary-expression's (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
static uint64_t EvaluateArrayTypeTrait(Sema &Self, ArrayTypeTrait ATT, QualType T, Expr *DimExpr, SourceLocation KeyLoc)
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
static bool CanThrow(Expr *E, ASTContext &Ctx)
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.
ParsedType getInheritingConstructorName(CXXScopeSpec &SS, SourceLocation NameLoc, IdentifierInfo &Name)
Handle the result of the special case name lookup for inheriting constructor declarations.
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
void CleanupVarDeclMarking()
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
ExprResult ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal, bool ArrayForm, Expr *Operand)
ActOnCXXDelete - Parsed a C++ 'delete' expression.
Represents a C++ conversion function within a class.
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
The result type of a method or function.
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
const Expr * getSubExpr() const
void removeLocalCVRQualifiers(unsigned Mask)
bool isNull() const
Return true if this QualType doesn't point to a type yet.
bool hasNonTrivialMoveAssignment() const
Determine whether this class has a non-trivial move assignment operator (C++11 [class.copy]p25)
A type, stored as a Type*.
bool hasEmptyCollections() const
Are the empty collection symbols available?
void removeCVRQualifiers(unsigned mask)
ExprResult BuildCXXNew(SourceRange Range, bool UseGlobal, SourceLocation PlacementLParen, MultiExprArg PlacementArgs, SourceLocation PlacementRParen, SourceRange TypeIdParens, QualType AllocType, TypeSourceInfo *AllocTypeInfo, Optional< Expr *> ArraySize, SourceRange DirectInitRange, Expr *Initializer)
CXXDestructorDecl * LookupDestructor(CXXRecordDecl *Class)
Look for the destructor of the given class.
SourceLocation getEndLoc() const LLVM_READONLY
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
static InitializationKind CreateCopy(SourceLocation InitLoc, SourceLocation EqualLoc, bool AllowExplicitConvs=false)
Create a copy initialization.
static CXXRecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, CXXRecordDecl *PrevDecl=nullptr, bool DelayTypeCreation=false)
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
ExprResult BuildPseudoDestructorExpr(Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, const CXXScopeSpec &SS, TypeSourceInfo *ScopeType, SourceLocation CCLoc, SourceLocation TildeLoc, PseudoDestructorTypeStorage DestroyedType)
ExtInfo withNoReturn(bool noReturn) const
ExprResult BuildCXXNoexceptExpr(SourceLocation KeyLoc, Expr *Operand, SourceLocation RParen)
Lvalue-to-rvalue conversion (C++ [conv.lval])
ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E)
bool isConstQualified() const
Determine whether this type is const-qualified.
RecordDecl * getDecl() const
bool Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef< Expr *> Args)
Diagnose an potentially-invalid initialization sequence.
noexcept(expression), evals to 'false'
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
void EraseUnwantedCUDAMatches(const FunctionDecl *Caller, SmallVectorImpl< std::pair< DeclAccessPair, FunctionDecl *>> &Matches)
Finds a function in Matches with highest calling priority from Caller context and erases all function...
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)
Add a C++ function template specialization as a candidate in the candidate set, using template argume...
void AddBuiltinOperatorCandidates(OverloadedOperatorKind Op, SourceLocation OpLoc, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet)
AddBuiltinOperatorCandidates - Add the appropriate built-in operator overloads to the candidate set (...
QualType getWideCharType() const
Return the type of wide characters.
bool isAddressOfOperand() const
char * location_data() const
Retrieve the data associated with the source-location information.
void MarkThisReferenced(CXXThisExpr *This)
CanThrowResult
Possible results from evaluation of a noexcept expression.
ExprResult BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType, NamedDecl *FoundDecl, CXXConstructorDecl *Constructor, MultiExprArg Exprs, bool HadMultipleCandidates, bool IsListInitialization, bool IsStdInitListInitialization, bool RequiresZeroInit, unsigned ConstructKind, SourceRange ParenRange)
BuildCXXConstructExpr - Creates a complete call to a constructor, including handling of its default a...
There is no lifetime qualification on this type.
ExprResult ActOnDecltypeExpression(Expr *E)
Process the expression contained within a decltype.
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Integral conversions (C++ [conv.integral])
SmallVectorImpl< OverloadCandidate >::iterator iterator
Complex promotions (Clang extension)
ExprResult MaybeBindToTemporary(Expr *E)
MaybeBindToTemporary - If the passed in expression has a record type with a non-trivial destructor...
Assigning into this object requires the old value to be released and the new value to be retained...
static CXXBindTemporaryExpr * Create(const ASTContext &C, CXXTemporary *Temp, Expr *SubExpr)
ImplicitConversionSequence - Represents an implicit conversion sequence, which may be a standard conv...
ExprResult BuildCXXThrow(SourceLocation OpLoc, Expr *Ex, bool IsThrownVarInScope)
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
ExceptionSpecificationType Type
The kind of exception specification this is.
ExprResult LookupInObjCMethod(LookupResult &LookUp, Scope *S, IdentifierInfo *II, bool AllowBuiltinCreation=false)
LookupInObjCMethod - The parser has read a name in, and Sema has detected that we're currently inside...
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on a template...
OverloadCandidate - A single candidate in an overload set (C++ 13.3).
LazyDeclPtr StdAlignValT
The C++ "std::align_val_t" enum class, which is defined by the C++ standard library.
ASTContext & getASTContext() const
bool hasTrivialCopyAssignment() const
Determine whether this class has a trivial copy assignment operator (C++ [class.copy]p11, C++11 [class.copy]p25)
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant...
Encodes a location in the source.
CharUnits getExnObjectAlignment() const
Return the alignment (in bytes) of the thrown exception object.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
CastKind PrepareCastToObjCObjectPointer(ExprResult &E)
Prepare a conversion of the given expression to an ObjC object pointer type.
LangAS getAddressSpace() const
Return the address space of this type.
Represents a C++ temporary.
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
CXXRecordDecl * Lambda
The class that describes the lambda.
CastKind getCastKind() const
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
FunctionDecl * FindUsualDeallocationFunction(SourceLocation StartLoc, bool CanProvideSize, bool Overaligned, DeclarationName Name)
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)"...
MemberExpr * BuildMemberExpr(Expr *Base, bool IsArrow, SourceLocation OpLoc, const CXXScopeSpec *SS, SourceLocation TemplateKWLoc, ValueDecl *Member, DeclAccessPair FoundDecl, bool HadMultipleCandidates, const DeclarationNameInfo &MemberNameInfo, QualType Ty, ExprValueKind VK, ExprObjectKind OK, const TemplateArgumentListInfo *TemplateArgs=nullptr)
DeclarationName getName() const
getName - Returns the embedded declaration name.
MutableArrayRef< Expr * > MultiExprArg
Represents a call to a member function that may be written either with member call syntax (e...
QualType DeduceTemplateSpecializationFromInitializer(TypeSourceInfo *TInfo, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Init)
IdentifierTable & getIdentifierTable()
A vector splat from an arithmetic type.
bool isUsualDeallocationFunction(SmallVectorImpl< const FunctionDecl *> &PreventedBy) const
Determine whether this is a usual deallocation function (C++ [basic.stc.dynamic.deallocation]p2), which is an overloaded delete or delete[] operator with a particular signature.
ExprObjectKind
A further classification of the kind of object referenced by an l-value or x-value.
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs. ...
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
Represents a static or instance method of a struct/union/class.
const LookupResult & getLookupResult() const
static ExprWithCleanups * Create(const ASTContext &C, EmptyShell empty, unsigned numObjects)
const ConstantArrayType * getAsConstantArrayType(QualType T) const
ExprResult DefaultLvalueConversion(Expr *E)
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
No ref-qualifier was provided.
Only look for allocation functions in the scope of the allocated class.
void setDestructor(const CXXDestructorDecl *Dtor)
Objective-C ARC writeback conversion.
const ParmVarDecl * getParamDecl(unsigned i) const
ExprResult ActOnCXXTypeConstructExpr(ParsedType TypeRep, SourceLocation LParenOrBraceLoc, MultiExprArg Exprs, SourceLocation RParenOrBraceLoc, bool ListInitialization)
ActOnCXXTypeConstructExpr - Parse construction of a specified type.
bool CheckObjCARCUnavailableWeakConversion(QualType castType, QualType ExprType)
Name lookup found an unresolvable value declaration and cannot yet complete.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
static bool isCast(CheckedConversionKind CCK)
OverloadingResult BestViableFunction(Sema &S, SourceLocation Loc, OverloadCandidateSet::iterator &Best)
Find the best viable function on this overload set, if it exists.
ExprResult CheckCXXBooleanCondition(Expr *CondExpr, bool IsConstexpr=false)
CheckCXXBooleanCondition - Returns true if conversion to bool is invalid.
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Describes the kind of initialization being performed, along with location information for tokens rela...
TemplateDeductionResult DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, const TemplateArgumentList &TemplateArgs, sema::TemplateDeductionInfo &Info)
Perform template argument deduction to determine whether the given template arguments match the given...
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
static void getUnambiguousPublicSubobjects(CXXRecordDecl *RD, llvm::SmallVectorImpl< CXXRecordDecl *> &Objects)
Look up any declaration with any name.
AssignConvertType CheckTransparentUnionArgumentConstraints(QualType ArgType, ExprResult &RHS)
bool isMemberFunctionPointerType() const
bool isAnyPointerType() const
bool isObjCObjectPointerType() const
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...
void MarkCaptureUsedInEnclosingContext(VarDecl *Capture, SourceLocation Loc, unsigned CapturingScopeIndex)
Pointer conversions (C++ [conv.ptr])
const TypoExprState & getTypoExprState(TypoExpr *TE) const
C++ [over.match.oper]: Lookup of operator function candidates in a call using operator syntax...
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
static bool VariableCanNeverBeAConstantExpression(VarDecl *Var, ASTContext &Context)
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after...
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language...
Requests that all candidates be shown.
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReciever=nullptr)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics...
bool isSuperClassOf(const ObjCInterfaceDecl *I) const
isSuperClassOf - Return true if this class is the specified class or is a super class of the specifie...
No entity found met the criteria.
TypeClass getTypeClass() const
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...
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
The name is a dependent name, so the results will differ from one instantiation to the next...
An expression trait intrinsic.
EnumDecl * getDecl() const
Derived-to-base (C++ [over.best.ics])
bool isVectorType() const
Complex-real conversions (C99 6.3.1.7)
An rvalue ref-qualifier was provided (&&).
Assigning into this object requires a lifetime extension.
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
ObjCBoxedExpr - used for generalized expression boxing.
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13...
Constant expression in a noptr-new-declarator.
ExprResult ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal, SourceLocation PlacementLParen, MultiExprArg PlacementArgs, SourceLocation PlacementRParen, SourceRange TypeIdParens, Declarator &D, Expr *Initializer)
ActOnCXXNew - Parsed a C++ 'new' expression.
bool isInvalid() const
An error occurred during parsing of the scope specifier.
static bool CheckUnaryTypeTraitTypeCompleteness(Sema &S, TypeTrait UTT, SourceLocation Loc, QualType ArgTy)
Check the completeness of a type in a unary type trait.
DependentTemplateName * getAsDependentTemplateName() const
Retrieve the underlying dependent template name structure, if any.
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
QualType CXXCheckConditionalOperands(ExprResult &cond, ExprResult &lhs, ExprResult &rhs, ExprValueKind &VK, ExprObjectKind &OK, SourceLocation questionLoc)
Check the operands of ?: under C++ semantics.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
TypeResult ActOnTemplateIdType(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, TemplateTy Template, IdentifierInfo *TemplateII, SourceLocation TemplateIILoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgs, SourceLocation RAngleLoc, bool IsCtorOrDtorName=false, bool IsClassName=false)
A POD class for pairing a NamedDecl* with an access specifier.
AccessResult CheckAllocationAccess(SourceLocation OperatorLoc, SourceRange PlacementRange, CXXRecordDecl *NamingClass, DeclAccessPair FoundDecl, bool Diagnose=true)
Checks access to an overloaded operator new or delete.
ExprResult BuildOverloadedArrowExpr(Scope *S, Expr *Base, SourceLocation OpLoc, bool *NoArrowOperatorFound=nullptr)
BuildOverloadedArrowExpr - Build a call to an overloaded operator-> (if one exists), where Base is an expression of class type and Member is the name of the member we're trying to find.
ExprResult BuildCXXMemberCallExpr(Expr *Exp, NamedDecl *FoundDecl, CXXConversionDecl *Method, bool HadMultipleCandidates)
bool isPlaceholderType() const
Test for a type which does not represent an actual type-system type but is instead used as a placehol...
The scope of a struct/union/class definition.
SourceRange getSourceRange() const LLVM_READONLY
Get the source range that spans this declarator.
static unsigned getMaxSizeBits(const ASTContext &Context)
Determine the maximum number of active bits that an array's size can require, which limits the maximu...
Represents a template argument.
ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)
static const TST TST_decltype_auto
DeclContextLookupResult LookupConstructors(CXXRecordDecl *Class)
Look up the constructors for the given class.
This file provides some common utility functions for processing Lambdas.
DeclAccessPair FoundCopyConstructor
static bool isInvalid(LocType Loc, bool *Invalid)
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
Abstract base class used to perform a contextual implicit conversion from an expression to any type p...
void CheckVirtualDtorCall(CXXDestructorDecl *dtor, SourceLocation Loc, bool IsDelete, bool CallCanBeVirtual, bool WarnOnNonAbstractTypes, SourceLocation DtorLoc)
Dataflow Directional Tag Classes.
bool isValid() const
Return true if this is a valid SourceLocation object.
CXXMethodDecl * getLambdaCallOperator() const
Retrieve the lambda call operator of the closure type if this is a closure type.
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type...
ExtInfo getExtInfo() const
not evaluated yet, for special member function
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
void DeclareGlobalAllocationFunction(DeclarationName Name, QualType Return, ArrayRef< QualType > Params)
DeclareGlobalAllocationFunction - Declares a single implicit global allocation function if it doesn't...
ExprResult BuildExpressionTrait(ExpressionTrait OET, SourceLocation KWLoc, Expr *Queried, SourceLocation RParen)
Represents a delete expression for memory deallocation and destructor calls, e.g. ...
static bool isLegalArrayNewInitializer(CXXNewExpr::InitializationStyle Style, Expr *Init)
The base class of all kinds of template declarations (e.g., class, function, etc.).
static void noteOperatorArrows(Sema &S, ArrayRef< FunctionDecl *> OperatorArrows)
Note a set of 'operator->' functions that were used for a member access.
static const TST TST_decltype
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
const Scope * getParent() const
getParent - Return the scope that this is nested in.
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_RValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CCK_ImplicitConversion)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
void addCopyConstructorForExceptionObject(CXXRecordDecl *RD, CXXConstructorDecl *CD)
CXXScopeSpec SS
The nested-name-specifier that precedes the template name.
SourceLocation RAngleLoc
The location of the '>' after the template argument list.
Optional< unsigned > getStackIndexOfNearestEnclosingCaptureCapableLambda(ArrayRef< const sema::FunctionScopeInfo *> FunctionScopes, VarDecl *VarToCapture, Sema &S)
Examines the FunctionScopeInfo stack to determine the nearest enclosing lambda (to the current lambda...
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=None)
AddOverloadCandidate - Adds the given function to the set of candidate functions, using the given fun...
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
AccessSpecifier getAccess() const
Conversions allowed in C, but not C++.
A constant boolean condition from 'if constexpr'.
Array-to-pointer conversion (C++ [conv.array])
llvm::VersionTuple alignedAllocMinVersion(llvm::Triple::OSType OS)
TypeSourceInfo * getTypeSourceInfo() const
bool GlobalNewDeleteDeclared
A flag to remember whether the implicit forms of operator new and delete have been declared...
The name of a declaration.
StandardConversionSequence Before
Represents the standard conversion that occurs before the actual user-defined conversion.
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined...
bool isBooleanType() const
ExprResult prepareVectorSplat(QualType VectorTy, Expr *SplattedExpr)
Prepare SplattedExpr for a vector splat operation, adding implicit casts if necessary.
AllocationFunctionScope
The scope in which to find allocation functions.
Requests that only viable candidates be shown.
A pointer to member type per C++ 8.3.3 - Pointers to members.
bool isCopyAssignmentOperator() const
Determine whether this is a copy-assignment operator, regardless of whether it was declared implicitl...
IdentifierResolver IdResolver
Optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
bool isAggregateType() const
Determines whether the type is a C++ aggregate type or C aggregate or union type. ...
static CastKind ScalarTypeToBooleanCastKind(QualType ScalarTy)
ScalarTypeToBooleanCastKind - Returns the cast kind corresponding to the conversion from scalar type ...
QualType getCallReturnType(const ASTContext &Ctx) const
getCallReturnType - Get the return type of the call expr.
bool exprNeedsCleanups() const
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
A type that was preceded by the 'template' keyword, stored as a Type*.
static EnumDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, EnumDecl *PrevDecl, bool IsScoped, bool IsScopedUsingClassTag, bool IsFixed)
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.
bool hasNonTrivialCopyAssignment() const
Determine whether this class has a non-trivial copy assignment operator (C++ [class.copy]p11, C++11 [class.copy]p25)
bool hasCVRQualifiers() const
bool isValid() const
A scope specifier is present, and it refers to a real scope.
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
llvm::MapVector< FieldDecl *, DeleteLocs > DeleteExprs
FunctionDecl * ConversionFunction
ConversionFunction - The function that will perform the user-defined conversion.
ExprResult IgnoredValueConversions(Expr *E)
IgnoredValueConversions - Given that an expression's result is syntactically ignored, perform any conversions that are required.
Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
Name lookup found a single declaration that met the criteria.
static void DiagnoseMismatchedNewDelete(Sema &SemaRef, SourceLocation DeleteLoc, const MismatchingNewDeleteDetector &Detector)
SourceLocation getBeginLoc() const
StmtResult ActOnFinishFullStmt(Stmt *Stmt)
ParsedType getConstructorName(IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec &SS, bool EnteringContext)
bool isIncompleteArrayType() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
bool cleanupsHaveSideEffects() const
Complex values, per C99 6.2.5p11.
void addThisCapture(bool isNested, SourceLocation Loc, QualType CaptureType, bool ByCopy)
The lookup is a reference to this name that is not for the purpose of redeclaring the name...
CUDAFunctionPreference IdentifyCUDAPreference(const FunctionDecl *Caller, const FunctionDecl *Callee)
Identifies relative preference of a given Caller/Callee combination, based on their host/device attri...
Represents a C++ base or member initializer.
Expr * BuildCXXThisExpr(SourceLocation Loc, QualType Type, bool IsImplicit)
Build a CXXThisExpr and mark it referenced in the current context.
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Look for allocation functions in both the global scope and in the scope of the allocated class...
bool hasNonTrivialObjCLifetime() const
ExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind)
ActOnCXXBoolLiteral - Parse {true,false} literals.
bool CheckDerivedToBaseConversion(QualType Derived, QualType Base, SourceLocation Loc, SourceRange Range, CXXCastPath *BasePath=nullptr, bool IgnoreAccess=false)
uint64_t getCharWidth() const
Return the size of the character type, in bits.
QualType CheckPointerToMemberOperands(ExprResult &LHS, ExprResult &RHS, ExprValueKind &VK, SourceLocation OpLoc, bool isIndirect)
bool isFunctionType() const
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 ...
QualType BuildDecltypeType(Expr *E, SourceLocation Loc, bool AsUnevaluated=true)
If AsUnevaluated is false, E is treated as though it were an evaluated context, such as when building...
CanQualType BoundMemberTy
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
AccessResult CheckMemberOperatorAccess(SourceLocation Loc, Expr *ObjectExpr, Expr *ArgExpr, DeclAccessPair FoundDecl)
Checks access to an overloaded member operator, including conversion operators.
DeduceAutoResult DeduceAutoType(TypeSourceInfo *AutoType, Expr *&Initializer, QualType &Result, Optional< unsigned > DependentDeductionDepth=None)
The template argument is a type.
ExprResult ActOnCXXTypeid(SourceLocation OpLoc, SourceLocation LParenLoc, bool isType, void *TyOrExpr, SourceLocation RParenLoc)
ActOnCXXTypeid - Parse typeid( something ).
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
Block Pointer conversions.
Holds information about the various types of exception specification.
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.
void addDecl(Decl *D)
Add the declaration D into this context.
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream...
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type...
void setExprNeedsCleanups(bool SideEffects)
SmallVector< BlockDecl *, 8 > ExprCleanupObjects
ExprCleanupObjects - This is the stack of objects requiring cleanup that are created by the current f...
Represents a base class of a C++ class.
A bitfield object is a bitfield on a C or C++ record.
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
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...
Capture & getCXXThisCapture()
Retrieve the capture of C++ 'this', if it has been captured.
bool isObjectType() const
Determine whether this type is an object type.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Condition in a constexpr if statement.
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types...
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 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.
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
EnumDecl * getStdAlignValT() const
A template argument list.
bool isSet() const
Deprecated.
bool isLValueReferenceType() const
ExprResult BuildCXXFunctionalCastExpr(TypeSourceInfo *TInfo, QualType Type, SourceLocation LParenLoc, Expr *CastExpr, SourceLocation RParenLoc)
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
CXXRecordDecl * getNamingClass() const
Returns the 'naming class' for this lookup, i.e.
Reading or writing from this object requires a barrier call.
An integral condition for a 'switch' statement.
FunctionDecl * FindDeallocationFunctionForDestructor(SourceLocation StartLoc, CXXRecordDecl *RD)
static CXXMemberCallExpr * Create(const ASTContext &Ctx, Expr *Fn, ArrayRef< Expr *> Args, QualType Ty, ExprValueKind VK, SourceLocation RP, unsigned MinNumArgs=0)
QualType getParamType(unsigned i) const
Expr * MaybeCreateExprWithCleanups(Expr *SubExpr)
MaybeCreateExprWithCleanups - If the current full-expression requires any cleanups, surround it with a ExprWithCleanups node.
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
Function-to-pointer (C++ [conv.array])
bool Failed() const
Determine whether the initialization sequence is invalid.
TranslationUnitDecl * getTranslationUnitDecl() const
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
static bool isNonPlacementDeallocationFunction(Sema &S, FunctionDecl *FD)
Determine whether the given function is a non-placement deallocation function.
Describes the sequence of initializations required to initialize a given object or reference with a s...
Captures information about "declaration specifiers".
ActionResult< Expr * > ExprResult
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Only look for allocation functions in the global scope.
Represents a C++ struct/union/class.
Compatible - the types are compatible according to the standard.
bool CompleteConstructorCall(CXXConstructorDecl *Constructor, 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 BuildTypeTrait(TypeTrait Kind, SourceLocation KWLoc, ArrayRef< TypeSourceInfo *> Args, SourceLocation RParenLoc)
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type...
static bool hasAnyTypeDependentArguments(ArrayRef< Expr *> Exprs)
hasAnyTypeDependentArguments - Determines if any of the expressions in Exprs is type-dependent.
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
static CXXTemporary * Create(const ASTContext &C, const CXXDestructorDecl *Destructor)
Expr * NumElts
This is the size of the array, or null if [] or [*] was specified.
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)
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
bool CheckAllocatedType(QualType AllocType, SourceLocation Loc, SourceRange R)
Checks that a type is suitable as the allocated type in a new-expression.
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
bool isCXXThisCaptured() const
Determine whether the C++ 'this' is captured.
Declaration of a class template.
Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const
Return the implicit lifetime for this type, which must not be dependent.
static bool isAddressSpaceSupersetOf(LangAS A, LangAS B)
Returns true if address space A is equal to or a superset of B.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
This class is used for builtin types like 'int'.
SourceManager & getSourceManager() const
A template-id, e.g., f<int>.
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
StringLiteral - This represents a string literal expression, e.g.
Defines the clang::TargetInfo interface.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
QualType CheckVectorOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign, bool AllowBothBool, bool AllowBoolConversion)
type checking for vector binary operators.
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
static Qualifiers fromCVRMask(unsigned CVR)
void EmitRelatedResultTypeNote(const Expr *E)
If the given expression involves a message send to a method with a related result type...
ExprResult CheckConvertedConstantExpression(Expr *From, QualType T, llvm::APSInt &Value, CCEKind CCE)
static OpaquePtr make(QualType P)
bool isFundamentalType() const
Tests whether the type is categorized as a fundamental type.
Microsoft __declspec(nothrow) extension.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
static bool canRecoverDotPseudoDestructorCallsOnPointerObjects(Sema &SemaRef, QualType DestructedType)
Check if it's ok to try and recover dot pseudo destructor calls on pointer objects.
A reference to a declared variable, function, enum, etc.
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Represents a type template specialization; the template must be a class template, a type alias templa...
bool isDeleted() const
Whether this function has been deleted.
bool isPointerType() const
Zero constant to event (OpenCL1.2 6.12.10)
unsigned getAddressSpaceAttributePrintValue() const
Get the address space attribute value to be printed by diagnostics.
ImplicitConversionKind First
First – The first conversion can be an lvalue-to-rvalue conversion, array-to-pointer conversion...
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
No viable function found.
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
An l-value expression is a reference to an object with independent storage.
bool empty() const
Return true if no decls were found.
bool isFloatingType() const
A trivial tuple used to represent a source range.
SourceLocation getBeginLoc() const LLVM_READONLY
void diagnoseNullableToNonnullConversion(QualType DstType, QualType SrcType, SourceLocation Loc)
Warn if we're implicitly casting from a _Nullable pointer type to a _Nonnull one. ...
ExprResult CheckBooleanCondition(SourceLocation Loc, Expr *E, bool IsConstexpr=false)
CheckBooleanCondition - Diagnose problems involving the use of the given expression as a boolean cond...
This represents a decl that may have a name.
A boolean literal, per ([C++ lex.bool] Boolean literals).
Expr * getRepAsExpr() const
bool CheckCallReturnType(QualType ReturnType, SourceLocation Loc, CallExpr *CE, FunctionDecl *FD)
CheckCallReturnType - Checks that a call expression's return type is complete.
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
No keyword precedes the qualified type name.
sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)
Retrieve the current lambda scope info, if any.
ExprResult BuildBinOp(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr)
bool isInterfaceType() const
Pointer-to-member conversions (C++ [conv.mem])
SourceLocation getNameLoc() const
Gets the location of the identifier.
Describes an entity that is being initialized.
unsigned NumArgs
NumArgs - The number of template arguments.
void DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc, ArrayRef< Expr *> Args)
DiagnoseSentinelCalls - This routine checks whether a call or message-send is to a declaration with t...
The global specifier '::'. There is no stored value.
static bool resolveBuiltinNewDeleteOverload(Sema &S, CallExpr *TheCall, bool IsDelete, FunctionDecl *&Operator)
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
static OpaquePtr getFromOpaquePtr(void *P)
SourceLocation getBegin() const
ExprResult BuildCXXTypeId(QualType TypeInfoType, SourceLocation TypeidLoc, TypeSourceInfo *Operand, SourceLocation RParenLoc)
Build a C++ typeid expression with a type operand.
const LangOptions & getLangOpts() const
void WillReplaceSpecifier(bool ForceReplacement)
Represents the canonical version of C arrays with a specified constant size.
This scope corresponds to an Objective-C method body.
ExceptionSpecInfo ExceptionSpec
The symbol does not exist.
Declaration of a template function.
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals)
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals...
Attr - This represents one attribute.
SourceLocation getLocation() const
QualType UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS, bool IsCompAssign=false)
UsualArithmeticConversions - Performs various conversions that are common to binary operators (C99 6...
QualType getPointeeType() const
TypeSourceInfo * GetTypeForDeclarator(Declarator &D, Scope *S)
GetTypeForDeclarator - Convert the type for the specified declarator to Type instances.
QualType getType() const
Return the type wrapped by this type source info.
bool isBeingDefined() const
Return true if this decl is currently being defined.
ParsedTemplateTy Template
The declaration of the template corresponding to the template-name.
noexcept(expression), evals to 'true'
static CXXNewExpr * Create(const ASTContext &Ctx, bool IsGlobalNew, FunctionDecl *OperatorNew, FunctionDecl *OperatorDelete, bool ShouldPassAlignment, bool UsualArrayDeleteWantsSize, ArrayRef< Expr *> PlacementArgs, SourceRange TypeIdParens, Optional< Expr *> ArraySize, InitializationStyle InitializationStyle, Expr *Initializer, QualType Ty, TypeSourceInfo *AllocatedTypeInfo, SourceRange Range, SourceRange DirectInitRange)
Create a c++ new expression.
Helper class that creates diagnostics with optional template instantiation stacks.
EvaluatedStmt * ensureEvaluatedStmt() const
Convert the initializer for this declaration to the elaborated EvaluatedStmt form, which contains extra information on the evaluated value of the initializer.
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point...
QualType getIncompleteArrayType(QualType EltTy, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return a unique reference to the type for an incomplete array of the specified element type...
bool hasErrorOccurred() const
Determine whether any SFINAE errors have been trapped.
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Structure used to store a statement, the constant value to which it was evaluated (if any)...
bool isCompoundType() const
Tests whether the type is categorized as a compound type.
StandardConversionSequence - represents a standard conversion sequence (C++ 13.3.3.1.1).