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,
86 bool EnteringContext) {
89 "not a constructor name");
99 if (SS.
isNotEmpty() && RequireCompleteDeclContext(SS, CurClass))
111 if (RD && RD->isInjectedClassName()) {
112 InjectedClassName = RD;
116 if (!InjectedClassName) {
121 diag::err_incomplete_nested_name_spec) << CurClass << SS.
getRange();
127 DiagnoseUseOfDecl(InjectedClassName, NameLoc);
128 MarkAnyDeclReferenced(NameLoc, InjectedClassName,
false);
138 bool EnteringContext) {
163 bool isDependent =
false;
164 bool LookInScope =
false;
173 SearchType = GetTypeFromParser(ObjectTypePtr);
178 bool AlreadySearched =
false;
179 bool LookAtPrefix =
true;
191 DeclContext *DC = computeDeclContext(SS, EnteringContext);
193 AlreadySearched =
true;
196 }
else if (DC && isa<CXXRecordDecl>(DC)) {
197 LookAtPrefix =
false;
203 if (AlreadySearched) {
205 }
else if (LookAtPrefix && (Prefix = NNS->
getPrefix())) {
208 LookupCtx = computeDeclContext(PrefixSS, EnteringContext);
209 isDependent = isDependentScopeSpecifier(PrefixSS);
210 }
else if (ObjectTypePtr) {
211 LookupCtx = computeDeclContext(SearchType);
214 LookupCtx = computeDeclContext(SS, EnteringContext);
217 }
else if (ObjectTypePtr) {
225 LookupCtx = computeDeclContext(SearchType);
228 "Caller should have completed object type");
236 TypeDecl *NonMatchingTypeDecl =
nullptr;
237 LookupResult Found(*
this, &II, NameLoc, LookupOrdinaryName);
243 if (
Step == 0 && LookupCtx) {
244 if (RequireCompleteDeclContext(SS, LookupCtx))
246 LookupQualifiedName(Found, LookupCtx);
247 }
else if (
Step == 1 && LookInScope && S) {
248 LookupName(Found, S);
259 MarkAnyDeclReferenced(
Type->getLocation(),
Type,
false);
265 return CreateParsedType(T,
270 NonMatchingTypeDecl =
Type;
282 if (
DeclContext *Ctx = computeDeclContext(SS, EnteringContext)) {
288 if (MemberOfType.
isNull())
289 MemberOfType = SearchType;
291 if (MemberOfType.
isNull())
299 = dyn_cast<ClassTemplateSpecializationDecl>(Record->getDecl())) {
300 if (Spec->getSpecializedTemplate()->getCanonicalDecl() ==
301 Template->getCanonicalDecl())
302 return CreateParsedType(
322 if (SpecTemplate->getCanonicalDecl() == Template->getCanonicalDecl())
323 return CreateParsedType(
334 if (DepTemplate->isIdentifier() &&
335 DepTemplate->getIdentifier() == Template->getIdentifier())
336 return CreateParsedType(
357 if (NonMatchingTypeDecl) {
359 Diag(NameLoc, diag::err_destructor_expr_type_mismatch)
361 Diag(NonMatchingTypeDecl->
getLocation(), diag::note_destructor_type_here)
363 }
else if (ObjectTypePtr)
364 Diag(NameLoc, diag::err_ident_in_dtor_not_a_type)
368 diag::err_destructor_class_name);
371 if (
const CXXRecordDecl *Class = dyn_cast_or_null<CXXRecordDecl>(Ctx))
373 Class->getNameAsString());
391 "unexpected type in getDestructorType");
396 QualType SearchType = GetTypeFromParser(ObjectType);
397 if (!SearchType.isNull() && !SearchType->isDependentType() &&
422 Diag(Name.
getLocStart(), diag::err_literal_operator_id_outside_namespace)
433 llvm_unreachable(
"unknown nested name specifier kind");
451 RequireCompleteType(TypeidLoc, T, diag::err_incomplete_typeid))
455 return ExprError(
Diag(TypeidLoc, diag::err_variably_modified_typeid) << T);
466 bool WasEvaluated =
false;
476 CXXRecordDecl *RecordD = cast<CXXRecordDecl>(RecordT->getDecl());
480 if (RequireCompleteType(TypeidLoc, T, diag::err_incomplete_typeid))
490 ExprResult Result = TransformToPotentiallyEvaluated(E);
495 MarkVTableUsed(TypeidLoc, RecordD);
509 E = ImpCastExprToType(E, UnqualT, CK_NoOp, E->
getValueKind()).
get();
514 return ExprError(
Diag(TypeidLoc, diag::err_variably_modified_typeid)
516 else if (!inTemplateInstantiation() &&
521 ? diag::warn_side_effects_typeid
522 : diag::warn_side_effects_unevaluated_context);
534 if (getLangOpts().OpenCLCPlusPlus) {
535 return ExprError(
Diag(OpLoc, diag::err_openclcxx_not_supported)
540 if (!getStdNamespace())
541 return ExprError(
Diag(OpLoc, diag::err_need_header_before_typeid));
543 if (!CXXTypeInfoDecl) {
544 IdentifierInfo *TypeInfoII = &PP.getIdentifierTable().get(
"type_info");
546 LookupQualifiedName(R, getStdNamespace());
550 if (!CXXTypeInfoDecl && LangOpts.MSVCCompat) {
554 if (!CXXTypeInfoDecl)
555 return ExprError(
Diag(OpLoc, diag::err_need_header_before_typeid));
558 if (!getLangOpts().RTTI) {
559 return ExprError(
Diag(OpLoc, diag::err_no_typeid_with_fno_rtti));
575 return BuildCXXTypeId(TypeInfoType, OpLoc, TInfo, RParenLoc);
579 return BuildCXXTypeId(TypeInfoType, OpLoc, (
Expr*)TyOrExpr, RParenLoc);
598 if (
const auto *Uuid = TD->getMostRecentDecl()->getAttr<UuidAttr>()) {
599 UuidAttrs.insert(Uuid);
604 if (
const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(TD)) {
607 const UuidAttr *UuidForTA =
nullptr;
614 UuidAttrs.insert(UuidForTA);
628 if (UuidAttrs.empty())
629 return ExprError(
Diag(TypeidLoc, diag::err_uuidof_without_guid));
630 if (UuidAttrs.size() > 1)
631 return ExprError(
Diag(TypeidLoc, diag::err_uuidof_with_multiple_guids));
632 UuidStr = UuidAttrs.back()->getGuid();
647 UuidStr =
"00000000-0000-0000-0000-000000000000";
651 if (UuidAttrs.empty())
652 return ExprError(
Diag(TypeidLoc, diag::err_uuidof_without_guid));
653 if (UuidAttrs.size() > 1)
654 return ExprError(
Diag(TypeidLoc, diag::err_uuidof_with_multiple_guids));
655 UuidStr = UuidAttrs.back()->getGuid();
674 return ExprError(
Diag(OpLoc, diag::err_need_header_before_ms_uuidof));
690 return BuildCXXUuidof(GuidType, OpLoc, TInfo, RParenLoc);
694 return BuildCXXUuidof(GuidType, OpLoc, (
Expr*)TyOrExpr, RParenLoc);
700 assert((Kind == tok::kw_true || Kind == tok::kw_false) &&
701 "Unknown C++ Boolean value!");
715 bool IsThrownVarInScope =
false;
729 if (
VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
730 if (Var->hasLocalStorage() && !Var->getType().isVolatileQualified()) {
733 IsThrownVarInScope =
true;
747 return BuildCXXThrow(OpLoc, Ex, IsThrownVarInScope);
751 bool IsThrownVarInScope) {
753 if (!getLangOpts().CXXExceptions &&
754 !getSourceManager().isInSystemHeader(OpLoc) &&
755 (!getLangOpts().OpenMPIsDevice ||
756 !getLangOpts().OpenMPHostCXXExceptions ||
757 isInOpenMPTargetExecutionDirective() ||
758 isInOpenMPDeclareTargetContext()))
759 Diag(OpLoc, diag::err_exceptions_disabled) <<
"throw";
762 if (getLangOpts().CUDA)
763 CUDADiagIfDeviceCode(OpLoc, diag::err_cuda_device_exceptions)
764 <<
"throw" << CurrentCUDATarget();
766 if (getCurScope() && getCurScope()->isOpenMPSimdDirectiveScope())
767 Diag(OpLoc, diag::err_omp_simd_region_cannot_use_stmt) <<
"throw";
771 if (CheckCXXThrowOperand(OpLoc, ExceptionObjectTy, Ex))
789 const VarDecl *NRVOVariable =
nullptr;
790 if (IsThrownVarInScope)
791 NRVOVariable = getCopyElisionCandidate(
QualType(), Ex, CES_Strict);
794 OpLoc, ExceptionObjectTy,
795 NRVOVariable !=
nullptr);
796 ExprResult Res = PerformMoveOrCopyInitialization(
797 Entity, NRVOVariable,
QualType(), Ex, IsThrownVarInScope);
809 llvm::DenseMap<CXXRecordDecl *, unsigned> &SubobjectsSeen,
810 llvm::SmallPtrSetImpl<CXXRecordDecl *> &VBases,
811 llvm::SetVector<CXXRecordDecl *> &PublicSubobjectsSeen,
812 bool ParentIsPublic) {
814 CXXRecordDecl *BaseDecl = BS.getType()->getAsCXXRecordDecl();
819 NewSubobject = VBases.insert(BaseDecl).second;
824 ++SubobjectsSeen[BaseDecl];
827 bool PublicPath = ParentIsPublic && BS.getAccessSpecifier() ==
AS_public;
829 PublicSubobjectsSeen.insert(BaseDecl);
839 llvm::DenseMap<CXXRecordDecl *, unsigned> SubobjectsSeen;
840 llvm::SmallSet<CXXRecordDecl *, 2> VBases;
841 llvm::SetVector<CXXRecordDecl *> PublicSubobjectsSeen;
842 SubobjectsSeen[RD] = 1;
843 PublicSubobjectsSeen.insert(RD);
847 for (
CXXRecordDecl *PublicSubobject : PublicSubobjectsSeen) {
849 if (SubobjectsSeen[PublicSubobject] > 1)
852 Objects.push_back(PublicSubobject);
862 bool isPointer =
false;
868 if (RequireCompleteType(ThrowLoc, Ty,
869 isPointer ? diag::err_throw_incomplete_ptr
870 : diag::err_throw_incomplete,
874 if (RequireNonAbstractType(ThrowLoc, ExceptionObjectTy,
875 diag::err_throw_abstract_type, E))
886 MarkVTableUsed(ThrowLoc, RD);
895 MarkFunctionReferenced(E->
getExprLoc(), Destructor);
896 CheckDestructorAccess(E->
getExprLoc(), Destructor,
897 PDiag(diag::err_access_dtor_exception) << Ty);
898 if (DiagnoseUseOfDecl(Destructor, E->
getExprLoc()))
913 for (
CXXRecordDecl *Subobject : UnambiguousPublicSubobjects) {
940 for (
unsigned I = 1, E = CD->
getNumParams(); I != E; ++I) {
941 if (CheckCXXDefaultArgExpr(ThrowLoc, CD, CD->
getParamDecl(I)))
994 for (
int I = FunctionScopes.size();
995 I-- && isa<LambdaScopeInfo>(FunctionScopes[I]) &&
997 cast<LambdaScopeInfo>(FunctionScopes[I])->CallOperator);
999 CurLSI = cast<LambdaScopeInfo>(FunctionScopes[I]);
1006 if (C.isCopyCapture()) {
1017 assert(CurLSI &&
"While computing 'this' capture-type for a generic " 1018 "lambda, we must have a corresponding LambdaScopeInfo");
1020 "While computing 'this' capture-type for a generic lambda, when we " 1021 "run out of enclosing LSI's, yet the enclosing DC is a " 1022 "lambda-call-operator we must be (i.e. Current LSI) in a generic " 1023 "lambda call oeprator");
1026 auto IsThisCaptured =
1030 for (
auto &&C : Closure->
captures()) {
1031 if (C.capturesThis()) {
1042 bool IsByCopyCapture =
false;
1043 bool IsConstCapture =
false;
1046 IsThisCaptured(Closure, IsByCopyCapture, IsConstCapture)) {
1047 if (IsByCopyCapture) {
1063 QualType ThisTy = CXXThisTypeOverride;
1066 if (method && method->isInstance())
1067 ThisTy = method->getThisType(Context);
1071 inTemplateInstantiation()) {
1073 assert(isa<CXXRecordDecl>(DC) &&
1074 "Trying to get 'this' type from static method?");
1091 CurContext, Context);
1097 unsigned CXXThisTypeQuals,
1099 : S(S), OldCXXThisTypeOverride(S.CXXThisTypeOverride), Enabled(
false)
1101 if (!Enabled || !ContextDecl)
1106 Record = Template->getTemplatedDecl();
1108 Record = cast<CXXRecordDecl>(ContextDecl);
1116 this->Enabled =
true;
1128 const bool ByCopy) {
1133 QualType CaptureThisFieldTy = ThisTy;
1144 Context, RD, Loc, Loc,
nullptr, CaptureThisFieldTy,
1158 nullptr, CaptureThisFieldTy, Loc);
1169 bool BuildAndDiagnose,
const unsigned *
const FunctionScopeIndexToStopAt,
1170 const bool ByCopy) {
1175 assert((!ByCopy || Explicit) &&
"cannot implicitly capture *this by value");
1177 const int MaxFunctionScopesIndex = FunctionScopeIndexToStopAt
1178 ? *FunctionScopeIndexToStopAt
1204 unsigned NumCapturingClosures = 0;
1205 for (
int idx = MaxFunctionScopesIndex; idx >= 0; idx--) {
1208 if (CSI->CXXThisCaptureIndex != 0) {
1210 CSI->Captures[CSI->CXXThisCaptureIndex - 1].markUsed(BuildAndDiagnose);
1216 if (BuildAndDiagnose)
1217 Diag(Loc, diag::err_this_capture)
1218 << (Explicit && idx == MaxFunctionScopesIndex);
1225 (Explicit && idx == MaxFunctionScopesIndex)) {
1231 NumCapturingClosures++;
1235 if (BuildAndDiagnose)
1236 Diag(Loc, diag::err_this_capture)
1237 << (Explicit && idx == MaxFunctionScopesIndex);
1242 if (!BuildAndDiagnose)
return false;
1254 dyn_cast<LambdaScopeInfo>(
FunctionScopes[MaxFunctionScopesIndex])) &&
1255 "Only a lambda can capture the enclosing object (referred to by " 1260 for (
int idx = MaxFunctionScopesIndex; NumCapturingClosures;
1261 --idx, --NumCapturingClosures) {
1263 Expr *ThisExpr =
nullptr;
1270 ByCopy && idx == MaxFunctionScopesIndex);
1278 bool isNested = NumCapturingClosures > 1;
1290 if (ThisTy.
isNull())
return Diag(Loc, diag::err_invalid_this_use);
1317 bool ListInitialization) {
1327 RParenOrBraceLoc, ListInitialization);
1331 if (!
Result.isInvalid() &&
Result.get()->isInstantiationDependent() &&
1332 !
Result.get()->isTypeDependent())
1342 bool ListInitialization) {
1351 : SourceRange(LParenOrBraceLoc, RParenOrBraceLoc);
1356 assert((!ListInitialization ||
1357 (Exprs.size() == 1 && isa<InitListExpr>(Exprs[0]))) &&
1358 "List initialization must have initializer list as expression.");
1364 ? ListInitialization
1366 TyBeginLoc, LParenOrBraceLoc, RParenOrBraceLoc)
1376 if (Deduced && isa<DeducedTemplateSpecializationType>(Deduced)) {
1388 if (Exprs.size() == 1 && !ListInitialization &&
1389 !isa<InitListExpr>(Exprs[0])) {
1390 Expr *Arg = Exprs[0];
1398 if (!ListInitialization)
1399 return ExprError(
Diag(TyBeginLoc, diag::err_value_init_for_array_type)
1407 return ExprError(
Diag(TyBeginLoc, diag::err_init_for_function_type)
1408 << Ty << FullRange);
1415 diag::err_invalid_incomplete_type_use, FullRange))
1428 Inner = BTE->getSubExpr();
1429 if (!isa<CXXTemporaryObjectExpr>(Inner) &&
1430 !isa<CXXScalarValueInitExpr>(Inner)) {
1442 : SourceRange(LParenOrBraceLoc, RParenOrBraceLoc);
1455 return Method->isUsualDeallocationFunction();
1461 unsigned UsualParams = 1;
1479 struct UsualDeallocFnInfo {
1480 UsualDeallocFnInfo() : Found(), FD(
nullptr) {}
1483 Destroying(
false), HasSizeT(
false), HasAlignValT(
false),
1488 unsigned NumBaseParams = 1;
1489 if (FD->isDestroyingOperatorDelete()) {
1493 if (FD->getNumParams() == NumBaseParams + 2)
1494 HasAlignValT = HasSizeT =
true;
1495 else if (FD->getNumParams() == NumBaseParams + 1) {
1496 HasSizeT = FD->getParamDecl(NumBaseParams)->getType()->isIntegerType();
1497 HasAlignValT = !HasSizeT;
1502 if (
auto *Caller = dyn_cast<FunctionDecl>(S.
CurContext))
1506 explicit operator bool()
const {
return FD; }
1508 bool isBetterThan(
const UsualDeallocFnInfo &Other,
bool WantSize,
1509 bool WantAlign)
const {
1513 if (Destroying != Other.Destroying)
1520 if (HasAlignValT != Other.HasAlignValT)
1521 return HasAlignValT == WantAlign;
1523 if (HasSizeT != Other.HasSizeT)
1524 return HasSizeT == WantSize;
1527 return CUDAPref > Other.CUDAPref;
1532 bool Destroying, HasSizeT, HasAlignValT;
1552 UsualDeallocFnInfo Best;
1554 for (
auto I = R.
begin(), E = R.
end(); I != E; ++I) {
1555 UsualDeallocFnInfo Info(S, I.getPair());
1563 BestFns->push_back(Info);
1567 if (Best.isBetterThan(Info, WantSize, WantAlign))
1572 if (BestFns && Info.isBetterThan(Best, WantSize, WantAlign))
1577 BestFns->push_back(Info);
1591 if (!record)
return false;
1604 if (ops.
empty())
return false;
1616 return Best && Best.HasSizeT;
1640 Expr *ArraySize =
nullptr;
1667 if (!NumElts->isTypeDependent() && !NumElts->isValueDependent()) {
1673 assert(IntWidth &&
"Builtin type of size 0?");
1674 llvm::APSInt
Value(IntWidth);
1682 diag::err_new_array_nonconst)
1698 if (
ParenListExpr *List = dyn_cast_or_null<ParenListExpr>(Initializer))
1699 DirectInitRange = List->getSourceRange();
1718 return PLE->getNumExprs() == 0;
1719 if (isa<ImplicitValueInitExpr>(Init))
1722 return !CCE->isListInitialization() &&
1723 CCE->getConstructor()->isDefaultConstructor();
1725 assert(isa<InitListExpr>(Init) &&
1726 "Shouldn't create list CXXConstructExprs for arrays.");
1737 if (!S.
getLangOpts().AlignedAllocationUnavailable)
1744 bool IsAligned =
false;
1747 StringRef OSName = AvailabilityAttr::getPlatformNameSourceSpelling(
1750 S.
Diag(Loc, diag::err_aligned_allocation_unavailable)
1753 S.
Diag(Loc, diag::note_silence_unligned_allocation_unavailable);
1767 Expr *Initializer) {
1772 if (DirectInitRange.
isValid()) {
1773 assert(Initializer &&
"Have parens but no initializer.");
1775 }
else if (Initializer && isa<InitListExpr>(Initializer))
1778 assert((!Initializer || isa<ImplicitValueInitExpr>(Initializer) ||
1779 isa<CXXConstructExpr>(Initializer)) &&
1780 "Initializer expression that cannot have been implicitly created.");
1785 unsigned NumInits = Initializer ? 1 : 0;
1786 if (
ParenListExpr *List = dyn_cast_or_null<ParenListExpr>(Initializer)) {
1788 Inits = List->getExprs();
1789 NumInits = List->getNumExprs();
1809 DirectInitRange.
getEnd());
1813 if (Deduced && isa<DeducedTemplateSpecializationType>(Deduced)) {
1816 diag::err_deduced_class_template_compound_type)
1822 AllocTypeInfo, Entity, Kind,
MultiExprArg(Inits, NumInits));
1825 }
else if (Deduced) {
1827 if (NumInits == 1) {
1828 if (
auto p = dyn_cast_or_null<InitListExpr>(Inits[0])) {
1829 Inits = p->getInits();
1830 NumInits = p->getNumInits();
1836 return ExprError(
Diag(StartLoc, diag::err_auto_new_requires_ctor_arg)
1837 << AllocType << TypeRange);
1839 Expr *FirstBad = Inits[1];
1841 diag::err_auto_new_ctor_multiple_expressions)
1842 << AllocType << TypeRange);
1846 << AllocType << TypeRange;
1847 Expr *Deduce = Inits[0];
1850 return ExprError(
Diag(StartLoc, diag::err_auto_new_deduction_failure)
1851 << AllocType << Deduce->getType()
1852 << TypeRange << Deduce->getSourceRange());
1853 if (DeducedType.
isNull())
1855 AllocType = DeducedType;
1866 AllocType = Array->getElementType();
1886 ArraySize = result.
get();
1904 if (!ConvertedSize.isInvalid() &&
1907 Diag(StartLoc, diag::warn_cxx98_compat_array_size_conversion)
1908 << ArraySize->
getType() << 0 <<
"'size_t'";
1915 SizeConvertDiagnoser(
Expr *ArraySize)
1917 ArraySize(ArraySize) {}
1921 return S.
Diag(Loc, diag::err_array_size_not_integral)
1927 return S.
Diag(Loc, diag::err_array_size_incomplete_type)
1933 return S.
Diag(Loc, diag::err_array_size_explicit_conversion) << T << ConvTy;
1944 return S.
Diag(Loc, diag::err_array_size_ambiguous_conversion) << T;
1958 ? diag::warn_cxx98_compat_array_size_conversion
1959 : diag::ext_array_size_conversion)
1962 } SizeDiagnoser(ArraySize);
1970 ArraySize = ConvertedSize.
get();
1991 if (Value.isSigned() && Value.isNegative()) {
1993 diag::err_typecheck_negative_array_size)
1998 unsigned ActiveSizeBits =
2002 diag::err_array_too_large)
2003 << Value.toString(10)
2007 KnownArraySize = Value.getZExtValue();
2008 }
else if (TypeIdParens.
isValid()) {
2025 unsigned Alignment =
2028 bool PassAlignment =
getLangOpts().AlignedAllocation &&
2029 Alignment > NewAlignment;
2036 Scope, Scope, AllocType, ArraySize, PassAlignment,
2037 PlacementArgs, OperatorNew, OperatorDelete))
2042 bool UsualArrayDeleteWantsSize =
false;
2044 UsualArrayDeleteWantsSize =
2059 PassAlignment ? 2 : 1, PlacementArgs,
2060 AllPlaceArgs, CallType))
2063 if (!AllPlaceArgs.empty())
2064 PlacementArgs = AllPlaceArgs;
2073 if (PlacementArgs.empty() && !PassAlignment &&
2077 if (Alignment > NewAlignment)
2078 Diag(StartLoc, diag::warn_overaligned_type)
2090 Inits[NumInits - 1]->getLocEnd());
2091 Diag(StartLoc, diag::err_new_array_init_args) << InitRange;
2099 llvm::makeArrayRef(Inits, NumInits))) {
2111 InitType = AllocType;
2126 dyn_cast_or_null<CXXBindTemporaryExpr>(FullInit.
get()))
2127 FullInit = Binder->getSubExpr();
2129 Initializer = FullInit.
get();
2139 if (OperatorDelete) {
2153 cast<CXXRecordDecl>(BaseRecordType->getDecl()))) {
2156 PDiag(diag::err_access_dtor)
2166 UsualArrayDeleteWantsSize, PlacementArgs, TypeIdParens,
2167 ArraySize, initStyle, Initializer, ResultType, AllocTypeInfo,
2168 Range, DirectInitRange);
2178 return Diag(Loc, diag::err_bad_new_type)
2179 << AllocType << 0 << R;
2181 return Diag(Loc, diag::err_bad_new_type)
2182 << AllocType << 1 << R;
2187 diag::err_allocation_of_abstract_type))
2190 return Diag(Loc, diag::err_variably_modified_new_type)
2194 return Diag(Loc, diag::err_address_space_qualified_new)
2202 return Diag(Loc, diag::err_arc_new_array_without_ownership)
2217 Alloc != AllocEnd; ++Alloc) {
2237 switch (Candidates.BestViableFunction(S, R.
getNameLoc(), Best)) {
2254 if (PassAlignment) {
2255 PassAlignment =
false;
2257 Args.erase(Args.begin() + 1);
2259 Operator, &Candidates, AlignArg,
2287 if (AlignedCandidates) {
2289 return C.Function->getNumParams() > 1 &&
2290 C.Function->getParamDecl(1)->getType()->isAlignValT();
2296 Args.insert(Args.begin() + 1, AlignArg);
2299 Args.erase(Args.begin() + 1);
2326 llvm_unreachable(
"Unreachable, bad result from BestViableFunction");
2348 AllocArgs.reserve((PassAlignment ? 2 : 1) + PlaceArgs.size());
2358 AllocArgs.push_back(&Size);
2361 if (PassAlignment) {
2367 AllocArgs.push_back(&Align);
2369 AllocArgs.insert(AllocArgs.end(), PlaceArgs.begin(), PlaceArgs.end());
2378 IsArray ? OO_Array_New : OO_New);
2410 Diag(StartLoc, diag::err_openclcxx_not_supported) <<
"default new";
2414 assert(!R.
empty() &&
"implicitly declared allocation functions not found");
2415 assert(!R.
isAmbiguous() &&
"global allocation functions are ambiguous");
2421 OperatorNew,
nullptr,
2428 OperatorDelete =
nullptr;
2457 bool FoundGlobalDelete = FoundDelete.
empty();
2458 if (FoundDelete.
empty()) {
2483 bool isPlacementNew = !PlaceArgs.empty() || OperatorNew->
param_size() != 1 ||
2486 if (isPlacementNew) {
2504 for (
unsigned I = 1, N = Proto->
getNumParams(); I < N; ++I)
2511 ExpectedFunctionType
2516 DEnd = FoundDelete.
end();
2520 dyn_cast<FunctionTemplateDecl>((*D)->getUnderlyingDecl())) {
2528 Fn = cast<FunctionDecl>((*D)->getUnderlyingDecl());
2531 ExpectedFunctionType,
2533 ExpectedFunctionType))
2534 Matches.push_back(std::make_pair(D.getPair(), Fn));
2549 *
this, FoundDelete, FoundGlobalDelete,
2553 Matches.push_back(std::make_pair(Selected.Found, Selected.FD));
2557 for (
auto Fn : BestDeallocFns)
2558 Matches.push_back(std::make_pair(Fn.Found, Fn.FD));
2566 if (Matches.size() == 1) {
2567 OperatorDelete = Matches[0].second;
2575 if (
getLangOpts().CPlusPlus11 && isPlacementNew &&
2577 UsualDeallocFnInfo Info(*
this,
2583 bool IsSizedDelete = Info.HasSizeT;
2584 if (IsSizedDelete && !FoundGlobalDelete) {
2585 auto NonSizedDelete =
2588 if (NonSizedDelete && !NonSizedDelete.HasSizeT &&
2589 NonSizedDelete.HasAlignValT == Info.HasAlignValT)
2590 IsSizedDelete =
false;
2593 if (IsSizedDelete) {
2597 PlaceArgs.back()->getLocEnd());
2598 Diag(StartLoc, diag::err_placement_new_non_placement_delete) << R;
2607 }
else if (!Matches.empty()) {
2611 Diag(StartLoc, diag::warn_ambiguous_suitable_delete_function_found)
2612 << DeleteName << AllocElemType;
2614 for (
auto &Match : Matches)
2615 Diag(Match.second->getLocation(),
2616 diag::note_member_declared_here) << DeleteName;
2702 AlignValT->setImplicit(
true);
2714 Params.push_back(Param);
2717 bool HasSizedVariant =
getLangOpts().SizedDeallocation &&
2718 (Kind == OO_Delete || Kind == OO_Array_Delete);
2719 bool HasAlignedVariant =
getLangOpts().AlignedAllocation;
2721 int NumSizeVariants = (HasSizedVariant ? 2 : 1);
2722 int NumAlignVariants = (HasAlignedVariant ? 2 : 1);
2723 for (
int Sized = 0; Sized < NumSizeVariants; ++Sized) {
2725 Params.push_back(SizeT);
2727 for (
int Aligned = 0; Aligned < NumAlignVariants; ++Aligned) {
2740 DeclareGlobalAllocationFunctions(OO_New, VoidPtr, SizeT);
2741 DeclareGlobalAllocationFunctions(OO_Array_New, VoidPtr, SizeT);
2742 DeclareGlobalAllocationFunctions(OO_Delete,
Context.
VoidTy, VoidPtr);
2743 DeclareGlobalAllocationFunctions(OO_Array_Delete,
Context.
VoidTy, VoidPtr);
2756 Alloc != AllocEnd; ++Alloc) {
2759 if (
FunctionDecl *Func = dyn_cast<FunctionDecl>(*Alloc)) {
2760 if (Func->getNumParams() == Params.size()) {
2762 for (
auto *
P : Func->parameters())
2763 FuncParams.push_back(
2765 if (llvm::makeArrayRef(FuncParams) == Params) {
2769 Func->setVisibleDespiteOwningModule();
2779 bool HasBadAllocExceptionSpec
2782 if (HasBadAllocExceptionSpec) {
2785 assert(
StdBadAlloc &&
"Must have std::bad_alloc declared");
2794 auto CreateAllocationFunctionDecl = [&](
Attr *ExtraAttr) {
2798 FnType,
nullptr,
SC_None,
false,
true);
2812 ParamDecls.back()->setImplicit();
2814 Alloc->setParams(ParamDecls);
2822 CreateAllocationFunctionDecl(
nullptr);
2826 CreateAllocationFunctionDecl(CUDAHostAttr::CreateImplicit(
Context));
2827 CreateAllocationFunctionDecl(CUDADeviceAttr::CreateImplicit(
Context));
2832 bool CanProvideSize,
2846 assert(Result.FD &&
"operator delete missing from global scope?");
2858 return OperatorDelete;
2886 Overaligned, &Matches);
2889 if (Matches.size() == 1) {
2890 Operator = cast<CXXMethodDecl>(Matches[0].FD);
2895 Diag(StartLoc, diag::err_deleted_function_use);
2911 if (!Matches.empty()) {
2913 Diag(StartLoc, diag::err_ambiguous_suitable_delete_member_function_found)
2915 for (
auto &Match : Matches)
2916 Diag(Match.FD->getLocation(), diag::note_member_declared_here) << Name;
2923 if (!Found.
empty()) {
2925 Diag(StartLoc, diag::err_no_suitable_delete_member_function_found)
2929 Diag(D->getUnderlyingDecl()->getLocation(),
2930 diag::note_member_declared_here) << Name;
2942 class MismatchingNewDeleteDetector {
2944 enum MismatchResult {
2950 MemberInitMismatches,
2959 explicit MismatchingNewDeleteDetector(
bool EndOfTU)
2960 : Field(
nullptr), IsArrayForm(
false), EndOfTU(EndOfTU),
2961 HasUndefinedConstructors(
false) {}
2978 MismatchResult analyzeField(
FieldDecl *Field,
bool DeleteWasArrayForm);
2988 bool HasUndefinedConstructors;
3000 MismatchResult analyzeMemberExpr(
const MemberExpr *ME);
3023 MismatchResult analyzeInClassInitializer();
3027 MismatchingNewDeleteDetector::MismatchResult
3028 MismatchingNewDeleteDetector::analyzeDeleteExpr(
const CXXDeleteExpr *DE) {
3030 assert(DE &&
"Expected delete-expression");
3033 if (
const MemberExpr *ME = dyn_cast<const MemberExpr>(E)) {
3034 return analyzeMemberExpr(ME);
3035 }
else if (
const DeclRefExpr *D = dyn_cast<const DeclRefExpr>(E)) {
3036 if (!hasMatchingVarInit(D))
3037 return VarInitMismatches;
3043 MismatchingNewDeleteDetector::getNewExprFromInitListOrExpr(
const Expr *E) {
3044 assert(E !=
nullptr &&
"Expected a valid initializer expression");
3046 if (
const InitListExpr *ILE = dyn_cast<const InitListExpr>(E)) {
3047 if (ILE->getNumInits() == 1)
3048 E = dyn_cast<const CXXNewExpr>(ILE->getInit(0)->IgnoreParenImpCasts());
3051 return dyn_cast_or_null<const CXXNewExpr>(E);
3054 bool MismatchingNewDeleteDetector::hasMatchingNewInCtorInit(
3058 (NE = getNewExprFromInitListOrExpr(CI->
getInit()))) {
3059 if (NE->
isArray() == IsArrayForm)
3062 NewExprs.push_back(NE);
3067 bool MismatchingNewDeleteDetector::hasMatchingNewInCtor(
3073 HasUndefinedConstructors =
true;
3076 for (
const auto *CI : cast<const CXXConstructorDecl>(Definition)->inits()) {
3077 if (hasMatchingNewInCtorInit(CI))
3083 MismatchingNewDeleteDetector::MismatchResult
3084 MismatchingNewDeleteDetector::analyzeInClassInitializer() {
3085 assert(Field !=
nullptr &&
"This should be called only for members");
3086 const Expr *InitExpr = Field->getInClassInitializer();
3088 return EndOfTU ? NoMismatch : AnalyzeLater;
3089 if (
const CXXNewExpr *NE = getNewExprFromInitListOrExpr(InitExpr)) {
3090 if (NE->isArray() != IsArrayForm) {
3091 NewExprs.push_back(NE);
3092 return MemberInitMismatches;
3098 MismatchingNewDeleteDetector::MismatchResult
3099 MismatchingNewDeleteDetector::analyzeField(
FieldDecl *Field,
3100 bool DeleteWasArrayForm) {
3101 assert(Field !=
nullptr &&
"Analysis requires a valid class member.");
3102 this->Field = Field;
3103 IsArrayForm = DeleteWasArrayForm;
3105 for (
const auto *CD : RD->
ctors()) {
3106 if (hasMatchingNewInCtor(CD))
3109 if (HasUndefinedConstructors)
3110 return EndOfTU ? NoMismatch : AnalyzeLater;
3111 if (!NewExprs.empty())
3112 return MemberInitMismatches;
3117 MismatchingNewDeleteDetector::MismatchResult
3118 MismatchingNewDeleteDetector::analyzeMemberExpr(
const MemberExpr *ME) {
3119 assert(ME !=
nullptr &&
"Expected a member expression");
3121 return analyzeField(F, IsArrayForm);
3125 bool MismatchingNewDeleteDetector::hasMatchingVarInit(
const DeclRefExpr *D) {
3128 if (VD->hasInit() && (NE = getNewExprFromInitListOrExpr(VD->getInit())) &&
3129 NE->
isArray() != IsArrayForm) {
3130 NewExprs.push_back(NE);
3133 return NewExprs.empty();
3138 const MismatchingNewDeleteDetector &Detector) {
3141 if (!Detector.IsArrayForm)
3150 SemaRef.
Diag(DeleteLoc, diag::warn_mismatched_delete_new)
3151 << Detector.IsArrayForm << H;
3153 for (
const auto *NE : Detector.NewExprs)
3154 SemaRef.
Diag(NE->getExprLoc(), diag::note_allocated_here)
3155 << Detector.IsArrayForm;
3158 void Sema::AnalyzeDeleteExprMismatch(
const CXXDeleteExpr *DE) {
3161 MismatchingNewDeleteDetector Detector(
false);
3162 switch (Detector.analyzeDeleteExpr(DE)) {
3163 case MismatchingNewDeleteDetector::VarInitMismatches:
3164 case MismatchingNewDeleteDetector::MemberInitMismatches: {
3168 case MismatchingNewDeleteDetector::AnalyzeLater: {
3173 case MismatchingNewDeleteDetector::NoMismatch:
3179 bool DeleteWasArrayForm) {
3180 MismatchingNewDeleteDetector Detector(
true);
3181 switch (Detector.analyzeField(Field, DeleteWasArrayForm)) {
3182 case MismatchingNewDeleteDetector::VarInitMismatches:
3183 llvm_unreachable(
"This analysis should have been done for class members.");
3184 case MismatchingNewDeleteDetector::AnalyzeLater:
3185 llvm_unreachable(
"Analysis cannot be postponed any point beyond end of " 3186 "translation unit.");
3187 case MismatchingNewDeleteDetector::MemberInitMismatches:
3190 case MismatchingNewDeleteDetector::NoMismatch:
3201 bool ArrayForm,
Expr *ExE) {
3211 bool ArrayFormAsWritten = ArrayForm;
3212 bool UsualArrayDeleteWantsSize =
false;
3214 if (!Ex.
get()->isTypeDependent()) {
3230 if (ConvPtrType->getPointeeType()->isIncompleteOrObjectType())
3237 return S.
Diag(Loc, diag::err_delete_operand) << T;
3242 return S.
Diag(Loc, diag::err_delete_incomplete_class_type) << T;
3248 return S.
Diag(Loc, diag::err_delete_explicit_conversion) << T << ConvTy;
3259 return S.
Diag(Loc, diag::err_ambiguous_delete_operand) << T;
3271 llvm_unreachable(
"conversion functions are permitted");
3278 Type = Ex.
get()->getType();
3279 if (!Converter.match(Type))
3289 return Diag(Ex.
get()->getLocStart(),
3290 diag::err_address_space_qualified_delete)
3299 Diag(StartLoc, diag::ext_delete_void_ptr_operand)
3300 << Type << Ex.
get()->getSourceRange();
3303 << Type << Ex.
get()->getSourceRange());
3308 diag::warn_delete_incomplete, Ex.
get())) {
3310 PointeeRD = cast<CXXRecordDecl>(RT->getDecl());
3315 Diag(StartLoc, diag::warn_delete_array_type)
3316 << Type << Ex.
get()->getSourceRange()
3322 ArrayForm ? OO_Array_Delete : OO_Delete);
3336 UsualArrayDeleteWantsSize =
3341 else if (OperatorDelete && isa<CXXMethodDecl>(OperatorDelete))
3342 UsualArrayDeleteWantsSize =
3343 UsualDeallocFnInfo(*
this,
3351 const_cast<CXXDestructorDecl*>(Dtor));
3362 if (!OperatorDelete) {
3364 Diag(StartLoc, diag::err_openclcxx_not_supported) <<
"default delete";
3369 bool CanProvideSize =
3370 IsComplete && (!ArrayForm || UsualArrayDeleteWantsSize ||
3376 Overaligned, DeleteName);
3383 bool IsVirtualDelete =
false;
3387 PDiag(diag::err_access_dtor) << PointeeElem);
3388 IsVirtualDelete = Dtor->isVirtual();
3418 UsualArrayDeleteWantsSize, OperatorDelete, Ex.
get(), StartLoc);
3419 AnalyzeDeleteExprMismatch(Result);
3428 IsDelete ? OO_Delete : OO_New);
3432 assert(!R.empty() &&
"implicitly declared allocation functions not found");
3433 assert(!R.isAmbiguous() &&
"global allocation functions are ambiguous");
3436 R.suppressDiagnostics();
3442 FnOvl != FnOvlEnd; ++FnOvl) {
3445 NamedDecl *D = (*FnOvl)->getUnderlyingDecl();
3464 switch (Candidates.BestViableFunction(S, R.getNameLoc(), Best)) {
3468 assert(R.getNamingClass() ==
nullptr &&
3469 "class members should not be considered");
3472 S.
Diag(R.getNameLoc(), diag::err_builtin_operator_new_delete_not_usual)
3473 << (IsDelete ? 1 : 0) << Range;
3474 S.
Diag(FnDecl->
getLocation(), diag::note_non_usual_function_declared_here)
3484 S.
Diag(R.getNameLoc(), diag::err_ovl_no_viable_function_in_call)
3485 << R.getLookupName() << Range;
3490 S.
Diag(R.getNameLoc(), diag::err_ovl_ambiguous_call)
3491 << R.getLookupName() << Range;
3496 S.
Diag(R.getNameLoc(), diag::err_ovl_deleted_call)
3497 << Best->Function->isDeleted() << R.getLookupName()
3503 llvm_unreachable(
"Unreachable, bad result from BestViableFunction");
3507 Sema::SemaBuiltinOperatorNewDeleteOverloaded(
ExprResult TheCallResult,
3509 CallExpr *TheCall = cast<CallExpr>(TheCallResult.
get());
3512 << (IsDelete ?
"__builtin_operator_delete" :
"__builtin_operator_new")
3522 OperatorNewOrDelete))
3524 assert(OperatorNewOrDelete &&
"should be found");
3527 for (
unsigned i = 0; i != TheCall->
getNumArgs(); ++i) {
3538 assert(Callee && Callee->getCastKind() == CK_BuiltinFnToFnPtr &&
3539 "Callee expected to be implicit cast to a builtin function pointer");
3542 return TheCallResult;
3546 bool IsDelete,
bool CallCanBeVirtual,
3547 bool WarnOnNonAbstractTypes,
3574 Diag(Loc, diag::warn_delete_abstract_non_virtual_dtor) << (IsDelete ? 0 : 1)
3576 }
else if (WarnOnNonAbstractTypes) {
3579 Diag(Loc, diag::warn_delete_non_virtual_dtor) << (IsDelete ? 0 : 1)
3583 std::string TypeStr;
3585 Diag(DtorLoc, diag::note_delete_non_virtual)
3615 diag::err_invalid_use_of_function_type)
3619 diag::err_invalid_use_of_array_type)
3640 llvm_unreachable(
"unexpected condition kind");
3654 llvm::APSInt
Value(1);
3669 From = Cast->getSubExpr();
3681 if (!ToPtrType->getPointeeType().hasQualifiers()) {
3682 switch (StrLit->getKind()) {
3689 return (ToPointeeType->getKind() == BuiltinType::Char_U ||
3690 ToPointeeType->getKind() == BuiltinType::Char_S);
3707 bool HadMultipleCandidates,
3710 default: llvm_unreachable(
"Unhandled cast kind!");
3711 case CK_ConstructorConversion: {
3716 diag::err_allocation_of_abstract_type))
3728 CastLoc, Ty, FoundDecl, cast<CXXConstructorDecl>(Method),
3729 ConstructorArgs, HadMultipleCandidates,
3730 false,
false,
false,
3738 case CK_UserDefinedConversion: {
3748 HadMultipleCandidates);
3749 if (Result.isInvalid())
3753 CK_UserDefinedConversion, Result.get(),
3754 nullptr, Result.get()->getValueKind());
3790 assert(FD &&
"no conversion function for user-defined conversion seq");
3792 CastKind = CK_UserDefinedConversion;
3800 CastKind = CK_ConstructorConversion;
3832 From = CastArg.
get();
3846 PDiag(diag::err_typecheck_ambiguous_condition)
3851 llvm_unreachable(
"Cannot perform an ellipsis conversion");
3856 From->
getType(), From, Action);
3857 assert(Diagnosed &&
"failed to diagnose bad conversion"); (void)Diagnosed;
3895 ConstructorArgs,
false,
3896 false,
false,
false,
3903 false,
false,
false,
3926 ToAtomicType = ToType;
3927 ToType = ToAtomic->getValueType();
3930 QualType InitialFromType = FromType;
3932 switch (SCS.
First) {
3935 FromType = FromAtomic->getValueType().getUnqualifiedType();
3944 assert(!FromRes.isInvalid() &&
"Can't perform deduced conversion?!");
3945 From = FromRes.get();
3946 FromType = From->getType();
3963 llvm_unreachable(
"Improper first standard conversion");
4000 "only enums with fixed underlying type can promote to bool");
4022 CK = CK_FloatingComplexCast;
4024 CK = CK_FloatingComplexToIntegralComplex;
4026 CK = CK_IntegralComplexToFloatingComplex;
4028 CK = CK_IntegralComplexCast;
4055 diag::ext_typecheck_convert_incompatible_pointer)
4056 << ToType << From->
getType() << Action
4060 diag::ext_typecheck_convert_incompatible_pointer)
4061 << From->
getType() << ToType << Action
4072 diag::err_arc_weak_unavailable_assign);
4075 diag::err_arc_convesion_of_weak_unavailable)
4087 if (Kind == CK_BlockPointerToObjCPointerCast) {
4092 if (
getLangOpts().allowsNonTrivialObjCLifetimeQualifiers())
4143 &BasePath, CCK).
get();
4156 nullptr, CCK).
get();
4163 QualType ElType = ToComplex->getElementType();
4171 isFloatingComplex ? CK_FloatingCast : CK_FloatingToIntegral).
get();
4175 isFloatingComplex ? CK_IntegralToFloating : CK_IntegralCast).
get();
4179 isFloatingComplex ? CK_FloatingRealToComplex
4180 : CK_IntegralRealToComplex).
get();
4185 assert(FromComplex);
4192 isFloatingComplex ? CK_FloatingComplexToReal
4193 : CK_IntegralComplexToReal,
4201 isFloatingComplex ? CK_FloatingCast : CK_IntegralToFloating,
4206 isFloatingComplex ? CK_FloatingToIntegral : CK_IntegralCast,
4224 From = FromRes.
get();
4226 "Improper transparent union conversion");
4251 llvm_unreachable(
"Improper second standard conversion");
4254 switch (SCS.
Third) {
4275 CK_NoOp, VK,
nullptr, CCK).
get();
4280 ? diag::ext_deprecated_string_literal_conversion
4281 : diag::warn_deprecated_string_literal_conversion)
4289 llvm_unreachable(
"Improper third standard conversion");
4294 if (!ToAtomicType.
isNull()) {
4329 default: llvm_unreachable(
"not a UTT");
4382 Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
4391 Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
4429 Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
4440 if ((RD->*HasTrivial)() && !(RD->*HasNonTrivial)())
4447 bool FoundOperator =
false;
4450 Op != OpEnd; ++Op) {
4451 if (isa<FunctionTemplateDecl>(*Op))
4455 if((Operator->*IsDesiredOp)()) {
4456 FoundOperator =
true;
4464 return FoundOperator;
4471 assert(!T->
isDependentType() &&
"Cannot evaluate traits of dependent type");
4475 default: llvm_unreachable(
"not a UTT");
4557 return !RD->isUnion() && RD->isEmpty();
4561 return !RD->isUnion() && RD->isPolymorphic();
4565 return !RD->isUnion() && RD->isAbstract();
4581 return RD->hasAttr<FinalAttr>();
4610 if (
CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
4611 return RD->hasTrivialDefaultConstructor() &&
4612 !RD->hasNonTrivialDefaultConstructor();
4620 if (
CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
4621 return RD->hasTrivialMoveConstructor() && !RD->hasNonTrivialMoveConstructor();
4632 return RD->hasTrivialCopyConstructor() &&
4633 !RD->hasNonTrivialCopyConstructor();
4641 if (
CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
4642 return RD->hasTrivialMoveAssignment() && !RD->hasNonTrivialMoveAssignment();
4662 return RD->hasTrivialCopyAssignment() &&
4663 !RD->hasNonTrivialCopyAssignment();
4693 if (
auto *RD = C.getBaseElementType(T)->getAsCXXRecordDecl()) {
4729 if (
CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
4730 return RD->hasTrivialDestructor();
4741 if (C.getBaseElementType(T).isConstQualified())
4776 if (RD->hasTrivialCopyConstructor() &&
4777 !RD->hasNonTrivialCopyConstructor())
4780 bool FoundConstructor =
false;
4786 if (isa<FunctionTemplateDecl>(ND->getUnderlyingDecl()))
4789 if (isa<UsingDecl>(ND))
4791 auto *Constructor = cast<CXXConstructorDecl>(ND->getUnderlyingDecl());
4792 if (Constructor->isCopyConstructor(FoundTQs)) {
4793 FoundConstructor =
true;
4806 return FoundConstructor;
4817 if (
CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl()) {
4818 if (RD->hasTrivialDefaultConstructor() &&
4819 !RD->hasNonTrivialDefaultConstructor())
4822 bool FoundConstructor =
false;
4825 if (isa<FunctionTemplateDecl>(ND->getUnderlyingDecl()))
4828 if (isa<UsingDecl>(ND))
4830 auto *Constructor = cast<CXXConstructorDecl>(ND->getUnderlyingDecl());
4831 if (Constructor->isDefaultConstructor()) {
4832 FoundConstructor =
true;
4844 return FoundConstructor;
4853 return Destructor->isVirtual();
4865 return C.hasUniqueObjectRepresentations(T);
4882 Args[1]->getType(), RParenLoc);
4902 assert(!Args.empty());
4907 for (
const auto *TSI : Args) {
4913 diag::err_incomplete_type_used_in_type_trait_expr))
4929 ArgExprs.reserve(Args.size() - 1);
4930 for (
unsigned I = 1, N = Args.size(); I != N; ++I) {
4931 QualType ArgTy = Args[I]->getType();
4934 OpaqueArgExprs.push_back(
4939 for (
Expr &E : OpaqueArgExprs)
4940 ArgExprs.push_back(&E);
4980 return !Result.
get()->hasNonTrivialCall(S.
Context);
4983 llvm_unreachable(
"unhandled type trait");
4986 default: llvm_unreachable(
"not a TT");
4998 *
this, Kind, KWLoc, Args[0]->getType()))
5001 bool Dependent =
false;
5002 for (
unsigned I = 0, N = Args.size(); I != N; ++I) {
5003 if (Args[I]->getType()->isDependentType()) {
5021 ConvertedArgs.reserve(Args.size());
5023 for (
unsigned I = 0, N = Args.size(); I != N; ++I) {
5029 ConvertedArgs.push_back(TInfo);
5038 "Cannot evaluate traits of dependent types");
5049 if (!rhsRecord || !lhsRecord) {
5052 if (!LHSObjTy || !RHSObjTy)
5057 if (!BaseInterface || !DerivedInterface)
5061 KeyLoc, RhsT, diag::err_incomplete_type_used_in_type_trait_expr))
5068 == (lhsRecord == rhsRecord));
5070 if (lhsRecord == rhsRecord)
5078 diag::err_incomplete_type_used_in_type_trait_expr))
5081 return cast<CXXRecordDecl>(rhsRecord->getDecl())
5082 ->isDerivedFrom(cast<CXXRecordDecl>(lhsRecord->
getDecl()));
5140 Expr *FromPtr = &From;
5174 diag::err_incomplete_type_used_in_type_trait_expr))
5178 diag::err_incomplete_type_used_in_type_trait_expr))
5219 return !Result.get()->hasNonTrivialCall(Self.
Context);
5222 llvm_unreachable(
"unhandled type trait");
5225 default: llvm_unreachable(
"not a BTT");
5227 llvm_unreachable(
"Unknown type trait or not implemented");
5246 assert(!T->
isDependentType() &&
"Cannot evaluate traits of dependent type");
5254 T = AT->getElementType();
5264 diag::err_dimension_expr_not_constant_integer,
5267 if (Value.isSigned() && Value.isNegative()) {
5268 Self.
Diag(KeyLoc, diag::err_dimension_expr_not_constant_integer)
5272 Dim = Value.getLimitedValue();
5276 bool Matched =
false;
5283 T = AT->getElementType();
5288 return CAT->getSize().getLimitedValue();
5294 llvm_unreachable(
"Unknown type trait or not implemented");
5337 llvm_unreachable(
"Expression trait not covered by switch");
5362 assert(!LHS.
get()->getType()->isPlaceholderType() &&
5363 !RHS.
get()->getType()->isPlaceholderType() &&
5364 "placeholders should have been weeded out by now");
5370 else if (LHS.
get()->isRValue())
5379 const char *OpSpelling = isIndirect ?
"->*" :
".*";
5387 Diag(Loc, diag::err_bad_memptr_rhs)
5388 << OpSpelling << RHSType << RHS.
get()->getSourceRange();
5407 LHSType = Ptr->getPointeeType();
5409 Diag(Loc, diag::err_bad_memptr_lhs)
5410 << OpSpelling << 1 << LHSType
5419 OpSpelling, (
int)isIndirect)) {
5424 Diag(Loc, diag::err_bad_memptr_lhs) << OpSpelling
5425 << (int)isIndirect << LHS.
get()->getType();
5432 RHS.
get()->getLocEnd()),
5445 if (isa<CXXScalarValueInitExpr>(RHS.
get()->IgnoreParens())) {
5448 Diag(Loc, diag::err_pointer_to_member_type) << isIndirect;
5467 switch (Proto->getRefQualifier()) {
5473 if (!isIndirect && !LHS.
get()->Classify(
Context).isLValue()) {
5476 if (Proto->isConst() && !Proto->isVolatile())
5478 ? diag::warn_cxx17_compat_pointer_to_const_ref_member_on_rvalue
5479 : diag::ext_pointer_to_const_ref_member_on_rvalue);
5481 Diag(Loc, diag::err_pointer_to_member_oper_value_classify)
5482 << RHSType << 1 << LHS.
get()->getSourceRange();
5487 if (isIndirect || !LHS.
get()->Classify(
Context).isRValue())
5488 Diag(Loc, diag::err_pointer_to_member_oper_value_classify)
5489 << RHSType << 0 << LHS.
get()->getSourceRange();
5504 }
else if (isIndirect) {
5507 VK = LHS.
get()->getValueKind();
5522 bool &HaveConversion,
5524 HaveConversion =
false;
5549 HaveConversion =
true;
5554 return InitSeq.
Diagnose(Self, Entity, Kind, From);
5564 bool FDerivedFromT = FRec && TRec && FRec != TRec &&
5566 if (FRec && TRec && (FRec == TRec || FDerivedFromT ||
5571 if (FRec == TRec || FDerivedFromT) {
5576 HaveConversion =
true;
5581 return InitSeq.
Diagnose(Self, Entity, Kind, From);
5599 HaveConversion = !InitSeq.
Failed();
5602 return InitSeq.
Diagnose(Self, Entity, Kind, From);
5625 LHS.
get(), Best->BuiltinParamTypes[0], Best->Conversions[0],
5632 RHS.
get(), Best->BuiltinParamTypes[1], Best->Conversions[1],
5650 Self.
Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
5651 << LHS.
get()->getType() << RHS.
get()->getType()
5652 << LHS.
get()->getSourceRange() << RHS.
get()->getSourceRange();
5656 Self.
Diag(QuestionLoc, diag::err_conditional_ambiguous_ovl)
5657 << LHS.
get()->getType() << RHS.
get()->getType()
5658 << LHS.
get()->getSourceRange() << RHS.
get()->getSourceRange();
5664 llvm_unreachable(
"Conditional operator has only built-in overloads");
5707 if (!Cond.
get()->isTypeDependent()) {
5719 if (LHS.
get()->isTypeDependent() || RHS.
get()->isTypeDependent())
5726 bool LVoid = LTy->isVoidType();
5728 if (LVoid || RVoid) {
5733 bool LThrow = isa<CXXThrowExpr>(LHS.
get()->IgnoreParenImpCasts());
5734 bool RThrow = isa<CXXThrowExpr>(RHS.
get()->IgnoreParenImpCasts());
5735 if (LThrow != RThrow) {
5736 Expr *NonThrow = LThrow ? RHS.
get() : LHS.
get();
5750 Diag(QuestionLoc, diag::err_conditional_void_nonvoid)
5751 << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1)
5752 << LHS.
get()->getSourceRange() << RHS.
get()->getSourceRange();
5766 bool HaveL2R, HaveR2L;
5773 if (HaveL2R && HaveR2L) {
5774 Diag(QuestionLoc, diag::err_conditional_ambiguous)
5775 << LTy << RTy << LHS.
get()->getSourceRange() << RHS.
get()->getSourceRange();
5785 LTy = LHS.
get()->getType();
5786 }
else if (HaveR2L) {
5789 RTy = RHS.
get()->getType();
5807 bool DerivedToBase, ObjCConversion, ObjCLifetimeConversion;
5809 QuestionLoc, LTy, RTy, DerivedToBase,
5811 !DerivedToBase && !ObjCConversion && !ObjCLifetimeConversion &&
5814 !RHS.
get()->refersToBitField() &&
5815 !RHS.
get()->refersToVectorElement()) {
5817 RTy = RHS.
get()->getType();
5819 QuestionLoc, RTy, LTy, DerivedToBase,
5821 !DerivedToBase && !ObjCConversion && !ObjCLifetimeConversion &&
5822 !LHS.
get()->refersToBitField() &&
5823 !LHS.
get()->refersToVectorElement()) {
5825 LTy = LHS.
get()->getType();
5837 if (Same && LVK == RVK && LVK !=
VK_RValue &&
5838 LHS.
get()->isOrdinaryOrBitFieldObject() &&
5839 RHS.
get()->isOrdinaryOrBitFieldObject()) {
5840 VK = LHS.
get()->getValueKind();
5847 if (LTy->isFunctionPointerType() || LTy->isMemberFunctionPointerType()) {
5853 assert(!LTy.isNull() &&
"failed to find composite pointer type for " 5854 "canonically equivalent function ptr types");
5864 if (!Same && (LTy->isRecordType() || RTy->
isRecordType())) {
5879 LTy = LHS.
get()->getType();
5880 RTy = RHS.get()->getType();
5889 if (LTy->isRecordType()) {
5911 if (LTy->isFunctionPointerType() || LTy->isMemberFunctionPointerType()) {
5913 assert(!LTy.isNull() &&
"failed to find composite pointer type for " 5914 "canonically equivalent function ptr types");
5935 diag::err_typecheck_cond_incompatible_operands) << LTy << RTy
5936 << LHS.
get()->getSourceRange() << RHS.get()->getSourceRange();
5971 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
5972 << LHS.
get()->getType() << RHS.get()->getType()
5973 << LHS.
get()->getSourceRange() << RHS.get()->getSourceRange();
6007 "computing composite pointer type of dependent types");
6021 llvm_unreachable(
"handled above");
6026 assert(EST2 ==
EST_Dynamic &&
"other cases should already be handled");
6027 llvm::SmallPtrSet<QualType, 8> Found;
6031 ExceptionTypeStorage.push_back(E);
6041 llvm_unreachable(
"shouldn't see unresolved exception specifications here");
6044 llvm_unreachable(
"invalid ExceptionSpecificationType");
6072 bool T2IsPointerLike = T2->isAnyPointerType() || T2->isMemberPointerType() ||
6073 T2->isNullPtrType();
6074 if (!T1IsPointerLike && !T2IsPointerLike)
6082 if (T1IsPointerLike &&
6086 ? CK_NullToMemberPointer
6087 : CK_NullToPointer).
get();
6090 if (T2IsPointerLike &&
6094 ? CK_NullToMemberPointer
6095 : CK_NullToPointer).
get();
6100 if (!T1IsPointerLike || !T2IsPointerLike)
6103 "nullptr_t should be a null pointer constant");
6143 unsigned NeedConstBefore = 0;
6154 NeedConstBefore = QualifierUnion.size();
6156 QualifierUnion.push_back(
6158 MemberOfClass.push_back(std::make_pair(
nullptr,
nullptr));
6171 NeedConstBefore = QualifierUnion.size();
6173 QualifierUnion.push_back(
6175 MemberOfClass.push_back(std::make_pair(MemPtr1->
getClass(),
6195 if (QualifierUnion.size() == 1) {
6211 ExceptionTypeStorage);
6214 FPT1->getParamTypes(), EPI1);
6216 FPT2->getParamTypes(), EPI2);
6221 if (NeedConstBefore) {
6225 for (
unsigned I = 0; I != NeedConstBefore; ++I)
6227 QualifierUnion[I] = QualifierUnion[I] | Qualifiers::Const;
6231 auto MOC = MemberOfClass.rbegin();
6232 for (
unsigned CVR : llvm::reverse(QualifierUnion)) {
6234 auto Classes = *MOC++;
6235 if (Classes.first && Classes.second) {
6261 : S(S), E1(E1), E2(E2), Composite(Composite),
6264 E1ToC(S, Entity, Kind, E1), E2ToC(S, Entity, Kind, E2),
6265 Viable(E1ToC && E2ToC) {}
6274 if (E2Result.isInvalid())
6276 E2 = E2Result.getAs<
Expr>();
6283 Conversion C1(*
this, Loc, E1, E2, Composite1);
6285 if (ConvertArgs && C1.perform())
6287 return C1.Composite;
6289 Conversion C2(*
this, Loc, E1, E2, Composite2);
6291 if (C1.Viable == C2.Viable) {
6299 if (ConvertArgs && (C1.Viable ? C1 : C2).perform())
6302 return C1.Viable ? C1.Composite : C2.Composite;
6309 assert(!isa<CXXBindTemporaryExpr>(E) &&
"Double-bound temporary?");
6320 bool ReturnsRetained;
6324 if (
CallExpr *Call = dyn_cast<CallExpr>(E)) {
6325 Expr *Callee = Call->getCallee()->IgnoreParens();
6331 T = BinOp->getRHS()->getType();
6332 else if (
MemberExpr *Mem = dyn_cast<MemberExpr>(Callee))
6333 T = Mem->getMemberDecl()->getType();
6344 assert(FTy &&
"call to value not of function type?");
6349 }
else if (isa<StmtExpr>(E)) {
6350 ReturnsRetained =
true;
6354 }
else if (isa<CastExpr>(E) &&
6355 isa<BlockExpr>(cast<CastExpr>(E)->getSubExpr())) {
6364 D = Send->getMethodDecl();
6365 }
else if (
ObjCBoxedExpr *BoxedExpr = dyn_cast<ObjCBoxedExpr>(E)) {
6366 D = BoxedExpr->getBoxingMethod();
6370 if (ArrayLit->getNumElements() == 0 &&
6374 D = ArrayLit->getArrayWithObjectsMethod();
6376 = dyn_cast<ObjCDictionaryLiteral>(E)) {
6379 if (DictLit->getNumElements() == 0 &&
6383 D = DictLit->getDictWithObjectsMethod();
6386 ReturnsRetained = (D && D->
hasAttr<NSReturnsRetainedAttr>());
6391 if (!ReturnsRetained &&
6402 CastKind ck = (ReturnsRetained ? CK_ARCConsumeObject
6403 : CK_ARCReclaimReturnedObject);
6418 RT = cast<RecordType>(T);
6420 case Type::ConstantArray:
6421 case Type::IncompleteArray:
6422 case Type::VariableArray:
6423 case Type::DependentSizedArray:
6424 T = cast<ArrayType>(T)->getElementType().getTypePtr();
6444 PDiag(diag::err_access_dtor_temp)
6475 assert(SubExpr &&
"subexpression can't be null!");
6497 assert(SubStmt &&
"sub-statement can't be null!");
6522 "not in a decltype expression");
6534 if (
ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
6538 if (SubExpr.
get() == PE->getSubExpr())
6543 if (BO->getOpcode() == BO_Comma) {
6547 if (RHS.
get() == BO->getRHS())
6550 BO->getLHS(), RHS.
get(), BO_Comma, BO->getType(), BO->getValueKind(),
6551 BO->getObjectKind(), BO->getOperatorLoc(), BO->getFPFeatures());
6573 for (
unsigned I = 0, N =
ExprEvalContexts.back().DelayedDecltypeCalls.size();
6576 if (Call == TopCall)
6587 for (
unsigned I = 0, N =
ExprEvalContexts.back().DelayedDecltypeBinds.size();
6591 if (Bind == TopBind)
6603 PDiag(diag::err_access_dtor_temp)
6619 unsigned SkipStart = OperatorArrows.size(), SkipCount = 0;
6622 if (OperatorArrows.size() > Limit) {
6624 SkipStart = (Limit - 1) / 2 + (Limit - 1) % 2;
6625 SkipCount = OperatorArrows.size() - (Limit - 1);
6628 for (
unsigned I = 0; I < OperatorArrows.size(); ) {
6629 if (I == SkipStart) {
6630 S.
Diag(OperatorArrows[I]->getLocation(),
6631 diag::note_operator_arrows_suppressed)
6635 S.
Diag(OperatorArrows[I]->getLocation(), diag::note_operator_arrow_here)
6636 << OperatorArrows[I]->getCallResultType();
6646 bool &MayBePseudoDestructor) {
6650 Base = Result.
get();
6654 Base = Result.
get();
6657 MayBePseudoDestructor =
false;
6662 if (OpKind == tok::arrow)
6667 MayBePseudoDestructor =
true;
6674 if (OpKind == tok::arrow) {
6676 bool NoArrowOperatorFound =
false;
6677 bool FirstIteration =
true;
6680 llvm::SmallPtrSet<CanQualType,8> CTypes;
6685 if (OperatorArrows.size() >=
getLangOpts().ArrowDepth) {
6686 Diag(OpLoc, diag::err_operator_arrow_depth_exceeded)
6689 Diag(OpLoc, diag::note_operator_arrow_depth)
6702 : &NoArrowOperatorFound);
6704 if (NoArrowOperatorFound) {
6705 if (FirstIteration) {
6706 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
6709 OpKind = tok::period;
6712 Diag(OpLoc, diag::err_typecheck_member_reference_arrow)
6717 diag::note_member_reference_arrow_from_operator_arrow);
6722 Base = Result.
get();
6724 OperatorArrows.push_back(OpCall->getDirectCallee());
6727 if (!CTypes.insert(CBaseType).second) {
6728 Diag(OpLoc, diag::err_operator_arrow_circular) << StartingType;
6732 FirstIteration =
false;
6735 if (OpKind == tok::arrow &&
6758 MayBePseudoDestructor =
true;
6761 ObjectType =
nullptr;
6762 MayBePseudoDestructor =
true;
6790 Base = result.
get();
6800 if (OpKind == tok::arrow) {
6805 S.
Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
6806 << ObjectType <<
true 6811 OpKind = tok::period;
6846 if (
CheckArrow(*
this, ObjectType, Base, OpKind, OpLoc))
6854 Diag(OpLoc, diag::err_pseudo_dtor_base_not_scalar)
6863 if (DestructedTypeInfo) {
6876 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
6881 *
this, DestructedType))
6886 ObjectType = DestructedType;
6887 OpKind = tok::arrow;
6889 Diag(DestructedTypeStart, diag::err_pseudo_dtor_type_mismatch)
6894 DestructedType = ObjectType;
6895 DestructedTypeInfo =
6906 Diag(DestructedTypeStart, diag::err_arc_pseudo_dtor_inconstant_quals)
6912 DestructedType = ObjectType;
6914 DestructedTypeStart);
6927 if (ScopeTypeInfo) {
6933 diag::err_pseudo_dtor_type_mismatch)
6938 ScopeTypeInfo =
nullptr;
6944 OpKind == tok::arrow, OpLoc,
6964 "Invalid first type name in pseudo-destructor");
6967 "Invalid second type name in pseudo-destructor");
6970 if (
CheckArrow(*
this, ObjectType, Base, OpKind, OpLoc))
6991 S, &SS,
true,
false, ObjectTypePtrForLookup,
7004 diag::err_pseudo_dtor_destructor_non_type)
7010 DestructedType = ObjectType;
7027 if (T.isInvalid() || !T.get()) {
7029 DestructedType = ObjectType;
7036 if (!DestructedType.
isNull()) {
7037 if (!DestructedTypeInfo)
7051 S, &SS,
true,
false, ObjectTypePtrForLookup,
7055 diag::err_pseudo_dtor_destructor_non_type)
7079 if (T.isInvalid() || !T.get()) {
7087 if (!ScopeType.
isNull() && !ScopeTypeInfo)
7093 ScopeTypeInfo, CCLoc, TildeLoc,
7103 if (
CheckArrow(*
this, ObjectType, Base, OpKind, OpLoc))
7122 bool HadMultipleCandidates) {
7140 SubE = BE->getSubExpr();
7141 if (isa<LambdaExpr>(SubE)) {
7151 Exp.
get()->getExprLoc(), Exp.
get()->getExprLoc(), Method, Exp.
get());
7155 Diag(Exp.
get()->getExprLoc(), diag::note_lambda_to_block_conv);
7163 if (HadMultipleCandidates)
7173 Exp.
get()->getLocEnd());
7175 if (CheckFunctionCall(Method, CE,
7197 Diag(Operand->
getExprLoc(), diag::warn_side_effects_unevaluated_context);
7219 if (isa<DeclRefExpr>(E))
7223 if (isa<ArraySubscriptExpr>(E))
7227 if (isa<MemberExpr>(E))
7232 if (UO->getOpcode() == UO_Deref)
7237 if (BO->isPtrMemOp())
7241 if (BO->getOpcode() == BO_Comma)
7252 dyn_cast<BinaryConditionalOperator>(E)) {
7253 if (
OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(BCO->getTrueExpr()))
7259 if (isa<PseudoObjectExpr>(E) || isa<ObjCIvarRefExpr>(E))
7317 if (!T->getDecl()->isComplete()) {
7331 diag::err_incomplete_type);
7349 if (isa<ParmVarDecl>(Var))
return true;
7350 const VarDecl *DefVD =
nullptr;
7355 if (DefVD->
isWeak())
return false;
7384 while (DC && isa<CapturedDecl>(DC))
7388 "The current call operator must be synchronized with Sema's CurContext");
7396 const unsigned NumPotentialCaptures =
7398 for (
unsigned I = 0; I != NumPotentialCaptures; ++I) {
7399 Expr *VarExpr =
nullptr;
7414 !IsFullExprInstantiationDependent)
7422 const unsigned FunctionScopeIndexOfCapturableLambda = Index.getValue();
7424 &FunctionScopeIndexOfCapturableLambda);
7426 const bool IsVarNeverAConstantExpression =
7428 if (!IsFullExprInstantiationDependent || IsVarNeverAConstantExpression) {
7440 DeclRefType,
nullptr)) {
7446 DeclRefType,
nullptr);
7458 const unsigned FunctionScopeIndexOfCapturableLambda = Index.getValue();
7461 &FunctionScopeIndexOfCapturableLambda);
7484 R.setLookupName(ND->getDeclName());
7486 if (ND->isCXXClassMember()) {
7490 Record = NNS->getAsType()->getAsCXXRecordDecl();
7493 dyn_cast<
CXXRecordDecl>(ND->getDeclContext()->getRedeclContext());
7495 R.setNamingClass(Record);
7499 bool MightBeImplicitMember;
7501 MightBeImplicitMember =
true;
7503 MightBeImplicitMember =
false;
7504 else if (R.isOverloadedResult())
7505 MightBeImplicitMember =
false;
7506 else if (R.isUnresolvableResult())
7507 MightBeImplicitMember =
true;
7509 MightBeImplicitMember = isa<FieldDecl>(ND) ||
7510 isa<IndirectFieldDecl>(ND) ||
7511 isa<MSPropertyDecl>(ND);
7513 if (MightBeImplicitMember)
7517 }
else if (
auto *Ivar = dyn_cast<ObjCIvarDecl>(ND)) {
7519 Ivar->getIdentifier());
7533 : TypoExprs(TypoExprs) {}
7535 TypoExprs.insert(TE);
7540 class TransformTypos :
public TreeTransform<TransformTypos> {
7545 llvm::function_ref<ExprResult(Expr *)> ExprFilter;
7547 llvm::SmallDenseMap<TypoExpr *, ExprResult, 2> TransformCache;
7548 llvm::SmallDenseMap<OverloadExpr *, Expr *, 4> OverloadResolution;
7554 void EmitAllDiagnostics() {
7556 auto &
State = SemaRef.getTypoExprState(TE);
7557 if (
State.DiagHandler) {
7567 Replacement.
isInvalid() ? nullptr : Replacement.
get()))
7570 State.DiagHandler(TC);
7572 SemaRef.clearDelayedTypo(TE);
7585 bool CheckAndAdvanceTypoExprCorrectionStreams() {
7586 for (
auto TE : TypoExprs) {
7587 auto &
State = SemaRef.getTypoExprState(TE);
7588 TransformCache.erase(TE);
7589 if (!
State.Consumer->finished())
7591 State.Consumer->resetCorrectionStream();
7597 if (
auto *OE = dyn_cast_or_null<OverloadExpr>(E))
7598 E = OverloadResolution[OE];
7602 if (
auto *DRE = dyn_cast<DeclRefExpr>(E))
7603 return DRE->getFoundDecl();
7604 if (
auto *ME = dyn_cast<MemberExpr>(E))
7618 return ExprFilter(Res.
get());
7623 : BaseTransform(SemaRef), InitDecl(InitDecl), ExprFilter(Filter) {}
7628 Expr *ExecConfig =
nullptr) {
7629 auto Result = BaseTransform::RebuildCallExpr(Callee, LParenLoc, Args,
7630 RParenLoc, ExecConfig);
7631 if (
auto *OE = dyn_cast<OverloadExpr>(Callee)) {
7634 if (
auto *BE = dyn_cast<CXXBindTemporaryExpr>(ResultCall))
7635 ResultCall = BE->getSubExpr();
7636 if (
auto *CE = dyn_cast<CallExpr>(ResultCall))
7637 OverloadResolution[OE] = CE->getCallee();
7650 Res = TryTransform(E);
7655 !CheckAndAdvanceTypoExprCorrectionStreams())
7668 while (!AmbiguousTypoExprs.empty()) {
7669 auto TE = AmbiguousTypoExprs.back();
7670 auto Cached = TransformCache[TE];
7672 State.Consumer->saveCurrentPosition();
7673 TransformCache.erase(TE);
7675 State.Consumer->resetCorrectionStream();
7676 TransformCache.erase(TE);
7680 AmbiguousTypoExprs.remove(TE);
7681 State.Consumer->restoreSavedPosition();
7682 TransformCache[TE] = Cached;
7688 FindTypoExprs(TypoExprs).TraverseStmt(E);
7690 EmitAllDiagnostics();
7699 auto &CacheEntry = TransformCache[E];
7700 if (!TypoExprs.insert(E) && !CacheEntry.isUnset()) {
7705 assert(
State.Consumer &&
"Cannot transform a cleared TypoExpr");
7710 if (InitDecl && TC.getFoundDecl() == InitDecl)
7715 State.RecoveryHandler(SemaRef, E, TC) :
7722 if ((Next =
State.Consumer->peekNextCorrection()) &&
7724 AmbiguousTypoExprs.insert(E);
7726 AmbiguousTypoExprs.remove(E);
7729 "Typo was transformed into a valid-but-null ExprResult");
7730 return CacheEntry = NE;
7747 auto TyposResolved = DelayedTypos.size();
7748 auto Result = TransformTypos(*
this, InitDecl, Filter).Transform(E);
7749 TyposResolved -= DelayedTypos.size();
7754 assert(TyposResolved == 0 &&
"Corrected typo but got same Expr back?");
7760 bool DiscardedValue,
7762 bool IsLambdaInitCaptureInitializer) {
7765 if (!FullExpr.
get())
7783 if (!IsLambdaInitCaptureInitializer &&
7788 if (DiscardedValue &&
getLangOpts().DebuggerCastResultToId &&
7795 if (DiscardedValue) {
7809 CheckCompletedExpr(FullExpr.
get(), CC, IsConstexpr);
7858 while (DC && isa<CapturedDecl>(DC))
7861 if (IsInLambdaDeclContext && CurrentLSI &&
7862 CurrentLSI->hasPotentialCaptures() && !FullExpr.
isInvalid())
7906 llvm_unreachable(
"Invalid LookupResult Kind!");
static bool CheckArrow(Sema &S, QualType &ObjectType, Expr *&Base, tok::TokenKind &OpKind, SourceLocation OpLoc)
A call to an overloaded operator written using operator syntax.
Function pointer conversion (C++17 [conv.fctptr])
DeclAccessPair FoundConversionFunction
The declaration that we found via name lookup, which might be the same as ConversionFunction or it mi...
Defines the clang::ASTContext interface.
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)
Represents a function declaration or definition.
bool FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD, DeclarationName Name, FunctionDecl *&Operator, bool Diagnose=true)
Name lookup found a set of overloaded functions that met the criteria.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
bool EllipsisConversion
EllipsisConversion - When this is true, it means user-defined conversion sequence starts with a ...
Expr * getInit() const
Get the initializer.
static bool EvaluateExpressionTrait(ExpressionTrait ET, Expr *E)
SourceRange getCorrectionRange() const
ExprResult PerformContextuallyConvertToBool(Expr *From)
PerformContextuallyConvertToBool - Perform a contextual conversion of the expression From to bool (C+...
no exception specification
QualType getObjCIdType() const
Represents the Objective-CC id type.
SourceLocation getLastQualifierNameLoc() const
Retrieve the location of the name in the last qualifier in this nested name specifier.
void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl=nullptr, ExpressionEvaluationContextRecord::ExpressionKind Type=ExpressionEvaluationContextRecord::EK_Other)
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
Stores the type being destroyed by a pseudo-destructor expression.
A (possibly-)qualified type.
bool isBlockPointerType() const
This is a scope that corresponds to the parameters within a function prototype.
Simple class containing the result of Sema::CorrectTypo.
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)
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
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.
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
bool isGenericLambdaCallOperatorSpecialization(const CXXMethodDecl *MD)
FunctionType - C99 6.7.5.3 - Function Declarators.
FullExprArg MakeFullExpr(Expr *Arg)
Provides information about an attempted template argument deduction, whose success or failure was des...
ARCConversionResult CheckObjCConversion(SourceRange castRange, QualType castType, Expr *&op, CheckedConversionKind CCK, bool Diagnose=true, bool DiagnoseCFAudited=false, BinaryOperatorKind Opc=BO_PtrMemD)
Checks for invalid conversions and casts between retainable pointers and other pointer kinds for ARC ...
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Microsoft __if_not_exists.
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
bool isRealFloatingType() const
Floating point categories.
bool hasPlaceholderType() const
Returns whether this expression has a placeholder type.
void addConst()
Add the const type qualifier to this QualType.
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in...
ExprResult BuildCXXTypeConstructExpr(TypeSourceInfo *Type, SourceLocation LParenLoc, MultiExprArg Exprs, SourceLocation RParenLoc, bool ListInitialization)
Complex conversions (C99 6.3.1.6)
bool isRecordType() const
unsigned getTypeAlignIfKnown(QualType T) const
Return the ABI-specified alignment of a type, in bits, or 0 if the type is incomplete and we cannot d...
bool isEmpty() const
No scope specifier.
static InitializedEntity InitializeParameter(ASTContext &Context, const ParmVarDecl *Parm)
Create the initialization entity for a parameter.
UserDefinedConversionSequence UserDefined
When ConversionKind == UserDefinedConversion, provides the details of the user-defined conversion seq...
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
static bool FindConditionalOverload(Sema &Self, ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
Try to find a common type for two according to C++0x 5.16p5.
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type...
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
bool hasIrrelevantDestructor() const
Determine whether this class has a destructor which has no semantic effect.
bool DiagnoseConditionalForNull(Expr *LHSExpr, Expr *RHSExpr, SourceLocation QuestionLoc)
Emit a specialized diagnostic when one expression is a null pointer constant and the other is not a p...
Decl - This represents one declaration (or definition), e.g.
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
Returns the parent of this field declaration, which is the struct in which this field is defined...
The base class of the type hierarchy.
This indicates that the scope corresponds to a function, which means that labels are set here...
unsigned IncompatibleObjC
IncompatibleObjC - Whether this is an Objective-C conversion that we should warn about (if we actuall...
One instance of this struct is used for each type in a declarator that is parsed. ...
Represents an array type, per C99 6.7.5.2 - Array Declarators.
The template argument is a declaration that was provided for a pointer, reference, or pointer to member non-type template parameter.
static InitializationKind CreateDefault(SourceLocation InitLoc)
Create a default initialization.
static void CheckIfAnyEnclosingLambdasMustCaptureAnyPotentialCaptures(Expr *const FE, LambdaScopeInfo *const CurrentLSI, Sema &S)
Check if the current lambda has any potential captures that must be captured by any of its enclosing ...
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Represents a call to a C++ constructor.
static ExprValueKind getValueKindForType(QualType T)
getValueKindForType - Given a formal return or parameter type, give its value kind.
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent...
Ambiguous candidates found.
QualType withConst() const
Incompatible - We reject this conversion outright, it is invalid to represent it in the AST...
const TargetInfo & getTargetInfo() const
A container of type source information.
static bool evaluateTypeTrait(Sema &S, TypeTrait Kind, SourceLocation KWLoc, ArrayRef< TypeSourceInfo *> Args, SourceLocation RParenLoc)
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
QualType getLogicalOperationType() const
The result type of logical operations, '<', '>', '!=', etc.
capture_const_range captures() const
Conversions between compatible types in C99.
bool isDefined(const FunctionDecl *&Definition) const
Returns true if the function has a definition that does not need to be instantiated.
static CXXFunctionalCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, TypeSourceInfo *Written, CastKind Kind, Expr *Op, const CXXCastPath *Path, SourceLocation LPLoc, SourceLocation RPLoc)
ExprResult ActOnExpressionTrait(ExpressionTrait OET, SourceLocation KWLoc, Expr *Queried, SourceLocation RParen)
ActOnExpressionTrait - Parsed one of the unary type trait support pseudo-functions.
const Expr * getAnyInitializer() const
Get the initializer for this variable, no matter which declaration it is attached to...
QualType getConversionType() const
Returns the type that this conversion function is converting to.
Represents a C++ constructor within a class.
void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, bool MightBeOdrUse=true)
Mark a function referenced, and check whether it is odr-used (C++ [basic.def.odr]p2, C99 6.9p3)
bool isVariableExprMarkedAsNonODRUsed(Expr *CapturingVarExpr) const
bool hasInClassInitializer() const
Determine whether this member has a C++11 default member initializer.
size_t param_size() const
static InitializedEntity InitializeTemporary(QualType Type)
Create the initialization entity for a temporary.
unsigned getTypeAlign(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in bits.
bool isTrivialType(const ASTContext &Context) const
Return true if this is a trivial type per (C++0x [basic.types]p9)
bool DisableTypoCorrection
Tracks whether we are in a context where typo correction is disabled.
An identifier, stored as an IdentifierInfo*.
bool isUnsignedIntegerType() const
Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...
This file provides some common utility functions for processing Lambda related AST Constructs...
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
RAII object that enters a new expression evaluation context.
Represents a variable declaration or definition.
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
bool isStructureType() const
bool hasPotentialThisCapture() const
ExprResult PerformObjectArgumentInitialization(Expr *From, NestedNameSpecifier *Qualifier, NamedDecl *FoundDecl, CXXMethodDecl *Method)
PerformObjectArgumentInitialization - Perform initialization of the implicit object parameter for the...
static ExprResult attemptRecovery(Sema &SemaRef, const TypoCorrectionConsumer &Consumer, const TypoCorrection &TC)
IfExistsResult
Describes the result of an "if-exists" condition check.
CleanupInfo Cleanup
Used to control the generation of ExprWithCleanups.
DeclarationName getLookupName() const
Gets the name to look up.
Information about one declarator, including the parsed type information and the identifier.
QualType getReturnType() const
DiagnosticsEngine & Diags
static QualType adjustCVQualifiersForCXXThisWithinLambda(ArrayRef< FunctionScopeInfo *> FunctionScopes, QualType ThisTy, DeclContext *CurSemaContext, ASTContext &ASTCtx)
unsigned getNumParams() const
bool isEnumeralType() const
bool isFixed() const
Returns true if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying...
const T * getAs() const
Member-template getAs<specific type>'.
bool isDirectReferenceBinding() const
Determine whether this initialization is a direct reference binding (C++ [dcl.init.ref]).
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
Extra information about a function prototype.
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.
noexcept(expression), value-dependent
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...
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
void setCorrectionDecl(NamedDecl *CDecl)
Clears the list of NamedDecls before adding the new one.
bool isMoveAssignmentOperator() const
Determine whether this is a move assignment operator.
Expr * FixOverloadedFunctionReference(Expr *E, DeclAccessPair FoundDecl, FunctionDecl *Fn)
FixOverloadedFunctionReference - E is an expression that refers to a C++ overloaded function (possibl...
Represents a struct/union/class.
QualType adjustCCAndNoReturn(QualType ArgFunctionType, QualType FunctionType, bool AdjustExceptionSpec=false)
Adjust the type ArgFunctionType to match the calling convention, noreturn, and optionally the excepti...
QualType FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
FindCompositeObjCPointerType - Helper method to find composite type of two objective-c pointer types ...
static bool ConvertForConditional(Sema &Self, ExprResult &E, QualType T)
Perform an "extended" implicit conversion as returned by TryClassUnification.
uint64_t getPointerWidth(unsigned AddrSpace) const
Return the width of pointers on this target, for the specified address space.
bool FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range, AllocationFunctionScope NewScope, AllocationFunctionScope DeleteScope, QualType AllocType, bool IsArray, bool &PassAlignment, MultiExprArg PlaceArgs, FunctionDecl *&OperatorNew, FunctionDecl *&OperatorDelete, bool Diagnose=true)
Finds the overloads of operator new and delete that are appropriate for the allocation.
TemplateIdAnnotation * TemplateId
When Kind == IK_TemplateId or IK_ConstructorTemplateId, the template-id annotation that contains the ...
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Boolean conversions (C++ [conv.bool])
FunctionType::ExtInfo ExtInfo
Represents a class template specialization, which refers to a class template with a given set of temp...
One of these records is kept for each identifier that is lexed.
void setIntegerType(QualType T)
Set the underlying integer type.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name)
Retrieves the declaration name from a parsed unqualified-id.
bool isNothrow(bool ResultIfDependent=false) const
Determine whether this function type has a non-throwing exception specification.
Represents a class type in Objective C.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
void DropFirstTypeObject()
A C++ nested-name-specifier augmented with source location information.
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
Represents a dependent template name that cannot be resolved prior to template instantiation.
The results of name lookup within a DeclContext.
SourceLocation getTypeSpecTypeLoc() const
bool allowsNonTrivialObjCLifetimeQualifiers() const
True if any ObjC types may have non-trivial lifetime qualifiers.
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
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
Represents a member of a struct/union/class.
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
The current expression is potentially evaluated at run time, which means that code may be generated t...
Identity conversion (no conversion)
unsigned getNewAlign() const
Return the largest alignment for which a suitably-sized allocation with '::operator new(size_t)' is g...
void setVisibleDespiteOwningModule()
Set that this declaration is globally visible, even if it came from a module that is not visible...
bool isAbstractType(SourceLocation Loc, QualType T)
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
bool hasAutoTypeSpec() const
Floating point conversions (C++ [conv.double].
bool isReferenceType() const
CXXRecordDecl * getStdBadAlloc() const
void setArg(unsigned Arg, Expr *ArgExpr)
setArg - Set the specified argument.
bool hasTrivialMoveAssignment() const
Determine whether this class has a trivial move assignment operator (C++11 [class.copy]p25)
The iterator over UnresolvedSets.
static const TST TST_error
ExprResult ActOnCXXUuidof(SourceLocation OpLoc, SourceLocation LParenLoc, bool isType, void *TyOrExpr, SourceLocation RParenLoc)
ActOnCXXUuidof - Parse __uuidof( something ).
ExprResult BuildArrayTypeTrait(ArrayTypeTrait ATT, SourceLocation KWLoc, TypeSourceInfo *TSInfo, Expr *DimExpr, SourceLocation RParen)
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'.
static bool resolveAllocationOverload(Sema &S, LookupResult &R, SourceRange Range, SmallVectorImpl< Expr *> &Args, bool &PassAlignment, FunctionDecl *&Operator, OverloadCandidateSet *AlignedCandidates, Expr *AlignArg, bool Diagnose)
OpaquePtr< QualType > ParsedType
An opaque type for threading parsed type information through the parser.
LookupResultKind getResultKind() const
ParsedType getDestructorName(SourceLocation TildeLoc, IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec &SS, ParsedType ObjectType, bool EnteringContext)
ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp, [NSNumber numberWithInt:42]];.
ExprResult DefaultFunctionArrayConversion(Expr *E, bool Diagnose=true)
DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).
void PopExpressionEvaluationContext()
bool isAtLeastAsQualifiedAs(QualType Other) const
Determine whether this type is at least as qualified as the other given type, requiring exact equalit...
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
A user-defined literal name, e.g., operator "" _i.
Stmt * MaybeCreateStmtWithCleanups(Stmt *SubStmt)
void NoteDeletedFunction(FunctionDecl *FD)
Emit a note explaining that this function is deleted.
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
bool isInvalidType() const
bool isDependentName() const
Determines whether the name itself is dependent, e.g., because it involves a C++ type that is itself ...
bool getProducesResult() const
DeclClass * getAsSingle() const
Floating point promotions (C++ [conv.fpprom])
ExprResult ActOnStartCXXMemberReference(Scope *S, Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, ParsedType &ObjectType, bool &MayBePseudoDestructor)
ObjCMethodFamily getMethodFamily() const
Determines the family of this method.
bool isReplaceableGlobalAllocationFunction(bool *IsAligned=nullptr) const
Determines whether this function is one of the replaceable global allocation functions: void *operato...
Describes an C or C++ initializer list.
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
This is a scope that corresponds to a block/closure object.
ExprResult ActOnCXXThrow(Scope *S, SourceLocation OpLoc, Expr *expr)
ActOnCXXThrow - Parse throw expressions.
Represents a C++ unqualified-id that has been parsed.
bool CanUseDecl(NamedDecl *D, bool TreatUnavailableAsInvalid)
Determine whether the use of this declaration is valid, without emitting diagnostics.
bool isCompleteType(SourceLocation Loc, QualType T)
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
Represents a declaration of a type.
A builtin binary operation expression such as "x + y" or "x <= y".
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
static CompoundStmt * Create(const ASTContext &C, ArrayRef< Stmt *> Stmts, SourceLocation LB, SourceLocation RB)
ImplicitConversionKind Second
Second - The second conversion can be an integral promotion, floating point promotion, integral conversion, floating point conversion, floating-integral conversion, pointer conversion, pointer-to-member conversion, or boolean conversion.
QualType getExceptionObjectType(QualType T) const
A conversion for an operand of a builtin overloaded operator.
ParsedTemplateArgument * getTemplateArgs()
Retrieves a pointer to the template arguments.
static InitializationKind CreateValue(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc, bool isImplicit=false)
Create a value initialization.
const Type * getClass() const
bool isRValueReferenceType() const
CheckedConversionKind
The kind of conversion being performed.
FunctionDecl * ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr, QualType TargetType, bool Complain, DeclAccessPair &Found, bool *pHadMultipleCandidates=nullptr)
ResolveAddressOfOverloadedFunction - Try to resolve the address of an overloaded function (C++ [over...
LazyDeclPtr StdBadAlloc
The C++ "std::bad_alloc" class, which is defined by the C++ standard library.
IfExistsResult CheckMicrosoftIfExistsSymbol(Scope *S, CXXScopeSpec &SS, const DeclarationNameInfo &TargetNameInfo)
bool isLambda() const
Determine whether this class describes a lambda function object.
DeclContext * getLambdaAwareParentOfDeclContext(DeclContext *DC)
Scope - A scope is a transient data structure that is used while parsing the program.
ExprResult Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType=nullptr)
Perform the actual initialization of the given entity based on the computed initialization sequence...
QualType getCVRQualifiedType(QualType T, unsigned CVR) const
Return a type with additional const, volatile, or restrict qualifiers.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
New-expression has a C++98 paren-delimited initializer.
void getAsStringInternal(std::string &Str, const PrintingPolicy &Policy) const
TypoExpr - Internal placeholder for expressions where typo correction still needs to be performed and...
Qualification conversions (C++ [conv.qual])
static unsigned getNumAddressingBits(const ASTContext &Context, QualType ElementType, const llvm::APInt &NumElements)
Determine the number of bits required to address a member of.
ExprResult ActOnCXXThis(SourceLocation loc)
Represents a C++ nested-name-specifier or a global scope specifier.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
enum clang::DeclaratorChunk::@196 Kind
ExprResult CheckSwitchCondition(SourceLocation SwitchLoc, Expr *Cond)
Represents binding an expression to a temporary.
ArrayTypeTrait
Names for the array type traits.
CXXTemporary * getTemporary()
AccessResult CheckConstructorAccess(SourceLocation Loc, CXXConstructorDecl *D, DeclAccessPair FoundDecl, const InitializedEntity &Entity, bool IsCopyBindingRefToTemp=false)
Checks access to a constructor.
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
const LangOptions & getLangOpts() const
static FunctionProtoType::ExceptionSpecInfo mergeExceptionSpecs(Sema &S, FunctionProtoType::ExceptionSpecInfo ESI1, FunctionProtoType::ExceptionSpecInfo ESI2, SmallVectorImpl< QualType > &ExceptionTypeStorage)
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
bool isTypeDependent() const
isTypeDependent - Determines whether this expression is type-dependent (C++ [temp.dep.expr]), which means that its type could change from one template instantiation to the next.
ExprResult DefaultFunctionArrayLvalueConversion(Expr *E, bool Diagnose=true)
bool isScalarType() const
An ordinary object is located at an address in memory.
bool isLambdaCallOperator(const CXXMethodDecl *MD)
SmallVector< BoundNodes, 1 > match(MatcherT Matcher, const NodeT &Node, ASTContext &Context)
Returns the results of matching Matcher on Node.
The number of conversion kinds.
A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5...
Represents an ObjC class declaration.
FieldDecl * getMember() const
If this is a member initializer, returns the declaration of the non-static data member being initiali...
CastKind PrepareScalarCast(ExprResult &src, QualType destType)
Prepares for a scalar cast, performing all the necessary stages except the final cast and returning t...
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface...
ImplicitConversionKind Third
Third - The third conversion can be a qualification conversion or a function conversion.
bool isAbstract() const
Determine whether this class has a pure virtual function.
ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context...
Integral promotions (C++ [conv.prom])
const LangOptions & LangOpts
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 DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics...
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...
SourceRange getRange() const
SourceLocation PotentialThisCaptureLocation
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location, which defaults to the empty location.
unsigned getEditDistance(bool Normalized=true) const
Gets the "edit distance" of the typo correction from the typo.
ExprResult CheckConditionVariable(VarDecl *ConditionVar, SourceLocation StmtLoc, ConditionKind CK)
Check the use of the given variable as a C++ condition in an if, while, do-while, or switch statement...
TST getTypeSpecType() const
bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const
HasSideEffects - This routine returns true for all those expressions which have any effect other than...
An Objective-C property is a logical field of an Objective-C object which is read and written via Obj...
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.
unsigned getIntWidth() const
getIntWidth/Align - Return the size of 'signed int' and 'unsigned int' for this target, in bits.
bool isObjCARCImplicitlyUnretainedType() const
Determines if this type, which must satisfy isObjCLifetimeType(), is implicitly __unsafe_unretained r...
ParsedType getDestructorTypeForDecltype(const DeclSpec &DS, ParsedType ObjectType)
static bool EvaluateUnaryTypeTrait(Sema &Self, TypeTrait UTT, SourceLocation KeyLoc, QualType T)
DeclContext * getEntity() const
static SourceLocation findLocationAfterToken(SourceLocation loc, tok::TokenKind TKind, const SourceManager &SM, const LangOptions &LangOpts, bool SkipTrailingWhitespaceAndNewLine)
Checks that the given token is the first token that occurs after the given location (this excludes co...
StandardConversionSequence After
After - Represents the standard conversion that occurs after the actual user-defined conversion...
This file defines the classes used to store parsed information about declaration-specifiers and decla...
const T * castAs() const
Member-template castAs<specific type>.
bool isObjCRetainableType() const
QualType FindCompositePointerType(SourceLocation Loc, Expr *&E1, Expr *&E2, bool ConvertArgs=true)
Find a merged pointer type and convert the two expressions to it.
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Represents a C++ destructor within a class.
New-expression has a C++11 list-initializer.
static 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...
const Expr * getCallee() const
Defines the clang::Preprocessor interface.
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++ [conv.fpint])
UnqualifiedIdKind getKind() const
Determine what kind of name we have.
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7)...
void DiscardCleanupsInEvaluationContext()
bool isFunctionTemplateSpecialization() const
Determine whether this function is a function template specialization.
Specifies that a value-dependent expression of integral or dependent type should be considered a null...
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char, signed char, short, int, long..], or an enum decl which has a signed representation.
bool isPolymorphic() const
Whether this class is polymorphic (C++ [class.virtual]), which means that the class contains or inher...
static bool EvaluateBinaryTypeTrait(Sema &Self, TypeTrait BTT, QualType LhsT, QualType RhsT, SourceLocation KeyLoc)
ExprResult ActOnTypeTrait(TypeTrait Kind, SourceLocation KWLoc, ArrayRef< ParsedType > Args, SourceLocation RParenLoc)
Parsed one of the type trait support pseudo-functions.
TagDecl * getAsTagDecl() const
Retrieves the TagDecl that this type refers to, either because the type is a TagType or because it is...
ExprResult BuildCXXUuidof(QualType TypeInfoType, SourceLocation TypeidLoc, TypeSourceInfo *Operand, SourceLocation RParenLoc)
Build a Microsoft __uuidof expression with a type operand.
SmallVector< sema::FunctionScopeInfo *, 4 > FunctionScopes
Stack containing information about each of the nested function, block, and method scopes that are cur...
SourceLocation Loc
Loc - The place where this type was defined.
StandardConversionSequence Standard
When ConversionKind == StandardConversion, provides the details of the standard conversion sequence...
clang::ObjCRuntime ObjCRuntime
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
void DiagnoseAmbiguousConversion(Sema &S, SourceLocation CaretLoc, const PartialDiagnostic &PDiag) const
Diagnoses an ambiguous conversion.
static void collectPublicBases(CXXRecordDecl *RD, llvm::DenseMap< CXXRecordDecl *, unsigned > &SubobjectsSeen, llvm::SmallPtrSetImpl< CXXRecordDecl *> &VBases, llvm::SetVector< CXXRecordDecl *> &PublicSubobjectsSeen, bool ParentIsPublic)
A boolean condition, from 'if', 'while', 'for', or 'do'.
An expression that sends a message to the given Objective-C object or class.
QualType getRecordType(const RecordDecl *Decl) const
SourceLocation getEnd() const
UnaryOperator - This represents the unary-expression's (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
static uint64_t EvaluateArrayTypeTrait(Sema &Self, ArrayTypeTrait ATT, QualType T, Expr *DimExpr, SourceLocation KeyLoc)
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
static bool CanThrow(Expr *E, ASTContext &Ctx)
ExprResult BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, const TemplateArgumentListInfo *TemplateArgs, const Scope *S)
Builds an expression which might be an implicit member expression.
ParsedType getInheritingConstructorName(CXXScopeSpec &SS, SourceLocation NameLoc, IdentifierInfo &Name)
Handle the result of the special case name lookup for inheriting constructor declarations.
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
void CleanupVarDeclMarking()
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
ExprResult ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal, bool ArrayForm, Expr *Operand)
ActOnCXXDelete - Parsed a C++ 'delete' expression.
Represents a C++ conversion function within a class.
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
The result type of a method or function.
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
const Expr * getSubExpr() const
void removeLocalCVRQualifiers(unsigned Mask)
bool isNull() const
Return true if this QualType doesn't point to a type yet.
bool hasNonTrivialMoveAssignment() const
Determine whether this class has a non-trivial move assignment operator (C++11 [class.copy]p25)
A type, stored as a Type*.
bool hasEmptyCollections() const
Are the empty collection symbols available?
void removeCVRQualifiers(unsigned mask)
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++ [conv.lval])
ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E)
bool isConstQualified() const
Determine whether this type is const-qualified.
RecordDecl * getDecl() const
bool Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef< Expr *> Args)
Diagnose an potentially-invalid initialization sequence.
noexcept(expression), evals to 'false'
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
void EraseUnwantedCUDAMatches(const FunctionDecl *Caller, SmallVectorImpl< std::pair< DeclAccessPair, FunctionDecl *>> &Matches)
Finds a function in Matches with highest calling priority from Caller context and erases all function...
void 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++ [conv.integral])
SmallVectorImpl< OverloadCandidate >::iterator iterator
Complex promotions (Clang extension)
ExprResult MaybeBindToTemporary(Expr *E)
MaybeBindToTemporary - If the passed in expression has a record type with a non-trivial destructor...
Assigning into this object requires the old value to be released and the new value to be retained...
static CXXBindTemporaryExpr * Create(const ASTContext &C, CXXTemporary *Temp, Expr *SubExpr)
ImplicitConversionSequence - Represents an implicit conversion sequence, which may be a standard conv...
ExprResult BuildCXXThrow(SourceLocation OpLoc, Expr *Ex, bool IsThrownVarInScope)
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
ExceptionSpecificationType Type
The kind of exception specification this is.
ExprResult LookupInObjCMethod(LookupResult &LookUp, Scope *S, IdentifierInfo *II, bool AllowBuiltinCreation=false)
LookupInObjCMethod - The parser has read a name in, and Sema has detected that we're currently inside...
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on a template...
OverloadCandidate - A single candidate in an overload set (C++ 13.3).
LazyDeclPtr StdAlignValT
The C++ "std::align_val_t" enum class, which is defined by the C++ standard library.
ASTContext & getASTContext() const
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.
MutableArrayRef< Expr * > MultiExprArg
Represents a call to a member function that may be written either with member call syntax (e...
QualType DeduceTemplateSpecializationFromInitializer(TypeSourceInfo *TInfo, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Init)
SourceLocation getLocStart() const LLVM_READONLY
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.
Only look for allocation functions in the scope of the allocated class.
void setDestructor(const CXXDestructorDecl *Dtor)
Objective-C ARC writeback conversion.
const ParmVarDecl * getParamDecl(unsigned i) const
ExprResult ActOnCXXTypeConstructExpr(ParsedType TypeRep, SourceLocation LParenOrBraceLoc, MultiExprArg Exprs, SourceLocation RParenOrBraceLoc, bool ListInitialization)
ActOnCXXTypeConstructExpr - Parse construction of a specified type.
bool CheckObjCARCUnavailableWeakConversion(QualType castType, QualType ExprType)
Name lookup found an unresolvable value declaration and cannot yet complete.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
static bool isCast(CheckedConversionKind CCK)
OverloadingResult BestViableFunction(Sema &S, SourceLocation Loc, OverloadCandidateSet::iterator &Best)
Find the best viable function on this overload set, if it exists.
ExprResult CheckCXXBooleanCondition(Expr *CondExpr, bool IsConstexpr=false)
CheckCXXBooleanCondition - Returns true if conversion to bool is invalid.
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Describes the kind of initialization being performed, along with location information for tokens rela...
TemplateDeductionResult DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, const TemplateArgumentList &TemplateArgs, sema::TemplateDeductionInfo &Info)
Perform template argument deduction to determine whether the given template arguments match the given...
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
static void getUnambiguousPublicSubobjects(CXXRecordDecl *RD, llvm::SmallVectorImpl< CXXRecordDecl *> &Objects)
Look up any declaration with any name.
AssignConvertType CheckTransparentUnionArgumentConstraints(QualType ArgType, ExprResult &RHS)
bool isMemberFunctionPointerType() const
bool isAnyPointerType() const
bool isObjCObjectPointerType() const
bool CheckMemberPointerConversion(Expr *From, QualType ToType, CastKind &Kind, CXXCastPath &BasePath, bool IgnoreBaseAccess)
CheckMemberPointerConversion - Check the member pointer conversion from the expression From to the ty...
Pointer conversions (C++ [conv.ptr])
const TypoExprState & getTypoExprState(TypoExpr *TE) const
C++ [over.match.oper]: Lookup of operator function candidates in a call using operator syntax...
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.
SourceLocation getLocEnd() const LLVM_READONLY
bool isSuperClassOf(const ObjCInterfaceDecl *I) const
isSuperClassOf - Return true if this class is the specified class or is a super class of the specifie...
No entity found met the criteria.
TypeClass getTypeClass() const
bool isThisOutsideMemberFunctionBody(QualType BaseType)
Determine whether the given type is the type of *this that is used outside of the body of a member fu...
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
The name is a dependent name, so the results will differ from one instantiation to the next...
An expression trait intrinsic.
EnumDecl * getDecl() const
Derived-to-base (C++ [over.best.ics])
bool isVectorType() const
Complex-real conversions (C99 6.3.1.7)
An rvalue ref-qualifier was provided (&&).
Assigning into this object requires a lifetime extension.
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
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.
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...
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
AccessSpecifier getAccess() const
Conversions allowed in C, but not C++.
A constant boolean condition from 'if constexpr'.
Array-to-pointer conversion (C++ [conv.array])
llvm::VersionTuple alignedAllocMinVersion(llvm::Triple::OSType OS)
TypeSourceInfo * getTypeSourceInfo() const
bool GlobalNewDeleteDeclared
A flag to remember whether the implicit forms of operator new and delete have been declared...
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
SourceLocation getLocStart() const LLVM_READONLY
ExprResult prepareVectorSplat(QualType VectorTy, Expr *SplattedExpr)
Prepare SplattedExpr for a vector splat operation, adding implicit casts if necessary.
AllocationFunctionScope
The scope in which to find allocation functions.
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)
ParsedType getConstructorName(IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec &SS, bool EnteringContext)
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...
Represents a C++ base or member initializer.
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Look for allocation functions in both the global scope and in the scope of the allocated class...
bool hasNonTrivialObjCLifetime() const
ExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind)
ActOnCXXBoolLiteral - Parse {true,false} literals.
bool CheckDerivedToBaseConversion(QualType Derived, QualType Base, SourceLocation Loc, SourceRange Range, CXXCastPath *BasePath=nullptr, bool IgnoreAccess=false)
uint64_t getCharWidth() const
Return the size of the character type, in bits.
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
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.
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++ [conv.array])
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".
ActionResult< Expr * > ExprResult
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Only look for allocation functions in the global scope.
Represents a C++ struct/union/class.
Compatible - the types are compatible according to the standard.
bool CompleteConstructorCall(CXXConstructorDecl *Constructor, MultiExprArg ArgsPtr, SourceLocation Loc, SmallVectorImpl< Expr *> &ConvertedArgs, bool AllowExplicit=false, bool IsListInitialization=false)
Given a constructor and the set of arguments provided for the constructor, convert the arguments and ...
ExprResult BuildTypeTrait(TypeTrait Kind, SourceLocation KWLoc, ArrayRef< TypeSourceInfo *> Args, SourceLocation RParenLoc)
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type...
static bool hasAnyTypeDependentArguments(ArrayRef< Expr *> Exprs)
hasAnyTypeDependentArguments - Determines if any of the expressions in Exprs is type-dependent.
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
static CXXTemporary * Create(const ASTContext &C, const CXXDestructorDecl *Destructor)
Expr * NumElts
This is the size of the array, or null if [] or [*] was specified.
static bool HasNoThrowOperator(const RecordType *RT, OverloadedOperatorKind Op, Sema &Self, SourceLocation KeyLoc, ASTContext &C, bool(CXXRecordDecl::*HasTrivial)() const, bool(CXXRecordDecl::*HasNonTrivial)() const, bool(CXXMethodDecl::*IsDesiredOp)() const)
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
bool CheckAllocatedType(QualType AllocType, SourceLocation Loc, SourceRange R)
Checks that a type is suitable as the allocated type in a new-expression.
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
bool isCXXThisCaptured() const
Determine whether the C++ 'this' is captured.
Declaration of a class template.
Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const
Return the implicit lifetime for this type, which must not be dependent.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
This class is used for builtin types like 'int'.
SourceManager & getSourceManager() const
A template-id, e.g., f<int>.
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
StringLiteral - This represents a string literal expression, e.g.
Defines the clang::TargetInfo interface.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
QualType CheckVectorOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign, bool AllowBothBool, bool AllowBoolConversion)
type checking for vector binary operators.
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
static Qualifiers fromCVRMask(unsigned CVR)
void EmitRelatedResultTypeNote(const Expr *E)
If the given expression involves a message send to a method with a related result type...
ExprResult CheckConvertedConstantExpression(Expr *From, QualType T, llvm::APSInt &Value, CCEKind CCE)
static OpaquePtr make(QualType P)
bool isFundamentalType() const
Tests whether the type is categorized as a fundamental type.
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...
This represents a decl that may have 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++ [conv.mem])
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.
static bool resolveBuiltinNewDeleteOverload(Sema &S, CallExpr *TheCall, bool IsDelete, FunctionDecl *&Operator)
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
static OpaquePtr getFromOpaquePtr(void *P)
SourceLocation getBegin() const
ExprResult BuildCXXTypeId(QualType TypeInfoType, SourceLocation TypeidLoc, TypeSourceInfo *Operand, SourceLocation RParenLoc)
Build a C++ typeid expression with a type operand.
const LangOptions & getLangOpts() const
void WillReplaceSpecifier(bool ForceReplacement)
void NoteCandidates(Sema &S, OverloadCandidateDisplayKind OCD, ArrayRef< Expr *> Args, StringRef Opc="", SourceLocation Loc=SourceLocation(), llvm::function_ref< bool(OverloadCandidate &)> Filter=[](OverloadCandidate &) { return true;})
When overload resolution fails, prints diagnostic messages containing the candidates in the candidate...
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
Return true if this decl is currently being defined.
ParsedTemplateTy Template
The declaration of the template corresponding to the template-name.
noexcept(expression), evals to 'true'
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).