39 #include "llvm/ADT/APInt.h" 40 #include "llvm/ADT/STLExtras.h" 41 #include "llvm/Support/ErrorHandling.h" 42 using namespace clang;
74 llvm_unreachable(
"Nested name specifier is not a type for inheriting ctor");
79 return CreateParsedType(Type,
88 bool EnteringContext) {
113 bool isDependent =
false;
114 bool LookInScope =
false;
123 SearchType = GetTypeFromParser(ObjectTypePtr);
128 bool AlreadySearched =
false;
129 bool LookAtPrefix =
true;
141 DeclContext *DC = computeDeclContext(SS, EnteringContext);
143 AlreadySearched =
true;
146 }
else if (DC && isa<CXXRecordDecl>(DC)) {
147 LookAtPrefix =
false;
153 if (AlreadySearched) {
155 }
else if (LookAtPrefix && (Prefix = NNS->
getPrefix())) {
158 LookupCtx = computeDeclContext(PrefixSS, EnteringContext);
159 isDependent = isDependentScopeSpecifier(PrefixSS);
160 }
else if (ObjectTypePtr) {
161 LookupCtx = computeDeclContext(SearchType);
164 LookupCtx = computeDeclContext(SS, EnteringContext);
167 }
else if (ObjectTypePtr) {
175 LookupCtx = computeDeclContext(SearchType);
178 "Caller should have completed object type");
186 TypeDecl *NonMatchingTypeDecl =
nullptr;
187 LookupResult Found(*
this, &II, NameLoc, LookupOrdinaryName);
193 if (
Step == 0 && LookupCtx) {
194 if (RequireCompleteDeclContext(SS, LookupCtx))
196 LookupQualifiedName(Found, LookupCtx);
197 }
else if (
Step == 1 && LookInScope && S) {
198 LookupName(Found, S);
209 MarkAnyDeclReferenced(
Type->getLocation(),
Type,
false);
215 return CreateParsedType(T,
220 NonMatchingTypeDecl =
Type;
232 if (
DeclContext *Ctx = computeDeclContext(SS, EnteringContext)) {
238 if (MemberOfType.
isNull())
239 MemberOfType = SearchType;
241 if (MemberOfType.
isNull())
249 = dyn_cast<ClassTemplateSpecializationDecl>(Record->getDecl())) {
250 if (Spec->getSpecializedTemplate()->getCanonicalDecl() ==
251 Template->getCanonicalDecl())
252 return CreateParsedType(
272 if (SpecTemplate->getCanonicalDecl() == Template->getCanonicalDecl())
273 return CreateParsedType(
284 if (DepTemplate->isIdentifier() &&
285 DepTemplate->getIdentifier() == Template->getIdentifier())
286 return CreateParsedType(
307 if (NonMatchingTypeDecl) {
309 Diag(NameLoc, diag::err_destructor_expr_type_mismatch)
311 Diag(NonMatchingTypeDecl->
getLocation(), diag::note_destructor_type_here)
313 }
else if (ObjectTypePtr)
314 Diag(NameLoc, diag::err_ident_in_dtor_not_a_type)
318 diag::err_destructor_class_name);
321 if (
const CXXRecordDecl *Class = dyn_cast_or_null<CXXRecordDecl>(Ctx))
323 Class->getNameAsString());
341 "unexpected type in getDestructorType");
346 QualType SearchType = GetTypeFromParser(ObjectType);
347 if (!SearchType.isNull() && !SearchType->isDependentType() &&
372 Diag(Name.
getLocStart(), diag::err_literal_operator_id_outside_namespace)
383 llvm_unreachable(
"unknown nested name specifier kind");
401 RequireCompleteType(TypeidLoc, T, diag::err_incomplete_typeid))
405 return ExprError(
Diag(TypeidLoc, diag::err_variably_modified_typeid) <<
T);
416 bool WasEvaluated =
false;
426 CXXRecordDecl *RecordD = cast<CXXRecordDecl>(RecordT->getDecl());
430 if (RequireCompleteType(TypeidLoc, T, diag::err_incomplete_typeid))
440 ExprResult Result = TransformToPotentiallyEvaluated(E);
445 MarkVTableUsed(TypeidLoc, RecordD);
459 E = ImpCastExprToType(E, UnqualT, CK_NoOp, E->
getValueKind()).
get();
464 return ExprError(
Diag(TypeidLoc, diag::err_variably_modified_typeid)
466 else if (!inTemplateInstantiation() &&
471 ? diag::warn_side_effects_typeid
472 : diag::warn_side_effects_unevaluated_context);
484 if (!getStdNamespace())
485 return ExprError(
Diag(OpLoc, diag::err_need_header_before_typeid));
487 if (!CXXTypeInfoDecl) {
488 IdentifierInfo *TypeInfoII = &PP.getIdentifierTable().get(
"type_info");
490 LookupQualifiedName(R, getStdNamespace());
494 if (!CXXTypeInfoDecl && LangOpts.MSVCCompat) {
498 if (!CXXTypeInfoDecl)
499 return ExprError(
Diag(OpLoc, diag::err_need_header_before_typeid));
502 if (!getLangOpts().RTTI) {
503 return ExprError(
Diag(OpLoc, diag::err_no_typeid_with_fno_rtti));
519 return BuildCXXTypeId(TypeInfoType, OpLoc, TInfo, RParenLoc);
523 return BuildCXXTypeId(TypeInfoType, OpLoc, (
Expr*)TyOrExpr, RParenLoc);
542 if (
const auto *Uuid = TD->getMostRecentDecl()->getAttr<UuidAttr>()) {
543 UuidAttrs.insert(Uuid);
548 if (
const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(TD)) {
551 const UuidAttr *UuidForTA =
nullptr;
558 UuidAttrs.insert(UuidForTA);
572 if (UuidAttrs.empty())
573 return ExprError(
Diag(TypeidLoc, diag::err_uuidof_without_guid));
574 if (UuidAttrs.size() > 1)
575 return ExprError(
Diag(TypeidLoc, diag::err_uuidof_with_multiple_guids));
576 UuidStr = UuidAttrs.back()->getGuid();
591 UuidStr =
"00000000-0000-0000-0000-000000000000";
595 if (UuidAttrs.empty())
596 return ExprError(
Diag(TypeidLoc, diag::err_uuidof_without_guid));
597 if (UuidAttrs.size() > 1)
598 return ExprError(
Diag(TypeidLoc, diag::err_uuidof_with_multiple_guids));
599 UuidStr = UuidAttrs.back()->getGuid();
618 return ExprError(
Diag(OpLoc, diag::err_need_header_before_ms_uuidof));
634 return BuildCXXUuidof(GuidType, OpLoc, TInfo, RParenLoc);
638 return BuildCXXUuidof(GuidType, OpLoc, (
Expr*)TyOrExpr, RParenLoc);
644 assert((Kind == tok::kw_true || Kind == tok::kw_false) &&
645 "Unknown C++ Boolean value!");
659 bool IsThrownVarInScope =
false;
673 if (
VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
674 if (Var->hasLocalStorage() && !Var->getType().isVolatileQualified()) {
677 IsThrownVarInScope =
true;
691 return BuildCXXThrow(OpLoc, Ex, IsThrownVarInScope);
695 bool IsThrownVarInScope) {
697 if (!getLangOpts().CXXExceptions &&
698 !getSourceManager().isInSystemHeader(OpLoc))
699 Diag(OpLoc, diag::err_exceptions_disabled) <<
"throw";
702 if (getLangOpts().CUDA)
703 CUDADiagIfDeviceCode(OpLoc, diag::err_cuda_device_exceptions)
704 <<
"throw" << CurrentCUDATarget();
706 if (getCurScope() && getCurScope()->isOpenMPSimdDirectiveScope())
707 Diag(OpLoc, diag::err_omp_simd_region_cannot_use_stmt) <<
"throw";
711 if (CheckCXXThrowOperand(OpLoc, ExceptionObjectTy, Ex))
729 const VarDecl *NRVOVariable =
nullptr;
730 if (IsThrownVarInScope)
731 NRVOVariable = getCopyElisionCandidate(
QualType(), Ex,
false);
734 OpLoc, ExceptionObjectTy,
735 NRVOVariable !=
nullptr);
736 ExprResult Res = PerformMoveOrCopyInitialization(
737 Entity, NRVOVariable,
QualType(), Ex, IsThrownVarInScope);
749 llvm::DenseMap<CXXRecordDecl *, unsigned> &SubobjectsSeen,
750 llvm::SmallPtrSetImpl<CXXRecordDecl *> &VBases,
751 llvm::SetVector<CXXRecordDecl *> &PublicSubobjectsSeen,
752 bool ParentIsPublic) {
754 CXXRecordDecl *BaseDecl = BS.getType()->getAsCXXRecordDecl();
759 NewSubobject = VBases.insert(BaseDecl).second;
764 ++SubobjectsSeen[BaseDecl];
767 bool PublicPath = ParentIsPublic && BS.getAccessSpecifier() ==
AS_public;
769 PublicSubobjectsSeen.insert(BaseDecl);
779 llvm::DenseMap<CXXRecordDecl *, unsigned> SubobjectsSeen;
780 llvm::SmallSet<CXXRecordDecl *, 2> VBases;
781 llvm::SetVector<CXXRecordDecl *> PublicSubobjectsSeen;
782 SubobjectsSeen[RD] = 1;
783 PublicSubobjectsSeen.insert(RD);
787 for (
CXXRecordDecl *PublicSubobject : PublicSubobjectsSeen) {
789 if (SubobjectsSeen[PublicSubobject] > 1)
792 Objects.push_back(PublicSubobject);
802 bool isPointer =
false;
808 if (RequireCompleteType(ThrowLoc, Ty,
809 isPointer ? diag::err_throw_incomplete_ptr
810 : diag::err_throw_incomplete,
814 if (RequireNonAbstractType(ThrowLoc, ExceptionObjectTy,
815 diag::err_throw_abstract_type, E))
826 MarkVTableUsed(ThrowLoc, RD);
835 MarkFunctionReferenced(E->
getExprLoc(), Destructor);
836 CheckDestructorAccess(E->
getExprLoc(), Destructor,
837 PDiag(diag::err_access_dtor_exception) << Ty);
838 if (DiagnoseUseOfDecl(Destructor, E->
getExprLoc()))
853 for (
CXXRecordDecl *Subobject : UnambiguousPublicSubobjects) {
880 for (
unsigned I = 1, E = CD->
getNumParams(); I != E; ++I) {
881 if (CheckCXXDefaultArgExpr(ThrowLoc, CD, CD->
getParamDecl(I)))
934 for (
int I = FunctionScopes.size();
935 I-- && isa<LambdaScopeInfo>(FunctionScopes[I]) &&
937 cast<LambdaScopeInfo>(FunctionScopes[I])->CallOperator);
939 CurLSI = cast<LambdaScopeInfo>(FunctionScopes[I]);
946 if (C.isCopyCapture()) {
957 assert(CurLSI &&
"While computing 'this' capture-type for a generic " 958 "lambda, we must have a corresponding LambdaScopeInfo");
960 "While computing 'this' capture-type for a generic lambda, when we " 961 "run out of enclosing LSI's, yet the enclosing DC is a " 962 "lambda-call-operator we must be (i.e. Current LSI) in a generic " 963 "lambda call oeprator");
966 auto IsThisCaptured =
970 for (
auto &&C : Closure->
captures()) {
971 if (C.capturesThis()) {
982 bool IsByCopyCapture =
false;
983 bool IsConstCapture =
false;
986 IsThisCaptured(Closure, IsByCopyCapture, IsConstCapture)) {
987 if (IsByCopyCapture) {
1003 QualType ThisTy = CXXThisTypeOverride;
1006 if (method && method->isInstance())
1007 ThisTy = method->getThisType(Context);
1011 inTemplateInstantiation()) {
1013 assert(isa<CXXRecordDecl>(DC) &&
1014 "Trying to get 'this' type from static method?");
1031 CurContext, Context);
1037 unsigned CXXThisTypeQuals,
1039 : S(S), OldCXXThisTypeOverride(S.CXXThisTypeOverride), Enabled(
false)
1041 if (!Enabled || !ContextDecl)
1046 Record = Template->getTemplatedDecl();
1048 Record = cast<CXXRecordDecl>(ContextDecl);
1056 this->Enabled =
true;
1068 const bool ByCopy) {
1073 QualType CaptureThisFieldTy = ThisTy;
1084 Context, RD, Loc, Loc,
nullptr, CaptureThisFieldTy,
1098 nullptr, CaptureThisFieldTy, Loc);
1109 bool BuildAndDiagnose,
const unsigned *
const FunctionScopeIndexToStopAt,
1110 const bool ByCopy) {
1115 assert((!ByCopy || Explicit) &&
"cannot implicitly capture *this by value");
1117 const unsigned MaxFunctionScopesIndex = FunctionScopeIndexToStopAt ?
1143 unsigned NumCapturingClosures = 0;
1144 for (
unsigned idx = MaxFunctionScopesIndex; idx != 0; idx--) {
1147 if (CSI->CXXThisCaptureIndex != 0) {
1149 CSI->Captures[CSI->CXXThisCaptureIndex - 1].markUsed(BuildAndDiagnose);
1155 if (BuildAndDiagnose)
1156 Diag(Loc, diag::err_this_capture)
1157 << (Explicit && idx == MaxFunctionScopesIndex);
1164 (Explicit && idx == MaxFunctionScopesIndex)) {
1170 NumCapturingClosures++;
1174 if (BuildAndDiagnose)
1175 Diag(Loc, diag::err_this_capture)
1176 << (Explicit && idx == MaxFunctionScopesIndex);
1181 if (!BuildAndDiagnose)
return false;
1193 dyn_cast<LambdaScopeInfo>(
FunctionScopes[MaxFunctionScopesIndex])) &&
1194 "Only a lambda can capture the enclosing object (referred to by " 1199 for (
unsigned idx = MaxFunctionScopesIndex; NumCapturingClosures;
1200 --idx, --NumCapturingClosures) {
1202 Expr *ThisExpr =
nullptr;
1209 ByCopy && idx == MaxFunctionScopesIndex);
1217 bool isNested = NumCapturingClosures > 1;
1229 if (ThisTy.
isNull())
return Diag(Loc, diag::err_invalid_this_use);
1264 if (!
Result.isInvalid() &&
Result.get()->isInstantiationDependent() &&
1265 !
Result.get()->isTypeDependent())
1287 bool ListInitialization = LParenLoc.
isInvalid();
1288 assert((!ListInitialization ||
1289 (Exprs.size() == 1 && isa<InitListExpr>(Exprs[0]))) &&
1290 "List initialization must have initializer list as expression.");
1292 ListInitialization ? Exprs[0]->
getSourceRange().getEnd() : RParenLoc);
1297 ? ListInitialization
1307 if (Deduced && isa<DeducedTemplateSpecializationType>(Deduced)) {
1319 if (Exprs.size() == 1 && !ListInitialization &&
1320 !isa<InitListExpr>(Exprs[0])) {
1321 Expr *Arg = Exprs[0];
1328 if (!ListInitialization)
1329 return ExprError(
Diag(TyBeginLoc, diag::err_value_init_for_array_type)
1337 return ExprError(
Diag(TyBeginLoc, diag::err_init_for_function_type)
1338 << Ty << FullRange);
1345 diag::err_invalid_incomplete_type_use, FullRange))
1358 Inner = BTE->getSubExpr();
1359 if (!isa<CXXTemporaryObjectExpr>(Inner) &&
1360 !isa<CXXScalarValueInitExpr>(Inner)) {
1372 CK_NoOp, Result.
get(),
nullptr, LParenLoc, RParenLoc);
1382 return Method->isUsualDeallocationFunction();
1388 unsigned UsualParams = 1;
1406 struct UsualDeallocFnInfo {
1407 UsualDeallocFnInfo() : Found(), FD(
nullptr) {}
1410 Destroying(
false), HasSizeT(
false), HasAlignValT(
false),
1415 unsigned NumBaseParams = 1;
1416 if (FD->isDestroyingOperatorDelete()) {
1420 if (FD->getNumParams() == NumBaseParams + 2)
1421 HasAlignValT = HasSizeT =
true;
1422 else if (FD->getNumParams() == NumBaseParams + 1) {
1423 HasSizeT = FD->getParamDecl(NumBaseParams)->getType()->isIntegerType();
1424 HasAlignValT = !HasSizeT;
1429 if (
auto *Caller = dyn_cast<FunctionDecl>(S.
CurContext))
1433 operator bool()
const {
return FD; }
1435 bool isBetterThan(
const UsualDeallocFnInfo &Other,
bool WantSize,
1436 bool WantAlign)
const {
1440 if (Destroying != Other.Destroying)
1447 if (HasAlignValT != Other.HasAlignValT)
1448 return HasAlignValT == WantAlign;
1450 if (HasSizeT != Other.HasSizeT)
1451 return HasSizeT == WantSize;
1454 return CUDAPref > Other.CUDAPref;
1459 bool Destroying, HasSizeT, HasAlignValT;
1479 UsualDeallocFnInfo Best;
1481 for (
auto I = R.
begin(), E = R.
end(); I != E; ++I) {
1482 UsualDeallocFnInfo Info(S, I.getPair());
1490 BestFns->push_back(Info);
1494 if (Best.isBetterThan(Info, WantSize, WantAlign))
1499 if (BestFns && Info.isBetterThan(Best, WantSize, WantAlign))
1504 BestFns->push_back(Info);
1518 if (!record)
return false;
1531 if (ops.
empty())
return false;
1543 return Best && Best.HasSizeT;
1567 Expr *ArraySize =
nullptr;
1594 if (!NumElts->isTypeDependent() && !NumElts->isValueDependent()) {
1600 assert(IntWidth &&
"Builtin type of size 0?");
1601 llvm::APSInt
Value(IntWidth);
1609 diag::err_new_array_nonconst)
1625 if (
ParenListExpr *List = dyn_cast_or_null<ParenListExpr>(Initializer))
1626 DirectInitRange = List->getSourceRange();
1645 return PLE->getNumExprs() == 0;
1646 if (isa<ImplicitValueInitExpr>(Init))
1649 return !CCE->isListInitialization() &&
1650 CCE->getConstructor()->isDefaultConstructor();
1652 assert(isa<InitListExpr>(Init) &&
1653 "Shouldn't create list CXXConstructExprs for arrays.");
1664 if (!S.
getLangOpts().AlignedAllocationUnavailable)
1671 bool IsAligned =
false;
1674 StringRef OSName = AvailabilityAttr::getPlatformNameSourceSpelling(
1677 S.
Diag(Loc, diag::warn_aligned_allocation_unavailable)
1680 S.
Diag(Loc, diag::note_silence_unligned_allocation_unavailable);
1694 Expr *Initializer) {
1699 if (DirectInitRange.
isValid()) {
1700 assert(Initializer &&
"Have parens but no initializer.");
1702 }
else if (Initializer && isa<InitListExpr>(Initializer))
1705 assert((!Initializer || isa<ImplicitValueInitExpr>(Initializer) ||
1706 isa<CXXConstructExpr>(Initializer)) &&
1707 "Initializer expression that cannot have been implicitly created.");
1712 unsigned NumInits = Initializer ? 1 : 0;
1713 if (
ParenListExpr *List = dyn_cast_or_null<ParenListExpr>(Initializer)) {
1715 Inits = List->getExprs();
1716 NumInits = List->getNumExprs();
1734 DirectInitRange.
getEnd());
1738 if (Deduced && isa<DeducedTemplateSpecializationType>(Deduced)) {
1741 diag::err_deduced_class_template_compound_type)
1747 AllocTypeInfo, Entity, Kind,
MultiExprArg(Inits, NumInits));
1750 }
else if (Deduced) {
1752 if (NumInits == 1) {
1753 if (
auto p = dyn_cast_or_null<InitListExpr>(Inits[0])) {
1754 Inits = p->getInits();
1755 NumInits = p->getNumInits();
1761 return ExprError(
Diag(StartLoc, diag::err_auto_new_requires_ctor_arg)
1762 << AllocType << TypeRange);
1764 Expr *FirstBad = Inits[1];
1766 diag::err_auto_new_ctor_multiple_expressions)
1767 << AllocType << TypeRange);
1771 << AllocType << TypeRange;
1772 Expr *Deduce = Inits[0];
1775 return ExprError(
Diag(StartLoc, diag::err_auto_new_deduction_failure)
1776 << AllocType << Deduce->getType()
1777 << TypeRange << Deduce->getSourceRange());
1778 if (DeducedType.
isNull())
1780 AllocType = DeducedType;
1791 AllocType = Array->getElementType();
1801 diag::warn_dangling_std_initializer_list)
1818 ArraySize = result.
get();
1836 if (!ConvertedSize.isInvalid() &&
1839 Diag(StartLoc, diag::warn_cxx98_compat_array_size_conversion)
1840 << ArraySize->
getType() << 0 <<
"'size_t'";
1847 SizeConvertDiagnoser(
Expr *ArraySize)
1849 ArraySize(ArraySize) {}
1853 return S.
Diag(Loc, diag::err_array_size_not_integral)
1859 return S.
Diag(Loc, diag::err_array_size_incomplete_type)
1865 return S.
Diag(Loc, diag::err_array_size_explicit_conversion) << T << ConvTy;
1876 return S.
Diag(Loc, diag::err_array_size_ambiguous_conversion) <<
T;
1890 ? diag::warn_cxx98_compat_array_size_conversion
1891 : diag::ext_array_size_conversion)
1894 } SizeDiagnoser(ArraySize);
1902 ArraySize = ConvertedSize.
get();
1923 if (Value.isSigned() && Value.isNegative()) {
1925 diag::err_typecheck_negative_array_size)
1930 unsigned ActiveSizeBits =
1934 diag::err_array_too_large)
1935 << Value.toString(10)
1939 KnownArraySize = Value.getZExtValue();
1940 }
else if (TypeIdParens.
isValid()) {
1957 unsigned Alignment =
1960 bool PassAlignment =
getLangOpts().AlignedAllocation &&
1961 Alignment > NewAlignment;
1967 UseGlobal, AllocType, ArraySize, PassAlignment,
1968 PlacementArgs, OperatorNew, OperatorDelete))
1973 bool UsualArrayDeleteWantsSize =
false;
1975 UsualArrayDeleteWantsSize =
1990 PassAlignment ? 2 : 1, PlacementArgs,
1991 AllPlaceArgs, CallType))
1994 if (!AllPlaceArgs.empty())
1995 PlacementArgs = AllPlaceArgs;
2004 if (PlacementArgs.empty() && !PassAlignment &&
2008 if (Alignment > NewAlignment)
2009 Diag(StartLoc, diag::warn_overaligned_type)
2021 Inits[NumInits - 1]->getLocEnd());
2022 Diag(StartLoc, diag::err_new_array_init_args) << InitRange;
2030 llvm::makeArrayRef(Inits, NumInits))) {
2042 InitType = AllocType;
2057 dyn_cast_or_null<CXXBindTemporaryExpr>(FullInit.
get()))
2058 FullInit = Binder->getSubExpr();
2060 Initializer = FullInit.
get();
2070 if (OperatorDelete) {
2084 cast<CXXRecordDecl>(BaseRecordType->getDecl()))) {
2087 PDiag(diag::err_access_dtor)
2097 UsualArrayDeleteWantsSize, PlacementArgs, TypeIdParens,
2098 ArraySize, initStyle, Initializer, ResultType, AllocTypeInfo,
2099 Range, DirectInitRange);
2109 return Diag(Loc, diag::err_bad_new_type)
2110 << AllocType << 0 << R;
2112 return Diag(Loc, diag::err_bad_new_type)
2113 << AllocType << 1 << R;
2118 diag::err_allocation_of_abstract_type))
2121 return Diag(Loc, diag::err_variably_modified_new_type)
2124 return Diag(Loc, diag::err_address_space_qualified_new)
2132 return Diag(Loc, diag::err_arc_new_array_without_ownership)
2145 Expr *AlignArg =
nullptr) {
2149 Alloc != AllocEnd; ++Alloc) {
2169 switch (Candidates.BestViableFunction(S, R.
getNameLoc(), Best)) {
2186 if (PassAlignment) {
2187 PassAlignment =
false;
2189 Args.erase(Args.begin() + 1);
2191 Operator, &Candidates, AlignArg);
2216 if (AlignedCandidates) {
2218 return C.Function->getNumParams() > 1 &&
2219 C.Function->getParamDecl(1)->getType()->isAlignValT();
2225 Args.insert(Args.begin() + 1, AlignArg);
2228 Args.erase(Args.begin() + 1);
2244 << Best->Function->isDeleted()
2252 llvm_unreachable(
"Unreachable, bad result from BestViableFunction");
2259 bool UseGlobal,
QualType AllocType,
2260 bool IsArray,
bool &PassAlignment,
2274 AllocArgs.reserve((PassAlignment ? 2 : 1) + PlaceArgs.size());
2284 AllocArgs.push_back(&Size);
2287 if (PassAlignment) {
2293 AllocArgs.push_back(&Align);
2295 AllocArgs.insert(AllocArgs.end(), PlaceArgs.begin(), PlaceArgs.end());
2304 IsArray ? OO_Array_New : OO_New);
2331 assert(!R.
empty() &&
"implicitly declared allocation functions not found");
2332 assert(!R.
isAmbiguous() &&
"global allocation functions are ambiguous");
2344 OperatorDelete =
nullptr;
2373 bool FoundGlobalDelete = FoundDelete.
empty();
2374 if (FoundDelete.
empty()) {
2396 bool isPlacementNew = !PlaceArgs.empty() || OperatorNew->
param_size() != 1 ||
2399 if (isPlacementNew) {
2417 for (
unsigned I = 1, N = Proto->
getNumParams(); I < N; ++I)
2424 ExpectedFunctionType
2429 DEnd = FoundDelete.
end();
2433 dyn_cast<FunctionTemplateDecl>((*D)->getUnderlyingDecl())) {
2441 Fn = cast<FunctionDecl>((*D)->getUnderlyingDecl());
2444 ExpectedFunctionType,
2446 ExpectedFunctionType))
2447 Matches.push_back(std::make_pair(D.getPair(), Fn));
2462 *
this, FoundDelete, FoundGlobalDelete,
2466 Matches.push_back(std::make_pair(Selected.Found, Selected.FD));
2470 for (
auto Fn : BestDeallocFns)
2471 Matches.push_back(std::make_pair(Fn.Found, Fn.FD));
2479 if (Matches.size() == 1) {
2480 OperatorDelete = Matches[0].second;
2488 if (
getLangOpts().CPlusPlus11 && isPlacementNew &&
2490 UsualDeallocFnInfo Info(*
this,
2496 bool IsSizedDelete = Info.HasSizeT;
2497 if (IsSizedDelete && !FoundGlobalDelete) {
2498 auto NonSizedDelete =
2501 if (NonSizedDelete && !NonSizedDelete.HasSizeT &&
2502 NonSizedDelete.HasAlignValT == Info.HasAlignValT)
2503 IsSizedDelete =
false;
2506 if (IsSizedDelete) {
2510 PlaceArgs.back()->getLocEnd());
2511 Diag(StartLoc, diag::err_placement_new_non_placement_delete) << R;
2520 }
else if (!Matches.empty()) {
2524 Diag(StartLoc, diag::warn_ambiguous_suitable_delete_function_found)
2525 << DeleteName << AllocElemType;
2527 for (
auto &Match : Matches)
2528 Diag(Match.second->getLocation(),
2529 diag::note_member_declared_here) << DeleteName;
2610 AlignValT->setImplicit(
true);
2622 Params.push_back(Param);
2625 bool HasSizedVariant =
getLangOpts().SizedDeallocation &&
2626 (Kind == OO_Delete || Kind == OO_Array_Delete);
2627 bool HasAlignedVariant =
getLangOpts().AlignedAllocation;
2629 int NumSizeVariants = (HasSizedVariant ? 2 : 1);
2630 int NumAlignVariants = (HasAlignedVariant ? 2 : 1);
2631 for (
int Sized = 0; Sized < NumSizeVariants; ++Sized) {
2633 Params.push_back(SizeT);
2635 for (
int Aligned = 0; Aligned < NumAlignVariants; ++Aligned) {
2648 DeclareGlobalAllocationFunctions(OO_New, VoidPtr, SizeT);
2649 DeclareGlobalAllocationFunctions(OO_Array_New, VoidPtr, SizeT);
2650 DeclareGlobalAllocationFunctions(OO_Delete,
Context.
VoidTy, VoidPtr);
2651 DeclareGlobalAllocationFunctions(OO_Array_Delete,
Context.
VoidTy, VoidPtr);
2664 Alloc != AllocEnd; ++Alloc) {
2667 if (
FunctionDecl *Func = dyn_cast<FunctionDecl>(*Alloc)) {
2668 if (Func->getNumParams() == Params.size()) {
2670 for (
auto *
P : Func->parameters())
2671 FuncParams.push_back(
2673 if (llvm::makeArrayRef(FuncParams) == Params) {
2677 Func->setVisibleDespiteOwningModule();
2687 bool HasBadAllocExceptionSpec
2690 if (HasBadAllocExceptionSpec) {
2693 assert(
StdBadAlloc &&
"Must have std::bad_alloc declared");
2702 auto CreateAllocationFunctionDecl = [&](
Attr *ExtraAttr) {
2706 FnType,
nullptr,
SC_None,
false,
true);
2720 ParamDecls.back()->setImplicit();
2722 Alloc->setParams(ParamDecls);
2730 CreateAllocationFunctionDecl(
nullptr);
2734 CreateAllocationFunctionDecl(CUDAHostAttr::CreateImplicit(
Context));
2735 CreateAllocationFunctionDecl(CUDADeviceAttr::CreateImplicit(
Context));
2740 bool CanProvideSize,
2754 assert(Result.FD &&
"operator delete missing from global scope?");
2766 return OperatorDelete;
2794 Overaligned, &Matches);
2797 if (Matches.size() == 1) {
2798 Operator = cast<CXXMethodDecl>(Matches[0].FD);
2803 Diag(StartLoc, diag::err_deleted_function_use);
2819 if (!Matches.empty()) {
2821 Diag(StartLoc, diag::err_ambiguous_suitable_delete_member_function_found)
2823 for (
auto &Match : Matches)
2824 Diag(Match.FD->getLocation(), diag::note_member_declared_here) << Name;
2831 if (!Found.
empty()) {
2833 Diag(StartLoc, diag::err_no_suitable_delete_member_function_found)
2837 Diag(D->getUnderlyingDecl()->getLocation(),
2838 diag::note_member_declared_here) << Name;
2850 class MismatchingNewDeleteDetector {
2852 enum MismatchResult {
2858 MemberInitMismatches,
2867 explicit MismatchingNewDeleteDetector(
bool EndOfTU)
2868 : Field(
nullptr), IsArrayForm(
false), EndOfTU(EndOfTU),
2869 HasUndefinedConstructors(
false) {}
2886 MismatchResult analyzeField(
FieldDecl *Field,
bool DeleteWasArrayForm);
2896 bool HasUndefinedConstructors;
2908 MismatchResult analyzeMemberExpr(
const MemberExpr *ME);
2931 MismatchResult analyzeInClassInitializer();
2935 MismatchingNewDeleteDetector::MismatchResult
2936 MismatchingNewDeleteDetector::analyzeDeleteExpr(
const CXXDeleteExpr *DE) {
2938 assert(DE &&
"Expected delete-expression");
2941 if (
const MemberExpr *ME = dyn_cast<const MemberExpr>(E)) {
2942 return analyzeMemberExpr(ME);
2943 }
else if (
const DeclRefExpr *D = dyn_cast<const DeclRefExpr>(E)) {
2944 if (!hasMatchingVarInit(D))
2945 return VarInitMismatches;
2951 MismatchingNewDeleteDetector::getNewExprFromInitListOrExpr(
const Expr *E) {
2952 assert(E !=
nullptr &&
"Expected a valid initializer expression");
2954 if (
const InitListExpr *ILE = dyn_cast<const InitListExpr>(E)) {
2955 if (ILE->getNumInits() == 1)
2956 E = dyn_cast<const CXXNewExpr>(ILE->getInit(0)->IgnoreParenImpCasts());
2959 return dyn_cast_or_null<const CXXNewExpr>(E);
2962 bool MismatchingNewDeleteDetector::hasMatchingNewInCtorInit(
2966 (NE = getNewExprFromInitListOrExpr(CI->
getInit()))) {
2967 if (NE->
isArray() == IsArrayForm)
2970 NewExprs.push_back(NE);
2975 bool MismatchingNewDeleteDetector::hasMatchingNewInCtor(
2981 HasUndefinedConstructors =
true;
2984 for (
const auto *CI : cast<const CXXConstructorDecl>(Definition)->inits()) {
2985 if (hasMatchingNewInCtorInit(CI))
2991 MismatchingNewDeleteDetector::MismatchResult
2992 MismatchingNewDeleteDetector::analyzeInClassInitializer() {
2993 assert(Field !=
nullptr &&
"This should be called only for members");
2994 const Expr *InitExpr = Field->getInClassInitializer();
2996 return EndOfTU ? NoMismatch : AnalyzeLater;
2997 if (
const CXXNewExpr *NE = getNewExprFromInitListOrExpr(InitExpr)) {
2998 if (NE->isArray() != IsArrayForm) {
2999 NewExprs.push_back(NE);
3000 return MemberInitMismatches;
3006 MismatchingNewDeleteDetector::MismatchResult
3007 MismatchingNewDeleteDetector::analyzeField(
FieldDecl *Field,
3008 bool DeleteWasArrayForm) {
3009 assert(Field !=
nullptr &&
"Analysis requires a valid class member.");
3010 this->Field = Field;
3011 IsArrayForm = DeleteWasArrayForm;
3013 for (
const auto *CD : RD->
ctors()) {
3014 if (hasMatchingNewInCtor(CD))
3017 if (HasUndefinedConstructors)
3018 return EndOfTU ? NoMismatch : AnalyzeLater;
3019 if (!NewExprs.empty())
3020 return MemberInitMismatches;
3025 MismatchingNewDeleteDetector::MismatchResult
3026 MismatchingNewDeleteDetector::analyzeMemberExpr(
const MemberExpr *ME) {
3027 assert(ME !=
nullptr &&
"Expected a member expression");
3029 return analyzeField(F, IsArrayForm);
3033 bool MismatchingNewDeleteDetector::hasMatchingVarInit(
const DeclRefExpr *D) {
3036 if (VD->hasInit() && (NE = getNewExprFromInitListOrExpr(VD->getInit())) &&
3037 NE->
isArray() != IsArrayForm) {
3038 NewExprs.push_back(NE);
3041 return NewExprs.empty();
3046 const MismatchingNewDeleteDetector &Detector) {
3049 if (!Detector.IsArrayForm)
3058 SemaRef.
Diag(DeleteLoc, diag::warn_mismatched_delete_new)
3059 << Detector.IsArrayForm << H;
3061 for (
const auto *NE : Detector.NewExprs)
3062 SemaRef.
Diag(NE->getExprLoc(), diag::note_allocated_here)
3063 << Detector.IsArrayForm;
3066 void Sema::AnalyzeDeleteExprMismatch(
const CXXDeleteExpr *DE) {
3069 MismatchingNewDeleteDetector Detector(
false);
3070 switch (Detector.analyzeDeleteExpr(DE)) {
3071 case MismatchingNewDeleteDetector::VarInitMismatches:
3072 case MismatchingNewDeleteDetector::MemberInitMismatches: {
3076 case MismatchingNewDeleteDetector::AnalyzeLater: {
3081 case MismatchingNewDeleteDetector::NoMismatch:
3087 bool DeleteWasArrayForm) {
3088 MismatchingNewDeleteDetector Detector(
true);
3089 switch (Detector.analyzeField(Field, DeleteWasArrayForm)) {
3090 case MismatchingNewDeleteDetector::VarInitMismatches:
3091 llvm_unreachable(
"This analysis should have been done for class members.");
3092 case MismatchingNewDeleteDetector::AnalyzeLater:
3093 llvm_unreachable(
"Analysis cannot be postponed any point beyond end of " 3094 "translation unit.");
3095 case MismatchingNewDeleteDetector::MemberInitMismatches:
3098 case MismatchingNewDeleteDetector::NoMismatch:
3109 bool ArrayForm,
Expr *ExE) {
3119 bool ArrayFormAsWritten = ArrayForm;
3120 bool UsualArrayDeleteWantsSize =
false;
3122 if (!Ex.
get()->isTypeDependent()) {
3138 if (ConvPtrType->getPointeeType()->isIncompleteOrObjectType())
3145 return S.
Diag(Loc, diag::err_delete_operand) <<
T;
3150 return S.
Diag(Loc, diag::err_delete_incomplete_class_type) <<
T;
3156 return S.
Diag(Loc, diag::err_delete_explicit_conversion) << T << ConvTy;
3167 return S.
Diag(Loc, diag::err_ambiguous_delete_operand) <<
T;
3179 llvm_unreachable(
"conversion functions are permitted");
3186 Type = Ex.
get()->getType();
3187 if (!Converter.match(Type))
3196 return Diag(Ex.
get()->getLocStart(),
3197 diag::err_address_space_qualified_delete)
3206 Diag(StartLoc, diag::ext_delete_void_ptr_operand)
3207 << Type << Ex.
get()->getSourceRange();
3210 << Type << Ex.
get()->getSourceRange());
3215 diag::warn_delete_incomplete, Ex.
get())) {
3217 PointeeRD = cast<CXXRecordDecl>(RT->getDecl());
3222 Diag(StartLoc, diag::warn_delete_array_type)
3223 << Type << Ex.
get()->getSourceRange()
3229 ArrayForm ? OO_Array_Delete : OO_Delete);
3243 UsualArrayDeleteWantsSize =
3248 else if (OperatorDelete && isa<CXXMethodDecl>(OperatorDelete))
3249 UsualArrayDeleteWantsSize =
3250 UsualDeallocFnInfo(*
this,
3258 const_cast<CXXDestructorDecl*>(Dtor));
3269 if (!OperatorDelete) {
3271 bool CanProvideSize =
3272 IsComplete && (!ArrayForm || UsualArrayDeleteWantsSize ||
3278 Overaligned, DeleteName);
3285 bool IsVirtualDelete =
false;
3289 PDiag(diag::err_access_dtor) << PointeeElem);
3290 IsVirtualDelete = Dtor->isVirtual();
3320 UsualArrayDeleteWantsSize, OperatorDelete, Ex.
get(), StartLoc);
3321 AnalyzeDeleteExprMismatch(Result);
3326 bool IsDelete,
bool CallCanBeVirtual,
3327 bool WarnOnNonAbstractTypes,
3354 Diag(Loc, diag::warn_delete_abstract_non_virtual_dtor) << (IsDelete ? 0 : 1)
3356 }
else if (WarnOnNonAbstractTypes) {
3359 Diag(Loc, diag::warn_delete_non_virtual_dtor) << (IsDelete ? 0 : 1)
3363 std::string TypeStr;
3365 Diag(DtorLoc, diag::note_delete_non_virtual)
3395 diag::err_invalid_use_of_function_type)
3399 diag::err_invalid_use_of_array_type)
3420 llvm_unreachable(
"unexpected condition kind");
3434 llvm::APSInt
Value(1);
3449 From = Cast->getSubExpr();
3461 if (!ToPtrType->getPointeeType().hasQualifiers()) {
3462 switch (StrLit->getKind()) {
3469 return (ToPointeeType->getKind() == BuiltinType::Char_U ||
3470 ToPointeeType->getKind() == BuiltinType::Char_S);
3487 bool HadMultipleCandidates,
3490 default: llvm_unreachable(
"Unhandled cast kind!");
3491 case CK_ConstructorConversion: {
3496 diag::err_allocation_of_abstract_type))
3508 CastLoc, Ty, FoundDecl, cast<CXXConstructorDecl>(Method),
3509 ConstructorArgs, HadMultipleCandidates,
3510 false,
false,
false,
3518 case CK_UserDefinedConversion: {
3528 HadMultipleCandidates);
3529 if (Result.isInvalid())
3533 CK_UserDefinedConversion, Result.get(),
3534 nullptr, Result.get()->getValueKind());
3566 assert(FD &&
"no conversion function for user-defined conversion seq");
3568 CastKind = CK_UserDefinedConversion;
3576 CastKind = CK_ConstructorConversion;
3608 From = CastArg.
get();
3616 PDiag(diag::err_typecheck_ambiguous_condition)
3621 llvm_unreachable(
"Cannot perform an ellipsis conversion");
3626 From->
getType(), From, Action);
3627 assert(Diagnosed &&
"failed to diagnose bad conversion"); (void)Diagnosed;
3665 ConstructorArgs,
false,
3666 false,
false,
false,
3673 false,
false,
false,
3696 ToAtomicType = ToType;
3697 ToType = ToAtomic->getValueType();
3700 QualType InitialFromType = FromType;
3702 switch (SCS.
First) {
3705 FromType = FromAtomic->getValueType().getUnqualifiedType();
3714 assert(!FromRes.isInvalid() &&
"Can't perform deduced conversion?!");
3715 From = FromRes.get();
3716 FromType = From->getType();
3733 llvm_unreachable(
"Improper first standard conversion");
3770 "only enums with fixed underlying type can promote to bool");
3792 CK = CK_FloatingComplexCast;
3794 CK = CK_FloatingComplexToIntegralComplex;
3796 CK = CK_IntegralComplexToFloatingComplex;
3798 CK = CK_IntegralComplexCast;
3825 diag::ext_typecheck_convert_incompatible_pointer)
3826 << ToType << From->
getType() << Action
3830 diag::ext_typecheck_convert_incompatible_pointer)
3831 << From->
getType() << ToType << Action
3842 diag::err_arc_weak_unavailable_assign);
3845 diag::err_arc_convesion_of_weak_unavailable)
3857 if (Kind == CK_BlockPointerToObjCPointerCast) {
3862 if (
getLangOpts().allowsNonTrivialObjCLifetimeQualifiers())
3913 &BasePath, CCK).
get();
3926 nullptr, CCK).
get();
3933 QualType ElType = ToComplex->getElementType();
3941 isFloatingComplex ? CK_FloatingCast : CK_FloatingToIntegral).
get();
3945 isFloatingComplex ? CK_IntegralToFloating : CK_IntegralCast).
get();
3949 isFloatingComplex ? CK_FloatingRealToComplex
3950 : CK_IntegralRealToComplex).
get();
3955 assert(FromComplex);
3962 isFloatingComplex ? CK_FloatingComplexToReal
3963 : CK_IntegralComplexToReal,
3971 isFloatingComplex ? CK_FloatingCast : CK_IntegralToFloating,
3976 isFloatingComplex ? CK_FloatingToIntegral : CK_IntegralCast,
3994 From = FromRes.
get();
3996 "Improper transparent union conversion");
4021 llvm_unreachable(
"Improper second standard conversion");
4024 switch (SCS.
Third) {
4045 CK_NoOp, VK,
nullptr, CCK).
get();
4050 ? diag::ext_deprecated_string_literal_conversion
4051 : diag::warn_deprecated_string_literal_conversion)
4059 llvm_unreachable(
"Improper third standard conversion");
4064 if (!ToAtomicType.
isNull()) {
4099 default: llvm_unreachable(
"not a UTT");
4152 Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
4161 Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
4199 Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
4210 if ((RD->*HasTrivial)() && !(RD->*HasNonTrivial)())
4217 bool FoundOperator =
false;
4220 Op != OpEnd; ++Op) {
4221 if (isa<FunctionTemplateDecl>(*Op))
4225 if((Operator->*IsDesiredOp)()) {
4226 FoundOperator =
true;
4234 return FoundOperator;
4241 assert(!T->
isDependentType() &&
"Cannot evaluate traits of dependent type");
4245 default: llvm_unreachable(
"not a UTT");
4327 return !RD->isUnion() && RD->isEmpty();
4331 return !RD->isUnion() && RD->isPolymorphic();
4335 return !RD->isUnion() && RD->isAbstract();
4351 return RD->hasAttr<FinalAttr>();
4380 if (
CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
4381 return RD->hasTrivialDefaultConstructor() &&
4382 !RD->hasNonTrivialDefaultConstructor();
4390 if (
CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
4391 return RD->hasTrivialMoveConstructor() && !RD->hasNonTrivialMoveConstructor();
4402 return RD->hasTrivialCopyConstructor() &&
4403 !RD->hasNonTrivialCopyConstructor();
4411 if (
CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
4412 return RD->hasTrivialMoveAssignment() && !RD->hasNonTrivialMoveAssignment();
4432 return RD->hasTrivialCopyAssignment() &&
4433 !RD->hasNonTrivialCopyAssignment();
4463 if (
auto *RD = C.getBaseElementType(T)->getAsCXXRecordDecl()) {
4499 if (
CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
4500 return RD->hasTrivialDestructor();
4511 if (C.getBaseElementType(T).isConstQualified())
4546 if (RD->hasTrivialCopyConstructor() &&
4547 !RD->hasNonTrivialCopyConstructor())
4550 bool FoundConstructor =
false;
4556 if (isa<FunctionTemplateDecl>(ND->getUnderlyingDecl()))
4559 if (isa<UsingDecl>(ND))
4561 auto *Constructor = cast<CXXConstructorDecl>(ND->getUnderlyingDecl());
4562 if (Constructor->isCopyConstructor(FoundTQs)) {
4563 FoundConstructor =
true;
4576 return FoundConstructor;
4587 if (
CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl()) {
4588 if (RD->hasTrivialDefaultConstructor() &&
4589 !RD->hasNonTrivialDefaultConstructor())
4592 bool FoundConstructor =
false;
4595 if (isa<FunctionTemplateDecl>(ND->getUnderlyingDecl()))
4598 if (isa<UsingDecl>(ND))
4600 auto *Constructor = cast<CXXConstructorDecl>(ND->getUnderlyingDecl());
4601 if (Constructor->isDefaultConstructor()) {
4602 FoundConstructor =
true;
4614 return FoundConstructor;
4623 return Destructor->isVirtual();
4635 return C.hasUniqueObjectRepresentations(T);
4650 Args[1]->getType(), RParenLoc);
4669 assert(!Args.empty());
4674 for (
const auto *TSI : Args) {
4680 diag::err_incomplete_type_used_in_type_trait_expr))
4696 ArgExprs.reserve(Args.size() - 1);
4697 for (
unsigned I = 1, N = Args.size(); I != N; ++I) {
4698 QualType ArgTy = Args[I]->getType();
4701 OpaqueArgExprs.push_back(
4706 for (
Expr &E : OpaqueArgExprs)
4707 ArgExprs.push_back(&E);
4740 return !Result.
get()->hasNonTrivialCall(S.
Context);
4743 llvm_unreachable(
"unhandled type trait");
4746 default: llvm_unreachable(
"not a TT");
4758 *
this, Kind, KWLoc, Args[0]->getType()))
4761 bool Dependent =
false;
4762 for (
unsigned I = 0, N = Args.size(); I != N; ++I) {
4763 if (Args[I]->getType()->isDependentType()) {
4781 ConvertedArgs.reserve(Args.size());
4783 for (
unsigned I = 0, N = Args.size(); I != N; ++I) {
4789 ConvertedArgs.push_back(TInfo);
4798 "Cannot evaluate traits of dependent types");
4809 if (!rhsRecord || !lhsRecord) {
4812 if (!LHSObjTy || !RHSObjTy)
4817 if (!BaseInterface || !DerivedInterface)
4821 KeyLoc, RhsT, diag::err_incomplete_type_used_in_type_trait_expr))
4828 == (lhsRecord == rhsRecord));
4830 if (lhsRecord == rhsRecord)
4838 diag::err_incomplete_type_used_in_type_trait_expr))
4841 return cast<CXXRecordDecl>(rhsRecord->getDecl())
4842 ->isDerivedFrom(cast<CXXRecordDecl>(lhsRecord->
getDecl()));
4900 Expr *FromPtr = &From;
4934 diag::err_incomplete_type_used_in_type_trait_expr))
4938 diag::err_incomplete_type_used_in_type_trait_expr))
4979 return !Result.get()->hasNonTrivialCall(Self.
Context);
4982 llvm_unreachable(
"unhandled type trait");
4985 default: llvm_unreachable(
"not a BTT");
4987 llvm_unreachable(
"Unknown type trait or not implemented");
5006 assert(!T->
isDependentType() &&
"Cannot evaluate traits of dependent type");
5014 T = AT->getElementType();
5024 diag::err_dimension_expr_not_constant_integer,
5027 if (Value.isSigned() && Value.isNegative()) {
5028 Self.
Diag(KeyLoc, diag::err_dimension_expr_not_constant_integer)
5032 Dim = Value.getLimitedValue();
5036 bool Matched =
false;
5043 T = AT->getElementType();
5048 return CAT->getSize().getLimitedValue();
5054 llvm_unreachable(
"Unknown type trait or not implemented");
5097 llvm_unreachable(
"Expression trait not covered by switch");
5122 assert(!LHS.
get()->getType()->isPlaceholderType() &&
5123 !RHS.
get()->getType()->isPlaceholderType() &&
5124 "placeholders should have been weeded out by now");
5130 else if (LHS.
get()->isRValue())
5139 const char *OpSpelling = isIndirect ?
"->*" :
".*";
5147 Diag(Loc, diag::err_bad_memptr_rhs)
5148 << OpSpelling << RHSType << RHS.
get()->getSourceRange();
5167 LHSType = Ptr->getPointeeType();
5169 Diag(Loc, diag::err_bad_memptr_lhs)
5170 << OpSpelling << 1 << LHSType
5179 OpSpelling, (
int)isIndirect)) {
5184 Diag(Loc, diag::err_bad_memptr_lhs) << OpSpelling
5185 << (int)isIndirect << LHS.
get()->getType();
5192 RHS.
get()->getLocEnd()),
5205 if (isa<CXXScalarValueInitExpr>(RHS.
get()->IgnoreParens())) {
5208 Diag(Loc, diag::err_pointer_to_member_type) << isIndirect;
5227 switch (Proto->getRefQualifier()) {
5233 if (!isIndirect && !LHS.
get()->Classify(
Context).isLValue()) {
5235 if (Proto->isConst())
5237 ? diag::warn_cxx17_compat_pointer_to_const_ref_member_on_rvalue
5238 : diag::ext_pointer_to_const_ref_member_on_rvalue);
5240 Diag(Loc, diag::err_pointer_to_member_oper_value_classify)
5241 << RHSType << 1 << LHS.
get()->getSourceRange();
5246 if (isIndirect || !LHS.
get()->Classify(
Context).isRValue())
5247 Diag(Loc, diag::err_pointer_to_member_oper_value_classify)
5248 << RHSType << 0 << LHS.
get()->getSourceRange();
5263 }
else if (isIndirect) {
5266 VK = LHS.
get()->getValueKind();
5281 bool &HaveConversion,
5283 HaveConversion =
false;
5308 HaveConversion =
true;
5313 return InitSeq.
Diagnose(Self, Entity, Kind, From);
5323 bool FDerivedFromT = FRec && TRec && FRec != TRec &&
5325 if (FRec && TRec && (FRec == TRec || FDerivedFromT ||
5330 if (FRec == TRec || FDerivedFromT) {
5335 HaveConversion =
true;
5340 return InitSeq.
Diagnose(Self, Entity, Kind, From);
5358 HaveConversion = !InitSeq.
Failed();
5361 return InitSeq.
Diagnose(Self, Entity, Kind, From);
5384 LHS.
get(), Best->BuiltinParamTypes[0], Best->Conversions[0],
5391 RHS.
get(), Best->BuiltinParamTypes[1], Best->Conversions[1],
5409 Self.
Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
5410 << LHS.
get()->getType() << RHS.
get()->getType()
5411 << LHS.
get()->getSourceRange() << RHS.
get()->getSourceRange();
5415 Self.
Diag(QuestionLoc, diag::err_conditional_ambiguous_ovl)
5416 << LHS.
get()->getType() << RHS.
get()->getType()
5417 << LHS.
get()->getSourceRange() << RHS.
get()->getSourceRange();
5423 llvm_unreachable(
"Conditional operator has only built-in overloads");
5466 if (!Cond.
get()->isTypeDependent()) {
5478 if (LHS.
get()->isTypeDependent() || RHS.
get()->isTypeDependent())
5485 bool LVoid = LTy->isVoidType();
5487 if (LVoid || RVoid) {
5492 bool LThrow = isa<CXXThrowExpr>(LHS.
get()->IgnoreParenImpCasts());
5493 bool RThrow = isa<CXXThrowExpr>(RHS.
get()->IgnoreParenImpCasts());
5494 if (LThrow != RThrow) {
5495 Expr *NonThrow = LThrow ? RHS.
get() : LHS.
get();
5509 Diag(QuestionLoc, diag::err_conditional_void_nonvoid)
5510 << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1)
5511 << LHS.
get()->getSourceRange() << RHS.
get()->getSourceRange();
5525 bool HaveL2R, HaveR2L;
5532 if (HaveL2R && HaveR2L) {
5533 Diag(QuestionLoc, diag::err_conditional_ambiguous)
5534 << LTy << RTy << LHS.
get()->getSourceRange() << RHS.
get()->getSourceRange();
5544 LTy = LHS.
get()->getType();
5545 }
else if (HaveR2L) {
5548 RTy = RHS.
get()->getType();
5566 bool DerivedToBase, ObjCConversion, ObjCLifetimeConversion;
5568 QuestionLoc, LTy, RTy, DerivedToBase,
5570 !DerivedToBase && !ObjCConversion && !ObjCLifetimeConversion &&
5573 !RHS.
get()->refersToBitField() &&
5574 !RHS.
get()->refersToVectorElement()) {
5576 RTy = RHS.
get()->getType();
5578 QuestionLoc, RTy, LTy, DerivedToBase,
5580 !DerivedToBase && !ObjCConversion && !ObjCLifetimeConversion &&
5581 !LHS.
get()->refersToBitField() &&
5582 !LHS.
get()->refersToVectorElement()) {
5584 LTy = LHS.
get()->getType();
5596 if (Same && LVK == RVK && LVK !=
VK_RValue &&
5597 LHS.
get()->isOrdinaryOrBitFieldObject() &&
5598 RHS.
get()->isOrdinaryOrBitFieldObject()) {
5599 VK = LHS.
get()->getValueKind();
5606 if (LTy->isFunctionPointerType() || LTy->isMemberFunctionPointerType()) {
5612 assert(!LTy.isNull() &&
"failed to find composite pointer type for " 5613 "canonically equivalent function ptr types");
5623 if (!Same && (LTy->isRecordType() || RTy->
isRecordType())) {
5638 LTy = LHS.
get()->getType();
5639 RTy = RHS.get()->getType();
5648 if (LTy->isRecordType()) {
5670 if (LTy->isFunctionPointerType() || LTy->isMemberFunctionPointerType()) {
5672 assert(!LTy.isNull() &&
"failed to find composite pointer type for " 5673 "canonically equivalent function ptr types");
5694 diag::err_typecheck_cond_incompatible_operands) << LTy << RTy
5695 << LHS.
get()->getSourceRange() << RHS.get()->getSourceRange();
5730 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
5731 << LHS.
get()->getType() << RHS.get()->getType()
5732 << LHS.
get()->getSourceRange() << RHS.get()->getSourceRange();
5770 "computing composite pointer type of dependent types");
5782 llvm_unreachable(
"handled above");
5787 assert(EST2 ==
EST_Dynamic &&
"other cases should already be handled");
5788 llvm::SmallPtrSet<QualType, 8> Found;
5792 ExceptionTypeStorage.push_back(E);
5802 llvm_unreachable(
"shouldn't see unresolved exception specifications here");
5805 llvm_unreachable(
"invalid ExceptionSpecificationType");
5833 bool T2IsPointerLike = T2->isAnyPointerType() || T2->isMemberPointerType() ||
5834 T2->isNullPtrType();
5835 if (!T1IsPointerLike && !T2IsPointerLike)
5843 if (T1IsPointerLike &&
5847 ? CK_NullToMemberPointer
5848 : CK_NullToPointer).
get();
5851 if (T2IsPointerLike &&
5855 ? CK_NullToMemberPointer
5856 : CK_NullToPointer).
get();
5861 if (!T1IsPointerLike || !T2IsPointerLike)
5864 "nullptr_t should be a null pointer constant");
5904 unsigned NeedConstBefore = 0;
5915 NeedConstBefore = QualifierUnion.size();
5917 QualifierUnion.push_back(
5919 MemberOfClass.push_back(std::make_pair(
nullptr,
nullptr));
5932 NeedConstBefore = QualifierUnion.size();
5934 QualifierUnion.push_back(
5936 MemberOfClass.push_back(std::make_pair(MemPtr1->
getClass(),
5956 if (QualifierUnion.size() == 1) {
5972 ExceptionTypeStorage);
5975 FPT1->getParamTypes(), EPI1);
5977 FPT2->getParamTypes(), EPI2);
5982 if (NeedConstBefore) {
5986 for (
unsigned I = 0; I != NeedConstBefore; ++I)
5988 QualifierUnion[I] = QualifierUnion[I] | Qualifiers::Const;
5992 auto MOC = MemberOfClass.rbegin();
5993 for (
unsigned CVR : llvm::reverse(QualifierUnion)) {
5995 auto Classes = *MOC++;
5996 if (Classes.first && Classes.second) {
6022 : S(S), E1(E1), E2(E2), Composite(Composite),
6025 E1ToC(S, Entity, Kind, E1), E2ToC(S, Entity, Kind, E2),
6026 Viable(E1ToC && E2ToC) {}
6035 if (E2Result.isInvalid())
6037 E2 = E2Result.getAs<
Expr>();
6044 Conversion C1(*
this, Loc, E1, E2, Composite1);
6046 if (ConvertArgs && C1.perform())
6048 return C1.Composite;
6050 Conversion C2(*
this, Loc, E1, E2, Composite2);
6052 if (C1.Viable == C2.Viable) {
6060 if (ConvertArgs && (C1.Viable ? C1 : C2).perform())
6063 return C1.Viable ? C1.Composite : C2.Composite;
6070 assert(!isa<CXXBindTemporaryExpr>(E) &&
"Double-bound temporary?");
6081 bool ReturnsRetained;
6085 if (
CallExpr *Call = dyn_cast<CallExpr>(E)) {
6086 Expr *Callee = Call->getCallee()->IgnoreParens();
6092 T = BinOp->getRHS()->getType();
6093 else if (
MemberExpr *Mem = dyn_cast<MemberExpr>(Callee))
6094 T = Mem->getMemberDecl()->getType();
6105 assert(FTy &&
"call to value not of function type?");
6110 }
else if (isa<StmtExpr>(E)) {
6111 ReturnsRetained =
true;
6115 }
else if (isa<CastExpr>(E) &&
6116 isa<BlockExpr>(cast<CastExpr>(E)->getSubExpr())) {
6125 D = Send->getMethodDecl();
6126 }
else if (
ObjCBoxedExpr *BoxedExpr = dyn_cast<ObjCBoxedExpr>(E)) {
6127 D = BoxedExpr->getBoxingMethod();
6131 if (ArrayLit->getNumElements() == 0 &&
6135 D = ArrayLit->getArrayWithObjectsMethod();
6137 = dyn_cast<ObjCDictionaryLiteral>(E)) {
6140 if (DictLit->getNumElements() == 0 &&
6144 D = DictLit->getDictWithObjectsMethod();
6147 ReturnsRetained = (D && D->
hasAttr<NSReturnsRetainedAttr>());
6152 if (!ReturnsRetained &&
6163 CastKind ck = (ReturnsRetained ? CK_ARCConsumeObject
6164 : CK_ARCReclaimReturnedObject);
6179 RT = cast<RecordType>(
T);
6181 case Type::ConstantArray:
6182 case Type::IncompleteArray:
6183 case Type::VariableArray:
6184 case Type::DependentSizedArray:
6185 T = cast<ArrayType>(
T)->getElementType().getTypePtr();
6204 PDiag(diag::err_access_dtor_temp)
6235 assert(SubExpr &&
"subexpression can't be null!");
6257 assert(SubStmt &&
"sub-statement can't be null!");
6280 assert(
ExprEvalContexts.back().IsDecltype &&
"not in a decltype expression");
6292 if (
ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
6296 if (SubExpr.
get() == PE->getSubExpr())
6301 if (BO->getOpcode() == BO_Comma) {
6305 if (RHS.
get() == BO->getRHS())
6308 BO->getLHS(), RHS.
get(), BO_Comma, BO->getType(), BO->getValueKind(),
6309 BO->getObjectKind(), BO->getOperatorLoc(), BO->getFPFeatures());
6330 for (
unsigned I = 0, N =
ExprEvalContexts.back().DelayedDecltypeCalls.size();
6333 if (Call == TopCall)
6344 for (
unsigned I = 0, N =
ExprEvalContexts.back().DelayedDecltypeBinds.size();
6348 if (Bind == TopBind)
6360 PDiag(diag::err_access_dtor_temp)
6376 unsigned SkipStart = OperatorArrows.size(), SkipCount = 0;
6379 if (OperatorArrows.size() > Limit) {
6381 SkipStart = (Limit - 1) / 2 + (Limit - 1) % 2;
6382 SkipCount = OperatorArrows.size() - (Limit - 1);
6385 for (
unsigned I = 0; I < OperatorArrows.size(); ) {
6386 if (I == SkipStart) {
6387 S.
Diag(OperatorArrows[I]->getLocation(),
6388 diag::note_operator_arrows_suppressed)
6392 S.
Diag(OperatorArrows[I]->getLocation(), diag::note_operator_arrow_here)
6393 << OperatorArrows[I]->getCallResultType();
6403 bool &MayBePseudoDestructor) {
6407 Base = Result.
get();
6411 Base = Result.
get();
6414 MayBePseudoDestructor =
false;
6419 if (OpKind == tok::arrow)
6424 MayBePseudoDestructor =
true;
6431 if (OpKind == tok::arrow) {
6433 bool NoArrowOperatorFound =
false;
6434 bool FirstIteration =
true;
6437 llvm::SmallPtrSet<CanQualType,8> CTypes;
6442 if (OperatorArrows.size() >=
getLangOpts().ArrowDepth) {
6443 Diag(OpLoc, diag::err_operator_arrow_depth_exceeded)
6446 Diag(OpLoc, diag::note_operator_arrow_depth)
6459 : &NoArrowOperatorFound);
6461 if (NoArrowOperatorFound) {
6462 if (FirstIteration) {
6463 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
6466 OpKind = tok::period;
6469 Diag(OpLoc, diag::err_typecheck_member_reference_arrow)
6474 diag::note_member_reference_arrow_from_operator_arrow);
6479 Base = Result.
get();
6481 OperatorArrows.push_back(OpCall->getDirectCallee());
6484 if (!CTypes.insert(CBaseType).second) {
6485 Diag(OpLoc, diag::err_operator_arrow_circular) << StartingType;
6489 FirstIteration =
false;
6492 if (OpKind == tok::arrow &&
6515 MayBePseudoDestructor =
true;
6518 ObjectType =
nullptr;
6519 MayBePseudoDestructor =
true;
6547 Base = result.
get();
6557 if (OpKind == tok::arrow) {
6562 S.
Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
6563 << ObjectType <<
true 6568 OpKind = tok::period;
6603 if (
CheckArrow(*
this, ObjectType, Base, OpKind, OpLoc))
6611 Diag(OpLoc, diag::err_pseudo_dtor_base_not_scalar)
6620 if (DestructedTypeInfo) {
6633 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
6638 *
this, DestructedType))
6643 ObjectType = DestructedType;
6644 OpKind = tok::arrow;
6646 Diag(DestructedTypeStart, diag::err_pseudo_dtor_type_mismatch)
6651 DestructedType = ObjectType;
6652 DestructedTypeInfo =
6663 Diag(DestructedTypeStart, diag::err_arc_pseudo_dtor_inconstant_quals)
6669 DestructedType = ObjectType;
6671 DestructedTypeStart);
6684 if (ScopeTypeInfo) {
6690 diag::err_pseudo_dtor_type_mismatch)
6695 ScopeTypeInfo =
nullptr;
6701 OpKind == tok::arrow, OpLoc,
6721 "Invalid first type name in pseudo-destructor");
6724 "Invalid second type name in pseudo-destructor");
6727 if (
CheckArrow(*
this, ObjectType, Base, OpKind, OpLoc))
6748 S, &SS,
true,
false, ObjectTypePtrForLookup,
6761 diag::err_pseudo_dtor_destructor_non_type)
6767 DestructedType = ObjectType;
6784 if (T.isInvalid() || !T.get()) {
6786 DestructedType = ObjectType;
6793 if (!DestructedType.
isNull()) {
6794 if (!DestructedTypeInfo)
6808 S, &SS,
true,
false, ObjectTypePtrForLookup,
6812 diag::err_pseudo_dtor_destructor_non_type)
6836 if (T.isInvalid() || !T.get()) {
6844 if (!ScopeType.
isNull() && !ScopeTypeInfo)
6850 ScopeTypeInfo, CCLoc, TildeLoc,
6860 if (
CheckArrow(*
this, ObjectType, Base, OpKind, OpLoc))
6879 bool HadMultipleCandidates) {
6890 SubE = BE->getSubExpr();
6891 if (isa<LambdaExpr>(SubE)) {
6919 if (HadMultipleCandidates)
6929 Exp.
get()->getLocEnd());
6931 if (CheckFunctionCall(Method, CE,
6953 Diag(Operand->
getExprLoc(), diag::warn_side_effects_unevaluated_context);
6975 if (isa<DeclRefExpr>(E))
6979 if (isa<ArraySubscriptExpr>(E))
6983 if (isa<MemberExpr>(E))
6988 if (UO->getOpcode() == UO_Deref)
6993 if (BO->isPtrMemOp())
6997 if (BO->getOpcode() == BO_Comma)
7008 dyn_cast<BinaryConditionalOperator>(E)) {
7009 if (
OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(BCO->getTrueExpr()))
7015 if (isa<PseudoObjectExpr>(E) || isa<ObjCIvarRefExpr>(E))
7073 if (!
T->getDecl()->isComplete()) {
7087 diag::err_incomplete_type);
7105 if (isa<ParmVarDecl>(Var))
return true;
7106 const VarDecl *DefVD =
nullptr;
7111 if (DefVD->
isWeak())
return false;
7140 while (DC && isa<CapturedDecl>(DC))
7144 "The current call operator must be synchronized with Sema's CurContext");
7155 const unsigned NumPotentialCaptures =
7157 for (
unsigned I = 0; I != NumPotentialCaptures; ++I) {
7158 Expr *VarExpr =
nullptr;
7173 !IsFullExprInstantiationDependent)
7180 FunctionScopesArrayRef, Var, S)) {
7181 const unsigned FunctionScopeIndexOfCapturableLambda = Index.getValue();
7183 &FunctionScopeIndexOfCapturableLambda);
7185 const bool IsVarNeverAConstantExpression =
7187 if (!IsFullExprInstantiationDependent || IsVarNeverAConstantExpression) {
7199 DeclRefType,
nullptr)) {
7205 DeclRefType,
nullptr);
7216 FunctionScopesArrayRef,
nullptr, S)) {
7217 const unsigned FunctionScopeIndexOfCapturableLambda = Index.getValue();
7220 &FunctionScopeIndexOfCapturableLambda);
7243 R.setLookupName(ND->getDeclName());
7245 if (ND->isCXXClassMember()) {
7249 Record = NNS->getAsType()->getAsCXXRecordDecl();
7252 dyn_cast<
CXXRecordDecl>(ND->getDeclContext()->getRedeclContext());
7254 R.setNamingClass(Record);
7258 bool MightBeImplicitMember;
7260 MightBeImplicitMember =
true;
7262 MightBeImplicitMember =
false;
7263 else if (R.isOverloadedResult())
7264 MightBeImplicitMember =
false;
7265 else if (R.isUnresolvableResult())
7266 MightBeImplicitMember =
true;
7268 MightBeImplicitMember = isa<FieldDecl>(ND) ||
7269 isa<IndirectFieldDecl>(ND) ||
7270 isa<MSPropertyDecl>(ND);
7272 if (MightBeImplicitMember)
7276 }
else if (
auto *Ivar = dyn_cast<ObjCIvarDecl>(ND)) {
7278 Ivar->getIdentifier());
7292 : TypoExprs(TypoExprs) {}
7294 TypoExprs.insert(TE);
7299 class TransformTypos :
public TreeTransform<TransformTypos> {
7304 llvm::function_ref<ExprResult(Expr *)> ExprFilter;
7306 llvm::SmallDenseMap<TypoExpr *, ExprResult, 2> TransformCache;
7307 llvm::SmallDenseMap<OverloadExpr *, Expr *, 4> OverloadResolution;
7313 void EmitAllDiagnostics() {
7314 for (
auto E : TypoExprs) {
7316 auto &
State = SemaRef.getTypoExprState(TE);
7317 if (State.DiagHandler) {
7327 Replacement.
isInvalid() ? nullptr : Replacement.
get()))
7330 State.DiagHandler(TC);
7332 SemaRef.clearDelayedTypo(TE);
7345 bool CheckAndAdvanceTypoExprCorrectionStreams() {
7346 for (
auto TE : TypoExprs) {
7347 auto &
State = SemaRef.getTypoExprState(TE);
7348 TransformCache.erase(TE);
7349 if (!
State.Consumer->finished())
7351 State.Consumer->resetCorrectionStream();
7357 if (
auto *OE = dyn_cast_or_null<OverloadExpr>(E))
7358 E = OverloadResolution[OE];
7362 if (
auto *DRE = dyn_cast<DeclRefExpr>(E))
7363 return DRE->getFoundDecl();
7364 if (
auto *ME = dyn_cast<MemberExpr>(E))
7378 return ExprFilter(Res.
get());
7383 : BaseTransform(SemaRef), InitDecl(InitDecl), ExprFilter(Filter) {}
7388 Expr *ExecConfig =
nullptr) {
7389 auto Result = BaseTransform::RebuildCallExpr(Callee, LParenLoc, Args,
7390 RParenLoc, ExecConfig);
7391 if (
auto *OE = dyn_cast<OverloadExpr>(Callee)) {
7394 if (
auto *BE = dyn_cast<CXXBindTemporaryExpr>(ResultCall))
7395 ResultCall = BE->getSubExpr();
7396 if (
auto *CE = dyn_cast<CallExpr>(ResultCall))
7397 OverloadResolution[OE] = CE->getCallee();
7410 Res = TryTransform(E);
7415 !CheckAndAdvanceTypoExprCorrectionStreams())
7428 while (!AmbiguousTypoExprs.empty()) {
7429 auto TE = AmbiguousTypoExprs.back();
7430 auto Cached = TransformCache[TE];
7432 State.Consumer->saveCurrentPosition();
7433 TransformCache.erase(TE);
7435 State.Consumer->resetCorrectionStream();
7436 TransformCache.erase(TE);
7440 AmbiguousTypoExprs.remove(TE);
7441 State.Consumer->restoreSavedPosition();
7442 TransformCache[TE] = Cached;
7448 FindTypoExprs(TypoExprs).TraverseStmt(E);
7450 EmitAllDiagnostics();
7459 auto &CacheEntry = TransformCache[E];
7460 if (!TypoExprs.insert(E) && !CacheEntry.isUnset()) {
7465 assert(
State.Consumer &&
"Cannot transform a cleared TypoExpr");
7470 if (InitDecl && TC.getFoundDecl() == InitDecl)
7475 State.RecoveryHandler(SemaRef, E, TC) :
7482 if ((Next =
State.Consumer->peekNextCorrection()) &&
7484 AmbiguousTypoExprs.insert(E);
7486 AmbiguousTypoExprs.remove(E);
7489 "Typo was transformed into a valid-but-null ExprResult");
7490 return CacheEntry = NE;
7508 assert(TyposInContext < ~0U &&
"Recursive call of CorrectDelayedTyposInExpr");
7510 auto TyposResolved = DelayedTypos.size();
7511 auto Result = TransformTypos(*
this, InitDecl, Filter).Transform(E);
7513 TyposResolved -= DelayedTypos.size();
7518 assert(TyposResolved == 0 &&
"Corrected typo but got same Expr back?");
7524 bool DiscardedValue,
7526 bool IsLambdaInitCaptureInitializer) {
7529 if (!FullExpr.
get())
7547 if (!IsLambdaInitCaptureInitializer &&
7552 if (DiscardedValue &&
getLangOpts().DebuggerCastResultToId &&
7559 if (DiscardedValue) {
7573 CheckCompletedExpr(FullExpr.
get(), CC, IsConstexpr);
7622 while (DC && isa<CapturedDecl>(DC))
7625 if (IsInLambdaDeclContext && CurrentLSI &&
7626 CurrentLSI->hasPotentialCaptures() && !FullExpr.
isInvalid())
7670 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 4.13)
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.
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)
void MarkVarDeclODRUsed(VarDecl *Var, SourceLocation Loc, Sema &SemaRef, const unsigned *const FunctionScopeIndexToStopAt)
An instance of this class is created to represent 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 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.
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.
void addThisCapture(bool isNested, SourceLocation Loc, Expr *Cpy, bool ByCopy)
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)
void getPotentialVariableCapture(unsigned Idx, VarDecl *&VD, Expr *&E) const
static InitializedEntity InitializeException(SourceLocation ThrowLoc, QualType Type, bool NRVO)
Create the initialization entity for an exception object.
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.
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.
void addConst()
Add the const type qualifier to this QualType.
ActionResult< Expr * > ExprResult
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in...
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.
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.
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...
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
getParent - Returns the parent of this field declaration, which is the struct in which this field is ...
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...
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 is defined at all, including a deleted definition.
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
getAnyInitializer - Get the initializer for this variable, no matter which declaration it is attached...
QualType getConversionType() const
Returns the type that this conversion function is converting to.
Represents a C++ constructor within a class.
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.
VarDecl - An instance of this class is created to represent 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.
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
Extra information about a function prototype.
void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=false, ConversionSequenceList EarlyConversions=None)
AddOverloadCandidate - Adds the given function to the set of candidate functions, using the given fun...
AccessResult CheckDestructorAccess(SourceLocation Loc, CXXDestructorDecl *Dtor, const PartialDiagnostic &PDiag, QualType objectType=QualType())
std::string getDeletedOrUnavailableSuffix(const FunctionDecl *FD)
Retrieve the message suffix that should be added to a diagnostic complaining about the given function...
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.
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.
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.
bool isObjCObjectOrInterfaceType() const
ExprResult PerformImplicitConversion(Expr *From, QualType ToType, AssignmentAction Action, bool AllowExplicit=false)
PerformImplicitConversion - Perform an implicit conversion of the expression From to the type ToType...
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.
Expr * FixOverloadedFunctionReference(Expr *E, DeclAccessPair FoundDecl, FunctionDecl *Fn)
FixOverloadedFunctionReference - E is an expression that refers to a C++ overloaded function (possibl...
RecordDecl - 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.
TemplateIdAnnotation * TemplateId
When Kind == IK_TemplateId or IK_ConstructorTemplateId, the template-id annotation that contains the ...
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
Boolean conversions (C++ 4.12)
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...
DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name)
Retrieves the declaration name from a parsed unqualified-id.
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...
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
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
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++ 4.8)
bool isReferenceType() const
CXXRecordDecl * getStdBadAlloc() const
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)
static DeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, QualType T, ExprValueKind VK, NamedDecl *FoundD=nullptr, const TemplateArgumentListInfo *TemplateArgs=nullptr)
ExprResult ActOnCXXNullPtrLiteral(SourceLocation Loc)
ActOnCXXNullPtrLiteral - Parse 'nullptr'.
LookupResultKind getResultKind() const
ParsedType getDestructorName(SourceLocation TildeLoc, IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec &SS, ParsedType ObjectType, bool EnteringContext)
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++ 4.6)
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)
QualType getThisType(ASTContext &C) const
Returns the type of the this pointer.
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...
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.
void MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base=nullptr)
Perform reference-marking and odr-use handling for a DeclRefExpr.
SourceLocation getLocStart() const LLVM_READONLY
TypeDecl - 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
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
enum clang::DeclaratorChunk::@198 Kind
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.
void getAsStringInternal(std::string &Str, const PrintingPolicy &Policy) const
bool isNothrow(const ASTContext &Ctx, bool ResultIfDependent=false) const
Determine whether this function type has a non-throwing exception specification.
TypoExpr - Internal placeholder for expressions where typo correction still needs to be performed and...
Qualification conversions (C++ 4.4)
bool FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range, bool UseGlobal, QualType AllocType, bool IsArray, bool &PassAlignment, MultiExprArg PlaceArgs, FunctionDecl *&OperatorNew, FunctionDecl *&OperatorDelete)
FindAllocationFunctions - Finds the overloads of operator new and delete that are appropriate for the...
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++ 4.5)
const LangOptions & LangOpts
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, bool isConstexprSpecified=false)
bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType)
Helper function to determine whether this is the (deprecated) C++ conversion from a string literal to...
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.
static NamedDecl * getDeclFromExpr(Expr *E)
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any...
Transparent Union Conversions.
Retains information about a captured region.
bool isStdInitializerList(QualType Ty, QualType *Element)
Tests whether Ty is an instance of std::initializer_list and, if it is and Element is not NULL...
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
OverloadedOperatorKind getCXXOverloadedOperator() const
getCXXOverloadedOperator - If this name is the name of an overloadable operator in C++ (e...
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...
bool isNonOverloadPlaceholderType() const
Test for a placeholder type other than Overload; see BuiltinType::isNonOverloadPlaceholderType.
Defines a function that returns the minimum OS versions supporting C++17's aligned allocation functio...
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.
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
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...
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.
Expr - 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.
const FunctionProtoType * T
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)
ExprResult BuildCXXTypeConstructExpr(TypeSourceInfo *Type, SourceLocation LParenLoc, MultiExprArg Exprs, SourceLocation RParenLoc)
ActOnCXXTypeConstructExpr - Parse construction of a specified type.
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 CXXUnresolvedConstructExpr * Create(const ASTContext &C, TypeSourceInfo *Type, SourceLocation LParenLoc, ArrayRef< Expr *> Args, SourceLocation RParenLoc)
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.
SmallVectorImpl< OverloadCandidate >::iterator iterator
bool isNullPtrType() const
bool IsVariableAConstantExpression(VarDecl *Var, ASTContext &Context)
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
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.
Represents a C++ template name within the type system.
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++ 4.9)
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)
CXXDestructorDecl * LookupDestructor(CXXRecordDecl *Class)
Look for the destructor of the given class.
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.
ExprResult ActOnFinishFullExpr(Expr *Expr)
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++ 4.1)
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.
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 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.
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++ 4.7)
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
StringRef getPlatformName() const
Retrieve the name of the platform as it is used in the availability attribute.
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.
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...
static InitializedEntity InitializeLambdaCapture(IdentifierInfo *VarID, QualType FieldType, SourceLocation Loc)
Create the initialization entity for a lambda capture.
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.
static void diagnoseUnavailableAlignedAllocation(const FunctionDecl &FD, SourceLocation Loc, bool IsDelete, Sema &S)
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)"...
DeclarationName getName() const
getName - Returns the embedded declaration name.
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.
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.
SourceLocation getLocStart() const LLVM_READONLY
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.
void setDestructor(const CXXDestructorDecl *Dtor)
Objective-C ARC writeback conversion.
const ParmVarDecl * getParamDecl(unsigned i) const
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 resolveAllocationOverload(Sema &S, LookupResult &R, SourceRange Range, SmallVectorImpl< Expr *> &Args, bool &PassAlignment, FunctionDecl *&Operator, OverloadCandidateSet *AlignedCandidates=nullptr, Expr *AlignArg=nullptr)
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...
Pointer conversions (C++ 4.10)
const TypoExprState & getTypoExprState(TypoExpr *TE) const
C++ [over.match.oper]: Lookup of operator function candidates in a call using operator syntax...
ExprResult BuildCXXNew(SourceRange Range, bool UseGlobal, SourceLocation PlacementLParen, MultiExprArg PlacementArgs, SourceLocation PlacementRParen, SourceRange TypeIdParens, QualType AllocType, TypeSourceInfo *AllocTypeInfo, Expr *ArraySize, SourceRange DirectInitRange, Expr *Initializer)
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 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.
VersionTuple alignedAllocMinVersion(llvm::Triple::OSType OS)
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;}).
static Expr * captureThis(Sema &S, ASTContext &Context, RecordDecl *RD, QualType ThisTy, SourceLocation Loc, const bool ByCopy)
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.
MutableArrayRef< Expr * > MultiExprArg
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.
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...
void MarkMemberReferenced(MemberExpr *E)
Perform reference-marking and odr-use handling for a MemberExpr.
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.
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return 0.
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...
bool DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics...
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++ 4.2)
TypeSourceInfo * getTypeSourceInfo() const
bool GlobalNewDeleteDeclared
A flag to remember whether the implicit forms of operator new and delete have been declared...
DeclarationName - 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
Returns 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.
SourceLocation getLocStart() const LLVM_READONLY
Requests that only viable candidates be shown.
A pointer to member type per C++ 8.3.3 - Pointers to members.
bool isIntegerConstantExpr(llvm::APSInt &Result, const ASTContext &Ctx, SourceLocation *Loc=nullptr, bool isEvaluated=true) const
isIntegerConstantExpr - Return true if this expression is a valid integer constant expression...
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 ...
CXXThisScopeRAII(Sema &S, Decl *ContextDecl, unsigned CXXThisTypeQuals, bool Enabled=true)
Introduce a new scope where 'this' may be allowed (when enabled), using the given declaration (which ...
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
IgnoreParenImpCasts - Ignore parentheses and implicit casts.
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)
StmtResult ActOnFinishFullStmt(Stmt *Stmt)
bool isIncompleteArrayType() const
void setHadMultipleCandidates(bool V=true)
Sets the flag telling whether this expression refers to a method that was resolved from an overloaded...
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.
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...
void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl=nullptr, bool IsDecltype=false)
Represents a C++ base or member initializer.
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
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.
void AddTemplateOverloadCandidate(FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false)
Add a C++ function template specialization as a candidate in the candidate set, using template argume...
QualType CheckPointerToMemberOperands(ExprResult &LHS, ExprResult &RHS, ExprValueKind &VK, SourceLocation OpLoc, bool isIndirect)
bool isFunctionType() const
ExprResult ActOnCXXTypeConstructExpr(ParsedType TypeRep, SourceLocation LParenLoc, MultiExprArg Exprs, SourceLocation RParenLoc)
ActOnCXXTypeConstructExpr - Parse construction of a specified type.
SourceLocation getLocStart() const LLVM_READONLY
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)
ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *InputExpr)
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.
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.
unsigned getNumPotentialVariableCaptures() const
A bitfield object is a bitfield on a C or C++ record.
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
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.
QualType withCVRQualifiers(unsigned CVR) const
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.
Expr * NoexceptExpr
Noexcept expression, if this is EST_ComputedNoexcept.
An integral condition for a 'switch' statement.
FunctionDecl * FindDeallocationFunctionForDestructor(SourceLocation StartLoc, CXXRecordDecl *RD)
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++ 4.3)
bool Failed() const
Determine whether the initialization sequence is invalid.
TypeResult ActOnTemplateIdType(CXXScopeSpec &SS, SourceLocation TemplateKWLoc, TemplateTy Template, IdentifierInfo *TemplateII, SourceLocation TemplateIILoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgs, SourceLocation RAngleLoc, bool IsCtorOrDtorName=false, bool IsClassName=false)
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".
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
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 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.
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?
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.
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.
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...
NamedDecl - This represents a decl with a name.
A boolean literal, per ([C++ lex.bool] Boolean literals).
Expr * getRepAsExpr() const
void setAccess(AccessSpecifier AS)
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++ 4.11)
SourceLocation getNameLoc() const
Gets the location of the identifier.
Describes an entity that is being initialized.
static FieldDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable, InClassInitStyle InitStyle)
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...
SourceLocation getLocEnd() const LLVM_READONLY
The global specifier '::'. There is no stored value.
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
SourceLocation getLocStart() const LLVM_READONLY
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.
void clear()
Clears out any current state.
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
isBeingDefined - Return true if this decl is currently being defined.
ParsedTemplateTy Template
The declaration of the template corresponding to the template-name.
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
IgnoreParens - Ignore parentheses.
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).