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.
getBeginLoc(), 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();
1071 inTemplateInstantiation()) {
1073 assert(isa<CXXRecordDecl>(DC) &&
1074 "Trying to get 'this' type from static method?");
1091 CurContext, Context);
1099 : S(S), OldCXXThisTypeOverride(S.CXXThisTypeOverride), Enabled(
false)
1101 if (!Enabled || !ContextDecl)
1106 Record = Template->getTemplatedDecl();
1108 Record = cast<CXXRecordDecl>(ContextDecl);
1115 this->Enabled =
true;
1127 const bool ByCopy) {
1132 QualType CaptureThisFieldTy = ThisTy;
1143 Context, RD, Loc, Loc,
nullptr, CaptureThisFieldTy,
1157 nullptr, CaptureThisFieldTy, Loc);
1168 bool BuildAndDiagnose,
const unsigned *
const FunctionScopeIndexToStopAt,
1169 const bool ByCopy) {
1174 assert((!ByCopy || Explicit) &&
"cannot implicitly capture *this by value");
1176 const int MaxFunctionScopesIndex = FunctionScopeIndexToStopAt
1177 ? *FunctionScopeIndexToStopAt
1203 unsigned NumCapturingClosures = 0;
1204 for (
int idx = MaxFunctionScopesIndex; idx >= 0; idx--) {
1207 if (CSI->CXXThisCaptureIndex != 0) {
1209 CSI->Captures[CSI->CXXThisCaptureIndex - 1].markUsed(BuildAndDiagnose);
1215 if (BuildAndDiagnose)
1216 Diag(Loc, diag::err_this_capture)
1217 << (Explicit && idx == MaxFunctionScopesIndex);
1224 (Explicit && idx == MaxFunctionScopesIndex)) {
1230 NumCapturingClosures++;
1234 if (BuildAndDiagnose)
1235 Diag(Loc, diag::err_this_capture)
1236 << (Explicit && idx == MaxFunctionScopesIndex);
1241 if (!BuildAndDiagnose)
return false;
1253 dyn_cast<LambdaScopeInfo>(
FunctionScopes[MaxFunctionScopesIndex])) &&
1254 "Only a lambda can capture the enclosing object (referred to by " 1259 for (
int idx = MaxFunctionScopesIndex; NumCapturingClosures;
1260 --idx, --NumCapturingClosures) {
1262 Expr *ThisExpr =
nullptr;
1269 ByCopy && idx == MaxFunctionScopesIndex);
1277 bool isNested = NumCapturingClosures > 1;
1289 if (ThisTy.
isNull())
return Diag(Loc, diag::err_invalid_this_use);
1316 bool ListInitialization) {
1326 RParenOrBraceLoc, ListInitialization);
1330 if (!
Result.isInvalid() &&
Result.get()->isInstantiationDependent() &&
1331 !
Result.get()->isTypeDependent())
1341 bool ListInitialization) {
1350 : SourceRange(LParenOrBraceLoc, RParenOrBraceLoc);
1355 assert((!ListInitialization ||
1356 (Exprs.size() == 1 && isa<InitListExpr>(Exprs[0]))) &&
1357 "List initialization must have initializer list as expression.");
1363 ? ListInitialization
1365 TyBeginLoc, LParenOrBraceLoc, RParenOrBraceLoc)
1375 if (Deduced && isa<DeducedTemplateSpecializationType>(Deduced)) {
1387 if (Exprs.size() == 1 && !ListInitialization &&
1388 !isa<InitListExpr>(Exprs[0])) {
1389 Expr *Arg = Exprs[0];
1397 if (!ListInitialization)
1398 return ExprError(
Diag(TyBeginLoc, diag::err_value_init_for_array_type)
1406 return ExprError(
Diag(TyBeginLoc, diag::err_init_for_function_type)
1407 << Ty << FullRange);
1414 diag::err_invalid_incomplete_type_use, FullRange))
1427 Inner = BTE->getSubExpr();
1428 if (!isa<CXXTemporaryObjectExpr>(Inner) &&
1429 !isa<CXXScalarValueInitExpr>(Inner)) {
1441 : SourceRange(LParenOrBraceLoc, RParenOrBraceLoc);
1460 if (Result || !
getLangOpts().CUDA || PreventedBy.empty())
1465 return llvm::none_of(PreventedBy, [&](
const FunctionDecl *FD) {
1467 "Only single-operand functions should be in PreventedBy");
1482 unsigned UsualParams = 1;
1500 struct UsualDeallocFnInfo {
1501 UsualDeallocFnInfo() : Found(), FD(
nullptr) {}
1504 Destroying(
false), HasSizeT(
false), HasAlignValT(
false),
1509 unsigned NumBaseParams = 1;
1510 if (FD->isDestroyingOperatorDelete()) {
1515 if (NumBaseParams < FD->getNumParams() &&
1517 FD->getParamDecl(NumBaseParams)->getType(),
1523 if (NumBaseParams < FD->getNumParams() &&
1524 FD->getParamDecl(NumBaseParams)->getType()->isAlignValT()) {
1526 HasAlignValT =
true;
1531 if (
auto *Caller = dyn_cast<FunctionDecl>(S.
CurContext))
1535 explicit operator bool()
const {
return FD; }
1537 bool isBetterThan(
const UsualDeallocFnInfo &Other,
bool WantSize,
1538 bool WantAlign)
const {
1542 if (Destroying != Other.Destroying)
1549 if (HasAlignValT != Other.HasAlignValT)
1550 return HasAlignValT == WantAlign;
1552 if (HasSizeT != Other.HasSizeT)
1553 return HasSizeT == WantSize;
1556 return CUDAPref > Other.CUDAPref;
1561 bool Destroying, HasSizeT, HasAlignValT;
1581 UsualDeallocFnInfo Best;
1583 for (
auto I = R.
begin(), E = R.
end(); I != E; ++I) {
1584 UsualDeallocFnInfo Info(S, I.getPair());
1592 BestFns->push_back(Info);
1596 if (Best.isBetterThan(Info, WantSize, WantAlign))
1601 if (BestFns && Info.isBetterThan(Best, WantSize, WantAlign))
1606 BestFns->push_back(Info);
1620 if (!record)
return false;
1633 if (ops.
empty())
return false;
1645 return Best && Best.HasSizeT;
1669 Expr *ArraySize =
nullptr;
1696 if (!NumElts->isTypeDependent() && !NumElts->isValueDependent()) {
1702 assert(IntWidth &&
"Builtin type of size 0?");
1703 llvm::APSInt
Value(IntWidth);
1711 diag::err_new_array_nonconst)
1727 if (
ParenListExpr *List = dyn_cast_or_null<ParenListExpr>(Initializer))
1728 DirectInitRange = List->getSourceRange();
1731 PlacementLParen, PlacementArgs, PlacementRParen,
1732 TypeIdParens, AllocType, TInfo, ArraySize, DirectInitRange,
1741 return PLE->getNumExprs() == 0;
1742 if (isa<ImplicitValueInitExpr>(Init))
1745 return !CCE->isListInitialization() &&
1746 CCE->getConstructor()->isDefaultConstructor();
1748 assert(isa<InitListExpr>(Init) &&
1749 "Shouldn't create list CXXConstructExprs for arrays.");
1761 bool IsAligned =
false;
1773 StringRef OSName = AvailabilityAttr::getPlatformNameSourceSpelling(
1777 bool IsDelete = Kind == OO_Delete || Kind == OO_Array_Delete;
1778 Diag(Loc, diag::err_aligned_allocation_unavailable)
1781 Diag(Loc, diag::note_silence_aligned_allocation_unavailable);
1795 Expr *Initializer) {
1800 if (DirectInitRange.
isValid()) {
1801 assert(Initializer &&
"Have parens but no initializer.");
1803 }
else if (Initializer && isa<InitListExpr>(Initializer))
1806 assert((!Initializer || isa<ImplicitValueInitExpr>(Initializer) ||
1807 isa<CXXConstructExpr>(Initializer)) &&
1808 "Initializer expression that cannot have been implicitly created.");
1813 unsigned NumInits = Initializer ? 1 : 0;
1814 if (
ParenListExpr *List = dyn_cast_or_null<ParenListExpr>(Initializer)) {
1816 Inits = List->getExprs();
1817 NumInits = List->getNumExprs();
1838 DirectInitRange.
getEnd());
1842 if (Deduced && isa<DeducedTemplateSpecializationType>(Deduced)) {
1845 diag::err_deduced_class_template_compound_type)
1851 AllocTypeInfo, Entity, Kind,
MultiExprArg(Inits, NumInits));
1854 }
else if (Deduced) {
1856 if (NumInits == 1) {
1857 if (
auto p = dyn_cast_or_null<InitListExpr>(Inits[0])) {
1858 Inits = p->getInits();
1859 NumInits = p->getNumInits();
1865 return ExprError(
Diag(StartLoc, diag::err_auto_new_requires_ctor_arg)
1866 << AllocType << TypeRange);
1868 Expr *FirstBad = Inits[1];
1870 diag::err_auto_new_ctor_multiple_expressions)
1871 << AllocType << TypeRange);
1875 << AllocType << TypeRange;
1878 return ExprError(
Diag(StartLoc, diag::err_auto_new_deduction_failure)
1879 << AllocType << Inits[0]->
getType()
1881 if (DeducedType.isNull())
1883 AllocType = DeducedType;
1894 AllocType = Array->getElementType();
1914 ArraySize = result.
get();
1932 if (!ConvertedSize.isInvalid() &&
1935 Diag(StartLoc, diag::warn_cxx98_compat_array_size_conversion)
1936 << ArraySize->
getType() << 0 <<
"'size_t'";
1943 SizeConvertDiagnoser(
Expr *ArraySize)
1945 ArraySize(ArraySize) {}
1949 return S.
Diag(Loc, diag::err_array_size_not_integral)
1955 return S.
Diag(Loc, diag::err_array_size_incomplete_type)
1961 return S.
Diag(Loc, diag::err_array_size_explicit_conversion) << T << ConvTy;
1972 return S.
Diag(Loc, diag::err_array_size_ambiguous_conversion) << T;
1986 ? diag::warn_cxx98_compat_array_size_conversion
1987 : diag::ext_array_size_conversion)
1990 } SizeDiagnoser(ArraySize);
1998 ArraySize = ConvertedSize.
get();
2019 if (Value.isSigned() && Value.isNegative()) {
2021 diag::err_typecheck_negative_array_size)
2026 unsigned ActiveSizeBits =
2034 KnownArraySize = Value.getZExtValue();
2035 }
else if (TypeIdParens.
isValid()) {
2052 unsigned Alignment =
2055 bool PassAlignment =
getLangOpts().AlignedAllocation &&
2056 Alignment > NewAlignment;
2063 Scope, Scope, AllocType, ArraySize, PassAlignment,
2064 PlacementArgs, OperatorNew, OperatorDelete))
2069 bool UsualArrayDeleteWantsSize =
false;
2071 UsualArrayDeleteWantsSize =
2086 PassAlignment ? 2 : 1, PlacementArgs,
2087 AllPlaceArgs, CallType))
2090 if (!AllPlaceArgs.empty())
2091 PlacementArgs = AllPlaceArgs;
2100 if (PlacementArgs.empty() && !PassAlignment &&
2104 if (Alignment > NewAlignment)
2105 Diag(StartLoc, diag::warn_overaligned_type)
2117 Inits[NumInits - 1]->getEndLoc());
2118 Diag(StartLoc, diag::err_new_array_init_args) << InitRange;
2126 llvm::makeArrayRef(Inits, NumInits))) {
2138 InitType = AllocType;
2153 dyn_cast_or_null<CXXBindTemporaryExpr>(FullInit.
get()))
2154 FullInit = Binder->getSubExpr();
2156 Initializer = FullInit.
get();
2165 if (OperatorDelete) {
2178 cast<CXXRecordDecl>(BaseRecordType->getDecl()))) {
2181 PDiag(diag::err_access_dtor)
2190 PassAlignment, UsualArrayDeleteWantsSize,
2191 PlacementArgs, TypeIdParens, ArraySize, initStyle,
2192 Initializer, ResultType, AllocTypeInfo, Range,
2203 return Diag(Loc, diag::err_bad_new_type)
2204 << AllocType << 0 << R;
2206 return Diag(Loc, diag::err_bad_new_type)
2207 << AllocType << 1 << R;
2212 diag::err_allocation_of_abstract_type))
2215 return Diag(Loc, diag::err_variably_modified_new_type)
2219 return Diag(Loc, diag::err_address_space_qualified_new)
2227 return Diag(Loc, diag::err_arc_new_array_without_ownership)
2242 Alloc != AllocEnd; ++Alloc) {
2262 switch (Candidates.BestViableFunction(S, R.
getNameLoc(), Best)) {
2279 if (PassAlignment) {
2280 PassAlignment =
false;
2282 Args.erase(Args.begin() + 1);
2284 Operator, &Candidates, AlignArg,
2312 if (AlignedCandidates) {
2314 return C.Function->getNumParams() > 1 &&
2315 C.Function->getParamDecl(1)->getType()->isAlignValT();
2321 Args.insert(Args.begin() + 1, AlignArg);
2324 Args.erase(Args.begin() + 1);
2351 llvm_unreachable(
"Unreachable, bad result from BestViableFunction");
2373 AllocArgs.reserve((PassAlignment ? 2 : 1) + PlaceArgs.size());
2383 AllocArgs.push_back(&Size);
2386 if (PassAlignment) {
2392 AllocArgs.push_back(&Align);
2394 AllocArgs.insert(AllocArgs.end(), PlaceArgs.begin(), PlaceArgs.end());
2403 IsArray ? OO_Array_New : OO_New);
2435 Diag(StartLoc, diag::err_openclcxx_not_supported) <<
"default new";
2439 assert(!R.
empty() &&
"implicitly declared allocation functions not found");
2440 assert(!R.
isAmbiguous() &&
"global allocation functions are ambiguous");
2446 OperatorNew,
nullptr,
2453 OperatorDelete =
nullptr;
2482 bool FoundGlobalDelete = FoundDelete.
empty();
2483 if (FoundDelete.
empty()) {
2508 bool isPlacementNew = !PlaceArgs.empty() || OperatorNew->
param_size() != 1 ||
2511 if (isPlacementNew) {
2529 for (
unsigned I = 1, N = Proto->
getNumParams(); I < N; ++I)
2536 ExpectedFunctionType
2541 DEnd = FoundDelete.
end();
2545 dyn_cast<FunctionTemplateDecl>((*D)->getUnderlyingDecl())) {
2553 Fn = cast<FunctionDecl>((*D)->getUnderlyingDecl());
2556 ExpectedFunctionType,
2558 ExpectedFunctionType))
2559 Matches.push_back(std::make_pair(D.getPair(), Fn));
2574 *
this, FoundDelete, FoundGlobalDelete,
2578 Matches.push_back(std::make_pair(Selected.Found, Selected.FD));
2582 for (
auto Fn : BestDeallocFns)
2583 Matches.push_back(std::make_pair(Fn.Found, Fn.FD));
2591 if (Matches.size() == 1) {
2592 OperatorDelete = Matches[0].second;
2600 if (
getLangOpts().CPlusPlus11 && isPlacementNew &&
2602 UsualDeallocFnInfo Info(*
this,
2608 bool IsSizedDelete = Info.HasSizeT;
2609 if (IsSizedDelete && !FoundGlobalDelete) {
2610 auto NonSizedDelete =
2613 if (NonSizedDelete && !NonSizedDelete.HasSizeT &&
2614 NonSizedDelete.HasAlignValT == Info.HasAlignValT)
2615 IsSizedDelete =
false;
2618 if (IsSizedDelete) {
2622 PlaceArgs.back()->getEndLoc());
2623 Diag(StartLoc, diag::err_placement_new_non_placement_delete) << R;
2632 }
else if (!Matches.empty()) {
2636 Diag(StartLoc, diag::warn_ambiguous_suitable_delete_function_found)
2637 << DeleteName << AllocElemType;
2639 for (
auto &Match : Matches)
2640 Diag(Match.second->getLocation(),
2641 diag::note_member_declared_here) << DeleteName;
2727 AlignValT->setImplicit(
true);
2739 Params.push_back(Param);
2742 bool HasSizedVariant =
getLangOpts().SizedDeallocation &&
2743 (Kind == OO_Delete || Kind == OO_Array_Delete);
2744 bool HasAlignedVariant =
getLangOpts().AlignedAllocation;
2746 int NumSizeVariants = (HasSizedVariant ? 2 : 1);
2747 int NumAlignVariants = (HasAlignedVariant ? 2 : 1);
2748 for (
int Sized = 0; Sized < NumSizeVariants; ++Sized) {
2750 Params.push_back(SizeT);
2752 for (
int Aligned = 0; Aligned < NumAlignVariants; ++Aligned) {
2765 DeclareGlobalAllocationFunctions(OO_New, VoidPtr, SizeT);
2766 DeclareGlobalAllocationFunctions(OO_Array_New, VoidPtr, SizeT);
2767 DeclareGlobalAllocationFunctions(OO_Delete,
Context.
VoidTy, VoidPtr);
2768 DeclareGlobalAllocationFunctions(OO_Array_Delete,
Context.
VoidTy, VoidPtr);
2781 Alloc != AllocEnd; ++Alloc) {
2784 if (
FunctionDecl *Func = dyn_cast<FunctionDecl>(*Alloc)) {
2785 if (Func->getNumParams() == Params.size()) {
2787 for (
auto *
P : Func->parameters())
2788 FuncParams.push_back(
2790 if (llvm::makeArrayRef(FuncParams) == Params) {
2794 Func->setVisibleDespiteOwningModule();
2804 bool HasBadAllocExceptionSpec
2807 if (HasBadAllocExceptionSpec) {
2810 assert(
StdBadAlloc &&
"Must have std::bad_alloc declared");
2819 auto CreateAllocationFunctionDecl = [&](
Attr *ExtraAttr) {
2823 FnType,
nullptr,
SC_None,
false,
true);
2828 Alloc->
addAttr(VisibilityAttr::CreateImplicit(
2830 ? VisibilityAttr::Hidden
2838 ParamDecls.back()->setImplicit();
2840 Alloc->setParams(ParamDecls);
2848 CreateAllocationFunctionDecl(
nullptr);
2852 CreateAllocationFunctionDecl(CUDAHostAttr::CreateImplicit(
Context));
2853 CreateAllocationFunctionDecl(CUDADeviceAttr::CreateImplicit(
Context));
2858 bool CanProvideSize,
2872 assert(Result.FD &&
"operator delete missing from global scope?");
2884 return OperatorDelete;
2912 Overaligned, &Matches);
2915 if (Matches.size() == 1) {
2916 Operator = cast<CXXMethodDecl>(Matches[0].FD);
2921 Diag(StartLoc, diag::err_deleted_function_use);
2937 if (!Matches.empty()) {
2939 Diag(StartLoc, diag::err_ambiguous_suitable_delete_member_function_found)
2941 for (
auto &Match : Matches)
2942 Diag(Match.FD->getLocation(), diag::note_member_declared_here) << Name;
2949 if (!Found.
empty()) {
2951 Diag(StartLoc, diag::err_no_suitable_delete_member_function_found)
2955 Diag(D->getUnderlyingDecl()->getLocation(),
2956 diag::note_member_declared_here) << Name;
2968 class MismatchingNewDeleteDetector {
2970 enum MismatchResult {
2976 MemberInitMismatches,
2985 explicit MismatchingNewDeleteDetector(
bool EndOfTU)
2986 : Field(
nullptr), IsArrayForm(
false), EndOfTU(EndOfTU),
2987 HasUndefinedConstructors(
false) {}
3004 MismatchResult analyzeField(
FieldDecl *Field,
bool DeleteWasArrayForm);
3014 bool HasUndefinedConstructors;
3026 MismatchResult analyzeMemberExpr(
const MemberExpr *ME);
3049 MismatchResult analyzeInClassInitializer();
3053 MismatchingNewDeleteDetector::MismatchResult
3054 MismatchingNewDeleteDetector::analyzeDeleteExpr(
const CXXDeleteExpr *DE) {
3056 assert(DE &&
"Expected delete-expression");
3059 if (
const MemberExpr *ME = dyn_cast<const MemberExpr>(E)) {
3060 return analyzeMemberExpr(ME);
3061 }
else if (
const DeclRefExpr *D = dyn_cast<const DeclRefExpr>(E)) {
3062 if (!hasMatchingVarInit(D))
3063 return VarInitMismatches;
3069 MismatchingNewDeleteDetector::getNewExprFromInitListOrExpr(
const Expr *E) {
3070 assert(E !=
nullptr &&
"Expected a valid initializer expression");
3072 if (
const InitListExpr *ILE = dyn_cast<const InitListExpr>(E)) {
3073 if (ILE->getNumInits() == 1)
3074 E = dyn_cast<const CXXNewExpr>(ILE->getInit(0)->IgnoreParenImpCasts());
3077 return dyn_cast_or_null<const CXXNewExpr>(E);
3080 bool MismatchingNewDeleteDetector::hasMatchingNewInCtorInit(
3084 (NE = getNewExprFromInitListOrExpr(CI->
getInit()))) {
3085 if (NE->
isArray() == IsArrayForm)
3088 NewExprs.push_back(NE);
3093 bool MismatchingNewDeleteDetector::hasMatchingNewInCtor(
3099 HasUndefinedConstructors =
true;
3102 for (
const auto *CI : cast<const CXXConstructorDecl>(Definition)->inits()) {
3103 if (hasMatchingNewInCtorInit(CI))
3109 MismatchingNewDeleteDetector::MismatchResult
3110 MismatchingNewDeleteDetector::analyzeInClassInitializer() {
3111 assert(Field !=
nullptr &&
"This should be called only for members");
3112 const Expr *InitExpr = Field->getInClassInitializer();
3114 return EndOfTU ? NoMismatch : AnalyzeLater;
3115 if (
const CXXNewExpr *NE = getNewExprFromInitListOrExpr(InitExpr)) {
3116 if (NE->isArray() != IsArrayForm) {
3117 NewExprs.push_back(NE);
3118 return MemberInitMismatches;
3124 MismatchingNewDeleteDetector::MismatchResult
3125 MismatchingNewDeleteDetector::analyzeField(
FieldDecl *Field,
3126 bool DeleteWasArrayForm) {
3127 assert(Field !=
nullptr &&
"Analysis requires a valid class member.");
3128 this->Field = Field;
3129 IsArrayForm = DeleteWasArrayForm;
3131 for (
const auto *CD : RD->
ctors()) {
3132 if (hasMatchingNewInCtor(CD))
3135 if (HasUndefinedConstructors)
3136 return EndOfTU ? NoMismatch : AnalyzeLater;
3137 if (!NewExprs.empty())
3138 return MemberInitMismatches;
3143 MismatchingNewDeleteDetector::MismatchResult
3144 MismatchingNewDeleteDetector::analyzeMemberExpr(
const MemberExpr *ME) {
3145 assert(ME !=
nullptr &&
"Expected a member expression");
3147 return analyzeField(F, IsArrayForm);
3151 bool MismatchingNewDeleteDetector::hasMatchingVarInit(
const DeclRefExpr *D) {
3154 if (VD->hasInit() && (NE = getNewExprFromInitListOrExpr(VD->getInit())) &&
3155 NE->
isArray() != IsArrayForm) {
3156 NewExprs.push_back(NE);
3159 return NewExprs.empty();
3164 const MismatchingNewDeleteDetector &Detector) {
3167 if (!Detector.IsArrayForm)
3176 SemaRef.
Diag(DeleteLoc, diag::warn_mismatched_delete_new)
3177 << Detector.IsArrayForm << H;
3179 for (
const auto *NE : Detector.NewExprs)
3180 SemaRef.
Diag(NE->getExprLoc(), diag::note_allocated_here)
3181 << Detector.IsArrayForm;
3184 void Sema::AnalyzeDeleteExprMismatch(
const CXXDeleteExpr *DE) {
3187 MismatchingNewDeleteDetector Detector(
false);
3188 switch (Detector.analyzeDeleteExpr(DE)) {
3189 case MismatchingNewDeleteDetector::VarInitMismatches:
3190 case MismatchingNewDeleteDetector::MemberInitMismatches: {
3194 case MismatchingNewDeleteDetector::AnalyzeLater: {
3199 case MismatchingNewDeleteDetector::NoMismatch:
3205 bool DeleteWasArrayForm) {
3206 MismatchingNewDeleteDetector Detector(
true);
3207 switch (Detector.analyzeField(Field, DeleteWasArrayForm)) {
3208 case MismatchingNewDeleteDetector::VarInitMismatches:
3209 llvm_unreachable(
"This analysis should have been done for class members.");
3210 case MismatchingNewDeleteDetector::AnalyzeLater:
3211 llvm_unreachable(
"Analysis cannot be postponed any point beyond end of " 3212 "translation unit.");
3213 case MismatchingNewDeleteDetector::MemberInitMismatches:
3216 case MismatchingNewDeleteDetector::NoMismatch:
3227 bool ArrayForm,
Expr *ExE) {
3237 bool ArrayFormAsWritten = ArrayForm;
3238 bool UsualArrayDeleteWantsSize =
false;
3240 if (!Ex.
get()->isTypeDependent()) {
3256 if (ConvPtrType->getPointeeType()->isIncompleteOrObjectType())
3263 return S.
Diag(Loc, diag::err_delete_operand) << T;
3268 return S.
Diag(Loc, diag::err_delete_incomplete_class_type) << T;
3274 return S.
Diag(Loc, diag::err_delete_explicit_conversion) << T << ConvTy;
3285 return S.
Diag(Loc, diag::err_ambiguous_delete_operand) << T;
3297 llvm_unreachable(
"conversion functions are permitted");
3304 Type = Ex.
get()->getType();
3305 if (!Converter.match(Type))
3315 return Diag(Ex.
get()->getBeginLoc(),
3316 diag::err_address_space_qualified_delete)
3325 Diag(StartLoc, diag::ext_delete_void_ptr_operand)
3326 << Type << Ex.
get()->getSourceRange();
3329 << Type << Ex.
get()->getSourceRange());
3334 diag::warn_delete_incomplete, Ex.
get())) {
3336 PointeeRD = cast<CXXRecordDecl>(RT->getDecl());
3341 Diag(StartLoc, diag::warn_delete_array_type)
3342 << Type << Ex.
get()->getSourceRange()
3348 ArrayForm ? OO_Array_Delete : OO_Delete);
3362 UsualArrayDeleteWantsSize =
3367 else if (OperatorDelete && isa<CXXMethodDecl>(OperatorDelete))
3368 UsualArrayDeleteWantsSize =
3369 UsualDeallocFnInfo(*
this,
3377 const_cast<CXXDestructorDecl*>(Dtor));
3388 if (!OperatorDelete) {
3390 Diag(StartLoc, diag::err_openclcxx_not_supported) <<
"default delete";
3395 bool CanProvideSize =
3396 IsComplete && (!ArrayForm || UsualArrayDeleteWantsSize ||
3402 Overaligned, DeleteName);
3409 bool IsVirtualDelete =
false;
3413 PDiag(diag::err_access_dtor) << PointeeElem);
3414 IsVirtualDelete = Dtor->isVirtual();
3443 UsualArrayDeleteWantsSize, OperatorDelete, Ex.
get(), StartLoc);
3444 AnalyzeDeleteExprMismatch(Result);
3453 IsDelete ? OO_Delete : OO_New);
3457 assert(!R.empty() &&
"implicitly declared allocation functions not found");
3458 assert(!R.isAmbiguous() &&
"global allocation functions are ambiguous");
3461 R.suppressDiagnostics();
3467 FnOvl != FnOvlEnd; ++FnOvl) {
3470 NamedDecl *D = (*FnOvl)->getUnderlyingDecl();
3489 switch (Candidates.BestViableFunction(S, R.getNameLoc(), Best)) {
3493 assert(R.getNamingClass() ==
nullptr &&
3494 "class members should not be considered");
3497 S.
Diag(R.getNameLoc(), diag::err_builtin_operator_new_delete_not_usual)
3498 << (IsDelete ? 1 : 0) << Range;
3499 S.
Diag(FnDecl->
getLocation(), diag::note_non_usual_function_declared_here)
3509 S.
Diag(R.getNameLoc(), diag::err_ovl_no_viable_function_in_call)
3510 << R.getLookupName() << Range;
3515 S.
Diag(R.getNameLoc(), diag::err_ovl_ambiguous_call)
3516 << R.getLookupName() << Range;
3521 S.
Diag(R.getNameLoc(), diag::err_ovl_deleted_call)
3522 << Best->Function->isDeleted() << R.getLookupName()
3528 llvm_unreachable(
"Unreachable, bad result from BestViableFunction");
3532 Sema::SemaBuiltinOperatorNewDeleteOverloaded(
ExprResult TheCallResult,
3534 CallExpr *TheCall = cast<CallExpr>(TheCallResult.
get());
3537 << (IsDelete ?
"__builtin_operator_delete" :
"__builtin_operator_new")
3547 OperatorNewOrDelete))
3549 assert(OperatorNewOrDelete &&
"should be found");
3555 for (
unsigned i = 0; i != TheCall->
getNumArgs(); ++i) {
3566 assert(Callee && Callee->getCastKind() == CK_BuiltinFnToFnPtr &&
3567 "Callee expected to be implicit cast to a builtin function pointer");
3570 return TheCallResult;
3574 bool IsDelete,
bool CallCanBeVirtual,
3575 bool WarnOnNonAbstractTypes,
3602 Diag(Loc, diag::warn_delete_abstract_non_virtual_dtor) << (IsDelete ? 0 : 1)
3604 }
else if (WarnOnNonAbstractTypes) {
3607 Diag(Loc, diag::warn_delete_non_virtual_dtor) << (IsDelete ? 0 : 1)
3611 std::string TypeStr;
3613 Diag(DtorLoc, diag::note_delete_non_virtual)
3643 diag::err_invalid_use_of_function_type)
3647 diag::err_invalid_use_of_array_type)
3668 llvm_unreachable(
"unexpected condition kind");
3682 llvm::APSInt
Value(1);
3697 From = Cast->getSubExpr();
3709 if (!ToPtrType->getPointeeType().hasQualifiers()) {
3710 switch (StrLit->getKind()) {
3717 return (ToPointeeType->getKind() == BuiltinType::Char_U ||
3718 ToPointeeType->getKind() == BuiltinType::Char_S);
3735 bool HadMultipleCandidates,
3738 default: llvm_unreachable(
"Unhandled cast kind!");
3739 case CK_ConstructorConversion: {
3744 diag::err_allocation_of_abstract_type))
3756 CastLoc, Ty, FoundDecl, cast<CXXConstructorDecl>(Method),
3757 ConstructorArgs, HadMultipleCandidates,
3758 false,
false,
false,
3766 case CK_UserDefinedConversion: {
3776 HadMultipleCandidates);
3777 if (Result.isInvalid())
3781 CK_UserDefinedConversion, Result.get(),
3782 nullptr, Result.get()->getValueKind());
3818 assert(FD &&
"no conversion function for user-defined conversion seq");
3820 CastKind = CK_UserDefinedConversion;
3828 CastKind = CK_ConstructorConversion;
3856 From = CastArg.
get();
3870 PDiag(diag::err_typecheck_ambiguous_condition)
3875 llvm_unreachable(
"Cannot perform an ellipsis conversion");
3880 From->
getType(), From, Action);
3881 assert(Diagnosed &&
"failed to diagnose bad conversion"); (void)Diagnosed;
3919 ConstructorArgs,
false,
3920 false,
false,
false,
3927 false,
false,
false,
3950 ToAtomicType = ToType;
3951 ToType = ToAtomic->getValueType();
3954 QualType InitialFromType = FromType;
3956 switch (SCS.
First) {
3959 FromType = FromAtomic->getValueType().getUnqualifiedType();
3968 assert(!FromRes.isInvalid() &&
"Can't perform deduced conversion?!");
3969 From = FromRes.get();
3970 FromType = From->getType();
3987 llvm_unreachable(
"Improper first standard conversion");
4024 "only enums with fixed underlying type can promote to bool");
4046 CK = CK_FloatingComplexCast;
4048 CK = CK_FloatingComplexToIntegralComplex;
4050 CK = CK_IntegralComplexToFloatingComplex;
4052 CK = CK_IntegralComplexCast;
4079 diag::ext_typecheck_convert_incompatible_pointer)
4084 diag::ext_typecheck_convert_incompatible_pointer)
4097 Diag(From->
getBeginLoc(), diag::err_arc_convesion_of_weak_unavailable)
4109 if (Kind == CK_BlockPointerToObjCPointerCast) {
4114 if (
getLangOpts().allowsNonTrivialObjCLifetimeQualifiers())
4162 &BasePath, CCK).
get();
4175 nullptr, CCK).
get();
4182 QualType ElType = ToComplex->getElementType();
4190 isFloatingComplex ? CK_FloatingCast : CK_FloatingToIntegral).
get();
4194 isFloatingComplex ? CK_IntegralToFloating : CK_IntegralCast).
get();
4198 isFloatingComplex ? CK_FloatingRealToComplex
4199 : CK_IntegralRealToComplex).
get();
4204 assert(FromComplex);
4211 isFloatingComplex ? CK_FloatingComplexToReal
4212 : CK_IntegralComplexToReal,
4220 isFloatingComplex ? CK_FloatingCast : CK_IntegralToFloating,
4225 isFloatingComplex ? CK_FloatingToIntegral : CK_IntegralCast,
4243 From = FromRes.
get();
4245 "Improper transparent union conversion");
4253 CK_ZeroToOCLOpaqueType,
4265 llvm_unreachable(
"Improper second standard conversion");
4268 switch (SCS.
Third) {
4294 CK = CK_AddressSpaceConversion;
4299 CK = CK_AddressSpaceConversion;
4309 ? diag::ext_deprecated_string_literal_conversion
4310 : diag::warn_deprecated_string_literal_conversion)
4318 llvm_unreachable(
"Improper third standard conversion");
4323 if (!ToAtomicType.
isNull()) {
4358 default: llvm_unreachable(
"not a UTT");
4411 Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
4420 Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
4458 Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
4469 if ((RD->*HasTrivial)() && !(RD->*HasNonTrivial)())
4476 bool FoundOperator =
false;
4479 Op != OpEnd; ++Op) {
4480 if (isa<FunctionTemplateDecl>(*Op))
4484 if((Operator->*IsDesiredOp)()) {
4485 FoundOperator =
true;
4493 return FoundOperator;
4500 assert(!T->
isDependentType() &&
"Cannot evaluate traits of dependent type");
4504 default: llvm_unreachable(
"not a UTT");
4586 return !RD->isUnion() && RD->isEmpty();
4590 return !RD->isUnion() && RD->isPolymorphic();
4594 return !RD->isUnion() && RD->isAbstract();
4610 return RD->hasAttr<FinalAttr>();
4639 if (
CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
4640 return RD->hasTrivialDefaultConstructor() &&
4641 !RD->hasNonTrivialDefaultConstructor();
4649 if (
CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
4650 return RD->hasTrivialMoveConstructor() && !RD->hasNonTrivialMoveConstructor();
4661 return RD->hasTrivialCopyConstructor() &&
4662 !RD->hasNonTrivialCopyConstructor();
4670 if (
CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
4671 return RD->hasTrivialMoveAssignment() && !RD->hasNonTrivialMoveAssignment();
4691 return RD->hasTrivialCopyAssignment() &&
4692 !RD->hasNonTrivialCopyAssignment();
4722 if (
auto *RD = C.getBaseElementType(T)->getAsCXXRecordDecl()) {
4758 if (
CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
4759 return RD->hasTrivialDestructor();
4770 if (C.getBaseElementType(T).isConstQualified())
4805 if (RD->hasTrivialCopyConstructor() &&
4806 !RD->hasNonTrivialCopyConstructor())
4809 bool FoundConstructor =
false;
4815 if (isa<FunctionTemplateDecl>(ND->getUnderlyingDecl()))
4818 if (isa<UsingDecl>(ND))
4820 auto *Constructor = cast<CXXConstructorDecl>(ND->getUnderlyingDecl());
4821 if (Constructor->isCopyConstructor(FoundTQs)) {
4822 FoundConstructor =
true;
4835 return FoundConstructor;
4846 if (
CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl()) {
4847 if (RD->hasTrivialDefaultConstructor() &&
4848 !RD->hasNonTrivialDefaultConstructor())
4851 bool FoundConstructor =
false;
4854 if (isa<FunctionTemplateDecl>(ND->getUnderlyingDecl()))
4857 if (isa<UsingDecl>(ND))
4859 auto *Constructor = cast<CXXConstructorDecl>(ND->getUnderlyingDecl());
4860 if (Constructor->isDefaultConstructor()) {
4861 FoundConstructor =
true;
4873 return FoundConstructor;
4882 return Destructor->isVirtual();
4894 return C.hasUniqueObjectRepresentations(T);
4911 Args[1]->getType(), RParenLoc);
4931 assert(!Args.empty());
4936 for (
const auto *TSI : Args) {
4942 diag::err_incomplete_type_used_in_type_trait_expr))
4958 ArgExprs.reserve(Args.size() - 1);
4959 for (
unsigned I = 1, N = Args.size(); I != N; ++I) {
4960 QualType ArgTy = Args[I]->getType();
4963 OpaqueArgExprs.push_back(
4968 for (
Expr &E : OpaqueArgExprs)
4969 ArgExprs.push_back(&E);
5009 return !Result.
get()->hasNonTrivialCall(S.
Context);
5012 llvm_unreachable(
"unhandled type trait");
5015 default: llvm_unreachable(
"not a TT");
5027 *
this, Kind, KWLoc, Args[0]->getType()))
5030 bool Dependent =
false;
5031 for (
unsigned I = 0, N = Args.size(); I != N; ++I) {
5032 if (Args[I]->getType()->isDependentType()) {
5050 ConvertedArgs.reserve(Args.size());
5052 for (
unsigned I = 0, N = Args.size(); I != N; ++I) {
5058 ConvertedArgs.push_back(TInfo);
5067 "Cannot evaluate traits of dependent types");
5078 if (!rhsRecord || !lhsRecord) {
5081 if (!LHSObjTy || !RHSObjTy)
5086 if (!BaseInterface || !DerivedInterface)
5090 KeyLoc, RhsT, diag::err_incomplete_type_used_in_type_trait_expr))
5097 == (lhsRecord == rhsRecord));
5099 if (lhsRecord == rhsRecord)
5107 diag::err_incomplete_type_used_in_type_trait_expr))
5110 return cast<CXXRecordDecl>(rhsRecord->getDecl())
5111 ->isDerivedFrom(cast<CXXRecordDecl>(lhsRecord->
getDecl()));
5169 Expr *FromPtr = &From;
5203 diag::err_incomplete_type_used_in_type_trait_expr))
5207 diag::err_incomplete_type_used_in_type_trait_expr))
5248 return !Result.get()->hasNonTrivialCall(Self.
Context);
5251 llvm_unreachable(
"unhandled type trait");
5254 default: llvm_unreachable(
"not a BTT");
5256 llvm_unreachable(
"Unknown type trait or not implemented");
5275 assert(!T->
isDependentType() &&
"Cannot evaluate traits of dependent type");
5283 T = AT->getElementType();
5293 diag::err_dimension_expr_not_constant_integer,
5296 if (Value.isSigned() && Value.isNegative()) {
5297 Self.
Diag(KeyLoc, diag::err_dimension_expr_not_constant_integer)
5301 Dim = Value.getLimitedValue();
5305 bool Matched =
false;
5312 T = AT->getElementType();
5317 return CAT->getSize().getLimitedValue();
5323 llvm_unreachable(
"Unknown type trait or not implemented");
5366 llvm_unreachable(
"Expression trait not covered by switch");
5391 assert(!LHS.
get()->getType()->isPlaceholderType() &&
5392 !RHS.
get()->getType()->isPlaceholderType() &&
5393 "placeholders should have been weeded out by now");
5399 else if (LHS.
get()->isRValue())
5408 const char *OpSpelling = isIndirect ?
"->*" :
".*";
5416 Diag(Loc, diag::err_bad_memptr_rhs)
5417 << OpSpelling << RHSType << RHS.
get()->getSourceRange();
5436 LHSType = Ptr->getPointeeType();
5438 Diag(Loc, diag::err_bad_memptr_lhs)
5439 << OpSpelling << 1 << LHSType
5448 OpSpelling, (
int)isIndirect)) {
5453 Diag(Loc, diag::err_bad_memptr_lhs) << OpSpelling
5454 << (int)isIndirect << LHS.
get()->getType();
5460 LHSType, Class, Loc,
5474 if (isa<CXXScalarValueInitExpr>(RHS.
get()->IgnoreParens())) {
5477 Diag(Loc, diag::err_pointer_to_member_type) << isIndirect;
5496 switch (Proto->getRefQualifier()) {
5502 if (!isIndirect && !LHS.
get()->Classify(
Context).isLValue()) {
5505 if (Proto->isConst() && !Proto->isVolatile())
5507 ? diag::warn_cxx17_compat_pointer_to_const_ref_member_on_rvalue
5508 : diag::ext_pointer_to_const_ref_member_on_rvalue);
5510 Diag(Loc, diag::err_pointer_to_member_oper_value_classify)
5511 << RHSType << 1 << LHS.
get()->getSourceRange();
5516 if (isIndirect || !LHS.
get()->Classify(
Context).isRValue())
5517 Diag(Loc, diag::err_pointer_to_member_oper_value_classify)
5518 << RHSType << 0 << LHS.
get()->getSourceRange();
5533 }
else if (isIndirect) {
5536 VK = LHS.
get()->getValueKind();
5551 bool &HaveConversion,
5553 HaveConversion =
false;
5578 HaveConversion =
true;
5583 return InitSeq.
Diagnose(Self, Entity, Kind, From);
5593 bool FDerivedFromT = FRec && TRec && FRec != TRec &&
5595 if (FRec && TRec && (FRec == TRec || FDerivedFromT ||
5600 if (FRec == TRec || FDerivedFromT) {
5605 HaveConversion =
true;
5610 return InitSeq.
Diagnose(Self, Entity, Kind, From);
5628 HaveConversion = !InitSeq.
Failed();
5631 return InitSeq.
Diagnose(Self, Entity, Kind, From);
5654 LHS.
get(), Best->BuiltinParamTypes[0], Best->Conversions[0],
5661 RHS.
get(), Best->BuiltinParamTypes[1], Best->Conversions[1],
5679 Self.
Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
5680 << LHS.
get()->getType() << RHS.
get()->getType()
5681 << LHS.
get()->getSourceRange() << RHS.
get()->getSourceRange();
5685 Self.
Diag(QuestionLoc, diag::err_conditional_ambiguous_ovl)
5686 << LHS.
get()->getType() << RHS.
get()->getType()
5687 << LHS.
get()->getSourceRange() << RHS.
get()->getSourceRange();
5693 llvm_unreachable(
"Conditional operator has only built-in overloads");
5736 if (!Cond.
get()->isTypeDependent()) {
5748 if (LHS.
get()->isTypeDependent() || RHS.
get()->isTypeDependent())
5755 bool LVoid = LTy->isVoidType();
5757 if (LVoid || RVoid) {
5762 bool LThrow = isa<CXXThrowExpr>(LHS.
get()->IgnoreParenImpCasts());
5763 bool RThrow = isa<CXXThrowExpr>(RHS.
get()->IgnoreParenImpCasts());
5764 if (LThrow != RThrow) {
5765 Expr *NonThrow = LThrow ? RHS.
get() : LHS.
get();
5779 Diag(QuestionLoc, diag::err_conditional_void_nonvoid)
5780 << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1)
5781 << LHS.
get()->getSourceRange() << RHS.
get()->getSourceRange();
5795 bool HaveL2R, HaveR2L;
5802 if (HaveL2R && HaveR2L) {
5803 Diag(QuestionLoc, diag::err_conditional_ambiguous)
5804 << LTy << RTy << LHS.
get()->getSourceRange() << RHS.
get()->getSourceRange();
5814 LTy = LHS.
get()->getType();
5815 }
else if (HaveR2L) {
5818 RTy = RHS.
get()->getType();
5836 bool DerivedToBase, ObjCConversion, ObjCLifetimeConversion;
5838 QuestionLoc, LTy, RTy, DerivedToBase,
5840 !DerivedToBase && !ObjCConversion && !ObjCLifetimeConversion &&
5843 !RHS.
get()->refersToBitField() &&
5844 !RHS.
get()->refersToVectorElement()) {
5846 RTy = RHS.
get()->getType();
5848 QuestionLoc, RTy, LTy, DerivedToBase,
5850 !DerivedToBase && !ObjCConversion && !ObjCLifetimeConversion &&
5851 !LHS.
get()->refersToBitField() &&
5852 !LHS.
get()->refersToVectorElement()) {
5854 LTy = LHS.
get()->getType();
5866 if (Same && LVK == RVK && LVK !=
VK_RValue &&
5867 LHS.
get()->isOrdinaryOrBitFieldObject() &&
5868 RHS.
get()->isOrdinaryOrBitFieldObject()) {
5869 VK = LHS.
get()->getValueKind();
5876 if (LTy->isFunctionPointerType() || LTy->isMemberFunctionPointerType()) {
5882 assert(!LTy.isNull() &&
"failed to find composite pointer type for " 5883 "canonically equivalent function ptr types");
5893 if (!Same && (LTy->isRecordType() || RTy->
isRecordType())) {
5908 LTy = LHS.
get()->getType();
5909 RTy = RHS.get()->getType();
5918 if (LTy->isRecordType()) {
5940 if (LTy->isFunctionPointerType() || LTy->isMemberFunctionPointerType()) {
5942 assert(!LTy.isNull() &&
"failed to find composite pointer type for " 5943 "canonically equivalent function ptr types");
5964 diag::err_typecheck_cond_incompatible_operands) << LTy << RTy
5965 << LHS.
get()->getSourceRange() << RHS.get()->getSourceRange();
6000 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
6001 << LHS.
get()->getType() << RHS.get()->getType()
6002 << LHS.
get()->getSourceRange() << RHS.get()->getSourceRange();
6036 "computing composite pointer type of dependent types");
6050 llvm_unreachable(
"handled above");
6055 assert(EST2 ==
EST_Dynamic &&
"other cases should already be handled");
6056 llvm::SmallPtrSet<QualType, 8> Found;
6060 ExceptionTypeStorage.push_back(E);
6070 llvm_unreachable(
"shouldn't see unresolved exception specifications here");
6073 llvm_unreachable(
"invalid ExceptionSpecificationType");
6101 bool T2IsPointerLike = T2->isAnyPointerType() || T2->isMemberPointerType() ||
6102 T2->isNullPtrType();
6103 if (!T1IsPointerLike && !T2IsPointerLike)
6111 if (T1IsPointerLike &&
6115 ? CK_NullToMemberPointer
6116 : CK_NullToPointer).
get();
6119 if (T2IsPointerLike &&
6123 ? CK_NullToMemberPointer
6124 : CK_NullToPointer).
get();
6129 if (!T1IsPointerLike || !T2IsPointerLike)
6132 "nullptr_t should be a null pointer constant");
6172 unsigned NeedConstBefore = 0;
6183 NeedConstBefore = QualifierUnion.size();
6185 QualifierUnion.push_back(
6187 MemberOfClass.push_back(std::make_pair(
nullptr,
nullptr));
6200 NeedConstBefore = QualifierUnion.size();
6202 QualifierUnion.push_back(
6204 MemberOfClass.push_back(std::make_pair(MemPtr1->
getClass(),
6224 if (QualifierUnion.size() == 1) {
6240 ExceptionTypeStorage);
6243 FPT1->getParamTypes(), EPI1);
6245 FPT2->getParamTypes(), EPI2);
6250 if (NeedConstBefore) {
6254 for (
unsigned I = 0; I != NeedConstBefore; ++I)
6256 QualifierUnion[I] = QualifierUnion[I] | Qualifiers::Const;
6260 auto MOC = MemberOfClass.rbegin();
6261 for (
unsigned CVR : llvm::reverse(QualifierUnion)) {
6263 auto Classes = *MOC++;
6264 if (Classes.first && Classes.second) {
6290 : S(S), E1(E1), E2(E2), Composite(Composite),
6293 E1ToC(S, Entity, Kind, E1), E2ToC(S, Entity, Kind, E2),
6294 Viable(E1ToC && E2ToC) {}
6303 if (E2Result.isInvalid())
6305 E2 = E2Result.getAs<
Expr>();
6312 Conversion C1(*
this, Loc, E1, E2, Composite1);
6314 if (ConvertArgs && C1.perform())
6316 return C1.Composite;
6318 Conversion C2(*
this, Loc, E1, E2, Composite2);
6320 if (C1.Viable == C2.Viable) {
6328 if (ConvertArgs && (C1.Viable ? C1 : C2).perform())
6331 return C1.Viable ? C1.Composite : C2.Composite;
6338 assert(!isa<CXXBindTemporaryExpr>(E) &&
"Double-bound temporary?");
6349 bool ReturnsRetained;
6353 if (
CallExpr *Call = dyn_cast<CallExpr>(E)) {
6354 Expr *Callee = Call->getCallee()->IgnoreParens();
6360 T = BinOp->getRHS()->getType();
6361 else if (
MemberExpr *Mem = dyn_cast<MemberExpr>(Callee))
6362 T = Mem->getMemberDecl()->getType();
6373 assert(FTy &&
"call to value not of function type?");
6378 }
else if (isa<StmtExpr>(E)) {
6379 ReturnsRetained =
true;
6383 }
else if (isa<CastExpr>(E) &&
6384 isa<BlockExpr>(cast<CastExpr>(E)->getSubExpr())) {
6393 D = Send->getMethodDecl();
6394 }
else if (
ObjCBoxedExpr *BoxedExpr = dyn_cast<ObjCBoxedExpr>(E)) {
6395 D = BoxedExpr->getBoxingMethod();
6399 if (ArrayLit->getNumElements() == 0 &&
6403 D = ArrayLit->getArrayWithObjectsMethod();
6405 = dyn_cast<ObjCDictionaryLiteral>(E)) {
6408 if (DictLit->getNumElements() == 0 &&
6412 D = DictLit->getDictWithObjectsMethod();
6415 ReturnsRetained = (D && D->
hasAttr<NSReturnsRetainedAttr>());
6420 if (!ReturnsRetained &&
6431 CastKind ck = (ReturnsRetained ? CK_ARCConsumeObject
6432 : CK_ARCReclaimReturnedObject);
6447 RT = cast<RecordType>(T);
6449 case Type::ConstantArray:
6450 case Type::IncompleteArray:
6451 case Type::VariableArray:
6452 case Type::DependentSizedArray:
6453 T = cast<ArrayType>(T)->getElementType().getTypePtr();
6473 PDiag(diag::err_access_dtor_temp)
6504 assert(SubExpr &&
"subexpression can't be null!");
6526 assert(SubStmt &&
"sub-statement can't be null!");
6551 "not in a decltype expression");
6554 if (Result.isInvalid())
6568 if (
ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
6572 if (SubExpr.
get() == PE->getSubExpr())
6577 if (BO->getOpcode() == BO_Comma) {
6581 if (RHS.
get() == BO->getRHS())
6584 BO->getLHS(), RHS.
get(), BO_Comma, BO->getType(), BO->getValueKind(),
6585 BO->getObjectKind(), BO->getOperatorLoc(), BO->getFPFeatures());
6607 for (
unsigned I = 0, N =
ExprEvalContexts.back().DelayedDecltypeCalls.size();
6610 if (Call == TopCall)
6620 for (
unsigned I = 0, N =
ExprEvalContexts.back().DelayedDecltypeBinds.size();
6624 if (Bind == TopBind)
6636 PDiag(diag::err_access_dtor_temp)
6652 unsigned SkipStart = OperatorArrows.size(), SkipCount = 0;
6655 if (OperatorArrows.size() > Limit) {
6657 SkipStart = (Limit - 1) / 2 + (Limit - 1) % 2;
6658 SkipCount = OperatorArrows.size() - (Limit - 1);
6661 for (
unsigned I = 0; I < OperatorArrows.size(); ) {
6662 if (I == SkipStart) {
6663 S.
Diag(OperatorArrows[I]->getLocation(),
6664 diag::note_operator_arrows_suppressed)
6668 S.
Diag(OperatorArrows[I]->getLocation(), diag::note_operator_arrow_here)
6669 << OperatorArrows[I]->getCallResultType();
6679 bool &MayBePseudoDestructor) {
6683 Base = Result.
get();
6687 Base = Result.
get();
6690 MayBePseudoDestructor =
false;
6695 if (OpKind == tok::arrow)
6700 MayBePseudoDestructor =
true;
6707 if (OpKind == tok::arrow) {
6709 bool NoArrowOperatorFound =
false;
6710 bool FirstIteration =
true;
6713 llvm::SmallPtrSet<CanQualType,8> CTypes;
6718 if (OperatorArrows.size() >=
getLangOpts().ArrowDepth) {
6719 Diag(OpLoc, diag::err_operator_arrow_depth_exceeded)
6722 Diag(OpLoc, diag::note_operator_arrow_depth)
6735 : &NoArrowOperatorFound);
6737 if (NoArrowOperatorFound) {
6738 if (FirstIteration) {
6739 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
6742 OpKind = tok::period;
6745 Diag(OpLoc, diag::err_typecheck_member_reference_arrow)
6750 diag::note_member_reference_arrow_from_operator_arrow);
6755 Base = Result.
get();
6757 OperatorArrows.push_back(OpCall->getDirectCallee());
6760 if (!CTypes.insert(CBaseType).second) {
6761 Diag(OpLoc, diag::err_operator_arrow_circular) << StartingType;
6765 FirstIteration =
false;
6768 if (OpKind == tok::arrow &&
6791 MayBePseudoDestructor =
true;
6794 ObjectType =
nullptr;
6795 MayBePseudoDestructor =
true;
6823 Base = result.
get();
6833 if (OpKind == tok::arrow) {
6838 S.
Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
6839 << ObjectType <<
true 6844 OpKind = tok::period;
6879 if (
CheckArrow(*
this, ObjectType, Base, OpKind, OpLoc))
6887 Diag(OpLoc, diag::err_pseudo_dtor_base_not_scalar)
6896 if (DestructedTypeInfo) {
6909 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
6914 *
this, DestructedType))
6919 ObjectType = DestructedType;
6920 OpKind = tok::arrow;
6922 Diag(DestructedTypeStart, diag::err_pseudo_dtor_type_mismatch)
6927 DestructedType = ObjectType;
6928 DestructedTypeInfo =
6939 Diag(DestructedTypeStart, diag::err_arc_pseudo_dtor_inconstant_quals)
6945 DestructedType = ObjectType;
6947 DestructedTypeStart);
6960 if (ScopeTypeInfo) {
6966 diag::err_pseudo_dtor_type_mismatch)
6971 ScopeTypeInfo =
nullptr;
6977 OpKind == tok::arrow, OpLoc,
6997 "Invalid first type name in pseudo-destructor");
7000 "Invalid second type name in pseudo-destructor");
7003 if (
CheckArrow(*
this, ObjectType, Base, OpKind, OpLoc))
7024 S, &SS,
true,
false, ObjectTypePtrForLookup,
7037 diag::err_pseudo_dtor_destructor_non_type)
7043 DestructedType = ObjectType;
7060 if (T.isInvalid() || !T.get()) {
7062 DestructedType = ObjectType;
7069 if (!DestructedType.
isNull()) {
7070 if (!DestructedTypeInfo)
7084 S, &SS,
true,
false, ObjectTypePtrForLookup,
7088 diag::err_pseudo_dtor_destructor_non_type)
7112 if (T.isInvalid() || !T.get()) {
7120 if (!ScopeType.
isNull() && !ScopeTypeInfo)
7126 ScopeTypeInfo, CCLoc, TildeLoc,
7136 if (
CheckArrow(*
this, ObjectType, Base, OpKind, OpLoc))
7155 bool HadMultipleCandidates) {
7173 SubE = BE->getSubExpr();
7174 if (isa<LambdaExpr>(SubE)) {
7184 Exp.
get()->getExprLoc(), Exp.
get()->getExprLoc(), Method, Exp.
get());
7188 Diag(Exp.
get()->getExprLoc(), diag::note_lambda_to_block_conv);
7196 if (HadMultipleCandidates)
7205 Context, ME, {}, ResultType, VK, Exp.
get()->getEndLoc());
7207 if (CheckFunctionCall(Method, CE,
7229 Diag(Operand->
getExprLoc(), diag::warn_side_effects_unevaluated_context);
7251 if (isa<DeclRefExpr>(E))
7255 if (isa<ArraySubscriptExpr>(E))
7259 if (isa<MemberExpr>(E))
7264 if (UO->getOpcode() == UO_Deref)
7269 if (BO->isPtrMemOp())
7273 if (BO->getOpcode() == BO_Comma)
7284 dyn_cast<BinaryConditionalOperator>(E)) {
7285 if (
OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(BCO->getTrueExpr()))
7291 if (isa<PseudoObjectExpr>(E) || isa<ObjCIvarRefExpr>(E))
7349 if (!T->getDecl()->isComplete()) {
7363 diag::err_incomplete_type);
7381 if (isa<ParmVarDecl>(Var))
return true;
7382 const VarDecl *DefVD =
nullptr;
7387 if (DefVD->
isWeak())
return false;
7416 while (DC && isa<CapturedDecl>(DC))
7420 "The current call operator must be synchronized with Sema's CurContext");
7428 const unsigned NumPotentialCaptures =
7430 for (
unsigned I = 0; I != NumPotentialCaptures; ++I) {
7431 Expr *VarExpr =
nullptr;
7446 !IsFullExprInstantiationDependent)
7454 const unsigned FunctionScopeIndexOfCapturableLambda = Index.getValue();
7456 &FunctionScopeIndexOfCapturableLambda);
7458 const bool IsVarNeverAConstantExpression =
7460 if (!IsFullExprInstantiationDependent || IsVarNeverAConstantExpression) {
7472 DeclRefType,
nullptr)) {
7478 DeclRefType,
nullptr);
7490 const unsigned FunctionScopeIndexOfCapturableLambda = Index.getValue();
7493 &FunctionScopeIndexOfCapturableLambda);
7516 R.setLookupName(ND->getDeclName());
7518 if (ND->isCXXClassMember()) {
7522 Record = NNS->getAsType()->getAsCXXRecordDecl();
7525 dyn_cast<
CXXRecordDecl>(ND->getDeclContext()->getRedeclContext());
7527 R.setNamingClass(Record);
7531 bool MightBeImplicitMember;
7533 MightBeImplicitMember =
true;
7535 MightBeImplicitMember =
false;
7536 else if (R.isOverloadedResult())
7537 MightBeImplicitMember =
false;
7538 else if (R.isUnresolvableResult())
7539 MightBeImplicitMember =
true;
7541 MightBeImplicitMember = isa<FieldDecl>(ND) ||
7542 isa<IndirectFieldDecl>(ND) ||
7543 isa<MSPropertyDecl>(ND);
7545 if (MightBeImplicitMember)
7549 }
else if (
auto *Ivar = dyn_cast<ObjCIvarDecl>(ND)) {
7551 Ivar->getIdentifier());
7565 : TypoExprs(TypoExprs) {}
7567 TypoExprs.insert(TE);
7572 class TransformTypos :
public TreeTransform<TransformTypos> {
7577 llvm::function_ref<ExprResult(Expr *)> ExprFilter;
7579 llvm::SmallDenseMap<TypoExpr *, ExprResult, 2> TransformCache;
7580 llvm::SmallDenseMap<OverloadExpr *, Expr *, 4> OverloadResolution;
7586 void EmitAllDiagnostics() {
7588 auto &
State = SemaRef.getTypoExprState(TE);
7589 if (
State.DiagHandler) {
7599 Replacement.
isInvalid() ? nullptr : Replacement.
get()))
7602 State.DiagHandler(TC);
7604 SemaRef.clearDelayedTypo(TE);
7617 bool CheckAndAdvanceTypoExprCorrectionStreams() {
7618 for (
auto TE : TypoExprs) {
7619 auto &
State = SemaRef.getTypoExprState(TE);
7620 TransformCache.erase(TE);
7621 if (!
State.Consumer->finished())
7623 State.Consumer->resetCorrectionStream();
7629 if (
auto *OE = dyn_cast_or_null<OverloadExpr>(E))
7630 E = OverloadResolution[OE];
7634 if (
auto *DRE = dyn_cast<DeclRefExpr>(E))
7635 return DRE->getFoundDecl();
7636 if (
auto *ME = dyn_cast<MemberExpr>(E))
7650 return ExprFilter(Res.
get());
7655 : BaseTransform(SemaRef), InitDecl(InitDecl), ExprFilter(
Filter) {}
7660 Expr *ExecConfig =
nullptr) {
7661 auto Result = BaseTransform::RebuildCallExpr(Callee, LParenLoc, Args,
7662 RParenLoc, ExecConfig);
7663 if (
auto *OE = dyn_cast<OverloadExpr>(Callee)) {
7666 if (
auto *BE = dyn_cast<CXXBindTemporaryExpr>(ResultCall))
7667 ResultCall = BE->getSubExpr();
7668 if (
auto *CE = dyn_cast<CallExpr>(ResultCall))
7669 OverloadResolution[OE] = CE->getCallee();
7682 Res = TryTransform(E);
7687 !CheckAndAdvanceTypoExprCorrectionStreams())
7700 while (!AmbiguousTypoExprs.empty()) {
7701 auto TE = AmbiguousTypoExprs.back();
7702 auto Cached = TransformCache[TE];
7704 State.Consumer->saveCurrentPosition();
7705 TransformCache.erase(TE);
7707 State.Consumer->resetCorrectionStream();
7708 TransformCache.erase(TE);
7712 AmbiguousTypoExprs.remove(TE);
7713 State.Consumer->restoreSavedPosition();
7714 TransformCache[TE] = Cached;
7720 FindTypoExprs(TypoExprs).TraverseStmt(E);
7722 EmitAllDiagnostics();
7731 auto &CacheEntry = TransformCache[E];
7732 if (!TypoExprs.insert(E) && !CacheEntry.isUnset()) {
7737 assert(
State.Consumer &&
"Cannot transform a cleared TypoExpr");
7742 if (InitDecl && TC.getFoundDecl() == InitDecl)
7747 State.RecoveryHandler(SemaRef, E, TC) :
7754 if ((Next =
State.Consumer->peekNextCorrection()) &&
7756 AmbiguousTypoExprs.insert(E);
7758 AmbiguousTypoExprs.remove(E);
7761 "Typo was transformed into a valid-but-null ExprResult");
7762 return CacheEntry = NE;
7779 auto TyposResolved = DelayedTypos.size();
7780 auto Result = TransformTypos(*
this, InitDecl,
Filter).Transform(E);
7781 TyposResolved -= DelayedTypos.size();
7786 assert(TyposResolved == 0 &&
"Corrected typo but got same Expr back?");
7792 bool DiscardedValue,
7796 if (!FullExpr.
get())
7802 if (DiscardedValue) {
7823 if (FullExpr.isInvalid())
7826 CheckCompletedExpr(FullExpr.get(), CC, IsConstexpr);
7875 while (DC && isa<CapturedDecl>(DC))
7878 if (IsInLambdaDeclContext && CurrentLSI &&
7879 CurrentLSI->hasPotentialCaptures() && !FullExpr.isInvalid())
7923 llvm_unreachable(
"Invalid LookupResult Kind!");
static bool CheckArrow(Sema &S, QualType &ObjectType, Expr *&Base, tok::TokenKind &OpKind, SourceLocation OpLoc)
A call to an overloaded operator written using operator syntax.
Function pointer conversion (C++17 [conv.fctptr])
DeclAccessPair FoundConversionFunction
The declaration that we found via name lookup, which might be the same as ConversionFunction or it mi...
Defines the clang::ASTContext interface.
void diagnoseUnavailableAlignedAllocation(const FunctionDecl &FD, SourceLocation Loc)
Produce diagnostics if FD is an aligned allocation or deallocation function that is unavailable...
CanThrowResult canThrow(const Expr *E)
unsigned DeprecatedStringLiteralToCharPtr
Whether this is the deprecated conversion of a string literal to a pointer to non-const character dat...
QualType getCurrentThisType()
Try to retrieve the type of the 'this' pointer.
This is the scope of a C++ try statement.
ExprResult ActOnArrayTypeTrait(ArrayTypeTrait ATT, SourceLocation KWLoc, ParsedType LhsTy, Expr *DimExpr, SourceLocation RParen)
ActOnArrayTypeTrait - Parsed one of the binary type trait support pseudo-functions.
The null pointer literal (C++11 [lex.nullptr])
void clearPotentialCaptures()
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
void setImplicit(bool I=true)
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.
bool isUnavailableAlignedAllocationFunction(const FunctionDecl &FD) const
Determine whether FD is an aligned allocation or deallocation function that is unavailable.
SourceLocation StartLocation
The location of the first token that describes this unqualified-id, which will be the location of the...
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
const DeclaratorChunk & getTypeObject(unsigned i) const
Return the specified TypeInfo from this declarator.
bool isMemberDataPointerType() const
bool tryAddTopLevelDecl(NamedDecl *D, DeclarationName Name)
Try to add the given declaration to the top level scope, if it (or a redeclaration of it) hasn't alre...
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
IdentifierInfo * Name
FIXME: Temporarily stores the name of a specialization.
void setLookupName(DeclarationName Name)
Sets the name to look up.
SourceLocation TemplateNameLoc
TemplateNameLoc - The location of the template name within the source.
static ConditionResult ConditionError()
QualType CXXThisTypeOverride
When non-NULL, the C++ 'this' expression is allowed despite the current context not being a non-stati...
bool isArithmeticType() const
Stmt - This represents one statement.
IdentifierInfo * Identifier
When Kind == IK_Identifier, the parsed identifier, or when Kind == IK_UserLiteralId, the identifier suffix.
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
bool isGenericLambdaCallOperatorSpecialization(const CXXMethodDecl *MD)
FunctionType - C99 6.7.5.3 - Function Declarators.
FullExprArg MakeFullExpr(Expr *Arg)
Provides information about an attempted template argument deduction, whose success or failure was des...
ARCConversionResult CheckObjCConversion(SourceRange castRange, QualType castType, Expr *&op, CheckedConversionKind CCK, bool Diagnose=true, bool DiagnoseCFAudited=false, BinaryOperatorKind Opc=BO_PtrMemD)
Checks for invalid conversions and casts between retainable pointers and other pointer kinds for ARC ...
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Microsoft __if_not_exists.
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
bool isRealFloatingType() const
Floating point categories.
bool hasPlaceholderType() const
Returns whether this expression has a placeholder type.
QualType getThisType() const
Returns the type of the this pointer.
void addConst()
Add the const type qualifier to this QualType.
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in...
ExprResult BuildCXXTypeConstructExpr(TypeSourceInfo *Type, SourceLocation LParenLoc, MultiExprArg Exprs, SourceLocation RParenLoc, bool ListInitialization)
Complex conversions (C99 6.3.1.6)
bool isRecordType() const
unsigned getTypeAlignIfKnown(QualType T) const
Return the ABI-specified alignment of a type, in bits, or 0 if the type is incomplete and we cannot d...
bool isEmpty() const
No scope specifier.
static InitializedEntity InitializeParameter(ASTContext &Context, const ParmVarDecl *Parm)
Create the initialization entity for a parameter.
UserDefinedConversionSequence UserDefined
When ConversionKind == UserDefinedConversion, provides the details of the user-defined conversion seq...
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
static bool FindConditionalOverload(Sema &Self, ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
Try to find a common type for two according to C++0x 5.16p5.
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type...
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
bool hasIrrelevantDestructor() const
Determine whether this class has a destructor which has no semantic effect.
bool DiagnoseConditionalForNull(Expr *LHSExpr, Expr *RHSExpr, SourceLocation QuestionLoc)
Emit a specialized diagnostic when one expression is a null pointer constant and the other is not a p...
Decl - This represents one declaration (or definition), e.g.
bool isVariadic() const
Whether this function prototype is variadic.
ExprResult ActOnNoexceptExpr(SourceLocation KeyLoc, SourceLocation LParen, Expr *Operand, SourceLocation RParen)
bool isExtVectorType() const
AssignConvertType
AssignConvertType - All of the 'assignment' semantic checks return this enum to indicate whether the ...
ExprResult PerformContextualImplicitConversion(SourceLocation Loc, Expr *FromE, ContextualImplicitConverter &Converter)
Perform a contextual implicit conversion.
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS, bool AllowBuiltinCreation=false, bool EnteringContext=false)
Performs name lookup for a name that was parsed in the source code, and may contain a C++ scope speci...
OverloadedOperatorKind getCXXOverloadedOperator() const
If this name is the name of an overloadable operator in C++ (e.g., operator+), retrieve the kind of o...
ExprResult BuildBlockForLambdaConversion(SourceLocation CurrentLocation, SourceLocation ConvLocation, CXXConversionDecl *Conv, Expr *Src)
ParenExpr - This represents a parethesized expression, e.g.
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
ExprResult forceUnknownAnyToType(Expr *E, QualType ToType)
Force an expression with unknown-type to an expression of the given type.
static InitializationKind CreateDirect(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc)
Create a direct initialization.
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined...
The base class of the type hierarchy.
This indicates that the scope corresponds to a function, which means that labels are set here...
unsigned IncompatibleObjC
IncompatibleObjC - Whether this is an Objective-C conversion that we should warn about (if we actuall...
One instance of this struct is used for each type in a declarator that is parsed. ...
Represents an array type, per C99 6.7.5.2 - Array Declarators.
The template argument is a declaration that was provided for a pointer, reference, or pointer to member non-type template parameter.
static InitializationKind CreateDefault(SourceLocation InitLoc)
Create a default initialization.
static void CheckIfAnyEnclosingLambdasMustCaptureAnyPotentialCaptures(Expr *const FE, LambdaScopeInfo *const CurrentLSI, Sema &S)
Check if the current lambda has any potential captures that must be captured by any of its enclosing ...
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Represents a call to a C++ constructor.
static ExprValueKind getValueKindForType(QualType T)
getValueKindForType - Given a formal return or parameter type, give its value kind.
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent...
SourceLocation getEndLoc() const LLVM_READONLY
Ambiguous candidates found.
QualType withConst() const
Incompatible - We reject this conversion outright, it is invalid to represent it in the AST...
const TargetInfo & getTargetInfo() const
A container of type source information.
static bool evaluateTypeTrait(Sema &S, TypeTrait Kind, SourceLocation KWLoc, ArrayRef< TypeSourceInfo *> Args, SourceLocation RParenLoc)
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
QualType getLogicalOperationType() const
The result type of logical operations, '<', '>', '!=', etc.
capture_const_range captures() const
Conversions between compatible types in C99.
bool isDefined(const FunctionDecl *&Definition) const
Returns true if the function has a definition that does not need to be instantiated.
static CXXFunctionalCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, TypeSourceInfo *Written, CastKind Kind, Expr *Op, const CXXCastPath *Path, SourceLocation LPLoc, SourceLocation RPLoc)
ExprResult ActOnExpressionTrait(ExpressionTrait OET, SourceLocation KWLoc, Expr *Queried, SourceLocation RParen)
ActOnExpressionTrait - Parsed one of the unary type trait support pseudo-functions.
const Expr * getAnyInitializer() const
Get the initializer for this variable, no matter which declaration it is attached to...
QualType getConversionType() const
Returns the type that this conversion function is converting to.
Represents a C++ constructor within a class.
LLVM_ATTRIBUTE_REINITIALIZES void clear()
Clears out any current state.
void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, bool MightBeOdrUse=true)
Mark a function referenced, and check whether it is odr-used (C++ [basic.def.odr]p2, C99 6.9p3)
bool isVariableExprMarkedAsNonODRUsed(Expr *CapturingVarExpr) const
bool hasInClassInitializer() const
Determine whether this member has a C++11 default member initializer.
size_t param_size() const
static InitializedEntity InitializeTemporary(QualType Type)
Create the initialization entity for a temporary.
unsigned getTypeAlign(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in bits.
bool isTrivialType(const ASTContext &Context) const
Return true if this is a trivial type per (C++0x [basic.types]p9)
bool DisableTypoCorrection
Tracks whether we are in a context where typo correction is disabled.
An identifier, stored as an IdentifierInfo*.
bool isUnsignedIntegerType() const
Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...
This file provides some common utility functions for processing Lambda related AST Constructs...
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
RAII object that enters a new expression evaluation context.
Represents a variable declaration or definition.
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
bool isStructureType() const
bool hasPotentialThisCapture() const
ExprResult PerformObjectArgumentInitialization(Expr *From, NestedNameSpecifier *Qualifier, NamedDecl *FoundDecl, CXXMethodDecl *Method)
PerformObjectArgumentInitialization - Perform initialization of the implicit object parameter for the...
static ExprResult attemptRecovery(Sema &SemaRef, const TypoCorrectionConsumer &Consumer, const TypoCorrection &TC)
IfExistsResult
Describes the result of an "if-exists" condition check.
CleanupInfo Cleanup
Used to control the generation of ExprWithCleanups.
DeclarationName getLookupName() const
Gets the name to look up.
Information about one declarator, including the parsed type information and the identifier.
QualType getReturnType() const
DiagnosticsEngine & Diags
static QualType adjustCVQualifiersForCXXThisWithinLambda(ArrayRef< FunctionScopeInfo *> FunctionScopes, QualType ThisTy, DeclContext *CurSemaContext, ASTContext &ASTCtx)
unsigned getNumParams() const
bool isEnumeralType() const
bool isFixed() const
Returns true if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying...
const T * getAs() const
Member-template getAs<specific type>'.
bool isDirectReferenceBinding() const
Determine whether this initialization is a direct reference binding (C++ [dcl.init.ref]).
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
Extra information about a function prototype.
AccessResult CheckDestructorAccess(SourceLocation Loc, CXXDestructorDecl *Dtor, const PartialDiagnostic &PDiag, QualType objectType=QualType())
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.
ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)
NestedNameSpecifier * getCorrectionSpecifier() const
Gets the NestedNameSpecifier needed to use the typo correction.
A namespace, stored as a NamespaceDecl*.
QualType getMemberPointerType(QualType T, const Type *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
bool HadMultipleCandidates
HadMultipleCandidates - When this is true, it means that the conversion function was resolved from an...
bool isInvalidDecl() const
static InitializationKind CreateDirectList(SourceLocation InitLoc)
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
ParsedType getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec *SS=nullptr, bool isClassName=false, bool HasTrailingDot=false, ParsedType ObjectType=nullptr, bool IsCtorOrDtorName=false, bool WantNontrivialTypeSourceInfo=false, bool IsClassTemplateDeductionContext=true, IdentifierInfo **CorrectedII=nullptr)
If the identifier refers to a type name within this scope, return the declaration of that type...
bool tryCaptureVariable(VarDecl *Var, SourceLocation Loc, TryCaptureKind Kind, SourceLocation EllipsisLoc, bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType, const unsigned *const FunctionScopeIndexToStopAt)
Try to capture the given variable.
A C++ throw-expression (C++ [except.throw]).
static bool doesUsualArrayDeleteWantSize(Sema &S, SourceLocation loc, QualType allocType)
Determine whether a given type is a class for which 'delete[]' would call a member 'operator delete[]...
Defines the clang::Expr interface and subclasses for C++ expressions.
noexcept(expression), value-dependent
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.
static CXXUnresolvedConstructExpr * Create(const ASTContext &Context, TypeSourceInfo *Type, SourceLocation LParenLoc, ArrayRef< Expr *> Args, SourceLocation RParenLoc)
Expr * FixOverloadedFunctionReference(Expr *E, DeclAccessPair FoundDecl, FunctionDecl *Fn)
FixOverloadedFunctionReference - E is an expression that refers to a C++ overloaded function (possibl...
Represents a struct/union/class.
QualType adjustCCAndNoReturn(QualType ArgFunctionType, QualType FunctionType, bool AdjustExceptionSpec=false)
Adjust the type ArgFunctionType to match the calling convention, noreturn, and optionally the excepti...
QualType FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
FindCompositeObjCPointerType - Helper method to find composite type of two objective-c pointer types ...
static bool ConvertForConditional(Sema &Self, ExprResult &E, QualType T)
Perform an "extended" implicit conversion as returned by TryClassUnification.
uint64_t getPointerWidth(unsigned AddrSpace) const
Return the width of pointers on this target, for the specified address space.
bool FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range, AllocationFunctionScope NewScope, AllocationFunctionScope DeleteScope, QualType AllocType, bool IsArray, bool &PassAlignment, MultiExprArg PlaceArgs, FunctionDecl *&OperatorNew, FunctionDecl *&OperatorDelete, bool Diagnose=true)
Finds the overloads of operator new and delete that are appropriate for the allocation.
TemplateIdAnnotation * TemplateId
When Kind == IK_TemplateId or IK_ConstructorTemplateId, the template-id annotation that contains the ...
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Boolean conversions (C++ [conv.bool])
FunctionType::ExtInfo ExtInfo
Represents a class template specialization, which refers to a class template with a given set of temp...
One of these records is kept for each identifier that is lexed.
void setIntegerType(QualType T)
Set the underlying integer type.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name)
Retrieves the declaration name from a parsed unqualified-id.
void DiagnoseUnusedExprResult(const Stmt *S)
DiagnoseUnusedExprResult - If the statement passed in is an expression whose result is unused...
bool isNothrow(bool ResultIfDependent=false) const
Determine whether this function type has a non-throwing exception specification.
Represents a class type in Objective C.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
void DropFirstTypeObject()
A C++ nested-name-specifier augmented with source location information.
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
Represents a dependent template name that cannot be resolved prior to template instantiation.
The results of name lookup within a DeclContext.
SourceLocation getTypeSpecTypeLoc() const
bool allowsNonTrivialObjCLifetimeQualifiers() const
True if any ObjC types may have non-trivial lifetime qualifiers.
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
FullExpr - Represents a "full-expression" node.
bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base)
Determine whether the type Derived is a C++ class that is derived from the type Base.
QualType getLifetimeQualifiedType(QualType type, Qualifiers::ObjCLifetime lifetime)
Return a type with the given lifetime qualifier.
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
SourceLocation getBeginLoc() const LLVM_READONLY
Represents a member of a struct/union/class.
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
The current expression is potentially evaluated at run time, which means that code may be generated t...
Identity conversion (no conversion)
unsigned getNewAlign() const
Return the largest alignment for which a suitably-sized allocation with '::operator new(size_t)' is g...
void setVisibleDespiteOwningModule()
Set that this declaration is globally visible, even if it came from a module that is not visible...
bool isAbstractType(SourceLocation Loc, QualType T)
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
bool hasAutoTypeSpec() const
Floating point conversions (C++ [conv.double].
bool isReferenceType() const
CXXRecordDecl * getStdBadAlloc() const
void setArg(unsigned Arg, Expr *ArgExpr)
setArg - Set the specified argument.
bool hasTrivialMoveAssignment() const
Determine whether this class has a trivial move assignment operator (C++11 [class.copy]p25)
The iterator over UnresolvedSets.
static const TST TST_error
ExprResult ActOnCXXUuidof(SourceLocation OpLoc, SourceLocation LParenLoc, bool isType, void *TyOrExpr, SourceLocation RParenLoc)
ActOnCXXUuidof - Parse __uuidof( something ).
ExprResult BuildArrayTypeTrait(ArrayTypeTrait ATT, SourceLocation KWLoc, TypeSourceInfo *TSInfo, Expr *DimExpr, SourceLocation RParen)
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)
SourceLocation getBeginLoc() const LLVM_READONLY
ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp, [NSNumber numberWithInt:42]];.
ExprResult DefaultFunctionArrayConversion(Expr *E, bool Diagnose=true)
DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).
void PopExpressionEvaluationContext()
bool isAtLeastAsQualifiedAs(QualType Other) const
Determine whether this type is at least as qualified as the other given type, requiring exact equalit...
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
A user-defined literal name, e.g., operator "" _i.
Stmt * MaybeCreateStmtWithCleanups(Stmt *SubStmt)
void NoteDeletedFunction(FunctionDecl *FD)
Emit a note explaining that this function is deleted.
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
bool isInvalidType() const
bool isDependentName() const
Determines whether the name itself is dependent, e.g., because it involves a C++ type that is itself ...
bool getProducesResult() const
DeclClass * getAsSingle() const
Floating point promotions (C++ [conv.fpprom])
ExprResult ActOnStartCXXMemberReference(Scope *S, Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, ParsedType &ObjectType, bool &MayBePseudoDestructor)
ObjCMethodFamily getMethodFamily() const
Determines the family of this method.
bool isReplaceableGlobalAllocationFunction(bool *IsAligned=nullptr) const
Determines whether this function is one of the replaceable global allocation functions: void *operato...
Describes an C or C++ initializer list.
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
This is a scope that corresponds to a block/closure object.
void AddTemplateOverloadCandidate(FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, ADLCallKind IsADLCandidate=ADLCallKind::NotADL)
Add a C++ function template specialization as a candidate in the candidate set, using template argume...
ExprResult ActOnCXXThrow(Scope *S, SourceLocation OpLoc, Expr *expr)
ActOnCXXThrow - Parse throw expressions.
Represents a C++ unqualified-id that has been parsed.
bool CanUseDecl(NamedDecl *D, bool TreatUnavailableAsInvalid)
Determine whether the use of this declaration is valid, without emitting diagnostics.
bool isCompleteType(SourceLocation Loc, QualType T)
IdentifierInfo * getAsIdentifier() const
Retrieve the identifier stored in this nested name specifier.
void setNameLoc(SourceLocation Loc)
NamespaceDecl * getOrCreateStdNamespace()
Retrieve the special "std" namespace, which may require us to implicitly define the namespace...
Represents the results of name lookup.
void DeclareGlobalNewDelete()
DeclareGlobalNewDelete - Declare the global forms of operator new and delete.
An lvalue ref-qualifier was provided (&).
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
ExprResult MaybeConvertParenListExprToParenExpr(Scope *S, Expr *ME)
This is not an AltiVec-style cast or or C++ direct-initialization, so turn the ParenListExpr into a s...
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.
Represents a declaration of a type.
A builtin binary operation expression such as "x + y" or "x <= y".
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
static CompoundStmt * Create(const ASTContext &C, ArrayRef< Stmt *> Stmts, SourceLocation LB, SourceLocation RB)
ImplicitConversionKind Second
Second - The second conversion can be an integral promotion, floating point promotion, integral conversion, floating point conversion, floating-integral conversion, pointer conversion, pointer-to-member conversion, or boolean conversion.
QualType getExceptionObjectType(QualType T) const
A conversion for an operand of a builtin overloaded operator.
ParsedTemplateArgument * getTemplateArgs()
Retrieves a pointer to the template arguments.
static InitializationKind CreateValue(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc, bool isImplicit=false)
Create a value initialization.
const Type * getClass() const
bool isRValueReferenceType() const
CheckedConversionKind
The kind of conversion being performed.
FunctionDecl * ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr, QualType TargetType, bool Complain, DeclAccessPair &Found, bool *pHadMultipleCandidates=nullptr)
ResolveAddressOfOverloadedFunction - Try to resolve the address of an overloaded function (C++ [over...
LazyDeclPtr StdBadAlloc
The C++ "std::bad_alloc" class, which is defined by the C++ standard library.
IfExistsResult CheckMicrosoftIfExistsSymbol(Scope *S, CXXScopeSpec &SS, const DeclarationNameInfo &TargetNameInfo)
bool isLambda() const
Determine whether this class describes a lambda function object.
DeclContext * getLambdaAwareParentOfDeclContext(DeclContext *DC)
Scope - A scope is a transient data structure that is used while parsing the program.
ExprResult Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType=nullptr)
Perform the actual initialization of the given entity based on the computed initialization sequence...
QualType getCVRQualifiedType(QualType T, unsigned CVR) const
Return a type with additional const, volatile, or restrict qualifiers.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
New-expression has a C++98 paren-delimited initializer.
TypoExpr - Internal placeholder for expressions where typo correction still needs to be performed and...
Qualification conversions (C++ [conv.qual])
static unsigned getNumAddressingBits(const ASTContext &Context, QualType ElementType, const llvm::APInt &NumElements)
Determine the number of bits required to address a member of.
ExprResult ActOnCXXThis(SourceLocation loc)
Represents a C++ nested-name-specifier or a global scope specifier.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
ExprResult CheckSwitchCondition(SourceLocation SwitchLoc, Expr *Cond)
Represents binding an expression to a temporary.
ArrayTypeTrait
Names for the array type traits.
CXXTemporary * getTemporary()
AccessResult CheckConstructorAccess(SourceLocation Loc, CXXConstructorDecl *D, DeclAccessPair FoundDecl, const InitializedEntity &Entity, bool IsCopyBindingRefToTemp=false)
Checks access to a constructor.
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
const LangOptions & getLangOpts() const
static FunctionProtoType::ExceptionSpecInfo mergeExceptionSpecs(Sema &S, FunctionProtoType::ExceptionSpecInfo ESI1, FunctionProtoType::ExceptionSpecInfo ESI2, SmallVectorImpl< QualType > &ExceptionTypeStorage)
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
bool isTypeDependent() const
isTypeDependent - Determines whether this expression is type-dependent (C++ [temp.dep.expr]), which means that its type could change from one template instantiation to the next.
ExprResult DefaultFunctionArrayLvalueConversion(Expr *E, bool Diagnose=true)
bool isScalarType() const
An ordinary object is located at an address in memory.
bool isLambdaCallOperator(const CXXMethodDecl *MD)
SmallVector< BoundNodes, 1 > match(MatcherT Matcher, const NodeT &Node, ASTContext &Context)
Returns the results of matching Matcher on Node.
The number of conversion kinds.
A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5...
Represents an ObjC class declaration.
FieldDecl * getMember() const
If this is a member initializer, returns the declaration of the non-static data member being initiali...
CastKind PrepareScalarCast(ExprResult &src, QualType destType)
Prepares for a scalar cast, performing all the necessary stages except the final cast and returning t...
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface...
ImplicitConversionKind Third
Third - The third conversion can be a qualification conversion or a function conversion.
bool isAbstract() const
Determine whether this class has a pure virtual function.
ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context...
Integral promotions (C++ [conv.prom])
const LangOptions & LangOpts
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.
enum clang::DeclaratorChunk::@215 Kind
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)
SourceLocation getBeginLoc() const LLVM_READONLY
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any...
Transparent Union Conversions.
Retains information about a captured region.
CastKind
CastKind - The kind of operation required for a conversion.
SourceRange getLocalSourceRange() const
Get the local source range.
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat)
DeclarationNameTable DeclarationNames
bool CheckPointerConversion(Expr *From, QualType ToType, CastKind &Kind, CXXCastPath &BasePath, bool IgnoreBaseAccess, bool Diagnose=true)
CheckPointerConversion - Check the pointer conversion from the expression From to the type ToType...
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...
bool isUsualDeallocationFunction(const CXXMethodDecl *FD)
unsigned hasStatic
True if this dimension included the 'static' keyword.
SourceLocation getBeginLoc() const
Get the begin source location.
An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type...
CXXMethodDecl * CallOperator
The lambda's compiler-generated operator().
QualType getElementType() const
bool isWeak() const
Determine whether this symbol is weakly-imported, or declared with the weak or weak-ref attr...
DeclAccessPair getFoundDecl() const
Retrieves the declaration found by lookup.
This represents one expression.
static TypeTraitExpr * Create(const ASTContext &C, QualType T, SourceLocation Loc, TypeTrait Kind, ArrayRef< TypeSourceInfo *> Args, SourceLocation RParenLoc, bool Value)
Create a new type trait expression.
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
static ExprResult BuildCXXCastArgument(Sema &S, SourceLocation CastLoc, QualType Ty, CastKind Kind, CXXMethodDecl *Method, DeclAccessPair FoundDecl, bool HadMultipleCandidates, Expr *From)
bool isVariadic() const
Whether this function is variadic.
llvm::StringRef getAsString(SyncScope S)
bool isDeclScope(Decl *D)
isDeclScope - Return true if this is the scope that the specified decl is declared in...
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
unsigned getIntWidth() const
getIntWidth/Align - Return the size of 'signed int' and 'unsigned int' for this target, in bits.
bool isObjCARCImplicitlyUnretainedType() const
Determines if this type, which must satisfy isObjCLifetimeType(), is implicitly __unsafe_unretained r...
ParsedType getDestructorTypeForDecltype(const DeclSpec &DS, ParsedType ObjectType)
static bool EvaluateUnaryTypeTrait(Sema &Self, TypeTrait UTT, SourceLocation KeyLoc, QualType T)
DeclContext * getEntity() const
static SourceLocation findLocationAfterToken(SourceLocation loc, tok::TokenKind TKind, const SourceManager &SM, const LangOptions &LangOpts, bool SkipTrailingWhitespaceAndNewLine)
Checks that the given token is the first token that occurs after the given location (this excludes co...
StandardConversionSequence After
After - Represents the standard conversion that occurs after the actual user-defined conversion...
This file defines the classes used to store parsed information about declaration-specifiers and decla...
const T * castAs() const
Member-template castAs<specific type>.
bool isObjCRetainableType() const
QualType FindCompositePointerType(SourceLocation Loc, Expr *&E1, Expr *&E2, bool ConvertArgs=true)
Find a merged pointer type and convert the two expressions to it.
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Represents a C++ destructor within a class.
New-expression has a C++11 list-initializer.
static UsualDeallocFnInfo resolveDeallocationOverload(Sema &S, LookupResult &R, bool WantSize, bool WantAlign, llvm::SmallVectorImpl< UsualDeallocFnInfo > *BestFns=nullptr)
Select the correct "usual" deallocation function to use from a selection of deallocation functions (e...
const CXXScopeSpec * getSS() const
bool isThisDeclarationADefinition() const
Returns whether this specific declaration of the function is also a definition that does not contain ...
ExprResult ActOnPseudoDestructorExpr(Scope *S, Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, CXXScopeSpec &SS, UnqualifiedId &FirstTypeName, SourceLocation CCLoc, SourceLocation TildeLoc, UnqualifiedId &SecondTypeName)
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl...
Defines the clang::Preprocessor interface.
bool isNullPtrType() const
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.
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return null.
Represents a C++ template name within the type system.
void getAsStringInternal(std::string &Str, const PrintingPolicy &Policy) const
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Defines the clang::TypeLoc interface and its subclasses.
A namespace alias, stored as a NamespaceAliasDecl*.
Floating-integral conversions (C++ [conv.fpint])
UnqualifiedIdKind getKind() const
Determine what kind of name we have.
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7)...
void DiscardCleanupsInEvaluationContext()
bool isFunctionTemplateSpecialization() const
Determine whether this function is a function template specialization.
Specifies that a value-dependent expression of integral or dependent type should be considered a null...
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char, signed char, short, int, long..], or an enum decl which has a signed representation.
bool isPolymorphic() const
Whether this class is polymorphic (C++ [class.virtual]), which means that the class contains or inher...
static bool EvaluateBinaryTypeTrait(Sema &Self, TypeTrait BTT, QualType LhsT, QualType RhsT, SourceLocation KeyLoc)
ExprResult ActOnTypeTrait(TypeTrait Kind, SourceLocation KWLoc, ArrayRef< ParsedType > Args, SourceLocation RParenLoc)
Parsed one of the type trait support pseudo-functions.
TagDecl * getAsTagDecl() const
Retrieves the TagDecl that this type refers to, either because the type is a TagType or because it is...
ExprResult BuildCXXUuidof(QualType TypeInfoType, SourceLocation TypeidLoc, TypeSourceInfo *Operand, SourceLocation RParenLoc)
Build a Microsoft __uuidof expression with a type operand.
SmallVector< sema::FunctionScopeInfo *, 4 > FunctionScopes
Stack containing information about each of the nested function, block, and method scopes that are cur...
SourceLocation Loc
Loc - The place where this type was defined.
StandardConversionSequence Standard
When ConversionKind == StandardConversion, provides the details of the standard conversion sequence...
clang::ObjCRuntime ObjCRuntime
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
void DiagnoseAmbiguousConversion(Sema &S, SourceLocation CaretLoc, const PartialDiagnostic &PDiag) const
Diagnoses an ambiguous conversion.
static void collectPublicBases(CXXRecordDecl *RD, llvm::DenseMap< CXXRecordDecl *, unsigned > &SubobjectsSeen, llvm::SmallPtrSetImpl< CXXRecordDecl *> &VBases, llvm::SetVector< CXXRecordDecl *> &PublicSubobjectsSeen, bool ParentIsPublic)
A boolean condition, from 'if', 'while', 'for', or 'do'.
An expression that sends a message to the given Objective-C object or class.
QualType getRecordType(const RecordDecl *Decl) const
SourceLocation getEnd() const
UnaryOperator - This represents the unary-expression's (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
static uint64_t EvaluateArrayTypeTrait(Sema &Self, ArrayTypeTrait ATT, QualType T, Expr *DimExpr, SourceLocation KeyLoc)
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
static bool CanThrow(Expr *E, ASTContext &Ctx)
ExprResult BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, const TemplateArgumentListInfo *TemplateArgs, const Scope *S)
Builds an expression which might be an implicit member expression.
ParsedType getInheritingConstructorName(CXXScopeSpec &SS, SourceLocation NameLoc, IdentifierInfo &Name)
Handle the result of the special case name lookup for inheriting constructor declarations.
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
void CleanupVarDeclMarking()
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
ExprResult ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal, bool ArrayForm, Expr *Operand)
ActOnCXXDelete - Parsed a C++ 'delete' expression.
Represents a C++ conversion function within a class.
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
The result type of a method or function.
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
const Expr * getSubExpr() const
void removeLocalCVRQualifiers(unsigned Mask)
bool isNull() const
Return true if this QualType doesn't point to a type yet.
bool hasNonTrivialMoveAssignment() const
Determine whether this class has a non-trivial move assignment operator (C++11 [class.copy]p25)
A type, stored as a Type*.
bool hasEmptyCollections() const
Are the empty collection symbols available?
void removeCVRQualifiers(unsigned mask)
CXXDestructorDecl * LookupDestructor(CXXRecordDecl *Class)
Look for the destructor of the given class.
SourceLocation getEndLoc() const LLVM_READONLY
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
static InitializationKind CreateCopy(SourceLocation InitLoc, SourceLocation EqualLoc, bool AllowExplicitConvs=false)
Create a copy initialization.
static CXXRecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, CXXRecordDecl *PrevDecl=nullptr, bool DelayTypeCreation=false)
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
ExprResult BuildPseudoDestructorExpr(Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, const CXXScopeSpec &SS, TypeSourceInfo *ScopeType, SourceLocation CCLoc, SourceLocation TildeLoc, PseudoDestructorTypeStorage DestroyedType)
ExtInfo withNoReturn(bool noReturn) const
ExprResult BuildCXXNoexceptExpr(SourceLocation KeyLoc, Expr *Operand, SourceLocation RParen)
Lvalue-to-rvalue conversion (C++ [conv.lval])
ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E)
bool isConstQualified() const
Determine whether this type is const-qualified.
RecordDecl * getDecl() const
bool Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef< Expr *> Args)
Diagnose an potentially-invalid initialization sequence.
noexcept(expression), evals to 'false'
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
void EraseUnwantedCUDAMatches(const FunctionDecl *Caller, SmallVectorImpl< std::pair< DeclAccessPair, FunctionDecl *>> &Matches)
Finds a function in Matches with highest calling priority from Caller context and erases all function...
void 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).
static CXXNewExpr * Create(const ASTContext &Ctx, bool IsGlobalNew, FunctionDecl *OperatorNew, FunctionDecl *OperatorDelete, bool ShouldPassAlignment, bool UsualArrayDeleteWantsSize, ArrayRef< Expr *> PlacementArgs, SourceRange TypeIdParens, Expr *ArraySize, InitializationStyle InitializationStyle, Expr *Initializer, QualType Ty, TypeSourceInfo *AllocatedTypeInfo, SourceRange Range, SourceRange DirectInitRange)
Create a c++ new expression.
LazyDeclPtr StdAlignValT
The C++ "std::align_val_t" enum class, which is defined by the C++ standard library.
ASTContext & getASTContext() const
bool hasTrivialCopyAssignment() const
Determine whether this class has a trivial copy assignment operator (C++ [class.copy]p11, C++11 [class.copy]p25)
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant...
Encodes a location in the source.
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.
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)
IdentifierTable & getIdentifierTable()
A vector splat from an arithmetic type.
bool isUsualDeallocationFunction(SmallVectorImpl< const FunctionDecl *> &PreventedBy) const
Determine whether this is a usual deallocation function (C++ [basic.stc.dynamic.deallocation]p2), which is an overloaded delete or delete[] operator with a particular signature.
ExprObjectKind
A further classification of the kind of object referenced by an l-value or x-value.
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
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.
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReciever=nullptr)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics...
bool isSuperClassOf(const ObjCInterfaceDecl *I) const
isSuperClassOf - Return true if this class is the specified class or is a super class of the specifie...
No entity found met the criteria.
void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=false, ADLCallKind IsADLCandidate=ADLCallKind::NotADL, ConversionSequenceList EarlyConversions=None)
AddOverloadCandidate - Adds the given function to the set of candidate functions, using the given fun...
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.
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...
The name of a declaration.
StandardConversionSequence Before
Represents the standard conversion that occurs before the actual user-defined conversion.
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
const CXXRecordDecl * getParent() const
Returns the parent of this method declaration, which is the class in which this method is defined...
bool isBooleanType() const
ExprResult prepareVectorSplat(QualType VectorTy, Expr *SplattedExpr)
Prepare SplattedExpr for a vector splat operation, adding implicit casts if necessary.
AllocationFunctionScope
The scope in which to find allocation functions.
Requests that only viable candidates be shown.
A pointer to member type per C++ 8.3.3 - Pointers to members.
bool 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 ...
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)
SourceLocation getBeginLoc() const
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.
QualType CheckPointerToMemberOperands(ExprResult &LHS, ExprResult &RHS, ExprValueKind &VK, SourceLocation OpLoc, bool isIndirect)
bool isFunctionType() const
CXXThisScopeRAII(Sema &S, Decl *ContextDecl, Qualifiers CXXThisTypeQuals, bool Enabled=true)
Introduce a new scope where 'this' may be allowed (when enabled), using the given declaration (which ...
QualType BuildDecltypeType(Expr *E, SourceLocation Loc, bool AsUnevaluated=true)
If AsUnevaluated is false, E is treated as though it were an evaluated context, such as when building...
CanQualType BoundMemberTy
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
AccessResult CheckMemberOperatorAccess(SourceLocation Loc, Expr *ObjectExpr, Expr *ArgExpr, DeclAccessPair FoundDecl)
Checks access to an overloaded member operator, including conversion operators.
DeduceAutoResult DeduceAutoType(TypeSourceInfo *AutoType, Expr *&Initializer, QualType &Result, Optional< unsigned > DependentDeductionDepth=None)
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.
Holds information about the various types of exception specification.
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
void addDecl(Decl *D)
Add the declaration D into this context.
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream...
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type...
void setExprNeedsCleanups(bool SideEffects)
SmallVector< BlockDecl *, 8 > ExprCleanupObjects
ExprCleanupObjects - This is the stack of objects requiring cleanup that are created by the current f...
Represents a base class of a C++ class.
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.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
EnumDecl * getStdAlignValT() const
A template argument list.
bool isSet() const
Deprecated.
bool isLValueReferenceType() const
ExprResult BuildCXXFunctionalCastExpr(TypeSourceInfo *TInfo, QualType Type, SourceLocation LParenLoc, Expr *CastExpr, SourceLocation RParenLoc)
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
CXXRecordDecl * getNamingClass() const
Returns the 'naming class' for this lookup, i.e.
Reading or writing from this object requires a barrier call.
An integral condition for a 'switch' statement.
FunctionDecl * FindDeallocationFunctionForDestructor(SourceLocation StartLoc, CXXRecordDecl *RD)
static CXXMemberCallExpr * Create(const ASTContext &Ctx, Expr *Fn, ArrayRef< Expr *> Args, QualType Ty, ExprValueKind VK, SourceLocation RP, unsigned MinNumArgs=0)
QualType getParamType(unsigned i) const
Expr * MaybeCreateExprWithCleanups(Expr *SubExpr)
MaybeCreateExprWithCleanups - If the current full-expression requires any cleanups, surround it with a ExprWithCleanups node.
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
Function-to-pointer (C++ [conv.array])
bool Failed() const
Determine whether the initialization sequence is invalid.
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.
SourceLocation getBeginLoc() const LLVM_READONLY
void diagnoseNullableToNonnullConversion(QualType DstType, QualType SrcType, SourceLocation Loc)
Warn if we're implicitly casting from a _Nullable pointer type to a _Nonnull one. ...
ExprResult CheckBooleanCondition(SourceLocation Loc, Expr *E, bool IsConstexpr=false)
CheckBooleanCondition - Diagnose problems involving the use of the given expression as a boolean cond...
This represents a decl that may have a name.
A boolean literal, per ([C++ lex.bool] Boolean literals).
Expr * getRepAsExpr() const
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...
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.
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).