1 //===--- SemaExprCXX.cpp - Semantic Analysis for Expressions --------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
11 /// \brief Implements semantic analysis for C++ expressions.
13 //===----------------------------------------------------------------------===//
15 #include "clang/Sema/SemaInternal.h"
16 #include "TreeTransform.h"
17 #include "TypeLocBuilder.h"
18 #include "clang/AST/ASTContext.h"
19 #include "clang/AST/ASTLambda.h"
20 #include "clang/AST/CXXInheritance.h"
21 #include "clang/AST/CharUnits.h"
22 #include "clang/AST/DeclObjC.h"
23 #include "clang/AST/ExprCXX.h"
24 #include "clang/AST/ExprObjC.h"
25 #include "clang/AST/RecursiveASTVisitor.h"
26 #include "clang/AST/TypeLoc.h"
27 #include "clang/Basic/PartialDiagnostic.h"
28 #include "clang/Basic/TargetInfo.h"
29 #include "clang/Lex/Preprocessor.h"
30 #include "clang/Sema/DeclSpec.h"
31 #include "clang/Sema/Initialization.h"
32 #include "clang/Sema/Lookup.h"
33 #include "clang/Sema/ParsedTemplate.h"
34 #include "clang/Sema/Scope.h"
35 #include "clang/Sema/ScopeInfo.h"
36 #include "clang/Sema/SemaLambda.h"
37 #include "clang/Sema/TemplateDeduction.h"
38 #include "llvm/ADT/APInt.h"
39 #include "llvm/ADT/STLExtras.h"
40 #include "llvm/Support/ErrorHandling.h"
41 using namespace clang;
44 /// \brief Handle the result of the special case name lookup for inheriting
45 /// constructor declarations. 'NS::X::X' and 'NS::X<...>::X' are treated as
46 /// constructor names in member using declarations, even if 'X' is not the
47 /// name of the corresponding type.
48 ParsedType Sema::getInheritingConstructorName(CXXScopeSpec &SS,
49 SourceLocation NameLoc,
50 IdentifierInfo &Name) {
51 NestedNameSpecifier *NNS = SS.getScopeRep();
53 // Convert the nested-name-specifier into a type.
55 switch (NNS->getKind()) {
56 case NestedNameSpecifier::TypeSpec:
57 case NestedNameSpecifier::TypeSpecWithTemplate:
58 Type = QualType(NNS->getAsType(), 0);
61 case NestedNameSpecifier::Identifier:
62 // Strip off the last layer of the nested-name-specifier and build a
63 // typename type for it.
64 assert(NNS->getAsIdentifier() == &Name && "not a constructor name");
65 Type = Context.getDependentNameType(ETK_None, NNS->getPrefix(),
66 NNS->getAsIdentifier());
69 case NestedNameSpecifier::Global:
70 case NestedNameSpecifier::Super:
71 case NestedNameSpecifier::Namespace:
72 case NestedNameSpecifier::NamespaceAlias:
73 llvm_unreachable("Nested name specifier is not a type for inheriting ctor");
76 // This reference to the type is located entirely at the location of the
77 // final identifier in the qualified-id.
78 return CreateParsedType(Type,
79 Context.getTrivialTypeSourceInfo(Type, NameLoc));
82 ParsedType Sema::getDestructorName(SourceLocation TildeLoc,
84 SourceLocation NameLoc,
85 Scope *S, CXXScopeSpec &SS,
86 ParsedType ObjectTypePtr,
87 bool EnteringContext) {
88 // Determine where to perform name lookup.
90 // FIXME: This area of the standard is very messy, and the current
91 // wording is rather unclear about which scopes we search for the
92 // destructor name; see core issues 399 and 555. Issue 399 in
93 // particular shows where the current description of destructor name
94 // lookup is completely out of line with existing practice, e.g.,
95 // this appears to be ill-formed:
98 // template <typename T> struct S {
103 // void f(N::S<int>* s) {
104 // s->N::S<int>::~S();
107 // See also PR6358 and PR6359.
108 // For this reason, we're currently only doing the C++03 version of this
109 // code; the C++0x version has to wait until we get a proper spec.
111 DeclContext *LookupCtx = nullptr;
112 bool isDependent = false;
113 bool LookInScope = false;
118 // If we have an object type, it's because we are in a
119 // pseudo-destructor-expression or a member access expression, and
120 // we know what type we're looking for.
122 SearchType = GetTypeFromParser(ObjectTypePtr);
125 NestedNameSpecifier *NNS = SS.getScopeRep();
127 bool AlreadySearched = false;
128 bool LookAtPrefix = true;
129 // C++11 [basic.lookup.qual]p6:
130 // If a pseudo-destructor-name (5.2.4) contains a nested-name-specifier,
131 // the type-names are looked up as types in the scope designated by the
132 // nested-name-specifier. Similarly, in a qualified-id of the form:
134 // nested-name-specifier[opt] class-name :: ~ class-name
136 // the second class-name is looked up in the same scope as the first.
138 // Here, we determine whether the code below is permitted to look at the
139 // prefix of the nested-name-specifier.
140 DeclContext *DC = computeDeclContext(SS, EnteringContext);
141 if (DC && DC->isFileContext()) {
142 AlreadySearched = true;
145 } else if (DC && isa<CXXRecordDecl>(DC)) {
146 LookAtPrefix = false;
150 // The second case from the C++03 rules quoted further above.
151 NestedNameSpecifier *Prefix = nullptr;
152 if (AlreadySearched) {
153 // Nothing left to do.
154 } else if (LookAtPrefix && (Prefix = NNS->getPrefix())) {
155 CXXScopeSpec PrefixSS;
156 PrefixSS.Adopt(NestedNameSpecifierLoc(Prefix, SS.location_data()));
157 LookupCtx = computeDeclContext(PrefixSS, EnteringContext);
158 isDependent = isDependentScopeSpecifier(PrefixSS);
159 } else if (ObjectTypePtr) {
160 LookupCtx = computeDeclContext(SearchType);
161 isDependent = SearchType->isDependentType();
163 LookupCtx = computeDeclContext(SS, EnteringContext);
164 isDependent = LookupCtx && LookupCtx->isDependentContext();
166 } else if (ObjectTypePtr) {
167 // C++ [basic.lookup.classref]p3:
168 // If the unqualified-id is ~type-name, the type-name is looked up
169 // in the context of the entire postfix-expression. If the type T
170 // of the object expression is of a class type C, the type-name is
171 // also looked up in the scope of class C. At least one of the
172 // lookups shall find a name that refers to (possibly
174 LookupCtx = computeDeclContext(SearchType);
175 isDependent = SearchType->isDependentType();
176 assert((isDependent || !SearchType->isIncompleteType()) &&
177 "Caller should have completed object type");
181 // Perform lookup into the current scope (only).
185 TypeDecl *NonMatchingTypeDecl = nullptr;
186 LookupResult Found(*this, &II, NameLoc, LookupOrdinaryName);
187 for (unsigned Step = 0; Step != 2; ++Step) {
188 // Look for the name first in the computed lookup context (if we
189 // have one) and, if that fails to find a match, in the scope (if
190 // we're allowed to look there).
192 if (Step == 0 && LookupCtx)
193 LookupQualifiedName(Found, LookupCtx);
194 else if (Step == 1 && LookInScope && S)
195 LookupName(Found, S);
199 // FIXME: Should we be suppressing ambiguities here?
200 if (Found.isAmbiguous())
203 if (TypeDecl *Type = Found.getAsSingle<TypeDecl>()) {
204 QualType T = Context.getTypeDeclType(Type);
205 MarkAnyDeclReferenced(Type->getLocation(), Type, /*OdrUse=*/false);
207 if (SearchType.isNull() || SearchType->isDependentType() ||
208 Context.hasSameUnqualifiedType(T, SearchType)) {
209 // We found our type!
211 return CreateParsedType(T,
212 Context.getTrivialTypeSourceInfo(T, NameLoc));
215 if (!SearchType.isNull())
216 NonMatchingTypeDecl = Type;
219 // If the name that we found is a class template name, and it is
220 // the same name as the template name in the last part of the
221 // nested-name-specifier (if present) or the object type, then
222 // this is the destructor for that class.
223 // FIXME: This is a workaround until we get real drafting for core
224 // issue 399, for which there isn't even an obvious direction.
225 if (ClassTemplateDecl *Template = Found.getAsSingle<ClassTemplateDecl>()) {
226 QualType MemberOfType;
228 if (DeclContext *Ctx = computeDeclContext(SS, EnteringContext)) {
229 // Figure out the type of the context, if it has one.
230 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Ctx))
231 MemberOfType = Context.getTypeDeclType(Record);
234 if (MemberOfType.isNull())
235 MemberOfType = SearchType;
237 if (MemberOfType.isNull())
240 // We're referring into a class template specialization. If the
241 // class template we found is the same as the template being
242 // specialized, we found what we are looking for.
243 if (const RecordType *Record = MemberOfType->getAs<RecordType>()) {
244 if (ClassTemplateSpecializationDecl *Spec
245 = dyn_cast<ClassTemplateSpecializationDecl>(Record->getDecl())) {
246 if (Spec->getSpecializedTemplate()->getCanonicalDecl() ==
247 Template->getCanonicalDecl())
248 return CreateParsedType(
250 Context.getTrivialTypeSourceInfo(MemberOfType, NameLoc));
256 // We're referring to an unresolved class template
257 // specialization. Determine whether we class template we found
258 // is the same as the template being specialized or, if we don't
259 // know which template is being specialized, that it at least
260 // has the same name.
261 if (const TemplateSpecializationType *SpecType
262 = MemberOfType->getAs<TemplateSpecializationType>()) {
263 TemplateName SpecName = SpecType->getTemplateName();
265 // The class template we found is the same template being
267 if (TemplateDecl *SpecTemplate = SpecName.getAsTemplateDecl()) {
268 if (SpecTemplate->getCanonicalDecl() == Template->getCanonicalDecl())
269 return CreateParsedType(
271 Context.getTrivialTypeSourceInfo(MemberOfType, NameLoc));
276 // The class template we found has the same name as the
277 // (dependent) template name being specialized.
278 if (DependentTemplateName *DepTemplate
279 = SpecName.getAsDependentTemplateName()) {
280 if (DepTemplate->isIdentifier() &&
281 DepTemplate->getIdentifier() == Template->getIdentifier())
282 return CreateParsedType(
284 Context.getTrivialTypeSourceInfo(MemberOfType, NameLoc));
293 // We didn't find our type, but that's okay: it's dependent
296 // FIXME: What if we have no nested-name-specifier?
297 QualType T = CheckTypenameType(ETK_None, SourceLocation(),
298 SS.getWithLocInContext(Context),
300 return ParsedType::make(T);
303 if (NonMatchingTypeDecl) {
304 QualType T = Context.getTypeDeclType(NonMatchingTypeDecl);
305 Diag(NameLoc, diag::err_destructor_expr_type_mismatch)
307 Diag(NonMatchingTypeDecl->getLocation(), diag::note_destructor_type_here)
309 } else if (ObjectTypePtr)
310 Diag(NameLoc, diag::err_ident_in_dtor_not_a_type)
313 SemaDiagnosticBuilder DtorDiag = Diag(NameLoc,
314 diag::err_destructor_class_name);
316 const DeclContext *Ctx = S->getEntity();
317 if (const CXXRecordDecl *Class = dyn_cast_or_null<CXXRecordDecl>(Ctx))
318 DtorDiag << FixItHint::CreateReplacement(SourceRange(NameLoc),
319 Class->getNameAsString());
326 ParsedType Sema::getDestructorType(const DeclSpec& DS, ParsedType ObjectType) {
327 if (DS.getTypeSpecType() == DeclSpec::TST_error || !ObjectType)
329 assert(DS.getTypeSpecType() == DeclSpec::TST_decltype
330 && "only get destructor types from declspecs");
331 QualType T = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc());
332 QualType SearchType = GetTypeFromParser(ObjectType);
333 if (SearchType->isDependentType() || Context.hasSameUnqualifiedType(SearchType, T)) {
334 return ParsedType::make(T);
337 Diag(DS.getTypeSpecTypeLoc(), diag::err_destructor_expr_type_mismatch)
342 bool Sema::checkLiteralOperatorId(const CXXScopeSpec &SS,
343 const UnqualifiedId &Name) {
344 assert(Name.getKind() == UnqualifiedId::IK_LiteralOperatorId);
349 switch (SS.getScopeRep()->getKind()) {
350 case NestedNameSpecifier::Identifier:
351 case NestedNameSpecifier::TypeSpec:
352 case NestedNameSpecifier::TypeSpecWithTemplate:
353 // Per C++11 [over.literal]p2, literal operators can only be declared at
354 // namespace scope. Therefore, this unqualified-id cannot name anything.
355 // Reject it early, because we have no AST representation for this in the
356 // case where the scope is dependent.
357 Diag(Name.getLocStart(), diag::err_literal_operator_id_outside_namespace)
361 case NestedNameSpecifier::Global:
362 case NestedNameSpecifier::Super:
363 case NestedNameSpecifier::Namespace:
364 case NestedNameSpecifier::NamespaceAlias:
368 llvm_unreachable("unknown nested name specifier kind");
371 /// \brief Build a C++ typeid expression with a type operand.
372 ExprResult Sema::BuildCXXTypeId(QualType TypeInfoType,
373 SourceLocation TypeidLoc,
374 TypeSourceInfo *Operand,
375 SourceLocation RParenLoc) {
376 // C++ [expr.typeid]p4:
377 // The top-level cv-qualifiers of the lvalue expression or the type-id
378 // that is the operand of typeid are always ignored.
379 // If the type of the type-id is a class type or a reference to a class
380 // type, the class shall be completely-defined.
383 = Context.getUnqualifiedArrayType(Operand->getType().getNonReferenceType(),
385 if (T->getAs<RecordType>() &&
386 RequireCompleteType(TypeidLoc, T, diag::err_incomplete_typeid))
389 if (T->isVariablyModifiedType())
390 return ExprError(Diag(TypeidLoc, diag::err_variably_modified_typeid) << T);
392 return new (Context) CXXTypeidExpr(TypeInfoType.withConst(), Operand,
393 SourceRange(TypeidLoc, RParenLoc));
396 /// \brief Build a C++ typeid expression with an expression operand.
397 ExprResult Sema::BuildCXXTypeId(QualType TypeInfoType,
398 SourceLocation TypeidLoc,
400 SourceLocation RParenLoc) {
401 bool WasEvaluated = false;
402 if (E && !E->isTypeDependent()) {
403 if (E->getType()->isPlaceholderType()) {
404 ExprResult result = CheckPlaceholderExpr(E);
405 if (result.isInvalid()) return ExprError();
409 QualType T = E->getType();
410 if (const RecordType *RecordT = T->getAs<RecordType>()) {
411 CXXRecordDecl *RecordD = cast<CXXRecordDecl>(RecordT->getDecl());
412 // C++ [expr.typeid]p3:
413 // [...] If the type of the expression is a class type, the class
414 // shall be completely-defined.
415 if (RequireCompleteType(TypeidLoc, T, diag::err_incomplete_typeid))
418 // C++ [expr.typeid]p3:
419 // When typeid is applied to an expression other than an glvalue of a
420 // polymorphic class type [...] [the] expression is an unevaluated
422 if (RecordD->isPolymorphic() && E->isGLValue()) {
423 // The subexpression is potentially evaluated; switch the context
424 // and recheck the subexpression.
425 ExprResult Result = TransformToPotentiallyEvaluated(E);
426 if (Result.isInvalid()) return ExprError();
429 // We require a vtable to query the type at run time.
430 MarkVTableUsed(TypeidLoc, RecordD);
435 // C++ [expr.typeid]p4:
436 // [...] If the type of the type-id is a reference to a possibly
437 // cv-qualified type, the result of the typeid expression refers to a
438 // std::type_info object representing the cv-unqualified referenced
441 QualType UnqualT = Context.getUnqualifiedArrayType(T, Quals);
442 if (!Context.hasSameType(T, UnqualT)) {
444 E = ImpCastExprToType(E, UnqualT, CK_NoOp, E->getValueKind()).get();
448 if (E->getType()->isVariablyModifiedType())
449 return ExprError(Diag(TypeidLoc, diag::err_variably_modified_typeid)
451 else if (ActiveTemplateInstantiations.empty() &&
452 E->HasSideEffects(Context, WasEvaluated)) {
453 // The expression operand for typeid is in an unevaluated expression
454 // context, so side effects could result in unintended consequences.
455 Diag(E->getExprLoc(), WasEvaluated
456 ? diag::warn_side_effects_typeid
457 : diag::warn_side_effects_unevaluated_context);
460 return new (Context) CXXTypeidExpr(TypeInfoType.withConst(), E,
461 SourceRange(TypeidLoc, RParenLoc));
464 /// ActOnCXXTypeidOfType - Parse typeid( type-id ) or typeid (expression);
466 Sema::ActOnCXXTypeid(SourceLocation OpLoc, SourceLocation LParenLoc,
467 bool isType, void *TyOrExpr, SourceLocation RParenLoc) {
468 // Find the std::type_info type.
469 if (!getStdNamespace())
470 return ExprError(Diag(OpLoc, diag::err_need_header_before_typeid));
472 if (!CXXTypeInfoDecl) {
473 IdentifierInfo *TypeInfoII = &PP.getIdentifierTable().get("type_info");
474 LookupResult R(*this, TypeInfoII, SourceLocation(), LookupTagName);
475 LookupQualifiedName(R, getStdNamespace());
476 CXXTypeInfoDecl = R.getAsSingle<RecordDecl>();
477 // Microsoft's typeinfo doesn't have type_info in std but in the global
478 // namespace if _HAS_EXCEPTIONS is defined to 0. See PR13153.
479 if (!CXXTypeInfoDecl && LangOpts.MSVCCompat) {
480 LookupQualifiedName(R, Context.getTranslationUnitDecl());
481 CXXTypeInfoDecl = R.getAsSingle<RecordDecl>();
483 if (!CXXTypeInfoDecl)
484 return ExprError(Diag(OpLoc, diag::err_need_header_before_typeid));
487 if (!getLangOpts().RTTI) {
488 return ExprError(Diag(OpLoc, diag::err_no_typeid_with_fno_rtti));
491 QualType TypeInfoType = Context.getTypeDeclType(CXXTypeInfoDecl);
494 // The operand is a type; handle it as such.
495 TypeSourceInfo *TInfo = nullptr;
496 QualType T = GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrExpr),
502 TInfo = Context.getTrivialTypeSourceInfo(T, OpLoc);
504 return BuildCXXTypeId(TypeInfoType, OpLoc, TInfo, RParenLoc);
507 // The operand is an expression.
508 return BuildCXXTypeId(TypeInfoType, OpLoc, (Expr*)TyOrExpr, RParenLoc);
511 /// \brief Build a Microsoft __uuidof expression with a type operand.
512 ExprResult Sema::BuildCXXUuidof(QualType TypeInfoType,
513 SourceLocation TypeidLoc,
514 TypeSourceInfo *Operand,
515 SourceLocation RParenLoc) {
516 if (!Operand->getType()->isDependentType()) {
517 bool HasMultipleGUIDs = false;
518 if (!CXXUuidofExpr::GetUuidAttrOfType(Operand->getType(),
519 &HasMultipleGUIDs)) {
520 if (HasMultipleGUIDs)
521 return ExprError(Diag(TypeidLoc, diag::err_uuidof_with_multiple_guids));
523 return ExprError(Diag(TypeidLoc, diag::err_uuidof_without_guid));
527 return new (Context) CXXUuidofExpr(TypeInfoType.withConst(), Operand,
528 SourceRange(TypeidLoc, RParenLoc));
531 /// \brief Build a Microsoft __uuidof expression with an expression operand.
532 ExprResult Sema::BuildCXXUuidof(QualType TypeInfoType,
533 SourceLocation TypeidLoc,
535 SourceLocation RParenLoc) {
536 if (!E->getType()->isDependentType()) {
537 bool HasMultipleGUIDs = false;
538 if (!CXXUuidofExpr::GetUuidAttrOfType(E->getType(), &HasMultipleGUIDs) &&
539 !E->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
540 if (HasMultipleGUIDs)
541 return ExprError(Diag(TypeidLoc, diag::err_uuidof_with_multiple_guids));
543 return ExprError(Diag(TypeidLoc, diag::err_uuidof_without_guid));
547 return new (Context) CXXUuidofExpr(TypeInfoType.withConst(), E,
548 SourceRange(TypeidLoc, RParenLoc));
551 /// ActOnCXXUuidof - Parse __uuidof( type-id ) or __uuidof (expression);
553 Sema::ActOnCXXUuidof(SourceLocation OpLoc, SourceLocation LParenLoc,
554 bool isType, void *TyOrExpr, SourceLocation RParenLoc) {
555 // If MSVCGuidDecl has not been cached, do the lookup.
557 IdentifierInfo *GuidII = &PP.getIdentifierTable().get("_GUID");
558 LookupResult R(*this, GuidII, SourceLocation(), LookupTagName);
559 LookupQualifiedName(R, Context.getTranslationUnitDecl());
560 MSVCGuidDecl = R.getAsSingle<RecordDecl>();
562 return ExprError(Diag(OpLoc, diag::err_need_header_before_ms_uuidof));
565 QualType GuidType = Context.getTypeDeclType(MSVCGuidDecl);
568 // The operand is a type; handle it as such.
569 TypeSourceInfo *TInfo = nullptr;
570 QualType T = GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrExpr),
576 TInfo = Context.getTrivialTypeSourceInfo(T, OpLoc);
578 return BuildCXXUuidof(GuidType, OpLoc, TInfo, RParenLoc);
581 // The operand is an expression.
582 return BuildCXXUuidof(GuidType, OpLoc, (Expr*)TyOrExpr, RParenLoc);
585 /// ActOnCXXBoolLiteral - Parse {true,false} literals.
587 Sema::ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind) {
588 assert((Kind == tok::kw_true || Kind == tok::kw_false) &&
589 "Unknown C++ Boolean value!");
591 CXXBoolLiteralExpr(Kind == tok::kw_true, Context.BoolTy, OpLoc);
594 /// ActOnCXXNullPtrLiteral - Parse 'nullptr'.
596 Sema::ActOnCXXNullPtrLiteral(SourceLocation Loc) {
597 return new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc);
600 /// ActOnCXXThrow - Parse throw expressions.
602 Sema::ActOnCXXThrow(Scope *S, SourceLocation OpLoc, Expr *Ex) {
603 bool IsThrownVarInScope = false;
605 // C++0x [class.copymove]p31:
606 // When certain criteria are met, an implementation is allowed to omit the
607 // copy/move construction of a class object [...]
609 // - in a throw-expression, when the operand is the name of a
610 // non-volatile automatic object (other than a function or catch-
611 // clause parameter) whose scope does not extend beyond the end of the
612 // innermost enclosing try-block (if there is one), the copy/move
613 // operation from the operand to the exception object (15.1) can be
614 // omitted by constructing the automatic object directly into the
616 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Ex->IgnoreParens()))
617 if (VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
618 if (Var->hasLocalStorage() && !Var->getType().isVolatileQualified()) {
619 for( ; S; S = S->getParent()) {
620 if (S->isDeclScope(Var)) {
621 IsThrownVarInScope = true;
626 (Scope::FnScope | Scope::ClassScope | Scope::BlockScope |
627 Scope::FunctionPrototypeScope | Scope::ObjCMethodScope |
635 return BuildCXXThrow(OpLoc, Ex, IsThrownVarInScope);
638 ExprResult Sema::BuildCXXThrow(SourceLocation OpLoc, Expr *Ex,
639 bool IsThrownVarInScope) {
640 // Don't report an error if 'throw' is used in system headers.
641 if (!getLangOpts().CXXExceptions &&
642 !getSourceManager().isInSystemHeader(OpLoc))
643 Diag(OpLoc, diag::err_exceptions_disabled) << "throw";
645 if (getCurScope() && getCurScope()->isOpenMPSimdDirectiveScope())
646 Diag(OpLoc, diag::err_omp_simd_region_cannot_use_stmt) << "throw";
648 if (Ex && !Ex->isTypeDependent()) {
649 QualType ExceptionObjectTy = Context.getExceptionObjectType(Ex->getType());
650 if (CheckCXXThrowOperand(OpLoc, ExceptionObjectTy, Ex))
653 // Initialize the exception result. This implicitly weeds out
654 // abstract types or types with inaccessible copy constructors.
656 // C++0x [class.copymove]p31:
657 // When certain criteria are met, an implementation is allowed to omit the
658 // copy/move construction of a class object [...]
660 // - in a throw-expression, when the operand is the name of a
661 // non-volatile automatic object (other than a function or
663 // parameter) whose scope does not extend beyond the end of the
664 // innermost enclosing try-block (if there is one), the copy/move
665 // operation from the operand to the exception object (15.1) can be
666 // omitted by constructing the automatic object directly into the
668 const VarDecl *NRVOVariable = nullptr;
669 if (IsThrownVarInScope)
670 NRVOVariable = getCopyElisionCandidate(QualType(), Ex, false);
672 InitializedEntity Entity = InitializedEntity::InitializeException(
673 OpLoc, ExceptionObjectTy,
674 /*NRVO=*/NRVOVariable != nullptr);
675 ExprResult Res = PerformMoveOrCopyInitialization(
676 Entity, NRVOVariable, QualType(), Ex, IsThrownVarInScope);
683 CXXThrowExpr(Ex, Context.VoidTy, OpLoc, IsThrownVarInScope);
687 collectPublicBases(CXXRecordDecl *RD,
688 llvm::DenseMap<CXXRecordDecl *, unsigned> &SubobjectsSeen,
689 llvm::SmallPtrSetImpl<CXXRecordDecl *> &VBases,
690 llvm::SetVector<CXXRecordDecl *> &PublicSubobjectsSeen,
691 bool ParentIsPublic) {
692 for (const CXXBaseSpecifier &BS : RD->bases()) {
693 CXXRecordDecl *BaseDecl = BS.getType()->getAsCXXRecordDecl();
695 // Virtual bases constitute the same subobject. Non-virtual bases are
696 // always distinct subobjects.
698 NewSubobject = VBases.insert(BaseDecl).second;
703 ++SubobjectsSeen[BaseDecl];
705 // Only add subobjects which have public access throughout the entire chain.
706 bool PublicPath = ParentIsPublic && BS.getAccessSpecifier() == AS_public;
708 PublicSubobjectsSeen.insert(BaseDecl);
710 // Recurse on to each base subobject.
711 collectPublicBases(BaseDecl, SubobjectsSeen, VBases, PublicSubobjectsSeen,
716 static void getUnambiguousPublicSubobjects(
717 CXXRecordDecl *RD, llvm::SmallVectorImpl<CXXRecordDecl *> &Objects) {
718 llvm::DenseMap<CXXRecordDecl *, unsigned> SubobjectsSeen;
719 llvm::SmallSet<CXXRecordDecl *, 2> VBases;
720 llvm::SetVector<CXXRecordDecl *> PublicSubobjectsSeen;
721 SubobjectsSeen[RD] = 1;
722 PublicSubobjectsSeen.insert(RD);
723 collectPublicBases(RD, SubobjectsSeen, VBases, PublicSubobjectsSeen,
724 /*ParentIsPublic=*/true);
726 for (CXXRecordDecl *PublicSubobject : PublicSubobjectsSeen) {
727 // Skip ambiguous objects.
728 if (SubobjectsSeen[PublicSubobject] > 1)
731 Objects.push_back(PublicSubobject);
735 /// CheckCXXThrowOperand - Validate the operand of a throw.
736 bool Sema::CheckCXXThrowOperand(SourceLocation ThrowLoc,
737 QualType ExceptionObjectTy, Expr *E) {
738 // If the type of the exception would be an incomplete type or a pointer
739 // to an incomplete type other than (cv) void the program is ill-formed.
740 QualType Ty = ExceptionObjectTy;
741 bool isPointer = false;
742 if (const PointerType* Ptr = Ty->getAs<PointerType>()) {
743 Ty = Ptr->getPointeeType();
746 if (!isPointer || !Ty->isVoidType()) {
747 if (RequireCompleteType(ThrowLoc, Ty,
748 isPointer ? diag::err_throw_incomplete_ptr
749 : diag::err_throw_incomplete,
750 E->getSourceRange()))
753 if (RequireNonAbstractType(ThrowLoc, ExceptionObjectTy,
754 diag::err_throw_abstract_type, E))
758 // If the exception has class type, we need additional handling.
759 CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();
763 // If we are throwing a polymorphic class type or pointer thereof,
764 // exception handling will make use of the vtable.
765 MarkVTableUsed(ThrowLoc, RD);
767 // If a pointer is thrown, the referenced object will not be destroyed.
771 // If the class has a destructor, we must be able to call it.
772 if (!RD->hasIrrelevantDestructor()) {
773 if (CXXDestructorDecl *Destructor = LookupDestructor(RD)) {
774 MarkFunctionReferenced(E->getExprLoc(), Destructor);
775 CheckDestructorAccess(E->getExprLoc(), Destructor,
776 PDiag(diag::err_access_dtor_exception) << Ty);
777 if (DiagnoseUseOfDecl(Destructor, E->getExprLoc()))
782 // The MSVC ABI creates a list of all types which can catch the exception
783 // object. This list also references the appropriate copy constructor to call
784 // if the object is caught by value and has a non-trivial copy constructor.
785 if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
786 // We are only interested in the public, unambiguous bases contained within
787 // the exception object. Bases which are ambiguous or otherwise
788 // inaccessible are not catchable types.
789 llvm::SmallVector<CXXRecordDecl *, 2> UnambiguousPublicSubobjects;
790 getUnambiguousPublicSubobjects(RD, UnambiguousPublicSubobjects);
792 for (CXXRecordDecl *Subobject : UnambiguousPublicSubobjects) {
793 // Attempt to lookup the copy constructor. Various pieces of machinery
794 // will spring into action, like template instantiation, which means this
795 // cannot be a simple walk of the class's decls. Instead, we must perform
796 // lookup and overload resolution.
797 CXXConstructorDecl *CD = LookupCopyingConstructor(Subobject, 0);
801 // Mark the constructor referenced as it is used by this throw expression.
802 MarkFunctionReferenced(E->getExprLoc(), CD);
804 // Skip this copy constructor if it is trivial, we don't need to record it
805 // in the catchable type data.
809 // The copy constructor is non-trivial, create a mapping from this class
810 // type to this constructor.
811 // N.B. The selection of copy constructor is not sensitive to this
812 // particular throw-site. Lookup will be performed at the catch-site to
813 // ensure that the copy constructor is, in fact, accessible (via
814 // friendship or any other means).
815 Context.addCopyConstructorForExceptionObject(Subobject, CD);
817 // We don't keep the instantiated default argument expressions around so
818 // we must rebuild them here.
819 for (unsigned I = 1, E = CD->getNumParams(); I != E; ++I) {
820 // Skip any default arguments that we've already instantiated.
821 if (Context.getDefaultArgExprForConstructor(CD, I))
825 BuildCXXDefaultArgExpr(ThrowLoc, CD, CD->getParamDecl(I)).get();
826 Context.addDefaultArgExprForConstructor(CD, I, DefaultArg);
834 QualType Sema::getCurrentThisType() {
835 DeclContext *DC = getFunctionLevelDeclContext();
836 QualType ThisTy = CXXThisTypeOverride;
837 if (CXXMethodDecl *method = dyn_cast<CXXMethodDecl>(DC)) {
838 if (method && method->isInstance())
839 ThisTy = method->getThisType(Context);
841 if (ThisTy.isNull()) {
842 if (isGenericLambdaCallOperatorSpecialization(CurContext) &&
843 CurContext->getParent()->getParent()->isRecord()) {
844 // This is a generic lambda call operator that is being instantiated
845 // within a default initializer - so use the enclosing class as 'this'.
846 // There is no enclosing member function to retrieve the 'this' pointer
848 QualType ClassTy = Context.getTypeDeclType(
849 cast<CXXRecordDecl>(CurContext->getParent()->getParent()));
850 // There are no cv-qualifiers for 'this' within default initializers,
851 // per [expr.prim.general]p4.
852 return Context.getPointerType(ClassTy);
858 Sema::CXXThisScopeRAII::CXXThisScopeRAII(Sema &S,
860 unsigned CXXThisTypeQuals,
862 : S(S), OldCXXThisTypeOverride(S.CXXThisTypeOverride), Enabled(false)
864 if (!Enabled || !ContextDecl)
867 CXXRecordDecl *Record = nullptr;
868 if (ClassTemplateDecl *Template = dyn_cast<ClassTemplateDecl>(ContextDecl))
869 Record = Template->getTemplatedDecl();
871 Record = cast<CXXRecordDecl>(ContextDecl);
873 S.CXXThisTypeOverride
874 = S.Context.getPointerType(
875 S.Context.getRecordType(Record).withCVRQualifiers(CXXThisTypeQuals));
877 this->Enabled = true;
881 Sema::CXXThisScopeRAII::~CXXThisScopeRAII() {
883 S.CXXThisTypeOverride = OldCXXThisTypeOverride;
887 static Expr *captureThis(ASTContext &Context, RecordDecl *RD,
888 QualType ThisTy, SourceLocation Loc) {
890 = FieldDecl::Create(Context, RD, Loc, Loc, nullptr, ThisTy,
891 Context.getTrivialTypeSourceInfo(ThisTy, Loc),
892 nullptr, false, ICIS_NoInit);
893 Field->setImplicit(true);
894 Field->setAccess(AS_private);
896 return new (Context) CXXThisExpr(Loc, ThisTy, /*isImplicit*/true);
899 bool Sema::CheckCXXThisCapture(SourceLocation Loc, bool Explicit,
900 bool BuildAndDiagnose, const unsigned *const FunctionScopeIndexToStopAt) {
901 // We don't need to capture this in an unevaluated context.
902 if (isUnevaluatedContext() && !Explicit)
905 const unsigned MaxFunctionScopesIndex = FunctionScopeIndexToStopAt ?
906 *FunctionScopeIndexToStopAt : FunctionScopes.size() - 1;
907 // Otherwise, check that we can capture 'this'.
908 unsigned NumClosures = 0;
909 for (unsigned idx = MaxFunctionScopesIndex; idx != 0; idx--) {
910 if (CapturingScopeInfo *CSI =
911 dyn_cast<CapturingScopeInfo>(FunctionScopes[idx])) {
912 if (CSI->CXXThisCaptureIndex != 0) {
913 // 'this' is already being captured; there isn't anything more to do.
916 LambdaScopeInfo *LSI = dyn_cast<LambdaScopeInfo>(CSI);
917 if (LSI && isGenericLambdaCallOperatorSpecialization(LSI->CallOperator)) {
918 // This context can't implicitly capture 'this'; fail out.
919 if (BuildAndDiagnose)
920 Diag(Loc, diag::err_this_capture) << Explicit;
923 if (CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_LambdaByref ||
924 CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_LambdaByval ||
925 CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_Block ||
926 CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_CapturedRegion ||
928 // This closure can capture 'this'; continue looking upwards.
933 // This context can't implicitly capture 'this'; fail out.
934 if (BuildAndDiagnose)
935 Diag(Loc, diag::err_this_capture) << Explicit;
940 if (!BuildAndDiagnose) return false;
941 // Mark that we're implicitly capturing 'this' in all the scopes we skipped.
942 // FIXME: We need to delay this marking in PotentiallyPotentiallyEvaluated
944 for (unsigned idx = MaxFunctionScopesIndex; NumClosures;
945 --idx, --NumClosures) {
946 CapturingScopeInfo *CSI = cast<CapturingScopeInfo>(FunctionScopes[idx]);
947 Expr *ThisExpr = nullptr;
948 QualType ThisTy = getCurrentThisType();
949 if (LambdaScopeInfo *LSI = dyn_cast<LambdaScopeInfo>(CSI))
950 // For lambda expressions, build a field and an initializing expression.
951 ThisExpr = captureThis(Context, LSI->Lambda, ThisTy, Loc);
952 else if (CapturedRegionScopeInfo *RSI
953 = dyn_cast<CapturedRegionScopeInfo>(FunctionScopes[idx]))
954 ThisExpr = captureThis(Context, RSI->TheRecordDecl, ThisTy, Loc);
956 bool isNested = NumClosures > 1;
957 CSI->addThisCapture(isNested, Loc, ThisTy, ThisExpr);
962 ExprResult Sema::ActOnCXXThis(SourceLocation Loc) {
963 /// C++ 9.3.2: In the body of a non-static member function, the keyword this
964 /// is a non-lvalue expression whose value is the address of the object for
965 /// which the function is called.
967 QualType ThisTy = getCurrentThisType();
968 if (ThisTy.isNull()) return Diag(Loc, diag::err_invalid_this_use);
970 CheckCXXThisCapture(Loc);
971 return new (Context) CXXThisExpr(Loc, ThisTy, /*isImplicit=*/false);
974 bool Sema::isThisOutsideMemberFunctionBody(QualType BaseType) {
975 // If we're outside the body of a member function, then we'll have a specified
977 if (CXXThisTypeOverride.isNull())
980 // Determine whether we're looking into a class that's currently being
982 CXXRecordDecl *Class = BaseType->getAsCXXRecordDecl();
983 return Class && Class->isBeingDefined();
987 Sema::ActOnCXXTypeConstructExpr(ParsedType TypeRep,
988 SourceLocation LParenLoc,
990 SourceLocation RParenLoc) {
994 TypeSourceInfo *TInfo;
995 QualType Ty = GetTypeFromParser(TypeRep, &TInfo);
997 TInfo = Context.getTrivialTypeSourceInfo(Ty, SourceLocation());
999 return BuildCXXTypeConstructExpr(TInfo, LParenLoc, exprs, RParenLoc);
1002 /// ActOnCXXTypeConstructExpr - Parse construction of a specified type.
1003 /// Can be interpreted either as function-style casting ("int(x)")
1004 /// or class type construction ("ClassType(x,y,z)")
1005 /// or creation of a value-initialized type ("int()").
1007 Sema::BuildCXXTypeConstructExpr(TypeSourceInfo *TInfo,
1008 SourceLocation LParenLoc,
1010 SourceLocation RParenLoc) {
1011 QualType Ty = TInfo->getType();
1012 SourceLocation TyBeginLoc = TInfo->getTypeLoc().getBeginLoc();
1014 if (Ty->isDependentType() || CallExpr::hasAnyTypeDependentArguments(Exprs)) {
1015 return CXXUnresolvedConstructExpr::Create(Context, TInfo, LParenLoc, Exprs,
1019 bool ListInitialization = LParenLoc.isInvalid();
1020 assert((!ListInitialization || (Exprs.size() == 1 && isa<InitListExpr>(Exprs[0])))
1021 && "List initialization must have initializer list as expression.");
1022 SourceRange FullRange = SourceRange(TyBeginLoc,
1023 ListInitialization ? Exprs[0]->getSourceRange().getEnd() : RParenLoc);
1025 // C++ [expr.type.conv]p1:
1026 // If the expression list is a single expression, the type conversion
1027 // expression is equivalent (in definedness, and if defined in meaning) to the
1028 // corresponding cast expression.
1029 if (Exprs.size() == 1 && !ListInitialization) {
1030 Expr *Arg = Exprs[0];
1031 return BuildCXXFunctionalCastExpr(TInfo, LParenLoc, Arg, RParenLoc);
1034 // C++14 [expr.type.conv]p2: The expression T(), where T is a
1035 // simple-type-specifier or typename-specifier for a non-array complete
1036 // object type or the (possibly cv-qualified) void type, creates a prvalue
1037 // of the specified type, whose value is that produced by value-initializing
1038 // an object of type T.
1039 QualType ElemTy = Ty;
1040 if (Ty->isArrayType()) {
1041 if (!ListInitialization)
1042 return ExprError(Diag(TyBeginLoc,
1043 diag::err_value_init_for_array_type) << FullRange);
1044 ElemTy = Context.getBaseElementType(Ty);
1047 if (!ListInitialization && Ty->isFunctionType())
1048 return ExprError(Diag(TyBeginLoc, diag::err_value_init_for_function_type)
1051 if (!Ty->isVoidType() &&
1052 RequireCompleteType(TyBeginLoc, ElemTy,
1053 diag::err_invalid_incomplete_type_use, FullRange))
1056 if (RequireNonAbstractType(TyBeginLoc, Ty,
1057 diag::err_allocation_of_abstract_type))
1060 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TInfo);
1061 InitializationKind Kind =
1062 Exprs.size() ? ListInitialization
1063 ? InitializationKind::CreateDirectList(TyBeginLoc)
1064 : InitializationKind::CreateDirect(TyBeginLoc, LParenLoc, RParenLoc)
1065 : InitializationKind::CreateValue(TyBeginLoc, LParenLoc, RParenLoc);
1066 InitializationSequence InitSeq(*this, Entity, Kind, Exprs);
1067 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Exprs);
1069 if (Result.isInvalid() || !ListInitialization)
1072 Expr *Inner = Result.get();
1073 if (CXXBindTemporaryExpr *BTE = dyn_cast_or_null<CXXBindTemporaryExpr>(Inner))
1074 Inner = BTE->getSubExpr();
1075 if (!isa<CXXTemporaryObjectExpr>(Inner)) {
1076 // If we created a CXXTemporaryObjectExpr, that node also represents the
1077 // functional cast. Otherwise, create an explicit cast to represent
1078 // the syntactic form of a functional-style cast that was used here.
1080 // FIXME: Creating a CXXFunctionalCastExpr around a CXXConstructExpr
1081 // would give a more consistent AST representation than using a
1082 // CXXTemporaryObjectExpr. It's also weird that the functional cast
1083 // is sometimes handled by initialization and sometimes not.
1084 QualType ResultType = Result.get()->getType();
1085 Result = CXXFunctionalCastExpr::Create(
1086 Context, ResultType, Expr::getValueKindForType(TInfo->getType()), TInfo,
1087 CK_NoOp, Result.get(), /*Path=*/nullptr, LParenLoc, RParenLoc);
1093 /// doesUsualArrayDeleteWantSize - Answers whether the usual
1094 /// operator delete[] for the given type has a size_t parameter.
1095 static bool doesUsualArrayDeleteWantSize(Sema &S, SourceLocation loc,
1096 QualType allocType) {
1097 const RecordType *record =
1098 allocType->getBaseElementTypeUnsafe()->getAs<RecordType>();
1099 if (!record) return false;
1101 // Try to find an operator delete[] in class scope.
1103 DeclarationName deleteName =
1104 S.Context.DeclarationNames.getCXXOperatorName(OO_Array_Delete);
1105 LookupResult ops(S, deleteName, loc, Sema::LookupOrdinaryName);
1106 S.LookupQualifiedName(ops, record->getDecl());
1108 // We're just doing this for information.
1109 ops.suppressDiagnostics();
1111 // Very likely: there's no operator delete[].
1112 if (ops.empty()) return false;
1114 // If it's ambiguous, it should be illegal to call operator delete[]
1115 // on this thing, so it doesn't matter if we allocate extra space or not.
1116 if (ops.isAmbiguous()) return false;
1118 LookupResult::Filter filter = ops.makeFilter();
1119 while (filter.hasNext()) {
1120 NamedDecl *del = filter.next()->getUnderlyingDecl();
1122 // C++0x [basic.stc.dynamic.deallocation]p2:
1123 // A template instance is never a usual deallocation function,
1124 // regardless of its signature.
1125 if (isa<FunctionTemplateDecl>(del)) {
1130 // C++0x [basic.stc.dynamic.deallocation]p2:
1131 // If class T does not declare [an operator delete[] with one
1132 // parameter] but does declare a member deallocation function
1133 // named operator delete[] with exactly two parameters, the
1134 // second of which has type std::size_t, then this function
1135 // is a usual deallocation function.
1136 if (!cast<CXXMethodDecl>(del)->isUsualDeallocationFunction()) {
1143 if (!ops.isSingleResult()) return false;
1145 const FunctionDecl *del = cast<FunctionDecl>(ops.getFoundDecl());
1146 return (del->getNumParams() == 2);
1149 /// \brief Parsed a C++ 'new' expression (C++ 5.3.4).
1152 /// @code new (memory) int[size][4] @endcode
1154 /// @code ::new Foo(23, "hello") @endcode
1156 /// \param StartLoc The first location of the expression.
1157 /// \param UseGlobal True if 'new' was prefixed with '::'.
1158 /// \param PlacementLParen Opening paren of the placement arguments.
1159 /// \param PlacementArgs Placement new arguments.
1160 /// \param PlacementRParen Closing paren of the placement arguments.
1161 /// \param TypeIdParens If the type is in parens, the source range.
1162 /// \param D The type to be allocated, as well as array dimensions.
1163 /// \param Initializer The initializing expression or initializer-list, or null
1164 /// if there is none.
1166 Sema::ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal,
1167 SourceLocation PlacementLParen, MultiExprArg PlacementArgs,
1168 SourceLocation PlacementRParen, SourceRange TypeIdParens,
1169 Declarator &D, Expr *Initializer) {
1170 bool TypeContainsAuto = D.getDeclSpec().containsPlaceholderType();
1172 Expr *ArraySize = nullptr;
1173 // If the specified type is an array, unwrap it and save the expression.
1174 if (D.getNumTypeObjects() > 0 &&
1175 D.getTypeObject(0).Kind == DeclaratorChunk::Array) {
1176 DeclaratorChunk &Chunk = D.getTypeObject(0);
1177 if (TypeContainsAuto)
1178 return ExprError(Diag(Chunk.Loc, diag::err_new_array_of_auto)
1179 << D.getSourceRange());
1180 if (Chunk.Arr.hasStatic)
1181 return ExprError(Diag(Chunk.Loc, diag::err_static_illegal_in_new)
1182 << D.getSourceRange());
1183 if (!Chunk.Arr.NumElts)
1184 return ExprError(Diag(Chunk.Loc, diag::err_array_new_needs_size)
1185 << D.getSourceRange());
1187 ArraySize = static_cast<Expr*>(Chunk.Arr.NumElts);
1188 D.DropFirstTypeObject();
1191 // Every dimension shall be of constant size.
1193 for (unsigned I = 0, N = D.getNumTypeObjects(); I < N; ++I) {
1194 if (D.getTypeObject(I).Kind != DeclaratorChunk::Array)
1197 DeclaratorChunk::ArrayTypeInfo &Array = D.getTypeObject(I).Arr;
1198 if (Expr *NumElts = (Expr *)Array.NumElts) {
1199 if (!NumElts->isTypeDependent() && !NumElts->isValueDependent()) {
1200 if (getLangOpts().CPlusPlus14) {
1201 // C++1y [expr.new]p6: Every constant-expression in a noptr-new-declarator
1202 // shall be a converted constant expression (5.19) of type std::size_t
1203 // and shall evaluate to a strictly positive value.
1204 unsigned IntWidth = Context.getTargetInfo().getIntWidth();
1205 assert(IntWidth && "Builtin type of size 0?");
1206 llvm::APSInt Value(IntWidth);
1208 = CheckConvertedConstantExpression(NumElts, Context.getSizeType(), Value,
1213 = VerifyIntegerConstantExpression(NumElts, nullptr,
1214 diag::err_new_array_nonconst)
1224 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, /*Scope=*/nullptr);
1225 QualType AllocType = TInfo->getType();
1226 if (D.isInvalidType())
1229 SourceRange DirectInitRange;
1230 if (ParenListExpr *List = dyn_cast_or_null<ParenListExpr>(Initializer))
1231 DirectInitRange = List->getSourceRange();
1233 return BuildCXXNew(SourceRange(StartLoc, D.getLocEnd()), UseGlobal,
1246 static bool isLegalArrayNewInitializer(CXXNewExpr::InitializationStyle Style,
1250 if (ParenListExpr *PLE = dyn_cast<ParenListExpr>(Init))
1251 return PLE->getNumExprs() == 0;
1252 if (isa<ImplicitValueInitExpr>(Init))
1254 else if (CXXConstructExpr *CCE = dyn_cast<CXXConstructExpr>(Init))
1255 return !CCE->isListInitialization() &&
1256 CCE->getConstructor()->isDefaultConstructor();
1257 else if (Style == CXXNewExpr::ListInit) {
1258 assert(isa<InitListExpr>(Init) &&
1259 "Shouldn't create list CXXConstructExprs for arrays.");
1266 Sema::BuildCXXNew(SourceRange Range, bool UseGlobal,
1267 SourceLocation PlacementLParen,
1268 MultiExprArg PlacementArgs,
1269 SourceLocation PlacementRParen,
1270 SourceRange TypeIdParens,
1272 TypeSourceInfo *AllocTypeInfo,
1274 SourceRange DirectInitRange,
1276 bool TypeMayContainAuto) {
1277 SourceRange TypeRange = AllocTypeInfo->getTypeLoc().getSourceRange();
1278 SourceLocation StartLoc = Range.getBegin();
1280 CXXNewExpr::InitializationStyle initStyle;
1281 if (DirectInitRange.isValid()) {
1282 assert(Initializer && "Have parens but no initializer.");
1283 initStyle = CXXNewExpr::CallInit;
1284 } else if (Initializer && isa<InitListExpr>(Initializer))
1285 initStyle = CXXNewExpr::ListInit;
1287 assert((!Initializer || isa<ImplicitValueInitExpr>(Initializer) ||
1288 isa<CXXConstructExpr>(Initializer)) &&
1289 "Initializer expression that cannot have been implicitly created.");
1290 initStyle = CXXNewExpr::NoInit;
1293 Expr **Inits = &Initializer;
1294 unsigned NumInits = Initializer ? 1 : 0;
1295 if (ParenListExpr *List = dyn_cast_or_null<ParenListExpr>(Initializer)) {
1296 assert(initStyle == CXXNewExpr::CallInit && "paren init for non-call init");
1297 Inits = List->getExprs();
1298 NumInits = List->getNumExprs();
1301 // C++11 [dcl.spec.auto]p6. Deduce the type which 'auto' stands in for.
1302 if (TypeMayContainAuto && AllocType->isUndeducedType()) {
1303 if (initStyle == CXXNewExpr::NoInit || NumInits == 0)
1304 return ExprError(Diag(StartLoc, diag::err_auto_new_requires_ctor_arg)
1305 << AllocType << TypeRange);
1306 if (initStyle == CXXNewExpr::ListInit ||
1307 (NumInits == 1 && isa<InitListExpr>(Inits[0])))
1308 return ExprError(Diag(Inits[0]->getLocStart(),
1309 diag::err_auto_new_list_init)
1310 << AllocType << TypeRange);
1312 Expr *FirstBad = Inits[1];
1313 return ExprError(Diag(FirstBad->getLocStart(),
1314 diag::err_auto_new_ctor_multiple_expressions)
1315 << AllocType << TypeRange);
1317 Expr *Deduce = Inits[0];
1318 QualType DeducedType;
1319 if (DeduceAutoType(AllocTypeInfo, Deduce, DeducedType) == DAR_Failed)
1320 return ExprError(Diag(StartLoc, diag::err_auto_new_deduction_failure)
1321 << AllocType << Deduce->getType()
1322 << TypeRange << Deduce->getSourceRange());
1323 if (DeducedType.isNull())
1325 AllocType = DeducedType;
1328 // Per C++0x [expr.new]p5, the type being constructed may be a
1329 // typedef of an array type.
1331 if (const ConstantArrayType *Array
1332 = Context.getAsConstantArrayType(AllocType)) {
1333 ArraySize = IntegerLiteral::Create(Context, Array->getSize(),
1334 Context.getSizeType(),
1335 TypeRange.getEnd());
1336 AllocType = Array->getElementType();
1340 if (CheckAllocatedType(AllocType, TypeRange.getBegin(), TypeRange))
1343 if (initStyle == CXXNewExpr::ListInit &&
1344 isStdInitializerList(AllocType, nullptr)) {
1345 Diag(AllocTypeInfo->getTypeLoc().getBeginLoc(),
1346 diag::warn_dangling_std_initializer_list)
1347 << /*at end of FE*/0 << Inits[0]->getSourceRange();
1350 // In ARC, infer 'retaining' for the allocated
1351 if (getLangOpts().ObjCAutoRefCount &&
1352 AllocType.getObjCLifetime() == Qualifiers::OCL_None &&
1353 AllocType->isObjCLifetimeType()) {
1354 AllocType = Context.getLifetimeQualifiedType(AllocType,
1355 AllocType->getObjCARCImplicitLifetime());
1358 QualType ResultType = Context.getPointerType(AllocType);
1360 if (ArraySize && ArraySize->getType()->isNonOverloadPlaceholderType()) {
1361 ExprResult result = CheckPlaceholderExpr(ArraySize);
1362 if (result.isInvalid()) return ExprError();
1363 ArraySize = result.get();
1365 // C++98 5.3.4p6: "The expression in a direct-new-declarator shall have
1366 // integral or enumeration type with a non-negative value."
1367 // C++11 [expr.new]p6: The expression [...] shall be of integral or unscoped
1368 // enumeration type, or a class type for which a single non-explicit
1369 // conversion function to integral or unscoped enumeration type exists.
1370 // C++1y [expr.new]p6: The expression [...] is implicitly converted to
1372 if (ArraySize && !ArraySize->isTypeDependent()) {
1373 ExprResult ConvertedSize;
1374 if (getLangOpts().CPlusPlus14) {
1375 assert(Context.getTargetInfo().getIntWidth() && "Builtin type of size 0?");
1377 ConvertedSize = PerformImplicitConversion(ArraySize, Context.getSizeType(),
1380 if (!ConvertedSize.isInvalid() &&
1381 ArraySize->getType()->getAs<RecordType>())
1382 // Diagnose the compatibility of this conversion.
1383 Diag(StartLoc, diag::warn_cxx98_compat_array_size_conversion)
1384 << ArraySize->getType() << 0 << "'size_t'";
1386 class SizeConvertDiagnoser : public ICEConvertDiagnoser {
1391 SizeConvertDiagnoser(Expr *ArraySize)
1392 : ICEConvertDiagnoser(/*AllowScopedEnumerations*/false, false, false),
1393 ArraySize(ArraySize) {}
1395 SemaDiagnosticBuilder diagnoseNotInt(Sema &S, SourceLocation Loc,
1396 QualType T) override {
1397 return S.Diag(Loc, diag::err_array_size_not_integral)
1398 << S.getLangOpts().CPlusPlus11 << T;
1401 SemaDiagnosticBuilder diagnoseIncomplete(
1402 Sema &S, SourceLocation Loc, QualType T) override {
1403 return S.Diag(Loc, diag::err_array_size_incomplete_type)
1404 << T << ArraySize->getSourceRange();
1407 SemaDiagnosticBuilder diagnoseExplicitConv(
1408 Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) override {
1409 return S.Diag(Loc, diag::err_array_size_explicit_conversion) << T << ConvTy;
1412 SemaDiagnosticBuilder noteExplicitConv(
1413 Sema &S, CXXConversionDecl *Conv, QualType ConvTy) override {
1414 return S.Diag(Conv->getLocation(), diag::note_array_size_conversion)
1415 << ConvTy->isEnumeralType() << ConvTy;
1418 SemaDiagnosticBuilder diagnoseAmbiguous(
1419 Sema &S, SourceLocation Loc, QualType T) override {
1420 return S.Diag(Loc, diag::err_array_size_ambiguous_conversion) << T;
1423 SemaDiagnosticBuilder noteAmbiguous(
1424 Sema &S, CXXConversionDecl *Conv, QualType ConvTy) override {
1425 return S.Diag(Conv->getLocation(), diag::note_array_size_conversion)
1426 << ConvTy->isEnumeralType() << ConvTy;
1429 SemaDiagnosticBuilder diagnoseConversion(Sema &S, SourceLocation Loc,
1431 QualType ConvTy) override {
1433 S.getLangOpts().CPlusPlus11
1434 ? diag::warn_cxx98_compat_array_size_conversion
1435 : diag::ext_array_size_conversion)
1436 << T << ConvTy->isEnumeralType() << ConvTy;
1438 } SizeDiagnoser(ArraySize);
1440 ConvertedSize = PerformContextualImplicitConversion(StartLoc, ArraySize,
1443 if (ConvertedSize.isInvalid())
1446 ArraySize = ConvertedSize.get();
1447 QualType SizeType = ArraySize->getType();
1449 if (!SizeType->isIntegralOrUnscopedEnumerationType())
1452 // C++98 [expr.new]p7:
1453 // The expression in a direct-new-declarator shall have integral type
1454 // with a non-negative value.
1456 // Let's see if this is a constant < 0. If so, we reject it out of
1457 // hand. Otherwise, if it's not a constant, we must have an unparenthesized
1460 // Note: such a construct has well-defined semantics in C++11: it throws
1461 // std::bad_array_new_length.
1462 if (!ArraySize->isValueDependent()) {
1464 // We've already performed any required implicit conversion to integer or
1465 // unscoped enumeration type.
1466 if (ArraySize->isIntegerConstantExpr(Value, Context)) {
1467 if (Value < llvm::APSInt(
1468 llvm::APInt::getNullValue(Value.getBitWidth()),
1469 Value.isUnsigned())) {
1470 if (getLangOpts().CPlusPlus11)
1471 Diag(ArraySize->getLocStart(),
1472 diag::warn_typecheck_negative_array_new_size)
1473 << ArraySize->getSourceRange();
1475 return ExprError(Diag(ArraySize->getLocStart(),
1476 diag::err_typecheck_negative_array_size)
1477 << ArraySize->getSourceRange());
1478 } else if (!AllocType->isDependentType()) {
1479 unsigned ActiveSizeBits =
1480 ConstantArrayType::getNumAddressingBits(Context, AllocType, Value);
1481 if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) {
1482 if (getLangOpts().CPlusPlus11)
1483 Diag(ArraySize->getLocStart(),
1484 diag::warn_array_new_too_large)
1485 << Value.toString(10)
1486 << ArraySize->getSourceRange();
1488 return ExprError(Diag(ArraySize->getLocStart(),
1489 diag::err_array_too_large)
1490 << Value.toString(10)
1491 << ArraySize->getSourceRange());
1494 } else if (TypeIdParens.isValid()) {
1495 // Can't have dynamic array size when the type-id is in parentheses.
1496 Diag(ArraySize->getLocStart(), diag::ext_new_paren_array_nonconst)
1497 << ArraySize->getSourceRange()
1498 << FixItHint::CreateRemoval(TypeIdParens.getBegin())
1499 << FixItHint::CreateRemoval(TypeIdParens.getEnd());
1501 TypeIdParens = SourceRange();
1505 // Note that we do *not* convert the argument in any way. It can
1506 // be signed, larger than size_t, whatever.
1509 FunctionDecl *OperatorNew = nullptr;
1510 FunctionDecl *OperatorDelete = nullptr;
1512 if (!AllocType->isDependentType() &&
1513 !Expr::hasAnyTypeDependentArguments(PlacementArgs) &&
1514 FindAllocationFunctions(StartLoc,
1515 SourceRange(PlacementLParen, PlacementRParen),
1516 UseGlobal, AllocType, ArraySize, PlacementArgs,
1517 OperatorNew, OperatorDelete))
1520 // If this is an array allocation, compute whether the usual array
1521 // deallocation function for the type has a size_t parameter.
1522 bool UsualArrayDeleteWantsSize = false;
1523 if (ArraySize && !AllocType->isDependentType())
1524 UsualArrayDeleteWantsSize
1525 = doesUsualArrayDeleteWantSize(*this, StartLoc, AllocType);
1527 SmallVector<Expr *, 8> AllPlaceArgs;
1529 const FunctionProtoType *Proto =
1530 OperatorNew->getType()->getAs<FunctionProtoType>();
1531 VariadicCallType CallType = Proto->isVariadic() ? VariadicFunction
1532 : VariadicDoesNotApply;
1534 // We've already converted the placement args, just fill in any default
1535 // arguments. Skip the first parameter because we don't have a corresponding
1537 if (GatherArgumentsForCall(PlacementLParen, OperatorNew, Proto, 1,
1538 PlacementArgs, AllPlaceArgs, CallType))
1541 if (!AllPlaceArgs.empty())
1542 PlacementArgs = AllPlaceArgs;
1544 // FIXME: This is wrong: PlacementArgs misses out the first (size) argument.
1545 DiagnoseSentinelCalls(OperatorNew, PlacementLParen, PlacementArgs);
1547 // FIXME: Missing call to CheckFunctionCall or equivalent
1550 // Warn if the type is over-aligned and is being allocated by global operator
1552 if (PlacementArgs.empty() && OperatorNew &&
1553 (OperatorNew->isImplicit() ||
1554 getSourceManager().isInSystemHeader(OperatorNew->getLocStart()))) {
1555 if (unsigned Align = Context.getPreferredTypeAlign(AllocType.getTypePtr())){
1556 unsigned SuitableAlign = Context.getTargetInfo().getSuitableAlign();
1557 if (Align > SuitableAlign)
1558 Diag(StartLoc, diag::warn_overaligned_type)
1560 << unsigned(Align / Context.getCharWidth())
1561 << unsigned(SuitableAlign / Context.getCharWidth());
1565 QualType InitType = AllocType;
1566 // Array 'new' can't have any initializers except empty parentheses.
1567 // Initializer lists are also allowed, in C++11. Rely on the parser for the
1568 // dialect distinction.
1569 if (ResultType->isArrayType() || ArraySize) {
1570 if (!isLegalArrayNewInitializer(initStyle, Initializer)) {
1571 SourceRange InitRange(Inits[0]->getLocStart(),
1572 Inits[NumInits - 1]->getLocEnd());
1573 Diag(StartLoc, diag::err_new_array_init_args) << InitRange;
1576 if (InitListExpr *ILE = dyn_cast_or_null<InitListExpr>(Initializer)) {
1577 // We do the initialization typechecking against the array type
1578 // corresponding to the number of initializers + 1 (to also check
1579 // default-initialization).
1580 unsigned NumElements = ILE->getNumInits() + 1;
1581 InitType = Context.getConstantArrayType(AllocType,
1582 llvm::APInt(Context.getTypeSize(Context.getSizeType()), NumElements),
1583 ArrayType::Normal, 0);
1587 // If we can perform the initialization, and we've not already done so,
1589 if (!AllocType->isDependentType() &&
1590 !Expr::hasAnyTypeDependentArguments(
1591 llvm::makeArrayRef(Inits, NumInits))) {
1592 // C++11 [expr.new]p15:
1593 // A new-expression that creates an object of type T initializes that
1594 // object as follows:
1595 InitializationKind Kind
1596 // - If the new-initializer is omitted, the object is default-
1597 // initialized (8.5); if no initialization is performed,
1598 // the object has indeterminate value
1599 = initStyle == CXXNewExpr::NoInit
1600 ? InitializationKind::CreateDefault(TypeRange.getBegin())
1601 // - Otherwise, the new-initializer is interpreted according to the
1602 // initialization rules of 8.5 for direct-initialization.
1603 : initStyle == CXXNewExpr::ListInit
1604 ? InitializationKind::CreateDirectList(TypeRange.getBegin())
1605 : InitializationKind::CreateDirect(TypeRange.getBegin(),
1606 DirectInitRange.getBegin(),
1607 DirectInitRange.getEnd());
1609 InitializedEntity Entity
1610 = InitializedEntity::InitializeNew(StartLoc, InitType);
1611 InitializationSequence InitSeq(*this, Entity, Kind, MultiExprArg(Inits, NumInits));
1612 ExprResult FullInit = InitSeq.Perform(*this, Entity, Kind,
1613 MultiExprArg(Inits, NumInits));
1614 if (FullInit.isInvalid())
1617 // FullInit is our initializer; strip off CXXBindTemporaryExprs, because
1618 // we don't want the initialized object to be destructed.
1619 if (CXXBindTemporaryExpr *Binder =
1620 dyn_cast_or_null<CXXBindTemporaryExpr>(FullInit.get()))
1621 FullInit = Binder->getSubExpr();
1623 Initializer = FullInit.get();
1626 // Mark the new and delete operators as referenced.
1628 if (DiagnoseUseOfDecl(OperatorNew, StartLoc))
1630 MarkFunctionReferenced(StartLoc, OperatorNew);
1632 if (OperatorDelete) {
1633 if (DiagnoseUseOfDecl(OperatorDelete, StartLoc))
1635 MarkFunctionReferenced(StartLoc, OperatorDelete);
1638 // C++0x [expr.new]p17:
1639 // If the new expression creates an array of objects of class type,
1640 // access and ambiguity control are done for the destructor.
1641 QualType BaseAllocType = Context.getBaseElementType(AllocType);
1642 if (ArraySize && !BaseAllocType->isDependentType()) {
1643 if (const RecordType *BaseRecordType = BaseAllocType->getAs<RecordType>()) {
1644 if (CXXDestructorDecl *dtor = LookupDestructor(
1645 cast<CXXRecordDecl>(BaseRecordType->getDecl()))) {
1646 MarkFunctionReferenced(StartLoc, dtor);
1647 CheckDestructorAccess(StartLoc, dtor,
1648 PDiag(diag::err_access_dtor)
1650 if (DiagnoseUseOfDecl(dtor, StartLoc))
1656 return new (Context)
1657 CXXNewExpr(Context, UseGlobal, OperatorNew, OperatorDelete,
1658 UsualArrayDeleteWantsSize, PlacementArgs, TypeIdParens,
1659 ArraySize, initStyle, Initializer, ResultType, AllocTypeInfo,
1660 Range, DirectInitRange);
1663 /// \brief Checks that a type is suitable as the allocated type
1664 /// in a new-expression.
1665 bool Sema::CheckAllocatedType(QualType AllocType, SourceLocation Loc,
1667 // C++ 5.3.4p1: "[The] type shall be a complete object type, but not an
1668 // abstract class type or array thereof.
1669 if (AllocType->isFunctionType())
1670 return Diag(Loc, diag::err_bad_new_type)
1671 << AllocType << 0 << R;
1672 else if (AllocType->isReferenceType())
1673 return Diag(Loc, diag::err_bad_new_type)
1674 << AllocType << 1 << R;
1675 else if (!AllocType->isDependentType() &&
1676 RequireCompleteType(Loc, AllocType, diag::err_new_incomplete_type,R))
1678 else if (RequireNonAbstractType(Loc, AllocType,
1679 diag::err_allocation_of_abstract_type))
1681 else if (AllocType->isVariablyModifiedType())
1682 return Diag(Loc, diag::err_variably_modified_new_type)
1684 else if (unsigned AddressSpace = AllocType.getAddressSpace())
1685 return Diag(Loc, diag::err_address_space_qualified_new)
1686 << AllocType.getUnqualifiedType() << AddressSpace;
1687 else if (getLangOpts().ObjCAutoRefCount) {
1688 if (const ArrayType *AT = Context.getAsArrayType(AllocType)) {
1689 QualType BaseAllocType = Context.getBaseElementType(AT);
1690 if (BaseAllocType.getObjCLifetime() == Qualifiers::OCL_None &&
1691 BaseAllocType->isObjCLifetimeType())
1692 return Diag(Loc, diag::err_arc_new_array_without_ownership)
1700 /// \brief Determine whether the given function is a non-placement
1701 /// deallocation function.
1702 static bool isNonPlacementDeallocationFunction(Sema &S, FunctionDecl *FD) {
1703 if (FD->isInvalidDecl())
1706 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FD))
1707 return Method->isUsualDeallocationFunction();
1709 if (FD->getOverloadedOperator() != OO_Delete &&
1710 FD->getOverloadedOperator() != OO_Array_Delete)
1713 if (FD->getNumParams() == 1)
1716 return S.getLangOpts().SizedDeallocation && FD->getNumParams() == 2 &&
1717 S.Context.hasSameUnqualifiedType(FD->getParamDecl(1)->getType(),
1718 S.Context.getSizeType());
1721 /// FindAllocationFunctions - Finds the overloads of operator new and delete
1722 /// that are appropriate for the allocation.
1723 bool Sema::FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
1724 bool UseGlobal, QualType AllocType,
1725 bool IsArray, MultiExprArg PlaceArgs,
1726 FunctionDecl *&OperatorNew,
1727 FunctionDecl *&OperatorDelete) {
1728 // --- Choosing an allocation function ---
1729 // C++ 5.3.4p8 - 14 & 18
1730 // 1) If UseGlobal is true, only look in the global scope. Else, also look
1731 // in the scope of the allocated class.
1732 // 2) If an array size is given, look for operator new[], else look for
1734 // 3) The first argument is always size_t. Append the arguments from the
1737 SmallVector<Expr*, 8> AllocArgs(1 + PlaceArgs.size());
1738 // We don't care about the actual value of this argument.
1739 // FIXME: Should the Sema create the expression and embed it in the syntax
1740 // tree? Or should the consumer just recalculate the value?
1741 IntegerLiteral Size(Context, llvm::APInt::getNullValue(
1742 Context.getTargetInfo().getPointerWidth(0)),
1743 Context.getSizeType(),
1745 AllocArgs[0] = &Size;
1746 std::copy(PlaceArgs.begin(), PlaceArgs.end(), AllocArgs.begin() + 1);
1748 // C++ [expr.new]p8:
1749 // If the allocated type is a non-array type, the allocation
1750 // function's name is operator new and the deallocation function's
1751 // name is operator delete. If the allocated type is an array
1752 // type, the allocation function's name is operator new[] and the
1753 // deallocation function's name is operator delete[].
1754 DeclarationName NewName = Context.DeclarationNames.getCXXOperatorName(
1755 IsArray ? OO_Array_New : OO_New);
1756 DeclarationName DeleteName = Context.DeclarationNames.getCXXOperatorName(
1757 IsArray ? OO_Array_Delete : OO_Delete);
1759 QualType AllocElemType = Context.getBaseElementType(AllocType);
1761 if (AllocElemType->isRecordType() && !UseGlobal) {
1762 CXXRecordDecl *Record
1763 = cast<CXXRecordDecl>(AllocElemType->getAs<RecordType>()->getDecl());
1764 if (FindAllocationOverload(StartLoc, Range, NewName, AllocArgs, Record,
1765 /*AllowMissing=*/true, OperatorNew))
1770 // Didn't find a member overload. Look for a global one.
1771 DeclareGlobalNewDelete();
1772 DeclContext *TUDecl = Context.getTranslationUnitDecl();
1773 bool FallbackEnabled = IsArray && Context.getLangOpts().MSVCCompat;
1774 if (FindAllocationOverload(StartLoc, Range, NewName, AllocArgs, TUDecl,
1775 /*AllowMissing=*/FallbackEnabled, OperatorNew,
1776 /*Diagnose=*/!FallbackEnabled)) {
1777 if (!FallbackEnabled)
1780 // MSVC will fall back on trying to find a matching global operator new
1781 // if operator new[] cannot be found. Also, MSVC will leak by not
1782 // generating a call to operator delete or operator delete[], but we
1783 // will not replicate that bug.
1784 NewName = Context.DeclarationNames.getCXXOperatorName(OO_New);
1785 DeleteName = Context.DeclarationNames.getCXXOperatorName(OO_Delete);
1786 if (FindAllocationOverload(StartLoc, Range, NewName, AllocArgs, TUDecl,
1787 /*AllowMissing=*/false, OperatorNew))
1792 // We don't need an operator delete if we're running under
1794 if (!getLangOpts().Exceptions) {
1795 OperatorDelete = nullptr;
1799 // C++ [expr.new]p19:
1801 // If the new-expression begins with a unary :: operator, the
1802 // deallocation function's name is looked up in the global
1803 // scope. Otherwise, if the allocated type is a class type T or an
1804 // array thereof, the deallocation function's name is looked up in
1805 // the scope of T. If this lookup fails to find the name, or if
1806 // the allocated type is not a class type or array thereof, the
1807 // deallocation function's name is looked up in the global scope.
1808 LookupResult FoundDelete(*this, DeleteName, StartLoc, LookupOrdinaryName);
1809 if (AllocElemType->isRecordType() && !UseGlobal) {
1811 = cast<CXXRecordDecl>(AllocElemType->getAs<RecordType>()->getDecl());
1812 LookupQualifiedName(FoundDelete, RD);
1814 if (FoundDelete.isAmbiguous())
1815 return true; // FIXME: clean up expressions?
1817 if (FoundDelete.empty()) {
1818 DeclareGlobalNewDelete();
1819 LookupQualifiedName(FoundDelete, Context.getTranslationUnitDecl());
1822 FoundDelete.suppressDiagnostics();
1824 SmallVector<std::pair<DeclAccessPair,FunctionDecl*>, 2> Matches;
1826 // Whether we're looking for a placement operator delete is dictated
1827 // by whether we selected a placement operator new, not by whether
1828 // we had explicit placement arguments. This matters for things like
1829 // struct A { void *operator new(size_t, int = 0); ... };
1831 bool isPlacementNew = (!PlaceArgs.empty() || OperatorNew->param_size() != 1);
1833 if (isPlacementNew) {
1834 // C++ [expr.new]p20:
1835 // A declaration of a placement deallocation function matches the
1836 // declaration of a placement allocation function if it has the
1837 // same number of parameters and, after parameter transformations
1838 // (8.3.5), all parameter types except the first are
1841 // To perform this comparison, we compute the function type that
1842 // the deallocation function should have, and use that type both
1843 // for template argument deduction and for comparison purposes.
1845 // FIXME: this comparison should ignore CC and the like.
1846 QualType ExpectedFunctionType;
1848 const FunctionProtoType *Proto
1849 = OperatorNew->getType()->getAs<FunctionProtoType>();
1851 SmallVector<QualType, 4> ArgTypes;
1852 ArgTypes.push_back(Context.VoidPtrTy);
1853 for (unsigned I = 1, N = Proto->getNumParams(); I < N; ++I)
1854 ArgTypes.push_back(Proto->getParamType(I));
1856 FunctionProtoType::ExtProtoInfo EPI;
1857 EPI.Variadic = Proto->isVariadic();
1859 ExpectedFunctionType
1860 = Context.getFunctionType(Context.VoidTy, ArgTypes, EPI);
1863 for (LookupResult::iterator D = FoundDelete.begin(),
1864 DEnd = FoundDelete.end();
1866 FunctionDecl *Fn = nullptr;
1867 if (FunctionTemplateDecl *FnTmpl
1868 = dyn_cast<FunctionTemplateDecl>((*D)->getUnderlyingDecl())) {
1869 // Perform template argument deduction to try to match the
1870 // expected function type.
1871 TemplateDeductionInfo Info(StartLoc);
1872 if (DeduceTemplateArguments(FnTmpl, nullptr, ExpectedFunctionType, Fn,
1876 Fn = cast<FunctionDecl>((*D)->getUnderlyingDecl());
1878 if (Context.hasSameType(Fn->getType(), ExpectedFunctionType))
1879 Matches.push_back(std::make_pair(D.getPair(), Fn));
1882 // C++ [expr.new]p20:
1883 // [...] Any non-placement deallocation function matches a
1884 // non-placement allocation function. [...]
1885 for (LookupResult::iterator D = FoundDelete.begin(),
1886 DEnd = FoundDelete.end();
1888 if (FunctionDecl *Fn = dyn_cast<FunctionDecl>((*D)->getUnderlyingDecl()))
1889 if (isNonPlacementDeallocationFunction(*this, Fn))
1890 Matches.push_back(std::make_pair(D.getPair(), Fn));
1893 // C++1y [expr.new]p22:
1894 // For a non-placement allocation function, the normal deallocation
1895 // function lookup is used
1896 // C++1y [expr.delete]p?:
1897 // If [...] deallocation function lookup finds both a usual deallocation
1898 // function with only a pointer parameter and a usual deallocation
1899 // function with both a pointer parameter and a size parameter, then the
1900 // selected deallocation function shall be the one with two parameters.
1901 // Otherwise, the selected deallocation function shall be the function
1902 // with one parameter.
1903 if (getLangOpts().SizedDeallocation && Matches.size() == 2) {
1904 if (Matches[0].second->getNumParams() == 1)
1905 Matches.erase(Matches.begin());
1907 Matches.erase(Matches.begin() + 1);
1908 assert(Matches[0].second->getNumParams() == 2 &&
1909 "found an unexpected usual deallocation function");
1913 // C++ [expr.new]p20:
1914 // [...] If the lookup finds a single matching deallocation
1915 // function, that function will be called; otherwise, no
1916 // deallocation function will be called.
1917 if (Matches.size() == 1) {
1918 OperatorDelete = Matches[0].second;
1920 // C++0x [expr.new]p20:
1921 // If the lookup finds the two-parameter form of a usual
1922 // deallocation function (3.7.4.2) and that function, considered
1923 // as a placement deallocation function, would have been
1924 // selected as a match for the allocation function, the program
1926 if (!PlaceArgs.empty() && getLangOpts().CPlusPlus11 &&
1927 isNonPlacementDeallocationFunction(*this, OperatorDelete)) {
1928 Diag(StartLoc, diag::err_placement_new_non_placement_delete)
1929 << SourceRange(PlaceArgs.front()->getLocStart(),
1930 PlaceArgs.back()->getLocEnd());
1931 if (!OperatorDelete->isImplicit())
1932 Diag(OperatorDelete->getLocation(), diag::note_previous_decl)
1935 CheckAllocationAccess(StartLoc, Range, FoundDelete.getNamingClass(),
1943 /// \brief Find an fitting overload for the allocation function
1944 /// in the specified scope.
1946 /// \param StartLoc The location of the 'new' token.
1947 /// \param Range The range of the placement arguments.
1948 /// \param Name The name of the function ('operator new' or 'operator new[]').
1949 /// \param Args The placement arguments specified.
1950 /// \param Ctx The scope in which we should search; either a class scope or the
1951 /// translation unit.
1952 /// \param AllowMissing If \c true, report an error if we can't find any
1953 /// allocation functions. Otherwise, succeed but don't fill in \p
1955 /// \param Operator Filled in with the found allocation function. Unchanged if
1956 /// no allocation function was found.
1957 /// \param Diagnose If \c true, issue errors if the allocation function is not
1959 bool Sema::FindAllocationOverload(SourceLocation StartLoc, SourceRange Range,
1960 DeclarationName Name, MultiExprArg Args,
1962 bool AllowMissing, FunctionDecl *&Operator,
1964 LookupResult R(*this, Name, StartLoc, LookupOrdinaryName);
1965 LookupQualifiedName(R, Ctx);
1967 if (AllowMissing || !Diagnose)
1969 return Diag(StartLoc, diag::err_ovl_no_viable_function_in_call)
1973 if (R.isAmbiguous())
1976 R.suppressDiagnostics();
1978 OverloadCandidateSet Candidates(StartLoc, OverloadCandidateSet::CSK_Normal);
1979 for (LookupResult::iterator Alloc = R.begin(), AllocEnd = R.end();
1980 Alloc != AllocEnd; ++Alloc) {
1981 // Even member operator new/delete are implicitly treated as
1982 // static, so don't use AddMemberCandidate.
1983 NamedDecl *D = (*Alloc)->getUnderlyingDecl();
1985 if (FunctionTemplateDecl *FnTemplate = dyn_cast<FunctionTemplateDecl>(D)) {
1986 AddTemplateOverloadCandidate(FnTemplate, Alloc.getPair(),
1987 /*ExplicitTemplateArgs=*/nullptr,
1989 /*SuppressUserConversions=*/false);
1993 FunctionDecl *Fn = cast<FunctionDecl>(D);
1994 AddOverloadCandidate(Fn, Alloc.getPair(), Args, Candidates,
1995 /*SuppressUserConversions=*/false);
1998 // Do the resolution.
1999 OverloadCandidateSet::iterator Best;
2000 switch (Candidates.BestViableFunction(*this, StartLoc, Best)) {
2003 FunctionDecl *FnDecl = Best->Function;
2004 if (CheckAllocationAccess(StartLoc, Range, R.getNamingClass(),
2005 Best->FoundDecl, Diagnose) == AR_inaccessible)
2012 case OR_No_Viable_Function:
2014 Diag(StartLoc, diag::err_ovl_no_viable_function_in_call)
2016 Candidates.NoteCandidates(*this, OCD_AllCandidates, Args);
2022 Diag(StartLoc, diag::err_ovl_ambiguous_call)
2024 Candidates.NoteCandidates(*this, OCD_ViableCandidates, Args);
2030 Diag(StartLoc, diag::err_ovl_deleted_call)
2031 << Best->Function->isDeleted()
2033 << getDeletedOrUnavailableSuffix(Best->Function)
2035 Candidates.NoteCandidates(*this, OCD_AllCandidates, Args);
2040 llvm_unreachable("Unreachable, bad result from BestViableFunction");
2044 /// DeclareGlobalNewDelete - Declare the global forms of operator new and
2045 /// delete. These are:
2048 /// void* operator new(std::size_t) throw(std::bad_alloc);
2049 /// void* operator new[](std::size_t) throw(std::bad_alloc);
2050 /// void operator delete(void *) throw();
2051 /// void operator delete[](void *) throw();
2053 /// void* operator new(std::size_t);
2054 /// void* operator new[](std::size_t);
2055 /// void operator delete(void *) noexcept;
2056 /// void operator delete[](void *) noexcept;
2058 /// void* operator new(std::size_t);
2059 /// void* operator new[](std::size_t);
2060 /// void operator delete(void *) noexcept;
2061 /// void operator delete[](void *) noexcept;
2062 /// void operator delete(void *, std::size_t) noexcept;
2063 /// void operator delete[](void *, std::size_t) noexcept;
2065 /// Note that the placement and nothrow forms of new are *not* implicitly
2066 /// declared. Their use requires including \<new\>.
2067 void Sema::DeclareGlobalNewDelete() {
2068 if (GlobalNewDeleteDeclared)
2071 // C++ [basic.std.dynamic]p2:
2072 // [...] The following allocation and deallocation functions (18.4) are
2073 // implicitly declared in global scope in each translation unit of a
2077 // void* operator new(std::size_t) throw(std::bad_alloc);
2078 // void* operator new[](std::size_t) throw(std::bad_alloc);
2079 // void operator delete(void*) throw();
2080 // void operator delete[](void*) throw();
2082 // void* operator new(std::size_t);
2083 // void* operator new[](std::size_t);
2084 // void operator delete(void*) noexcept;
2085 // void operator delete[](void*) noexcept;
2087 // void* operator new(std::size_t);
2088 // void* operator new[](std::size_t);
2089 // void operator delete(void*) noexcept;
2090 // void operator delete[](void*) noexcept;
2091 // void operator delete(void*, std::size_t) noexcept;
2092 // void operator delete[](void*, std::size_t) noexcept;
2094 // These implicit declarations introduce only the function names operator
2095 // new, operator new[], operator delete, operator delete[].
2097 // Here, we need to refer to std::bad_alloc, so we will implicitly declare
2098 // "std" or "bad_alloc" as necessary to form the exception specification.
2099 // However, we do not make these implicit declarations visible to name
2101 if (!StdBadAlloc && !getLangOpts().CPlusPlus11) {
2102 // The "std::bad_alloc" class has not yet been declared, so build it
2104 StdBadAlloc = CXXRecordDecl::Create(Context, TTK_Class,
2105 getOrCreateStdNamespace(),
2106 SourceLocation(), SourceLocation(),
2107 &PP.getIdentifierTable().get("bad_alloc"),
2109 getStdBadAlloc()->setImplicit(true);
2112 GlobalNewDeleteDeclared = true;
2114 QualType VoidPtr = Context.getPointerType(Context.VoidTy);
2115 QualType SizeT = Context.getSizeType();
2116 bool AssumeSaneOperatorNew = getLangOpts().AssumeSaneOperatorNew;
2118 DeclareGlobalAllocationFunction(
2119 Context.DeclarationNames.getCXXOperatorName(OO_New),
2120 VoidPtr, SizeT, QualType(), AssumeSaneOperatorNew);
2121 DeclareGlobalAllocationFunction(
2122 Context.DeclarationNames.getCXXOperatorName(OO_Array_New),
2123 VoidPtr, SizeT, QualType(), AssumeSaneOperatorNew);
2124 DeclareGlobalAllocationFunction(
2125 Context.DeclarationNames.getCXXOperatorName(OO_Delete),
2126 Context.VoidTy, VoidPtr);
2127 DeclareGlobalAllocationFunction(
2128 Context.DeclarationNames.getCXXOperatorName(OO_Array_Delete),
2129 Context.VoidTy, VoidPtr);
2130 if (getLangOpts().SizedDeallocation) {
2131 DeclareGlobalAllocationFunction(
2132 Context.DeclarationNames.getCXXOperatorName(OO_Delete),
2133 Context.VoidTy, VoidPtr, Context.getSizeType());
2134 DeclareGlobalAllocationFunction(
2135 Context.DeclarationNames.getCXXOperatorName(OO_Array_Delete),
2136 Context.VoidTy, VoidPtr, Context.getSizeType());
2140 /// DeclareGlobalAllocationFunction - Declares a single implicit global
2141 /// allocation function if it doesn't already exist.
2142 void Sema::DeclareGlobalAllocationFunction(DeclarationName Name,
2144 QualType Param1, QualType Param2,
2145 bool AddRestrictAttr) {
2146 DeclContext *GlobalCtx = Context.getTranslationUnitDecl();
2147 unsigned NumParams = Param2.isNull() ? 1 : 2;
2149 // Check if this function is already declared.
2150 DeclContext::lookup_result R = GlobalCtx->lookup(Name);
2151 for (DeclContext::lookup_iterator Alloc = R.begin(), AllocEnd = R.end();
2152 Alloc != AllocEnd; ++Alloc) {
2153 // Only look at non-template functions, as it is the predefined,
2154 // non-templated allocation function we are trying to declare here.
2155 if (FunctionDecl *Func = dyn_cast<FunctionDecl>(*Alloc)) {
2156 if (Func->getNumParams() == NumParams) {
2157 QualType InitialParam1Type =
2158 Context.getCanonicalType(Func->getParamDecl(0)
2159 ->getType().getUnqualifiedType());
2160 QualType InitialParam2Type =
2162 ? Context.getCanonicalType(Func->getParamDecl(1)
2163 ->getType().getUnqualifiedType())
2165 // FIXME: Do we need to check for default arguments here?
2166 if (InitialParam1Type == Param1 &&
2167 (NumParams == 1 || InitialParam2Type == Param2)) {
2168 if (AddRestrictAttr && !Func->hasAttr<RestrictAttr>())
2169 Func->addAttr(RestrictAttr::CreateImplicit(
2170 Context, RestrictAttr::GNU_malloc));
2171 // Make the function visible to name lookup, even if we found it in
2172 // an unimported module. It either is an implicitly-declared global
2173 // allocation function, or is suppressing that function.
2174 Func->setHidden(false);
2181 FunctionProtoType::ExtProtoInfo EPI;
2183 QualType BadAllocType;
2184 bool HasBadAllocExceptionSpec
2185 = (Name.getCXXOverloadedOperator() == OO_New ||
2186 Name.getCXXOverloadedOperator() == OO_Array_New);
2187 if (HasBadAllocExceptionSpec) {
2188 if (!getLangOpts().CPlusPlus11) {
2189 BadAllocType = Context.getTypeDeclType(getStdBadAlloc());
2190 assert(StdBadAlloc && "Must have std::bad_alloc declared");
2191 EPI.ExceptionSpec.Type = EST_Dynamic;
2192 EPI.ExceptionSpec.Exceptions = llvm::makeArrayRef(BadAllocType);
2196 getLangOpts().CPlusPlus11 ? EST_BasicNoexcept : EST_DynamicNone;
2199 QualType Params[] = { Param1, Param2 };
2201 QualType FnType = Context.getFunctionType(
2202 Return, llvm::makeArrayRef(Params, NumParams), EPI);
2203 FunctionDecl *Alloc =
2204 FunctionDecl::Create(Context, GlobalCtx, SourceLocation(),
2205 SourceLocation(), Name,
2206 FnType, /*TInfo=*/nullptr, SC_None, false, true);
2207 Alloc->setImplicit();
2209 // Implicit sized deallocation functions always have default visibility.
2210 Alloc->addAttr(VisibilityAttr::CreateImplicit(Context,
2211 VisibilityAttr::Default));
2213 if (AddRestrictAttr)
2215 RestrictAttr::CreateImplicit(Context, RestrictAttr::GNU_malloc));
2217 ParmVarDecl *ParamDecls[2];
2218 for (unsigned I = 0; I != NumParams; ++I) {
2219 ParamDecls[I] = ParmVarDecl::Create(Context, Alloc, SourceLocation(),
2220 SourceLocation(), nullptr,
2221 Params[I], /*TInfo=*/nullptr,
2223 ParamDecls[I]->setImplicit();
2225 Alloc->setParams(llvm::makeArrayRef(ParamDecls, NumParams));
2227 Context.getTranslationUnitDecl()->addDecl(Alloc);
2228 IdResolver.tryAddTopLevelDecl(Alloc, Name);
2231 FunctionDecl *Sema::FindUsualDeallocationFunction(SourceLocation StartLoc,
2232 bool CanProvideSize,
2233 DeclarationName Name) {
2234 DeclareGlobalNewDelete();
2236 LookupResult FoundDelete(*this, Name, StartLoc, LookupOrdinaryName);
2237 LookupQualifiedName(FoundDelete, Context.getTranslationUnitDecl());
2239 // C++ [expr.new]p20:
2240 // [...] Any non-placement deallocation function matches a
2241 // non-placement allocation function. [...]
2242 llvm::SmallVector<FunctionDecl*, 2> Matches;
2243 for (LookupResult::iterator D = FoundDelete.begin(),
2244 DEnd = FoundDelete.end();
2246 if (FunctionDecl *Fn = dyn_cast<FunctionDecl>(*D))
2247 if (isNonPlacementDeallocationFunction(*this, Fn))
2248 Matches.push_back(Fn);
2251 // C++1y [expr.delete]p?:
2252 // If the type is complete and deallocation function lookup finds both a
2253 // usual deallocation function with only a pointer parameter and a usual
2254 // deallocation function with both a pointer parameter and a size
2255 // parameter, then the selected deallocation function shall be the one
2256 // with two parameters. Otherwise, the selected deallocation function
2257 // shall be the function with one parameter.
2258 if (getLangOpts().SizedDeallocation && Matches.size() == 2) {
2259 unsigned NumArgs = CanProvideSize ? 2 : 1;
2260 if (Matches[0]->getNumParams() != NumArgs)
2261 Matches.erase(Matches.begin());
2263 Matches.erase(Matches.begin() + 1);
2264 assert(Matches[0]->getNumParams() == NumArgs &&
2265 "found an unexpected usual deallocation function");
2268 if (getLangOpts().CUDA && getLangOpts().CUDATargetOverloads)
2269 EraseUnwantedCUDAMatches(dyn_cast<FunctionDecl>(CurContext), Matches);
2271 assert(Matches.size() == 1 &&
2272 "unexpectedly have multiple usual deallocation functions");
2273 return Matches.front();
2276 bool Sema::FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD,
2277 DeclarationName Name,
2278 FunctionDecl* &Operator, bool Diagnose) {
2279 LookupResult Found(*this, Name, StartLoc, LookupOrdinaryName);
2280 // Try to find operator delete/operator delete[] in class scope.
2281 LookupQualifiedName(Found, RD);
2283 if (Found.isAmbiguous())
2286 Found.suppressDiagnostics();
2288 SmallVector<DeclAccessPair,4> Matches;
2289 for (LookupResult::iterator F = Found.begin(), FEnd = Found.end();
2291 NamedDecl *ND = (*F)->getUnderlyingDecl();
2293 // Ignore template operator delete members from the check for a usual
2294 // deallocation function.
2295 if (isa<FunctionTemplateDecl>(ND))
2298 if (cast<CXXMethodDecl>(ND)->isUsualDeallocationFunction())
2299 Matches.push_back(F.getPair());
2302 if (getLangOpts().CUDA && getLangOpts().CUDATargetOverloads)
2303 EraseUnwantedCUDAMatches(dyn_cast<FunctionDecl>(CurContext), Matches);
2305 // There's exactly one suitable operator; pick it.
2306 if (Matches.size() == 1) {
2307 Operator = cast<CXXMethodDecl>(Matches[0]->getUnderlyingDecl());
2309 if (Operator->isDeleted()) {
2311 Diag(StartLoc, diag::err_deleted_function_use);
2312 NoteDeletedFunction(Operator);
2317 if (CheckAllocationAccess(StartLoc, SourceRange(), Found.getNamingClass(),
2318 Matches[0], Diagnose) == AR_inaccessible)
2323 // We found multiple suitable operators; complain about the ambiguity.
2324 } else if (!Matches.empty()) {
2326 Diag(StartLoc, diag::err_ambiguous_suitable_delete_member_function_found)
2329 for (SmallVectorImpl<DeclAccessPair>::iterator
2330 F = Matches.begin(), FEnd = Matches.end(); F != FEnd; ++F)
2331 Diag((*F)->getUnderlyingDecl()->getLocation(),
2332 diag::note_member_declared_here) << Name;
2337 // We did find operator delete/operator delete[] declarations, but
2338 // none of them were suitable.
2339 if (!Found.empty()) {
2341 Diag(StartLoc, diag::err_no_suitable_delete_member_function_found)
2344 for (LookupResult::iterator F = Found.begin(), FEnd = Found.end();
2346 Diag((*F)->getUnderlyingDecl()->getLocation(),
2347 diag::note_member_declared_here) << Name;
2357 /// \brief Checks whether delete-expression, and new-expression used for
2358 /// initializing deletee have the same array form.
2359 class MismatchingNewDeleteDetector {
2361 enum MismatchResult {
2362 /// Indicates that there is no mismatch or a mismatch cannot be proven.
2364 /// Indicates that variable is initialized with mismatching form of \a new.
2366 /// Indicates that member is initialized with mismatching form of \a new.
2367 MemberInitMismatches,
2368 /// Indicates that 1 or more constructors' definitions could not been
2369 /// analyzed, and they will be checked again at the end of translation unit.
2373 /// \param EndOfTU True, if this is the final analysis at the end of
2374 /// translation unit. False, if this is the initial analysis at the point
2375 /// delete-expression was encountered.
2376 explicit MismatchingNewDeleteDetector(bool EndOfTU)
2377 : IsArrayForm(false), Field(nullptr), EndOfTU(EndOfTU),
2378 HasUndefinedConstructors(false) {}
2380 /// \brief Checks whether pointee of a delete-expression is initialized with
2381 /// matching form of new-expression.
2383 /// If return value is \c VarInitMismatches or \c MemberInitMismatches at the
2384 /// point where delete-expression is encountered, then a warning will be
2385 /// issued immediately. If return value is \c AnalyzeLater at the point where
2386 /// delete-expression is seen, then member will be analyzed at the end of
2387 /// translation unit. \c AnalyzeLater is returned iff at least one constructor
2388 /// couldn't be analyzed. If at least one constructor initializes the member
2389 /// with matching type of new, the return value is \c NoMismatch.
2390 MismatchResult analyzeDeleteExpr(const CXXDeleteExpr *DE);
2391 /// \brief Analyzes a class member.
2392 /// \param Field Class member to analyze.
2393 /// \param DeleteWasArrayForm Array form-ness of the delete-expression used
2394 /// for deleting the \p Field.
2395 MismatchResult analyzeField(FieldDecl *Field, bool DeleteWasArrayForm);
2396 /// List of mismatching new-expressions used for initialization of the pointee
2397 llvm::SmallVector<const CXXNewExpr *, 4> NewExprs;
2398 /// Indicates whether delete-expression was in array form.
2404 /// \brief Indicates that there is at least one constructor without body.
2405 bool HasUndefinedConstructors;
2406 /// \brief Returns \c CXXNewExpr from given initialization expression.
2407 /// \param E Expression used for initializing pointee in delete-expression.
2408 /// E can be a single-element \c InitListExpr consisting of new-expression.
2409 const CXXNewExpr *getNewExprFromInitListOrExpr(const Expr *E);
2410 /// \brief Returns whether member is initialized with mismatching form of
2411 /// \c new either by the member initializer or in-class initialization.
2413 /// If bodies of all constructors are not visible at the end of translation
2414 /// unit or at least one constructor initializes member with the matching
2415 /// form of \c new, mismatch cannot be proven, and this function will return
2417 MismatchResult analyzeMemberExpr(const MemberExpr *ME);
2418 /// \brief Returns whether variable is initialized with mismatching form of
2421 /// If variable is initialized with matching form of \c new or variable is not
2422 /// initialized with a \c new expression, this function will return true.
2423 /// If variable is initialized with mismatching form of \c new, returns false.
2424 /// \param D Variable to analyze.
2425 bool hasMatchingVarInit(const DeclRefExpr *D);
2426 /// \brief Checks whether the constructor initializes pointee with mismatching
2429 /// Returns true, if member is initialized with matching form of \c new in
2430 /// member initializer list. Returns false, if member is initialized with the
2431 /// matching form of \c new in this constructor's initializer or given
2432 /// constructor isn't defined at the point where delete-expression is seen, or
2433 /// member isn't initialized by the constructor.
2434 bool hasMatchingNewInCtor(const CXXConstructorDecl *CD);
2435 /// \brief Checks whether member is initialized with matching form of
2436 /// \c new in member initializer list.
2437 bool hasMatchingNewInCtorInit(const CXXCtorInitializer *CI);
2438 /// Checks whether member is initialized with mismatching form of \c new by
2439 /// in-class initializer.
2440 MismatchResult analyzeInClassInitializer();
2444 MismatchingNewDeleteDetector::MismatchResult
2445 MismatchingNewDeleteDetector::analyzeDeleteExpr(const CXXDeleteExpr *DE) {
2447 assert(DE && "Expected delete-expression");
2448 IsArrayForm = DE->isArrayForm();
2449 const Expr *E = DE->getArgument()->IgnoreParenImpCasts();
2450 if (const MemberExpr *ME = dyn_cast<const MemberExpr>(E)) {
2451 return analyzeMemberExpr(ME);
2452 } else if (const DeclRefExpr *D = dyn_cast<const DeclRefExpr>(E)) {
2453 if (!hasMatchingVarInit(D))
2454 return VarInitMismatches;
2460 MismatchingNewDeleteDetector::getNewExprFromInitListOrExpr(const Expr *E) {
2461 assert(E != nullptr && "Expected a valid initializer expression");
2462 E = E->IgnoreParenImpCasts();
2463 if (const InitListExpr *ILE = dyn_cast<const InitListExpr>(E)) {
2464 if (ILE->getNumInits() == 1)
2465 E = dyn_cast<const CXXNewExpr>(ILE->getInit(0)->IgnoreParenImpCasts());
2468 return dyn_cast_or_null<const CXXNewExpr>(E);
2471 bool MismatchingNewDeleteDetector::hasMatchingNewInCtorInit(
2472 const CXXCtorInitializer *CI) {
2473 const CXXNewExpr *NE = nullptr;
2474 if (Field == CI->getMember() &&
2475 (NE = getNewExprFromInitListOrExpr(CI->getInit()))) {
2476 if (NE->isArray() == IsArrayForm)
2479 NewExprs.push_back(NE);
2484 bool MismatchingNewDeleteDetector::hasMatchingNewInCtor(
2485 const CXXConstructorDecl *CD) {
2486 if (CD->isImplicit())
2488 const FunctionDecl *Definition = CD;
2489 if (!CD->isThisDeclarationADefinition() && !CD->isDefined(Definition)) {
2490 HasUndefinedConstructors = true;
2493 for (const auto *CI : cast<const CXXConstructorDecl>(Definition)->inits()) {
2494 if (hasMatchingNewInCtorInit(CI))
2500 MismatchingNewDeleteDetector::MismatchResult
2501 MismatchingNewDeleteDetector::analyzeInClassInitializer() {
2502 assert(Field != nullptr && "This should be called only for members");
2503 const Expr *InitExpr = Field->getInClassInitializer();
2505 return EndOfTU ? NoMismatch : AnalyzeLater;
2506 if (const CXXNewExpr *NE = getNewExprFromInitListOrExpr(InitExpr)) {
2507 if (NE->isArray() != IsArrayForm) {
2508 NewExprs.push_back(NE);
2509 return MemberInitMismatches;
2515 MismatchingNewDeleteDetector::MismatchResult
2516 MismatchingNewDeleteDetector::analyzeField(FieldDecl *Field,
2517 bool DeleteWasArrayForm) {
2518 assert(Field != nullptr && "Analysis requires a valid class member.");
2519 this->Field = Field;
2520 IsArrayForm = DeleteWasArrayForm;
2521 const CXXRecordDecl *RD = cast<const CXXRecordDecl>(Field->getParent());
2522 for (const auto *CD : RD->ctors()) {
2523 if (hasMatchingNewInCtor(CD))
2526 if (HasUndefinedConstructors)
2527 return EndOfTU ? NoMismatch : AnalyzeLater;
2528 if (!NewExprs.empty())
2529 return MemberInitMismatches;
2530 return Field->hasInClassInitializer() ? analyzeInClassInitializer()
2534 MismatchingNewDeleteDetector::MismatchResult
2535 MismatchingNewDeleteDetector::analyzeMemberExpr(const MemberExpr *ME) {
2536 assert(ME != nullptr && "Expected a member expression");
2537 if (FieldDecl *F = dyn_cast<FieldDecl>(ME->getMemberDecl()))
2538 return analyzeField(F, IsArrayForm);
2542 bool MismatchingNewDeleteDetector::hasMatchingVarInit(const DeclRefExpr *D) {
2543 const CXXNewExpr *NE = nullptr;
2544 if (const VarDecl *VD = dyn_cast<const VarDecl>(D->getDecl())) {
2545 if (VD->hasInit() && (NE = getNewExprFromInitListOrExpr(VD->getInit())) &&
2546 NE->isArray() != IsArrayForm) {
2547 NewExprs.push_back(NE);
2550 return NewExprs.empty();
2554 DiagnoseMismatchedNewDelete(Sema &SemaRef, SourceLocation DeleteLoc,
2555 const MismatchingNewDeleteDetector &Detector) {
2556 SourceLocation EndOfDelete = SemaRef.getLocForEndOfToken(DeleteLoc);
2558 if (!Detector.IsArrayForm)
2559 H = FixItHint::CreateInsertion(EndOfDelete, "[]");
2561 SourceLocation RSquare = Lexer::findLocationAfterToken(
2562 DeleteLoc, tok::l_square, SemaRef.getSourceManager(),
2563 SemaRef.getLangOpts(), true);
2564 if (RSquare.isValid())
2565 H = FixItHint::CreateRemoval(SourceRange(EndOfDelete, RSquare));
2567 SemaRef.Diag(DeleteLoc, diag::warn_mismatched_delete_new)
2568 << Detector.IsArrayForm << H;
2570 for (const auto *NE : Detector.NewExprs)
2571 SemaRef.Diag(NE->getExprLoc(), diag::note_allocated_here)
2572 << Detector.IsArrayForm;
2575 void Sema::AnalyzeDeleteExprMismatch(const CXXDeleteExpr *DE) {
2576 if (Diags.isIgnored(diag::warn_mismatched_delete_new, SourceLocation()))
2578 MismatchingNewDeleteDetector Detector(/*EndOfTU=*/false);
2579 switch (Detector.analyzeDeleteExpr(DE)) {
2580 case MismatchingNewDeleteDetector::VarInitMismatches:
2581 case MismatchingNewDeleteDetector::MemberInitMismatches: {
2582 DiagnoseMismatchedNewDelete(*this, DE->getLocStart(), Detector);
2585 case MismatchingNewDeleteDetector::AnalyzeLater: {
2586 DeleteExprs[Detector.Field].push_back(
2587 std::make_pair(DE->getLocStart(), DE->isArrayForm()));
2590 case MismatchingNewDeleteDetector::NoMismatch:
2595 void Sema::AnalyzeDeleteExprMismatch(FieldDecl *Field, SourceLocation DeleteLoc,
2596 bool DeleteWasArrayForm) {
2597 MismatchingNewDeleteDetector Detector(/*EndOfTU=*/true);
2598 switch (Detector.analyzeField(Field, DeleteWasArrayForm)) {
2599 case MismatchingNewDeleteDetector::VarInitMismatches:
2600 llvm_unreachable("This analysis should have been done for class members.");
2601 case MismatchingNewDeleteDetector::AnalyzeLater:
2602 llvm_unreachable("Analysis cannot be postponed any point beyond end of "
2603 "translation unit.");
2604 case MismatchingNewDeleteDetector::MemberInitMismatches:
2605 DiagnoseMismatchedNewDelete(*this, DeleteLoc, Detector);
2607 case MismatchingNewDeleteDetector::NoMismatch:
2612 /// ActOnCXXDelete - Parsed a C++ 'delete' expression (C++ 5.3.5), as in:
2613 /// @code ::delete ptr; @endcode
2615 /// @code delete [] ptr; @endcode
2617 Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal,
2618 bool ArrayForm, Expr *ExE) {
2619 // C++ [expr.delete]p1:
2620 // The operand shall have a pointer type, or a class type having a single
2621 // non-explicit conversion function to a pointer type. The result has type
2624 // DR599 amends "pointer type" to "pointer to object type" in both cases.
2626 ExprResult Ex = ExE;
2627 FunctionDecl *OperatorDelete = nullptr;
2628 bool ArrayFormAsWritten = ArrayForm;
2629 bool UsualArrayDeleteWantsSize = false;
2631 if (!Ex.get()->isTypeDependent()) {
2632 // Perform lvalue-to-rvalue cast, if needed.
2633 Ex = DefaultLvalueConversion(Ex.get());
2637 QualType Type = Ex.get()->getType();
2639 class DeleteConverter : public ContextualImplicitConverter {
2641 DeleteConverter() : ContextualImplicitConverter(false, true) {}
2643 bool match(QualType ConvType) override {
2644 // FIXME: If we have an operator T* and an operator void*, we must pick
2646 if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>())
2647 if (ConvPtrType->getPointeeType()->isIncompleteOrObjectType())
2652 SemaDiagnosticBuilder diagnoseNoMatch(Sema &S, SourceLocation Loc,
2653 QualType T) override {
2654 return S.Diag(Loc, diag::err_delete_operand) << T;
2657 SemaDiagnosticBuilder diagnoseIncomplete(Sema &S, SourceLocation Loc,
2658 QualType T) override {
2659 return S.Diag(Loc, diag::err_delete_incomplete_class_type) << T;
2662 SemaDiagnosticBuilder diagnoseExplicitConv(Sema &S, SourceLocation Loc,
2664 QualType ConvTy) override {
2665 return S.Diag(Loc, diag::err_delete_explicit_conversion) << T << ConvTy;
2668 SemaDiagnosticBuilder noteExplicitConv(Sema &S, CXXConversionDecl *Conv,
2669 QualType ConvTy) override {
2670 return S.Diag(Conv->getLocation(), diag::note_delete_conversion)
2674 SemaDiagnosticBuilder diagnoseAmbiguous(Sema &S, SourceLocation Loc,
2675 QualType T) override {
2676 return S.Diag(Loc, diag::err_ambiguous_delete_operand) << T;
2679 SemaDiagnosticBuilder noteAmbiguous(Sema &S, CXXConversionDecl *Conv,
2680 QualType ConvTy) override {
2681 return S.Diag(Conv->getLocation(), diag::note_delete_conversion)
2685 SemaDiagnosticBuilder diagnoseConversion(Sema &S, SourceLocation Loc,
2687 QualType ConvTy) override {
2688 llvm_unreachable("conversion functions are permitted");
2692 Ex = PerformContextualImplicitConversion(StartLoc, Ex.get(), Converter);
2695 Type = Ex.get()->getType();
2696 if (!Converter.match(Type))
2697 // FIXME: PerformContextualImplicitConversion should return ExprError
2698 // itself in this case.
2701 QualType Pointee = Type->getAs<PointerType>()->getPointeeType();
2702 QualType PointeeElem = Context.getBaseElementType(Pointee);
2704 if (unsigned AddressSpace = Pointee.getAddressSpace())
2705 return Diag(Ex.get()->getLocStart(),
2706 diag::err_address_space_qualified_delete)
2707 << Pointee.getUnqualifiedType() << AddressSpace;
2709 CXXRecordDecl *PointeeRD = nullptr;
2710 if (Pointee->isVoidType() && !isSFINAEContext()) {
2711 // The C++ standard bans deleting a pointer to a non-object type, which
2712 // effectively bans deletion of "void*". However, most compilers support
2713 // this, so we treat it as a warning unless we're in a SFINAE context.
2714 Diag(StartLoc, diag::ext_delete_void_ptr_operand)
2715 << Type << Ex.get()->getSourceRange();
2716 } else if (Pointee->isFunctionType() || Pointee->isVoidType()) {
2717 return ExprError(Diag(StartLoc, diag::err_delete_operand)
2718 << Type << Ex.get()->getSourceRange());
2719 } else if (!Pointee->isDependentType()) {
2720 // FIXME: This can result in errors if the definition was imported from a
2721 // module but is hidden.
2722 if (!RequireCompleteType(StartLoc, Pointee,
2723 diag::warn_delete_incomplete, Ex.get())) {
2724 if (const RecordType *RT = PointeeElem->getAs<RecordType>())
2725 PointeeRD = cast<CXXRecordDecl>(RT->getDecl());
2729 if (Pointee->isArrayType() && !ArrayForm) {
2730 Diag(StartLoc, diag::warn_delete_array_type)
2731 << Type << Ex.get()->getSourceRange()
2732 << FixItHint::CreateInsertion(getLocForEndOfToken(StartLoc), "[]");
2736 DeclarationName DeleteName = Context.DeclarationNames.getCXXOperatorName(
2737 ArrayForm ? OO_Array_Delete : OO_Delete);
2741 FindDeallocationFunction(StartLoc, PointeeRD, DeleteName,
2745 // If we're allocating an array of records, check whether the
2746 // usual operator delete[] has a size_t parameter.
2748 // If the user specifically asked to use the global allocator,
2749 // we'll need to do the lookup into the class.
2751 UsualArrayDeleteWantsSize =
2752 doesUsualArrayDeleteWantSize(*this, StartLoc, PointeeElem);
2754 // Otherwise, the usual operator delete[] should be the
2755 // function we just found.
2756 else if (OperatorDelete && isa<CXXMethodDecl>(OperatorDelete))
2757 UsualArrayDeleteWantsSize = (OperatorDelete->getNumParams() == 2);
2760 if (!PointeeRD->hasIrrelevantDestructor())
2761 if (CXXDestructorDecl *Dtor = LookupDestructor(PointeeRD)) {
2762 MarkFunctionReferenced(StartLoc,
2763 const_cast<CXXDestructorDecl*>(Dtor));
2764 if (DiagnoseUseOfDecl(Dtor, StartLoc))
2768 // C++ [expr.delete]p3:
2769 // In the first alternative (delete object), if the static type of the
2770 // object to be deleted is different from its dynamic type, the static
2771 // type shall be a base class of the dynamic type of the object to be
2772 // deleted and the static type shall have a virtual destructor or the
2773 // behavior is undefined.
2775 // Note: a final class cannot be derived from, no issue there
2776 if (PointeeRD->isPolymorphic() && !PointeeRD->hasAttr<FinalAttr>()) {
2777 CXXDestructorDecl *dtor = PointeeRD->getDestructor();
2778 if (dtor && !dtor->isVirtual()) {
2779 if (PointeeRD->isAbstract()) {
2780 // If the class is abstract, we warn by default, because we're
2781 // sure the code has undefined behavior.
2782 Diag(StartLoc, diag::warn_delete_abstract_non_virtual_dtor)
2784 } else if (!ArrayForm) {
2785 // Otherwise, if this is not an array delete, it's a bit suspect,
2786 // but not necessarily wrong.
2787 Diag(StartLoc, diag::warn_delete_non_virtual_dtor) << PointeeElem;
2794 if (!OperatorDelete)
2795 // Look for a global declaration.
2796 OperatorDelete = FindUsualDeallocationFunction(
2797 StartLoc, isCompleteType(StartLoc, Pointee) &&
2798 (!ArrayForm || UsualArrayDeleteWantsSize ||
2799 Pointee.isDestructedType()),
2802 MarkFunctionReferenced(StartLoc, OperatorDelete);
2804 // Check access and ambiguity of operator delete and destructor.
2806 if (CXXDestructorDecl *Dtor = LookupDestructor(PointeeRD)) {
2807 CheckDestructorAccess(Ex.get()->getExprLoc(), Dtor,
2808 PDiag(diag::err_access_dtor) << PointeeElem);
2813 CXXDeleteExpr *Result = new (Context) CXXDeleteExpr(
2814 Context.VoidTy, UseGlobal, ArrayForm, ArrayFormAsWritten,
2815 UsualArrayDeleteWantsSize, OperatorDelete, Ex.get(), StartLoc);
2816 AnalyzeDeleteExprMismatch(Result);
2820 /// \brief Check the use of the given variable as a C++ condition in an if,
2821 /// while, do-while, or switch statement.
2822 ExprResult Sema::CheckConditionVariable(VarDecl *ConditionVar,
2823 SourceLocation StmtLoc,
2824 bool ConvertToBoolean) {
2825 if (ConditionVar->isInvalidDecl())
2828 QualType T = ConditionVar->getType();
2830 // C++ [stmt.select]p2:
2831 // The declarator shall not specify a function or an array.
2832 if (T->isFunctionType())
2833 return ExprError(Diag(ConditionVar->getLocation(),
2834 diag::err_invalid_use_of_function_type)
2835 << ConditionVar->getSourceRange());
2836 else if (T->isArrayType())
2837 return ExprError(Diag(ConditionVar->getLocation(),
2838 diag::err_invalid_use_of_array_type)
2839 << ConditionVar->getSourceRange());
2841 ExprResult Condition = DeclRefExpr::Create(
2842 Context, NestedNameSpecifierLoc(), SourceLocation(), ConditionVar,
2843 /*enclosing*/ false, ConditionVar->getLocation(),
2844 ConditionVar->getType().getNonReferenceType(), VK_LValue);
2846 MarkDeclRefReferenced(cast<DeclRefExpr>(Condition.get()));
2848 if (ConvertToBoolean) {
2849 Condition = CheckBooleanCondition(Condition.get(), StmtLoc);
2850 if (Condition.isInvalid())
2857 /// CheckCXXBooleanCondition - Returns true if a conversion to bool is invalid.
2858 ExprResult Sema::CheckCXXBooleanCondition(Expr *CondExpr) {
2860 // The value of a condition that is an initialized declaration in a statement
2861 // other than a switch statement is the value of the declared variable
2862 // implicitly converted to type bool. If that conversion is ill-formed, the
2863 // program is ill-formed.
2864 // The value of a condition that is an expression is the value of the
2865 // expression, implicitly converted to bool.
2867 return PerformContextuallyConvertToBool(CondExpr);
2870 /// Helper function to determine whether this is the (deprecated) C++
2871 /// conversion from a string literal to a pointer to non-const char or
2872 /// non-const wchar_t (for narrow and wide string literals,
2875 Sema::IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType) {
2876 // Look inside the implicit cast, if it exists.
2877 if (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(From))
2878 From = Cast->getSubExpr();
2880 // A string literal (2.13.4) that is not a wide string literal can
2881 // be converted to an rvalue of type "pointer to char"; a wide
2882 // string literal can be converted to an rvalue of type "pointer
2883 // to wchar_t" (C++ 4.2p2).
2884 if (StringLiteral *StrLit = dyn_cast<StringLiteral>(From->IgnoreParens()))
2885 if (const PointerType *ToPtrType = ToType->getAs<PointerType>())
2886 if (const BuiltinType *ToPointeeType
2887 = ToPtrType->getPointeeType()->getAs<BuiltinType>()) {
2888 // This conversion is considered only when there is an
2889 // explicit appropriate pointer target type (C++ 4.2p2).
2890 if (!ToPtrType->getPointeeType().hasQualifiers()) {
2891 switch (StrLit->getKind()) {
2892 case StringLiteral::UTF8:
2893 case StringLiteral::UTF16:
2894 case StringLiteral::UTF32:
2895 // We don't allow UTF literals to be implicitly converted
2897 case StringLiteral::Ascii:
2898 return (ToPointeeType->getKind() == BuiltinType::Char_U ||
2899 ToPointeeType->getKind() == BuiltinType::Char_S);
2900 case StringLiteral::Wide:
2901 return ToPointeeType->isWideCharType();
2909 static ExprResult BuildCXXCastArgument(Sema &S,
2910 SourceLocation CastLoc,
2913 CXXMethodDecl *Method,
2914 DeclAccessPair FoundDecl,
2915 bool HadMultipleCandidates,
2918 default: llvm_unreachable("Unhandled cast kind!");
2919 case CK_ConstructorConversion: {
2920 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Method);
2921 SmallVector<Expr*, 8> ConstructorArgs;
2923 if (S.RequireNonAbstractType(CastLoc, Ty,
2924 diag::err_allocation_of_abstract_type))
2927 if (S.CompleteConstructorCall(Constructor, From, CastLoc, ConstructorArgs))
2930 S.CheckConstructorAccess(CastLoc, Constructor,
2931 InitializedEntity::InitializeTemporary(Ty),
2932 Constructor->getAccess());
2933 if (S.DiagnoseUseOfDecl(Method, CastLoc))
2936 ExprResult Result = S.BuildCXXConstructExpr(
2937 CastLoc, Ty, cast<CXXConstructorDecl>(Method),
2938 ConstructorArgs, HadMultipleCandidates,
2939 /*ListInit*/ false, /*StdInitListInit*/ false, /*ZeroInit*/ false,
2940 CXXConstructExpr::CK_Complete, SourceRange());
2941 if (Result.isInvalid())
2944 return S.MaybeBindToTemporary(Result.getAs<Expr>());
2947 case CK_UserDefinedConversion: {
2948 assert(!From->getType()->isPointerType() && "Arg can't have pointer type!");
2950 S.CheckMemberOperatorAccess(CastLoc, From, /*arg*/ nullptr, FoundDecl);
2951 if (S.DiagnoseUseOfDecl(Method, CastLoc))
2954 // Create an implicit call expr that calls it.
2955 CXXConversionDecl *Conv = cast<CXXConversionDecl>(Method);
2956 ExprResult Result = S.BuildCXXMemberCallExpr(From, FoundDecl, Conv,
2957 HadMultipleCandidates);
2958 if (Result.isInvalid())
2960 // Record usage of conversion in an implicit cast.
2961 Result = ImplicitCastExpr::Create(S.Context, Result.get()->getType(),
2962 CK_UserDefinedConversion, Result.get(),
2963 nullptr, Result.get()->getValueKind());
2965 return S.MaybeBindToTemporary(Result.get());
2970 /// PerformImplicitConversion - Perform an implicit conversion of the
2971 /// expression From to the type ToType using the pre-computed implicit
2972 /// conversion sequence ICS. Returns the converted
2973 /// expression. Action is the kind of conversion we're performing,
2974 /// used in the error message.
2976 Sema::PerformImplicitConversion(Expr *From, QualType ToType,
2977 const ImplicitConversionSequence &ICS,
2978 AssignmentAction Action,
2979 CheckedConversionKind CCK) {
2980 switch (ICS.getKind()) {
2981 case ImplicitConversionSequence::StandardConversion: {
2982 ExprResult Res = PerformImplicitConversion(From, ToType, ICS.Standard,
2984 if (Res.isInvalid())
2990 case ImplicitConversionSequence::UserDefinedConversion: {
2992 FunctionDecl *FD = ICS.UserDefined.ConversionFunction;
2994 QualType BeforeToType;
2995 assert(FD && "no conversion function for user-defined conversion seq");
2996 if (const CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(FD)) {
2997 CastKind = CK_UserDefinedConversion;
2999 // If the user-defined conversion is specified by a conversion function,
3000 // the initial standard conversion sequence converts the source type to
3001 // the implicit object parameter of the conversion function.
3002 BeforeToType = Context.getTagDeclType(Conv->getParent());
3004 const CXXConstructorDecl *Ctor = cast<CXXConstructorDecl>(FD);
3005 CastKind = CK_ConstructorConversion;
3006 // Do no conversion if dealing with ... for the first conversion.
3007 if (!ICS.UserDefined.EllipsisConversion) {
3008 // If the user-defined conversion is specified by a constructor, the
3009 // initial standard conversion sequence converts the source type to
3010 // the type required by the argument of the constructor
3011 BeforeToType = Ctor->getParamDecl(0)->getType().getNonReferenceType();
3014 // Watch out for ellipsis conversion.
3015 if (!ICS.UserDefined.EllipsisConversion) {
3017 PerformImplicitConversion(From, BeforeToType,
3018 ICS.UserDefined.Before, AA_Converting,
3020 if (Res.isInvalid())
3026 = BuildCXXCastArgument(*this,
3027 From->getLocStart(),
3028 ToType.getNonReferenceType(),
3029 CastKind, cast<CXXMethodDecl>(FD),
3030 ICS.UserDefined.FoundConversionFunction,
3031 ICS.UserDefined.HadMultipleCandidates,
3034 if (CastArg.isInvalid())
3037 From = CastArg.get();
3039 return PerformImplicitConversion(From, ToType, ICS.UserDefined.After,
3040 AA_Converting, CCK);
3043 case ImplicitConversionSequence::AmbiguousConversion:
3044 ICS.DiagnoseAmbiguousConversion(*this, From->getExprLoc(),
3045 PDiag(diag::err_typecheck_ambiguous_condition)
3046 << From->getSourceRange());
3049 case ImplicitConversionSequence::EllipsisConversion:
3050 llvm_unreachable("Cannot perform an ellipsis conversion");
3052 case ImplicitConversionSequence::BadConversion:
3056 // Everything went well.
3060 /// PerformImplicitConversion - Perform an implicit conversion of the
3061 /// expression From to the type ToType by following the standard
3062 /// conversion sequence SCS. Returns the converted
3063 /// expression. Flavor is the context in which we're performing this
3064 /// conversion, for use in error messages.
3066 Sema::PerformImplicitConversion(Expr *From, QualType ToType,
3067 const StandardConversionSequence& SCS,
3068 AssignmentAction Action,
3069 CheckedConversionKind CCK) {
3070 bool CStyle = (CCK == CCK_CStyleCast || CCK == CCK_FunctionalCast);
3072 // Overall FIXME: we are recomputing too many types here and doing far too
3073 // much extra work. What this means is that we need to keep track of more
3074 // information that is computed when we try the implicit conversion initially,
3075 // so that we don't need to recompute anything here.
3076 QualType FromType = From->getType();
3078 if (SCS.CopyConstructor) {
3079 // FIXME: When can ToType be a reference type?
3080 assert(!ToType->isReferenceType());
3081 if (SCS.Second == ICK_Derived_To_Base) {
3082 SmallVector<Expr*, 8> ConstructorArgs;
3083 if (CompleteConstructorCall(cast<CXXConstructorDecl>(SCS.CopyConstructor),
3084 From, /*FIXME:ConstructLoc*/SourceLocation(),
3087 return BuildCXXConstructExpr(
3088 /*FIXME:ConstructLoc*/ SourceLocation(), ToType, SCS.CopyConstructor,
3089 ConstructorArgs, /*HadMultipleCandidates*/ false,
3090 /*ListInit*/ false, /*StdInitListInit*/ false, /*ZeroInit*/ false,
3091 CXXConstructExpr::CK_Complete, SourceRange());
3093 return BuildCXXConstructExpr(
3094 /*FIXME:ConstructLoc*/ SourceLocation(), ToType, SCS.CopyConstructor,
3095 From, /*HadMultipleCandidates*/ false,
3096 /*ListInit*/ false, /*StdInitListInit*/ false, /*ZeroInit*/ false,
3097 CXXConstructExpr::CK_Complete, SourceRange());
3100 // Resolve overloaded function references.
3101 if (Context.hasSameType(FromType, Context.OverloadTy)) {
3102 DeclAccessPair Found;
3103 FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(From, ToType,
3108 if (DiagnoseUseOfDecl(Fn, From->getLocStart()))
3111 From = FixOverloadedFunctionReference(From, Found, Fn);
3112 FromType = From->getType();
3115 // If we're converting to an atomic type, first convert to the corresponding
3117 QualType ToAtomicType;
3118 if (const AtomicType *ToAtomic = ToType->getAs<AtomicType>()) {
3119 ToAtomicType = ToType;
3120 ToType = ToAtomic->getValueType();
3123 QualType InitialFromType = FromType;
3124 // Perform the first implicit conversion.
3125 switch (SCS.First) {
3127 if (const AtomicType *FromAtomic = FromType->getAs<AtomicType>()) {
3128 FromType = FromAtomic->getValueType().getUnqualifiedType();
3129 From = ImplicitCastExpr::Create(Context, FromType, CK_AtomicToNonAtomic,
3130 From, /*BasePath=*/nullptr, VK_RValue);
3134 case ICK_Lvalue_To_Rvalue: {
3135 assert(From->getObjectKind() != OK_ObjCProperty);
3136 ExprResult FromRes = DefaultLvalueConversion(From);
3137 assert(!FromRes.isInvalid() && "Can't perform deduced conversion?!");
3138 From = FromRes.get();
3139 FromType = From->getType();
3143 case ICK_Array_To_Pointer:
3144 FromType = Context.getArrayDecayedType(FromType);
3145 From = ImpCastExprToType(From, FromType, CK_ArrayToPointerDecay,
3146 VK_RValue, /*BasePath=*/nullptr, CCK).get();
3149 case ICK_Function_To_Pointer:
3150 FromType = Context.getPointerType(FromType);
3151 From = ImpCastExprToType(From, FromType, CK_FunctionToPointerDecay,
3152 VK_RValue, /*BasePath=*/nullptr, CCK).get();
3156 llvm_unreachable("Improper first standard conversion");
3159 // Perform the second implicit conversion
3160 switch (SCS.Second) {
3162 // C++ [except.spec]p5:
3163 // [For] assignment to and initialization of pointers to functions,
3164 // pointers to member functions, and references to functions: the
3165 // target entity shall allow at least the exceptions allowed by the
3166 // source value in the assignment or initialization.
3169 case AA_Initializing:
3170 // Note, function argument passing and returning are initialization.
3174 case AA_Passing_CFAudited:
3175 if (CheckExceptionSpecCompatibility(From, ToType))
3181 // Casts and implicit conversions are not initialization, so are not
3182 // checked for exception specification mismatches.
3185 // Nothing else to do.
3188 case ICK_NoReturn_Adjustment:
3189 // If both sides are functions (or pointers/references to them), there could
3190 // be incompatible exception declarations.
3191 if (CheckExceptionSpecCompatibility(From, ToType))
3194 From = ImpCastExprToType(From, ToType, CK_NoOp,
3195 VK_RValue, /*BasePath=*/nullptr, CCK).get();
3198 case ICK_Integral_Promotion:
3199 case ICK_Integral_Conversion:
3200 if (ToType->isBooleanType()) {
3201 assert(FromType->castAs<EnumType>()->getDecl()->isFixed() &&
3202 SCS.Second == ICK_Integral_Promotion &&
3203 "only enums with fixed underlying type can promote to bool");
3204 From = ImpCastExprToType(From, ToType, CK_IntegralToBoolean,
3205 VK_RValue, /*BasePath=*/nullptr, CCK).get();
3207 From = ImpCastExprToType(From, ToType, CK_IntegralCast,
3208 VK_RValue, /*BasePath=*/nullptr, CCK).get();
3212 case ICK_Floating_Promotion:
3213 case ICK_Floating_Conversion:
3214 From = ImpCastExprToType(From, ToType, CK_FloatingCast,
3215 VK_RValue, /*BasePath=*/nullptr, CCK).get();
3218 case ICK_Complex_Promotion:
3219 case ICK_Complex_Conversion: {
3220 QualType FromEl = From->getType()->getAs<ComplexType>()->getElementType();
3221 QualType ToEl = ToType->getAs<ComplexType>()->getElementType();
3223 if (FromEl->isRealFloatingType()) {
3224 if (ToEl->isRealFloatingType())
3225 CK = CK_FloatingComplexCast;
3227 CK = CK_FloatingComplexToIntegralComplex;
3228 } else if (ToEl->isRealFloatingType()) {
3229 CK = CK_IntegralComplexToFloatingComplex;
3231 CK = CK_IntegralComplexCast;
3233 From = ImpCastExprToType(From, ToType, CK,
3234 VK_RValue, /*BasePath=*/nullptr, CCK).get();
3238 case ICK_Floating_Integral:
3239 if (ToType->isRealFloatingType())
3240 From = ImpCastExprToType(From, ToType, CK_IntegralToFloating,
3241 VK_RValue, /*BasePath=*/nullptr, CCK).get();
3243 From = ImpCastExprToType(From, ToType, CK_FloatingToIntegral,
3244 VK_RValue, /*BasePath=*/nullptr, CCK).get();
3247 case ICK_Compatible_Conversion:
3248 From = ImpCastExprToType(From, ToType, CK_NoOp,
3249 VK_RValue, /*BasePath=*/nullptr, CCK).get();
3252 case ICK_Writeback_Conversion:
3253 case ICK_Pointer_Conversion: {
3254 if (SCS.IncompatibleObjC && Action != AA_Casting) {
3255 // Diagnose incompatible Objective-C conversions
3256 if (Action == AA_Initializing || Action == AA_Assigning)
3257 Diag(From->getLocStart(),
3258 diag::ext_typecheck_convert_incompatible_pointer)
3259 << ToType << From->getType() << Action
3260 << From->getSourceRange() << 0;
3262 Diag(From->getLocStart(),
3263 diag::ext_typecheck_convert_incompatible_pointer)
3264 << From->getType() << ToType << Action
3265 << From->getSourceRange() << 0;
3267 if (From->getType()->isObjCObjectPointerType() &&
3268 ToType->isObjCObjectPointerType())
3269 EmitRelatedResultTypeNote(From);
3271 else if (getLangOpts().ObjCAutoRefCount &&
3272 !CheckObjCARCUnavailableWeakConversion(ToType,
3274 if (Action == AA_Initializing)
3275 Diag(From->getLocStart(),
3276 diag::err_arc_weak_unavailable_assign);
3278 Diag(From->getLocStart(),
3279 diag::err_arc_convesion_of_weak_unavailable)
3280 << (Action == AA_Casting) << From->getType() << ToType
3281 << From->getSourceRange();
3284 CastKind Kind = CK_Invalid;
3285 CXXCastPath BasePath;
3286 if (CheckPointerConversion(From, ToType, Kind, BasePath, CStyle))
3289 // Make sure we extend blocks if necessary.
3290 // FIXME: doing this here is really ugly.
3291 if (Kind == CK_BlockPointerToObjCPointerCast) {
3292 ExprResult E = From;
3293 (void) PrepareCastToObjCObjectPointer(E);
3296 if (getLangOpts().ObjCAutoRefCount)
3297 CheckObjCARCConversion(SourceRange(), ToType, From, CCK);
3298 From = ImpCastExprToType(From, ToType, Kind, VK_RValue, &BasePath, CCK)
3303 case ICK_Pointer_Member: {
3304 CastKind Kind = CK_Invalid;
3305 CXXCastPath BasePath;
3306 if (CheckMemberPointerConversion(From, ToType, Kind, BasePath, CStyle))
3308 if (CheckExceptionSpecCompatibility(From, ToType))
3311 // We may not have been able to figure out what this member pointer resolved
3312 // to up until this exact point. Attempt to lock-in it's inheritance model.
3313 if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
3314 (void)isCompleteType(From->getExprLoc(), From->getType());
3315 (void)isCompleteType(From->getExprLoc(), ToType);
3318 From = ImpCastExprToType(From, ToType, Kind, VK_RValue, &BasePath, CCK)
3323 case ICK_Boolean_Conversion:
3324 // Perform half-to-boolean conversion via float.
3325 if (From->getType()->isHalfType()) {
3326 From = ImpCastExprToType(From, Context.FloatTy, CK_FloatingCast).get();
3327 FromType = Context.FloatTy;
3330 From = ImpCastExprToType(From, Context.BoolTy,
3331 ScalarTypeToBooleanCastKind(FromType),
3332 VK_RValue, /*BasePath=*/nullptr, CCK).get();
3335 case ICK_Derived_To_Base: {
3336 CXXCastPath BasePath;
3337 if (CheckDerivedToBaseConversion(From->getType(),
3338 ToType.getNonReferenceType(),
3339 From->getLocStart(),
3340 From->getSourceRange(),
3345 From = ImpCastExprToType(From, ToType.getNonReferenceType(),
3346 CK_DerivedToBase, From->getValueKind(),
3347 &BasePath, CCK).get();
3351 case ICK_Vector_Conversion:
3352 From = ImpCastExprToType(From, ToType, CK_BitCast,
3353 VK_RValue, /*BasePath=*/nullptr, CCK).get();
3356 case ICK_Vector_Splat: {
3357 // Vector splat from any arithmetic type to a vector.
3358 Expr *Elem = prepareVectorSplat(ToType, From).get();
3359 From = ImpCastExprToType(Elem, ToType, CK_VectorSplat, VK_RValue,
3360 /*BasePath=*/nullptr, CCK).get();
3364 case ICK_Complex_Real:
3365 // Case 1. x -> _Complex y
3366 if (const ComplexType *ToComplex = ToType->getAs<ComplexType>()) {
3367 QualType ElType = ToComplex->getElementType();
3368 bool isFloatingComplex = ElType->isRealFloatingType();
3371 if (Context.hasSameUnqualifiedType(ElType, From->getType())) {
3373 } else if (From->getType()->isRealFloatingType()) {
3374 From = ImpCastExprToType(From, ElType,
3375 isFloatingComplex ? CK_FloatingCast : CK_FloatingToIntegral).get();
3377 assert(From->getType()->isIntegerType());
3378 From = ImpCastExprToType(From, ElType,
3379 isFloatingComplex ? CK_IntegralToFloating : CK_IntegralCast).get();
3382 From = ImpCastExprToType(From, ToType,
3383 isFloatingComplex ? CK_FloatingRealToComplex
3384 : CK_IntegralRealToComplex).get();
3386 // Case 2. _Complex x -> y
3388 const ComplexType *FromComplex = From->getType()->getAs<ComplexType>();
3389 assert(FromComplex);
3391 QualType ElType = FromComplex->getElementType();
3392 bool isFloatingComplex = ElType->isRealFloatingType();
3395 From = ImpCastExprToType(From, ElType,
3396 isFloatingComplex ? CK_FloatingComplexToReal
3397 : CK_IntegralComplexToReal,
3398 VK_RValue, /*BasePath=*/nullptr, CCK).get();
3401 if (Context.hasSameUnqualifiedType(ElType, ToType)) {
3403 } else if (ToType->isRealFloatingType()) {
3404 From = ImpCastExprToType(From, ToType,
3405 isFloatingComplex ? CK_FloatingCast : CK_IntegralToFloating,
3406 VK_RValue, /*BasePath=*/nullptr, CCK).get();
3408 assert(ToType->isIntegerType());
3409 From = ImpCastExprToType(From, ToType,
3410 isFloatingComplex ? CK_FloatingToIntegral : CK_IntegralCast,
3411 VK_RValue, /*BasePath=*/nullptr, CCK).get();
3416 case ICK_Block_Pointer_Conversion: {
3417 From = ImpCastExprToType(From, ToType.getUnqualifiedType(), CK_BitCast,
3418 VK_RValue, /*BasePath=*/nullptr, CCK).get();
3422 case ICK_TransparentUnionConversion: {
3423 ExprResult FromRes = From;
3424 Sema::AssignConvertType ConvTy =
3425 CheckTransparentUnionArgumentConstraints(ToType, FromRes);
3426 if (FromRes.isInvalid())
3428 From = FromRes.get();
3429 assert ((ConvTy == Sema::Compatible) &&
3430 "Improper transparent union conversion");
3435 case ICK_Zero_Event_Conversion:
3436 From = ImpCastExprToType(From, ToType,
3438 From->getValueKind()).get();
3441 case ICK_Lvalue_To_Rvalue:
3442 case ICK_Array_To_Pointer:
3443 case ICK_Function_To_Pointer:
3444 case ICK_Qualification:
3445 case ICK_Num_Conversion_Kinds:
3446 case ICK_C_Only_Conversion:
3447 llvm_unreachable("Improper second standard conversion");
3450 switch (SCS.Third) {
3455 case ICK_Qualification: {
3456 // The qualification keeps the category of the inner expression, unless the
3457 // target type isn't a reference.
3458 ExprValueKind VK = ToType->isReferenceType() ?
3459 From->getValueKind() : VK_RValue;
3460 From = ImpCastExprToType(From, ToType.getNonLValueExprType(Context),
3461 CK_NoOp, VK, /*BasePath=*/nullptr, CCK).get();
3463 if (SCS.DeprecatedStringLiteralToCharPtr &&
3464 !getLangOpts().WritableStrings) {
3465 Diag(From->getLocStart(), getLangOpts().CPlusPlus11
3466 ? diag::ext_deprecated_string_literal_conversion
3467 : diag::warn_deprecated_string_literal_conversion)
3468 << ToType.getNonReferenceType();
3475 llvm_unreachable("Improper third standard conversion");
3478 // If this conversion sequence involved a scalar -> atomic conversion, perform
3479 // that conversion now.
3480 if (!ToAtomicType.isNull()) {
3481 assert(Context.hasSameType(
3482 ToAtomicType->castAs<AtomicType>()->getValueType(), From->getType()));
3483 From = ImpCastExprToType(From, ToAtomicType, CK_NonAtomicToAtomic,
3484 VK_RValue, nullptr, CCK).get();
3487 // If this conversion sequence succeeded and involved implicitly converting a
3488 // _Nullable type to a _Nonnull one, complain.
3489 if (CCK == CCK_ImplicitConversion)
3490 diagnoseNullableToNonnullConversion(ToType, InitialFromType,
3491 From->getLocStart());
3496 /// \brief Check the completeness of a type in a unary type trait.
3498 /// If the particular type trait requires a complete type, tries to complete
3499 /// it. If completing the type fails, a diagnostic is emitted and false
3500 /// returned. If completing the type succeeds or no completion was required,
3502 static bool CheckUnaryTypeTraitTypeCompleteness(Sema &S, TypeTrait UTT,
3505 // C++0x [meta.unary.prop]p3:
3506 // For all of the class templates X declared in this Clause, instantiating
3507 // that template with a template argument that is a class template
3508 // specialization may result in the implicit instantiation of the template
3509 // argument if and only if the semantics of X require that the argument
3510 // must be a complete type.
3511 // We apply this rule to all the type trait expressions used to implement
3512 // these class templates. We also try to follow any GCC documented behavior
3513 // in these expressions to ensure portability of standard libraries.
3515 default: llvm_unreachable("not a UTT");
3516 // is_complete_type somewhat obviously cannot require a complete type.
3517 case UTT_IsCompleteType:
3520 // These traits are modeled on the type predicates in C++0x
3521 // [meta.unary.cat] and [meta.unary.comp]. They are not specified as
3522 // requiring a complete type, as whether or not they return true cannot be
3523 // impacted by the completeness of the type.
3525 case UTT_IsIntegral:
3526 case UTT_IsFloatingPoint:
3529 case UTT_IsLvalueReference:
3530 case UTT_IsRvalueReference:
3531 case UTT_IsMemberFunctionPointer:
3532 case UTT_IsMemberObjectPointer:
3536 case UTT_IsFunction:
3537 case UTT_IsReference:
3538 case UTT_IsArithmetic:
3539 case UTT_IsFundamental:
3542 case UTT_IsCompound:
3543 case UTT_IsMemberPointer:
3546 // These traits are modeled on type predicates in C++0x [meta.unary.prop]
3547 // which requires some of its traits to have the complete type. However,
3548 // the completeness of the type cannot impact these traits' semantics, and
3549 // so they don't require it. This matches the comments on these traits in
3552 case UTT_IsVolatile:
3554 case UTT_IsUnsigned:
3556 // This type trait always returns false, checking the type is moot.
3557 case UTT_IsInterfaceClass:
3560 // C++14 [meta.unary.prop]:
3561 // If T is a non-union class type, T shall be a complete type.
3563 case UTT_IsPolymorphic:
3564 case UTT_IsAbstract:
3565 if (const auto *RD = ArgTy->getAsCXXRecordDecl())
3567 return !S.RequireCompleteType(
3568 Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
3571 // C++14 [meta.unary.prop]:
3572 // If T is a class type, T shall be a complete type.
3575 if (ArgTy->getAsCXXRecordDecl())
3576 return !S.RequireCompleteType(
3577 Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
3580 // C++0x [meta.unary.prop] Table 49 requires the following traits to be
3581 // applied to a complete type.
3583 case UTT_IsTriviallyCopyable:
3584 case UTT_IsStandardLayout:
3588 case UTT_IsDestructible:
3589 case UTT_IsNothrowDestructible:
3592 // These trait expressions are designed to help implement predicates in
3593 // [meta.unary.prop] despite not being named the same. They are specified
3594 // by both GCC and the Embarcadero C++ compiler, and require the complete
3595 // type due to the overarching C++0x type predicates being implemented
3596 // requiring the complete type.
3597 case UTT_HasNothrowAssign:
3598 case UTT_HasNothrowMoveAssign:
3599 case UTT_HasNothrowConstructor:
3600 case UTT_HasNothrowCopy:
3601 case UTT_HasTrivialAssign:
3602 case UTT_HasTrivialMoveAssign:
3603 case UTT_HasTrivialDefaultConstructor:
3604 case UTT_HasTrivialMoveConstructor:
3605 case UTT_HasTrivialCopy:
3606 case UTT_HasTrivialDestructor:
3607 case UTT_HasVirtualDestructor:
3608 // Arrays of unknown bound are expressly allowed.
3609 QualType ElTy = ArgTy;
3610 if (ArgTy->isIncompleteArrayType())
3611 ElTy = S.Context.getAsArrayType(ArgTy)->getElementType();
3613 // The void type is expressly allowed.
3614 if (ElTy->isVoidType())
3617 return !S.RequireCompleteType(
3618 Loc, ElTy, diag::err_incomplete_type_used_in_type_trait_expr);
3622 static bool HasNoThrowOperator(const RecordType *RT, OverloadedOperatorKind Op,
3623 Sema &Self, SourceLocation KeyLoc, ASTContext &C,
3624 bool (CXXRecordDecl::*HasTrivial)() const,
3625 bool (CXXRecordDecl::*HasNonTrivial)() const,
3626 bool (CXXMethodDecl::*IsDesiredOp)() const)
3628 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
3629 if ((RD->*HasTrivial)() && !(RD->*HasNonTrivial)())
3632 DeclarationName Name = C.DeclarationNames.getCXXOperatorName(Op);
3633 DeclarationNameInfo NameInfo(Name, KeyLoc);
3634 LookupResult Res(Self, NameInfo, Sema::LookupOrdinaryName);
3635 if (Self.LookupQualifiedName(Res, RD)) {
3636 bool FoundOperator = false;
3637 Res.suppressDiagnostics();
3638 for (LookupResult::iterator Op = Res.begin(), OpEnd = Res.end();
3639 Op != OpEnd; ++Op) {
3640 if (isa<FunctionTemplateDecl>(*Op))
3643 CXXMethodDecl *Operator = cast<CXXMethodDecl>(*Op);
3644 if((Operator->*IsDesiredOp)()) {
3645 FoundOperator = true;
3646 const FunctionProtoType *CPT =
3647 Operator->getType()->getAs<FunctionProtoType>();
3648 CPT = Self.ResolveExceptionSpec(KeyLoc, CPT);
3649 if (!CPT || !CPT->isNothrow(C))
3653 return FoundOperator;
3658 static bool EvaluateUnaryTypeTrait(Sema &Self, TypeTrait UTT,
3659 SourceLocation KeyLoc, QualType T) {
3660 assert(!T->isDependentType() && "Cannot evaluate traits of dependent type");
3662 ASTContext &C = Self.Context;
3664 default: llvm_unreachable("not a UTT");
3665 // Type trait expressions corresponding to the primary type category
3666 // predicates in C++0x [meta.unary.cat].
3668 return T->isVoidType();
3669 case UTT_IsIntegral:
3670 return T->isIntegralType(C);
3671 case UTT_IsFloatingPoint:
3672 return T->isFloatingType();
3674 return T->isArrayType();
3676 return T->isPointerType();
3677 case UTT_IsLvalueReference:
3678 return T->isLValueReferenceType();
3679 case UTT_IsRvalueReference:
3680 return T->isRValueReferenceType();
3681 case UTT_IsMemberFunctionPointer:
3682 return T->isMemberFunctionPointerType();
3683 case UTT_IsMemberObjectPointer:
3684 return T->isMemberDataPointerType();
3686 return T->isEnumeralType();
3688 return T->isUnionType();
3690 return T->isClassType() || T->isStructureType() || T->isInterfaceType();
3691 case UTT_IsFunction:
3692 return T->isFunctionType();
3694 // Type trait expressions which correspond to the convenient composition
3695 // predicates in C++0x [meta.unary.comp].
3696 case UTT_IsReference:
3697 return T->isReferenceType();
3698 case UTT_IsArithmetic:
3699 return T->isArithmeticType() && !T->isEnumeralType();
3700 case UTT_IsFundamental:
3701 return T->isFundamentalType();
3703 return T->isObjectType();
3705 // Note: semantic analysis depends on Objective-C lifetime types to be
3706 // considered scalar types. However, such types do not actually behave
3707 // like scalar types at run time (since they may require retain/release
3708 // operations), so we report them as non-scalar.
3709 if (T->isObjCLifetimeType()) {
3710 switch (T.getObjCLifetime()) {
3711 case Qualifiers::OCL_None:
3712 case Qualifiers::OCL_ExplicitNone:
3715 case Qualifiers::OCL_Strong:
3716 case Qualifiers::OCL_Weak:
3717 case Qualifiers::OCL_Autoreleasing:
3722 return T->isScalarType();
3723 case UTT_IsCompound:
3724 return T->isCompoundType();
3725 case UTT_IsMemberPointer:
3726 return T->isMemberPointerType();
3728 // Type trait expressions which correspond to the type property predicates
3729 // in C++0x [meta.unary.prop].
3731 return T.isConstQualified();
3732 case UTT_IsVolatile:
3733 return T.isVolatileQualified();
3735 return T.isTrivialType(C);
3736 case UTT_IsTriviallyCopyable:
3737 return T.isTriviallyCopyableType(C);
3738 case UTT_IsStandardLayout:
3739 return T->isStandardLayoutType();
3741 return T.isPODType(C);
3743 return T->isLiteralType(C);
3745 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
3746 return !RD->isUnion() && RD->isEmpty();
3748 case UTT_IsPolymorphic:
3749 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
3750 return !RD->isUnion() && RD->isPolymorphic();
3752 case UTT_IsAbstract:
3753 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
3754 return !RD->isUnion() && RD->isAbstract();
3756 // __is_interface_class only returns true when CL is invoked in /CLR mode and
3757 // even then only when it is used with the 'interface struct ...' syntax
3758 // Clang doesn't support /CLR which makes this type trait moot.
3759 case UTT_IsInterfaceClass:
3763 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
3764 return RD->hasAttr<FinalAttr>();
3767 return T->isSignedIntegerType();
3768 case UTT_IsUnsigned:
3769 return T->isUnsignedIntegerType();
3771 // Type trait expressions which query classes regarding their construction,
3772 // destruction, and copying. Rather than being based directly on the
3773 // related type predicates in the standard, they are specified by both
3774 // GCC[1] and the Embarcadero C++ compiler[2], and Clang implements those
3777 // 1: http://gcc.gnu/.org/onlinedocs/gcc/Type-Traits.html
3778 // 2: http://docwiki.embarcadero.com/RADStudio/XE/en/Type_Trait_Functions_(C%2B%2B0x)_Index
3780 // Note that these builtins do not behave as documented in g++: if a class
3781 // has both a trivial and a non-trivial special member of a particular kind,
3782 // they return false! For now, we emulate this behavior.
3783 // FIXME: This appears to be a g++ bug: more complex cases reveal that it
3784 // does not correctly compute triviality in the presence of multiple special
3785 // members of the same kind. Revisit this once the g++ bug is fixed.
3786 case UTT_HasTrivialDefaultConstructor:
3787 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
3788 // If __is_pod (type) is true then the trait is true, else if type is
3789 // a cv class or union type (or array thereof) with a trivial default
3790 // constructor ([class.ctor]) then the trait is true, else it is false.
3793 if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
3794 return RD->hasTrivialDefaultConstructor() &&
3795 !RD->hasNonTrivialDefaultConstructor();
3797 case UTT_HasTrivialMoveConstructor:
3798 // This trait is implemented by MSVC 2012 and needed to parse the
3799 // standard library headers. Specifically this is used as the logic
3800 // behind std::is_trivially_move_constructible (20.9.4.3).
3803 if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
3804 return RD->hasTrivialMoveConstructor() && !RD->hasNonTrivialMoveConstructor();
3806 case UTT_HasTrivialCopy:
3807 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
3808 // If __is_pod (type) is true or type is a reference type then
3809 // the trait is true, else if type is a cv class or union type
3810 // with a trivial copy constructor ([class.copy]) then the trait
3811 // is true, else it is false.
3812 if (T.isPODType(C) || T->isReferenceType())
3814 if (CXXRecordDecl *RD = T->getAsCXXRecordDecl())
3815 return RD->hasTrivialCopyConstructor() &&
3816 !RD->hasNonTrivialCopyConstructor();
3818 case UTT_HasTrivialMoveAssign:
3819 // This trait is implemented by MSVC 2012 and needed to parse the
3820 // standard library headers. Specifically it is used as the logic
3821 // behind std::is_trivially_move_assignable (20.9.4.3)
3824 if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
3825 return RD->hasTrivialMoveAssignment() && !RD->hasNonTrivialMoveAssignment();
3827 case UTT_HasTrivialAssign:
3828 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
3829 // If type is const qualified or is a reference type then the
3830 // trait is false. Otherwise if __is_pod (type) is true then the
3831 // trait is true, else if type is a cv class or union type with
3832 // a trivial copy assignment ([class.copy]) then the trait is
3833 // true, else it is false.
3834 // Note: the const and reference restrictions are interesting,
3835 // given that const and reference members don't prevent a class
3836 // from having a trivial copy assignment operator (but do cause
3837 // errors if the copy assignment operator is actually used, q.v.
3838 // [class.copy]p12).
3840 if (T.isConstQualified())
3844 if (CXXRecordDecl *RD = T->getAsCXXRecordDecl())
3845 return RD->hasTrivialCopyAssignment() &&
3846 !RD->hasNonTrivialCopyAssignment();
3848 case UTT_IsDestructible:
3849 case UTT_IsNothrowDestructible:
3850 // C++14 [meta.unary.prop]:
3851 // For reference types, is_destructible<T>::value is true.
3852 if (T->isReferenceType())
3855 // Objective-C++ ARC: autorelease types don't require destruction.
3856 if (T->isObjCLifetimeType() &&
3857 T.getObjCLifetime() == Qualifiers::OCL_Autoreleasing)
3860 // C++14 [meta.unary.prop]:
3861 // For incomplete types and function types, is_destructible<T>::value is
3863 if (T->isIncompleteType() || T->isFunctionType())
3866 // C++14 [meta.unary.prop]:
3867 // For object types and given U equal to remove_all_extents_t<T>, if the
3868 // expression std::declval<U&>().~U() is well-formed when treated as an
3869 // unevaluated operand (Clause 5), then is_destructible<T>::value is true
3870 if (auto *RD = C.getBaseElementType(T)->getAsCXXRecordDecl()) {
3871 CXXDestructorDecl *Destructor = Self.LookupDestructor(RD);
3874 // C++14 [dcl.fct.def.delete]p2:
3875 // A program that refers to a deleted function implicitly or
3876 // explicitly, other than to declare it, is ill-formed.
3877 if (Destructor->isDeleted())
3879 if (C.getLangOpts().AccessControl && Destructor->getAccess() != AS_public)
3881 if (UTT == UTT_IsNothrowDestructible) {
3882 const FunctionProtoType *CPT =
3883 Destructor->getType()->getAs<FunctionProtoType>();
3884 CPT = Self.ResolveExceptionSpec(KeyLoc, CPT);
3885 if (!CPT || !CPT->isNothrow(C))
3891 case UTT_HasTrivialDestructor:
3892 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html
3893 // If __is_pod (type) is true or type is a reference type
3894 // then the trait is true, else if type is a cv class or union
3895 // type (or array thereof) with a trivial destructor
3896 // ([class.dtor]) then the trait is true, else it is
3898 if (T.isPODType(C) || T->isReferenceType())
3901 // Objective-C++ ARC: autorelease types don't require destruction.
3902 if (T->isObjCLifetimeType() &&
3903 T.getObjCLifetime() == Qualifiers::OCL_Autoreleasing)
3906 if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
3907 return RD->hasTrivialDestructor();
3909 // TODO: Propagate nothrowness for implicitly declared special members.
3910 case UTT_HasNothrowAssign:
3911 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
3912 // If type is const qualified or is a reference type then the
3913 // trait is false. Otherwise if __has_trivial_assign (type)
3914 // is true then the trait is true, else if type is a cv class
3915 // or union type with copy assignment operators that are known
3916 // not to throw an exception then the trait is true, else it is
3918 if (C.getBaseElementType(T).isConstQualified())
3920 if (T->isReferenceType())
3922 if (T.isPODType(C) || T->isObjCLifetimeType())
3925 if (const RecordType *RT = T->getAs<RecordType>())
3926 return HasNoThrowOperator(RT, OO_Equal, Self, KeyLoc, C,
3927 &CXXRecordDecl::hasTrivialCopyAssignment,
3928 &CXXRecordDecl::hasNonTrivialCopyAssignment,
3929 &CXXMethodDecl::isCopyAssignmentOperator);
3931 case UTT_HasNothrowMoveAssign:
3932 // This trait is implemented by MSVC 2012 and needed to parse the
3933 // standard library headers. Specifically this is used as the logic
3934 // behind std::is_nothrow_move_assignable (20.9.4.3).
3938 if (const RecordType *RT = C.getBaseElementType(T)->getAs<RecordType>())
3939 return HasNoThrowOperator(RT, OO_Equal, Self, KeyLoc, C,
3940 &CXXRecordDecl::hasTrivialMoveAssignment,
3941 &CXXRecordDecl::hasNonTrivialMoveAssignment,
3942 &CXXMethodDecl::isMoveAssignmentOperator);
3944 case UTT_HasNothrowCopy:
3945 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
3946 // If __has_trivial_copy (type) is true then the trait is true, else
3947 // if type is a cv class or union type with copy constructors that are
3948 // known not to throw an exception then the trait is true, else it is
3950 if (T.isPODType(C) || T->isReferenceType() || T->isObjCLifetimeType())
3952 if (CXXRecordDecl *RD = T->getAsCXXRecordDecl()) {
3953 if (RD->hasTrivialCopyConstructor() &&
3954 !RD->hasNonTrivialCopyConstructor())
3957 bool FoundConstructor = false;
3959 for (const auto *ND : Self.LookupConstructors(RD)) {
3960 // A template constructor is never a copy constructor.
3961 // FIXME: However, it may actually be selected at the actual overload
3962 // resolution point.
3963 if (isa<FunctionTemplateDecl>(ND))
3965 const CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(ND);
3966 if (Constructor->isCopyConstructor(FoundTQs)) {
3967 FoundConstructor = true;
3968 const FunctionProtoType *CPT
3969 = Constructor->getType()->getAs<FunctionProtoType>();
3970 CPT = Self.ResolveExceptionSpec(KeyLoc, CPT);
3973 // TODO: check whether evaluating default arguments can throw.
3974 // For now, we'll be conservative and assume that they can throw.
3975 if (!CPT->isNothrow(C) || CPT->getNumParams() > 1)
3980 return FoundConstructor;
3983 case UTT_HasNothrowConstructor:
3984 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html
3985 // If __has_trivial_constructor (type) is true then the trait is
3986 // true, else if type is a cv class or union type (or array
3987 // thereof) with a default constructor that is known not to
3988 // throw an exception then the trait is true, else it is false.
3989 if (T.isPODType(C) || T->isObjCLifetimeType())
3991 if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl()) {
3992 if (RD->hasTrivialDefaultConstructor() &&
3993 !RD->hasNonTrivialDefaultConstructor())
3996 bool FoundConstructor = false;
3997 for (const auto *ND : Self.LookupConstructors(RD)) {
3998 // FIXME: In C++0x, a constructor template can be a default constructor.
3999 if (isa<FunctionTemplateDecl>(ND))
4001 const CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(ND);
4002 if (Constructor->isDefaultConstructor()) {
4003 FoundConstructor = true;
4004 const FunctionProtoType *CPT
4005 = Constructor->getType()->getAs<FunctionProtoType>();
4006 CPT = Self.ResolveExceptionSpec(KeyLoc, CPT);
4009 // FIXME: check whether evaluating default arguments can throw.
4010 // For now, we'll be conservative and assume that they can throw.
4011 if (!CPT->isNothrow(C) || CPT->getNumParams() > 0)
4015 return FoundConstructor;
4018 case UTT_HasVirtualDestructor:
4019 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
4020 // If type is a class type with a virtual destructor ([class.dtor])
4021 // then the trait is true, else it is false.
4022 if (CXXRecordDecl *RD = T->getAsCXXRecordDecl())
4023 if (CXXDestructorDecl *Destructor = Self.LookupDestructor(RD))
4024 return Destructor->isVirtual();
4027 // These type trait expressions are modeled on the specifications for the
4028 // Embarcadero C++0x type trait functions:
4029 // http://docwiki.embarcadero.com/RADStudio/XE/en/Type_Trait_Functions_(C%2B%2B0x)_Index
4030 case UTT_IsCompleteType:
4031 // http://docwiki.embarcadero.com/RADStudio/XE/en/Is_complete_type_(typename_T_):
4032 // Returns True if and only if T is a complete type at the point of the
4034 return !T->isIncompleteType();
4038 /// \brief Determine whether T has a non-trivial Objective-C lifetime in
4040 static bool hasNontrivialObjCLifetime(QualType T) {
4041 switch (T.getObjCLifetime()) {
4042 case Qualifiers::OCL_ExplicitNone:
4045 case Qualifiers::OCL_Strong:
4046 case Qualifiers::OCL_Weak:
4047 case Qualifiers::OCL_Autoreleasing:
4050 case Qualifiers::OCL_None:
4051 return T->isObjCLifetimeType();
4054 llvm_unreachable("Unknown ObjC lifetime qualifier");
4057 static bool EvaluateBinaryTypeTrait(Sema &Self, TypeTrait BTT, QualType LhsT,
4058 QualType RhsT, SourceLocation KeyLoc);
4060 static bool evaluateTypeTrait(Sema &S, TypeTrait Kind, SourceLocation KWLoc,
4061 ArrayRef<TypeSourceInfo *> Args,
4062 SourceLocation RParenLoc) {
4063 if (Kind <= UTT_Last)
4064 return EvaluateUnaryTypeTrait(S, Kind, KWLoc, Args[0]->getType());
4066 if (Kind <= BTT_Last)
4067 return EvaluateBinaryTypeTrait(S, Kind, Args[0]->getType(),
4068 Args[1]->getType(), RParenLoc);
4071 case clang::TT_IsConstructible:
4072 case clang::TT_IsNothrowConstructible:
4073 case clang::TT_IsTriviallyConstructible: {
4074 // C++11 [meta.unary.prop]:
4075 // is_trivially_constructible is defined as:
4077 // is_constructible<T, Args...>::value is true and the variable
4078 // definition for is_constructible, as defined below, is known to call
4079 // no operation that is not trivial.
4081 // The predicate condition for a template specialization
4082 // is_constructible<T, Args...> shall be satisfied if and only if the
4083 // following variable definition would be well-formed for some invented
4086 // T t(create<Args>()...);
4087 assert(!Args.empty());
4089 // Precondition: T and all types in the parameter pack Args shall be
4090 // complete types, (possibly cv-qualified) void, or arrays of
4092 for (const auto *TSI : Args) {
4093 QualType ArgTy = TSI->getType();
4094 if (ArgTy->isVoidType() || ArgTy->isIncompleteArrayType())
4097 if (S.RequireCompleteType(KWLoc, ArgTy,
4098 diag::err_incomplete_type_used_in_type_trait_expr))
4102 // Make sure the first argument is not incomplete nor a function type.
4103 QualType T = Args[0]->getType();
4104 if (T->isIncompleteType() || T->isFunctionType())
4107 // Make sure the first argument is not an abstract type.
4108 CXXRecordDecl *RD = T->getAsCXXRecordDecl();
4109 if (RD && RD->isAbstract())
4112 SmallVector<OpaqueValueExpr, 2> OpaqueArgExprs;
4113 SmallVector<Expr *, 2> ArgExprs;
4114 ArgExprs.reserve(Args.size() - 1);
4115 for (unsigned I = 1, N = Args.size(); I != N; ++I) {
4116 QualType ArgTy = Args[I]->getType();
4117 if (ArgTy->isObjectType() || ArgTy->isFunctionType())
4118 ArgTy = S.Context.getRValueReferenceType(ArgTy);
4119 OpaqueArgExprs.push_back(
4120 OpaqueValueExpr(Args[I]->getTypeLoc().getLocStart(),
4121 ArgTy.getNonLValueExprType(S.Context),
4122 Expr::getValueKindForType(ArgTy)));
4124 for (Expr &E : OpaqueArgExprs)
4125 ArgExprs.push_back(&E);
4127 // Perform the initialization in an unevaluated context within a SFINAE
4128 // trap at translation unit scope.
4129 EnterExpressionEvaluationContext Unevaluated(S, Sema::Unevaluated);
4130 Sema::SFINAETrap SFINAE(S, /*AccessCheckingSFINAE=*/true);
4131 Sema::ContextRAII TUContext(S, S.Context.getTranslationUnitDecl());
4132 InitializedEntity To(InitializedEntity::InitializeTemporary(Args[0]));
4133 InitializationKind InitKind(InitializationKind::CreateDirect(KWLoc, KWLoc,
4135 InitializationSequence Init(S, To, InitKind, ArgExprs);
4139 ExprResult Result = Init.Perform(S, To, InitKind, ArgExprs);
4140 if (Result.isInvalid() || SFINAE.hasErrorOccurred())
4143 if (Kind == clang::TT_IsConstructible)
4146 if (Kind == clang::TT_IsNothrowConstructible)
4147 return S.canThrow(Result.get()) == CT_Cannot;
4149 if (Kind == clang::TT_IsTriviallyConstructible) {
4150 // Under Objective-C ARC, if the destination has non-trivial Objective-C
4151 // lifetime, this is a non-trivial construction.
4152 if (S.getLangOpts().ObjCAutoRefCount &&
4153 hasNontrivialObjCLifetime(T.getNonReferenceType()))
4156 // The initialization succeeded; now make sure there are no non-trivial
4158 return !Result.get()->hasNonTrivialCall(S.Context);
4161 llvm_unreachable("unhandled type trait");
4164 default: llvm_unreachable("not a TT");
4170 ExprResult Sema::BuildTypeTrait(TypeTrait Kind, SourceLocation KWLoc,
4171 ArrayRef<TypeSourceInfo *> Args,
4172 SourceLocation RParenLoc) {
4173 QualType ResultType = Context.getLogicalOperationType();
4175 if (Kind <= UTT_Last && !CheckUnaryTypeTraitTypeCompleteness(
4176 *this, Kind, KWLoc, Args[0]->getType()))
4179 bool Dependent = false;
4180 for (unsigned I = 0, N = Args.size(); I != N; ++I) {
4181 if (Args[I]->getType()->isDependentType()) {
4187 bool Result = false;
4189 Result = evaluateTypeTrait(*this, Kind, KWLoc, Args, RParenLoc);
4191 return TypeTraitExpr::Create(Context, ResultType, KWLoc, Kind, Args,
4195 ExprResult Sema::ActOnTypeTrait(TypeTrait Kind, SourceLocation KWLoc,
4196 ArrayRef<ParsedType> Args,
4197 SourceLocation RParenLoc) {
4198 SmallVector<TypeSourceInfo *, 4> ConvertedArgs;
4199 ConvertedArgs.reserve(Args.size());
4201 for (unsigned I = 0, N = Args.size(); I != N; ++I) {
4202 TypeSourceInfo *TInfo;
4203 QualType T = GetTypeFromParser(Args[I], &TInfo);
4205 TInfo = Context.getTrivialTypeSourceInfo(T, KWLoc);
4207 ConvertedArgs.push_back(TInfo);
4210 return BuildTypeTrait(Kind, KWLoc, ConvertedArgs, RParenLoc);
4213 static bool EvaluateBinaryTypeTrait(Sema &Self, TypeTrait BTT, QualType LhsT,
4214 QualType RhsT, SourceLocation KeyLoc) {
4215 assert(!LhsT->isDependentType() && !RhsT->isDependentType() &&
4216 "Cannot evaluate traits of dependent types");
4219 case BTT_IsBaseOf: {
4220 // C++0x [meta.rel]p2
4221 // Base is a base class of Derived without regard to cv-qualifiers or
4222 // Base and Derived are not unions and name the same class type without
4223 // regard to cv-qualifiers.
4225 const RecordType *lhsRecord = LhsT->getAs<RecordType>();
4226 if (!lhsRecord) return false;
4228 const RecordType *rhsRecord = RhsT->getAs<RecordType>();
4229 if (!rhsRecord) return false;
4231 assert(Self.Context.hasSameUnqualifiedType(LhsT, RhsT)
4232 == (lhsRecord == rhsRecord));
4234 if (lhsRecord == rhsRecord)
4235 return !lhsRecord->getDecl()->isUnion();
4237 // C++0x [meta.rel]p2:
4238 // If Base and Derived are class types and are different types
4239 // (ignoring possible cv-qualifiers) then Derived shall be a
4241 if (Self.RequireCompleteType(KeyLoc, RhsT,
4242 diag::err_incomplete_type_used_in_type_trait_expr))
4245 return cast<CXXRecordDecl>(rhsRecord->getDecl())
4246 ->isDerivedFrom(cast<CXXRecordDecl>(lhsRecord->getDecl()));
4249 return Self.Context.hasSameType(LhsT, RhsT);
4250 case BTT_TypeCompatible:
4251 return Self.Context.typesAreCompatible(LhsT.getUnqualifiedType(),
4252 RhsT.getUnqualifiedType());
4253 case BTT_IsConvertible:
4254 case BTT_IsConvertibleTo: {
4255 // C++0x [meta.rel]p4:
4256 // Given the following function prototype:
4258 // template <class T>
4259 // typename add_rvalue_reference<T>::type create();
4261 // the predicate condition for a template specialization
4262 // is_convertible<From, To> shall be satisfied if and only if
4263 // the return expression in the following code would be
4264 // well-formed, including any implicit conversions to the return
4265 // type of the function:
4268 // return create<From>();
4271 // Access checking is performed as if in a context unrelated to To and
4272 // From. Only the validity of the immediate context of the expression
4273 // of the return-statement (including conversions to the return type)
4276 // We model the initialization as a copy-initialization of a temporary
4277 // of the appropriate type, which for this expression is identical to the
4278 // return statement (since NRVO doesn't apply).
4280 // Functions aren't allowed to return function or array types.
4281 if (RhsT->isFunctionType() || RhsT->isArrayType())
4284 // A return statement in a void function must have void type.
4285 if (RhsT->isVoidType())
4286 return LhsT->isVoidType();
4288 // A function definition requires a complete, non-abstract return type.
4289 if (!Self.isCompleteType(KeyLoc, RhsT) || Self.isAbstractType(KeyLoc, RhsT))
4292 // Compute the result of add_rvalue_reference.
4293 if (LhsT->isObjectType() || LhsT->isFunctionType())
4294 LhsT = Self.Context.getRValueReferenceType(LhsT);
4296 // Build a fake source and destination for initialization.
4297 InitializedEntity To(InitializedEntity::InitializeTemporary(RhsT));
4298 OpaqueValueExpr From(KeyLoc, LhsT.getNonLValueExprType(Self.Context),
4299 Expr::getValueKindForType(LhsT));
4300 Expr *FromPtr = &From;
4301 InitializationKind Kind(InitializationKind::CreateCopy(KeyLoc,
4304 // Perform the initialization in an unevaluated context within a SFINAE
4305 // trap at translation unit scope.
4306 EnterExpressionEvaluationContext Unevaluated(Self, Sema::Unevaluated);
4307 Sema::SFINAETrap SFINAE(Self, /*AccessCheckingSFINAE=*/true);
4308 Sema::ContextRAII TUContext(Self, Self.Context.getTranslationUnitDecl());
4309 InitializationSequence Init(Self, To, Kind, FromPtr);
4313 ExprResult Result = Init.Perform(Self, To, Kind, FromPtr);
4314 return !Result.isInvalid() && !SFINAE.hasErrorOccurred();
4317 case BTT_IsNothrowAssignable:
4318 case BTT_IsTriviallyAssignable: {
4319 // C++11 [meta.unary.prop]p3:
4320 // is_trivially_assignable is defined as:
4321 // is_assignable<T, U>::value is true and the assignment, as defined by
4322 // is_assignable, is known to call no operation that is not trivial
4324 // is_assignable is defined as:
4325 // The expression declval<T>() = declval<U>() is well-formed when
4326 // treated as an unevaluated operand (Clause 5).
4328 // For both, T and U shall be complete types, (possibly cv-qualified)
4329 // void, or arrays of unknown bound.
4330 if (!LhsT->isVoidType() && !LhsT->isIncompleteArrayType() &&
4331 Self.RequireCompleteType(KeyLoc, LhsT,
4332 diag::err_incomplete_type_used_in_type_trait_expr))
4334 if (!RhsT->isVoidType() && !RhsT->isIncompleteArrayType() &&
4335 Self.RequireCompleteType(KeyLoc, RhsT,
4336 diag::err_incomplete_type_used_in_type_trait_expr))
4339 // cv void is never assignable.
4340 if (LhsT->isVoidType() || RhsT->isVoidType())
4343 // Build expressions that emulate the effect of declval<T>() and
4345 if (LhsT->isObjectType() || LhsT->isFunctionType())
4346 LhsT = Self.Context.getRValueReferenceType(LhsT);
4347 if (RhsT->isObjectType() || RhsT->isFunctionType())
4348 RhsT = Self.Context.getRValueReferenceType(RhsT);
4349 OpaqueValueExpr Lhs(KeyLoc, LhsT.getNonLValueExprType(Self.Context),
4350 Expr::getValueKindForType(LhsT));
4351 OpaqueValueExpr Rhs(KeyLoc, RhsT.getNonLValueExprType(Self.Context),
4352 Expr::getValueKindForType(RhsT));
4354 // Attempt the assignment in an unevaluated context within a SFINAE
4355 // trap at translation unit scope.
4356 EnterExpressionEvaluationContext Unevaluated(Self, Sema::Unevaluated);
4357 Sema::SFINAETrap SFINAE(Self, /*AccessCheckingSFINAE=*/true);
4358 Sema::ContextRAII TUContext(Self, Self.Context.getTranslationUnitDecl());
4359 ExprResult Result = Self.BuildBinOp(/*S=*/nullptr, KeyLoc, BO_Assign, &Lhs,
4361 if (Result.isInvalid() || SFINAE.hasErrorOccurred())
4364 if (BTT == BTT_IsNothrowAssignable)
4365 return Self.canThrow(Result.get()) == CT_Cannot;
4367 if (BTT == BTT_IsTriviallyAssignable) {
4368 // Under Objective-C ARC, if the destination has non-trivial Objective-C
4369 // lifetime, this is a non-trivial assignment.
4370 if (Self.getLangOpts().ObjCAutoRefCount &&
4371 hasNontrivialObjCLifetime(LhsT.getNonReferenceType()))
4374 return !Result.get()->hasNonTrivialCall(Self.Context);
4377 llvm_unreachable("unhandled type trait");
4380 default: llvm_unreachable("not a BTT");
4382 llvm_unreachable("Unknown type trait or not implemented");
4385 ExprResult Sema::ActOnArrayTypeTrait(ArrayTypeTrait ATT,
4386 SourceLocation KWLoc,
4389 SourceLocation RParen) {
4390 TypeSourceInfo *TSInfo;
4391 QualType T = GetTypeFromParser(Ty, &TSInfo);
4393 TSInfo = Context.getTrivialTypeSourceInfo(T);
4395 return BuildArrayTypeTrait(ATT, KWLoc, TSInfo, DimExpr, RParen);
4398 static uint64_t EvaluateArrayTypeTrait(Sema &Self, ArrayTypeTrait ATT,
4399 QualType T, Expr *DimExpr,
4400 SourceLocation KeyLoc) {
4401 assert(!T->isDependentType() && "Cannot evaluate traits of dependent type");
4405 if (T->isArrayType()) {
4407 while (const ArrayType *AT = Self.Context.getAsArrayType(T)) {
4409 T = AT->getElementType();
4415 case ATT_ArrayExtent: {
4418 if (Self.VerifyIntegerConstantExpression(DimExpr, &Value,
4419 diag::err_dimension_expr_not_constant_integer,
4422 if (Value.isSigned() && Value.isNegative()) {
4423 Self.Diag(KeyLoc, diag::err_dimension_expr_not_constant_integer)
4424 << DimExpr->getSourceRange();
4427 Dim = Value.getLimitedValue();
4429 if (T->isArrayType()) {
4431 bool Matched = false;
4432 while (const ArrayType *AT = Self.Context.getAsArrayType(T)) {
4438 T = AT->getElementType();
4441 if (Matched && T->isArrayType()) {
4442 if (const ConstantArrayType *CAT = Self.Context.getAsConstantArrayType(T))
4443 return CAT->getSize().getLimitedValue();
4449 llvm_unreachable("Unknown type trait or not implemented");
4452 ExprResult Sema::BuildArrayTypeTrait(ArrayTypeTrait ATT,
4453 SourceLocation KWLoc,
4454 TypeSourceInfo *TSInfo,
4456 SourceLocation RParen) {
4457 QualType T = TSInfo->getType();
4459 // FIXME: This should likely be tracked as an APInt to remove any host
4460 // assumptions about the width of size_t on the target.
4462 if (!T->isDependentType())
4463 Value = EvaluateArrayTypeTrait(*this, ATT, T, DimExpr, KWLoc);
4465 // While the specification for these traits from the Embarcadero C++
4466 // compiler's documentation says the return type is 'unsigned int', Clang
4467 // returns 'size_t'. On Windows, the primary platform for the Embarcadero
4468 // compiler, there is no difference. On several other platforms this is an
4469 // important distinction.
4470 return new (Context) ArrayTypeTraitExpr(KWLoc, ATT, TSInfo, Value, DimExpr,
4471 RParen, Context.getSizeType());
4474 ExprResult Sema::ActOnExpressionTrait(ExpressionTrait ET,
4475 SourceLocation KWLoc,
4477 SourceLocation RParen) {
4478 // If error parsing the expression, ignore.
4482 ExprResult Result = BuildExpressionTrait(ET, KWLoc, Queried, RParen);
4487 static bool EvaluateExpressionTrait(ExpressionTrait ET, Expr *E) {
4489 case ET_IsLValueExpr: return E->isLValue();
4490 case ET_IsRValueExpr: return E->isRValue();
4492 llvm_unreachable("Expression trait not covered by switch");
4495 ExprResult Sema::BuildExpressionTrait(ExpressionTrait ET,
4496 SourceLocation KWLoc,
4498 SourceLocation RParen) {
4499 if (Queried->isTypeDependent()) {
4500 // Delay type-checking for type-dependent expressions.
4501 } else if (Queried->getType()->isPlaceholderType()) {
4502 ExprResult PE = CheckPlaceholderExpr(Queried);
4503 if (PE.isInvalid()) return ExprError();
4504 return BuildExpressionTrait(ET, KWLoc, PE.get(), RParen);
4507 bool Value = EvaluateExpressionTrait(ET, Queried);
4509 return new (Context)
4510 ExpressionTraitExpr(KWLoc, ET, Queried, Value, RParen, Context.BoolTy);
4513 QualType Sema::CheckPointerToMemberOperands(ExprResult &LHS, ExprResult &RHS,
4517 assert(!LHS.get()->getType()->isPlaceholderType() &&
4518 !RHS.get()->getType()->isPlaceholderType() &&
4519 "placeholders should have been weeded out by now");
4521 // The LHS undergoes lvalue conversions if this is ->*.
4523 LHS = DefaultLvalueConversion(LHS.get());
4524 if (LHS.isInvalid()) return QualType();
4527 // The RHS always undergoes lvalue conversions.
4528 RHS = DefaultLvalueConversion(RHS.get());
4529 if (RHS.isInvalid()) return QualType();
4531 const char *OpSpelling = isIndirect ? "->*" : ".*";
4533 // The binary operator .* [p3: ->*] binds its second operand, which shall
4534 // be of type "pointer to member of T" (where T is a completely-defined
4535 // class type) [...]
4536 QualType RHSType = RHS.get()->getType();
4537 const MemberPointerType *MemPtr = RHSType->getAs<MemberPointerType>();
4539 Diag(Loc, diag::err_bad_memptr_rhs)
4540 << OpSpelling << RHSType << RHS.get()->getSourceRange();
4544 QualType Class(MemPtr->getClass(), 0);
4546 // Note: C++ [expr.mptr.oper]p2-3 says that the class type into which the
4547 // member pointer points must be completely-defined. However, there is no
4548 // reason for this semantic distinction, and the rule is not enforced by
4549 // other compilers. Therefore, we do not check this property, as it is
4550 // likely to be considered a defect.
4553 // [...] to its first operand, which shall be of class T or of a class of
4554 // which T is an unambiguous and accessible base class. [p3: a pointer to
4556 QualType LHSType = LHS.get()->getType();
4558 if (const PointerType *Ptr = LHSType->getAs<PointerType>())
4559 LHSType = Ptr->getPointeeType();
4561 Diag(Loc, diag::err_bad_memptr_lhs)
4562 << OpSpelling << 1 << LHSType
4563 << FixItHint::CreateReplacement(SourceRange(Loc), ".*");
4568 if (!Context.hasSameUnqualifiedType(Class, LHSType)) {
4569 // If we want to check the hierarchy, we need a complete type.
4570 if (RequireCompleteType(Loc, LHSType, diag::err_bad_memptr_lhs,
4571 OpSpelling, (int)isIndirect)) {
4575 if (!IsDerivedFrom(Loc, LHSType, Class)) {
4576 Diag(Loc, diag::err_bad_memptr_lhs) << OpSpelling
4577 << (int)isIndirect << LHS.get()->getType();
4581 CXXCastPath BasePath;
4582 if (CheckDerivedToBaseConversion(LHSType, Class, Loc,
4583 SourceRange(LHS.get()->getLocStart(),
4584 RHS.get()->getLocEnd()),
4588 // Cast LHS to type of use.
4589 QualType UseType = isIndirect ? Context.getPointerType(Class) : Class;
4590 ExprValueKind VK = isIndirect ? VK_RValue : LHS.get()->getValueKind();
4591 LHS = ImpCastExprToType(LHS.get(), UseType, CK_DerivedToBase, VK,
4595 if (isa<CXXScalarValueInitExpr>(RHS.get()->IgnoreParens())) {
4596 // Diagnose use of pointer-to-member type which when used as
4597 // the functional cast in a pointer-to-member expression.
4598 Diag(Loc, diag::err_pointer_to_member_type) << isIndirect;
4603 // The result is an object or a function of the type specified by the
4605 // The cv qualifiers are the union of those in the pointer and the left side,
4606 // in accordance with 5.5p5 and 5.2.5.
4607 QualType Result = MemPtr->getPointeeType();
4608 Result = Context.getCVRQualifiedType(Result, LHSType.getCVRQualifiers());
4610 // C++0x [expr.mptr.oper]p6:
4611 // In a .* expression whose object expression is an rvalue, the program is
4612 // ill-formed if the second operand is a pointer to member function with
4613 // ref-qualifier &. In a ->* expression or in a .* expression whose object
4614 // expression is an lvalue, the program is ill-formed if the second operand
4615 // is a pointer to member function with ref-qualifier &&.
4616 if (const FunctionProtoType *Proto = Result->getAs<FunctionProtoType>()) {
4617 switch (Proto->getRefQualifier()) {
4623 if (!isIndirect && !LHS.get()->Classify(Context).isLValue())
4624 Diag(Loc, diag::err_pointer_to_member_oper_value_classify)
4625 << RHSType << 1 << LHS.get()->getSourceRange();
4629 if (isIndirect || !LHS.get()->Classify(Context).isRValue())
4630 Diag(Loc, diag::err_pointer_to_member_oper_value_classify)
4631 << RHSType << 0 << LHS.get()->getSourceRange();
4636 // C++ [expr.mptr.oper]p6:
4637 // The result of a .* expression whose second operand is a pointer
4638 // to a data member is of the same value category as its
4639 // first operand. The result of a .* expression whose second
4640 // operand is a pointer to a member function is a prvalue. The
4641 // result of an ->* expression is an lvalue if its second operand
4642 // is a pointer to data member and a prvalue otherwise.
4643 if (Result->isFunctionType()) {
4645 return Context.BoundMemberTy;
4646 } else if (isIndirect) {
4649 VK = LHS.get()->getValueKind();
4655 /// \brief Try to convert a type to another according to C++0x 5.16p3.
4657 /// This is part of the parameter validation for the ? operator. If either
4658 /// value operand is a class type, the two operands are attempted to be
4659 /// converted to each other. This function does the conversion in one direction.
4660 /// It returns true if the program is ill-formed and has already been diagnosed
4662 static bool TryClassUnification(Sema &Self, Expr *From, Expr *To,
4663 SourceLocation QuestionLoc,
4664 bool &HaveConversion,
4666 HaveConversion = false;
4667 ToType = To->getType();
4669 InitializationKind Kind = InitializationKind::CreateCopy(To->getLocStart(),
4672 // The process for determining whether an operand expression E1 of type T1
4673 // can be converted to match an operand expression E2 of type T2 is defined
4675 // -- If E2 is an lvalue:
4676 bool ToIsLvalue = To->isLValue();
4678 // E1 can be converted to match E2 if E1 can be implicitly converted to
4679 // type "lvalue reference to T2", subject to the constraint that in the
4680 // conversion the reference must bind directly to E1.
4681 QualType T = Self.Context.getLValueReferenceType(ToType);
4682 InitializedEntity Entity = InitializedEntity::InitializeTemporary(T);
4684 InitializationSequence InitSeq(Self, Entity, Kind, From);
4685 if (InitSeq.isDirectReferenceBinding()) {
4687 HaveConversion = true;
4691 if (InitSeq.isAmbiguous())
4692 return InitSeq.Diagnose(Self, Entity, Kind, From);
4695 // -- If E2 is an rvalue, or if the conversion above cannot be done:
4696 // -- if E1 and E2 have class type, and the underlying class types are
4697 // the same or one is a base class of the other:
4698 QualType FTy = From->getType();
4699 QualType TTy = To->getType();
4700 const RecordType *FRec = FTy->getAs<RecordType>();
4701 const RecordType *TRec = TTy->getAs<RecordType>();
4702 bool FDerivedFromT = FRec && TRec && FRec != TRec &&
4703 Self.IsDerivedFrom(QuestionLoc, FTy, TTy);
4704 if (FRec && TRec && (FRec == TRec || FDerivedFromT ||
4705 Self.IsDerivedFrom(QuestionLoc, TTy, FTy))) {
4706 // E1 can be converted to match E2 if the class of T2 is the
4707 // same type as, or a base class of, the class of T1, and
4709 if (FRec == TRec || FDerivedFromT) {
4710 if (TTy.isAtLeastAsQualifiedAs(FTy)) {
4711 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy);
4712 InitializationSequence InitSeq(Self, Entity, Kind, From);
4714 HaveConversion = true;
4718 if (InitSeq.isAmbiguous())
4719 return InitSeq.Diagnose(Self, Entity, Kind, From);
4726 // -- Otherwise: E1 can be converted to match E2 if E1 can be
4727 // implicitly converted to the type that expression E2 would have
4728 // if E2 were converted to an rvalue (or the type it has, if E2 is
4731 // This actually refers very narrowly to the lvalue-to-rvalue conversion, not
4732 // to the array-to-pointer or function-to-pointer conversions.
4733 if (!TTy->getAs<TagType>())
4734 TTy = TTy.getUnqualifiedType();
4736 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy);
4737 InitializationSequence InitSeq(Self, Entity, Kind, From);
4738 HaveConversion = !InitSeq.Failed();
4740 if (InitSeq.isAmbiguous())
4741 return InitSeq.Diagnose(Self, Entity, Kind, From);
4746 /// \brief Try to find a common type for two according to C++0x 5.16p5.
4748 /// This is part of the parameter validation for the ? operator. If either
4749 /// value operand is a class type, overload resolution is used to find a
4750 /// conversion to a common type.
4751 static bool FindConditionalOverload(Sema &Self, ExprResult &LHS, ExprResult &RHS,
4752 SourceLocation QuestionLoc) {
4753 Expr *Args[2] = { LHS.get(), RHS.get() };
4754 OverloadCandidateSet CandidateSet(QuestionLoc,
4755 OverloadCandidateSet::CSK_Operator);
4756 Self.AddBuiltinOperatorCandidates(OO_Conditional, QuestionLoc, Args,
4759 OverloadCandidateSet::iterator Best;
4760 switch (CandidateSet.BestViableFunction(Self, QuestionLoc, Best)) {
4762 // We found a match. Perform the conversions on the arguments and move on.
4764 Self.PerformImplicitConversion(LHS.get(), Best->BuiltinTypes.ParamTypes[0],
4765 Best->Conversions[0], Sema::AA_Converting);
4766 if (LHSRes.isInvalid())
4771 Self.PerformImplicitConversion(RHS.get(), Best->BuiltinTypes.ParamTypes[1],
4772 Best->Conversions[1], Sema::AA_Converting);
4773 if (RHSRes.isInvalid())
4777 Self.MarkFunctionReferenced(QuestionLoc, Best->Function);
4781 case OR_No_Viable_Function:
4783 // Emit a better diagnostic if one of the expressions is a null pointer
4784 // constant and the other is a pointer type. In this case, the user most
4785 // likely forgot to take the address of the other expression.
4786 if (Self.DiagnoseConditionalForNull(LHS.get(), RHS.get(), QuestionLoc))
4789 Self.Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
4790 << LHS.get()->getType() << RHS.get()->getType()
4791 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
4795 Self.Diag(QuestionLoc, diag::err_conditional_ambiguous_ovl)
4796 << LHS.get()->getType() << RHS.get()->getType()
4797 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
4798 // FIXME: Print the possible common types by printing the return types of
4799 // the viable candidates.
4803 llvm_unreachable("Conditional operator has only built-in overloads");
4808 /// \brief Perform an "extended" implicit conversion as returned by
4809 /// TryClassUnification.
4810 static bool ConvertForConditional(Sema &Self, ExprResult &E, QualType T) {
4811 InitializedEntity Entity = InitializedEntity::InitializeTemporary(T);
4812 InitializationKind Kind = InitializationKind::CreateCopy(E.get()->getLocStart(),
4814 Expr *Arg = E.get();
4815 InitializationSequence InitSeq(Self, Entity, Kind, Arg);
4816 ExprResult Result = InitSeq.Perform(Self, Entity, Kind, Arg);
4817 if (Result.isInvalid())
4824 /// \brief Check the operands of ?: under C++ semantics.
4826 /// See C++ [expr.cond]. Note that LHS is never null, even for the GNU x ?: y
4827 /// extension. In this case, LHS == Cond. (But they're not aliases.)
4828 QualType Sema::CXXCheckConditionalOperands(ExprResult &Cond, ExprResult &LHS,
4829 ExprResult &RHS, ExprValueKind &VK,
4831 SourceLocation QuestionLoc) {
4832 // FIXME: Handle C99's complex types, vector types, block pointers and Obj-C++
4833 // interface pointers.
4835 // C++11 [expr.cond]p1
4836 // The first expression is contextually converted to bool.
4837 if (!Cond.get()->isTypeDependent()) {
4838 ExprResult CondRes = CheckCXXBooleanCondition(Cond.get());
4839 if (CondRes.isInvalid())
4848 // Either of the arguments dependent?
4849 if (LHS.get()->isTypeDependent() || RHS.get()->isTypeDependent())
4850 return Context.DependentTy;
4852 // C++11 [expr.cond]p2
4853 // If either the second or the third operand has type (cv) void, ...
4854 QualType LTy = LHS.get()->getType();
4855 QualType RTy = RHS.get()->getType();
4856 bool LVoid = LTy->isVoidType();
4857 bool RVoid = RTy->isVoidType();
4858 if (LVoid || RVoid) {
4859 // ... one of the following shall hold:
4860 // -- The second or the third operand (but not both) is a (possibly
4861 // parenthesized) throw-expression; the result is of the type
4862 // and value category of the other.
4863 bool LThrow = isa<CXXThrowExpr>(LHS.get()->IgnoreParenImpCasts());
4864 bool RThrow = isa<CXXThrowExpr>(RHS.get()->IgnoreParenImpCasts());
4865 if (LThrow != RThrow) {
4866 Expr *NonThrow = LThrow ? RHS.get() : LHS.get();
4867 VK = NonThrow->getValueKind();
4868 // DR (no number yet): the result is a bit-field if the
4869 // non-throw-expression operand is a bit-field.
4870 OK = NonThrow->getObjectKind();
4871 return NonThrow->getType();
4874 // -- Both the second and third operands have type void; the result is of
4875 // type void and is a prvalue.
4877 return Context.VoidTy;
4879 // Neither holds, error.
4880 Diag(QuestionLoc, diag::err_conditional_void_nonvoid)
4881 << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1)
4882 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
4888 // C++11 [expr.cond]p3
4889 // Otherwise, if the second and third operand have different types, and
4890 // either has (cv) class type [...] an attempt is made to convert each of
4891 // those operands to the type of the other.
4892 if (!Context.hasSameType(LTy, RTy) &&
4893 (LTy->isRecordType() || RTy->isRecordType())) {
4894 // These return true if a single direction is already ambiguous.
4895 QualType L2RType, R2LType;
4896 bool HaveL2R, HaveR2L;
4897 if (TryClassUnification(*this, LHS.get(), RHS.get(), QuestionLoc, HaveL2R, L2RType))
4899 if (TryClassUnification(*this, RHS.get(), LHS.get(), QuestionLoc, HaveR2L, R2LType))
4902 // If both can be converted, [...] the program is ill-formed.
4903 if (HaveL2R && HaveR2L) {
4904 Diag(QuestionLoc, diag::err_conditional_ambiguous)
4905 << LTy << RTy << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
4909 // If exactly one conversion is possible, that conversion is applied to
4910 // the chosen operand and the converted operands are used in place of the
4911 // original operands for the remainder of this section.
4913 if (ConvertForConditional(*this, LHS, L2RType) || LHS.isInvalid())
4915 LTy = LHS.get()->getType();
4916 } else if (HaveR2L) {
4917 if (ConvertForConditional(*this, RHS, R2LType) || RHS.isInvalid())
4919 RTy = RHS.get()->getType();
4923 // C++11 [expr.cond]p3
4924 // if both are glvalues of the same value category and the same type except
4925 // for cv-qualification, an attempt is made to convert each of those
4926 // operands to the type of the other.
4927 ExprValueKind LVK = LHS.get()->getValueKind();
4928 ExprValueKind RVK = RHS.get()->getValueKind();
4929 if (!Context.hasSameType(LTy, RTy) &&
4930 Context.hasSameUnqualifiedType(LTy, RTy) &&
4931 LVK == RVK && LVK != VK_RValue) {
4932 // Since the unqualified types are reference-related and we require the
4933 // result to be as if a reference bound directly, the only conversion
4934 // we can perform is to add cv-qualifiers.
4935 Qualifiers LCVR = Qualifiers::fromCVRMask(LTy.getCVRQualifiers());
4936 Qualifiers RCVR = Qualifiers::fromCVRMask(RTy.getCVRQualifiers());
4937 if (RCVR.isStrictSupersetOf(LCVR)) {
4938 LHS = ImpCastExprToType(LHS.get(), RTy, CK_NoOp, LVK);
4939 LTy = LHS.get()->getType();
4941 else if (LCVR.isStrictSupersetOf(RCVR)) {
4942 RHS = ImpCastExprToType(RHS.get(), LTy, CK_NoOp, RVK);
4943 RTy = RHS.get()->getType();
4947 // C++11 [expr.cond]p4
4948 // If the second and third operands are glvalues of the same value
4949 // category and have the same type, the result is of that type and
4950 // value category and it is a bit-field if the second or the third
4951 // operand is a bit-field, or if both are bit-fields.
4952 // We only extend this to bitfields, not to the crazy other kinds of
4954 bool Same = Context.hasSameType(LTy, RTy);
4955 if (Same && LVK == RVK && LVK != VK_RValue &&
4956 LHS.get()->isOrdinaryOrBitFieldObject() &&
4957 RHS.get()->isOrdinaryOrBitFieldObject()) {
4958 VK = LHS.get()->getValueKind();
4959 if (LHS.get()->getObjectKind() == OK_BitField ||
4960 RHS.get()->getObjectKind() == OK_BitField)
4965 // C++11 [expr.cond]p5
4966 // Otherwise, the result is a prvalue. If the second and third operands
4967 // do not have the same type, and either has (cv) class type, ...
4968 if (!Same && (LTy->isRecordType() || RTy->isRecordType())) {
4969 // ... overload resolution is used to determine the conversions (if any)
4970 // to be applied to the operands. If the overload resolution fails, the
4971 // program is ill-formed.
4972 if (FindConditionalOverload(*this, LHS, RHS, QuestionLoc))
4976 // C++11 [expr.cond]p6
4977 // Lvalue-to-rvalue, array-to-pointer, and function-to-pointer standard
4978 // conversions are performed on the second and third operands.
4979 LHS = DefaultFunctionArrayLvalueConversion(LHS.get());
4980 RHS = DefaultFunctionArrayLvalueConversion(RHS.get());
4981 if (LHS.isInvalid() || RHS.isInvalid())
4983 LTy = LHS.get()->getType();
4984 RTy = RHS.get()->getType();
4986 // After those conversions, one of the following shall hold:
4987 // -- The second and third operands have the same type; the result
4988 // is of that type. If the operands have class type, the result
4989 // is a prvalue temporary of the result type, which is
4990 // copy-initialized from either the second operand or the third
4991 // operand depending on the value of the first operand.
4992 if (Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy)) {
4993 if (LTy->isRecordType()) {
4994 // The operands have class type. Make a temporary copy.
4995 if (RequireNonAbstractType(QuestionLoc, LTy,
4996 diag::err_allocation_of_abstract_type))
4998 InitializedEntity Entity = InitializedEntity::InitializeTemporary(LTy);
5000 ExprResult LHSCopy = PerformCopyInitialization(Entity,
5003 if (LHSCopy.isInvalid())
5006 ExprResult RHSCopy = PerformCopyInitialization(Entity,
5009 if (RHSCopy.isInvalid())
5019 // Extension: conditional operator involving vector types.
5020 if (LTy->isVectorType() || RTy->isVectorType())
5021 return CheckVectorOperands(LHS, RHS, QuestionLoc, /*isCompAssign*/false,
5022 /*AllowBothBool*/true,
5023 /*AllowBoolConversions*/false);
5025 // -- The second and third operands have arithmetic or enumeration type;
5026 // the usual arithmetic conversions are performed to bring them to a
5027 // common type, and the result is of that type.
5028 if (LTy->isArithmeticType() && RTy->isArithmeticType()) {
5029 QualType ResTy = UsualArithmeticConversions(LHS, RHS);
5030 if (LHS.isInvalid() || RHS.isInvalid())
5033 LHS = ImpCastExprToType(LHS.get(), ResTy, PrepareScalarCast(LHS, ResTy));
5034 RHS = ImpCastExprToType(RHS.get(), ResTy, PrepareScalarCast(RHS, ResTy));
5039 // -- The second and third operands have pointer type, or one has pointer
5040 // type and the other is a null pointer constant, or both are null
5041 // pointer constants, at least one of which is non-integral; pointer
5042 // conversions and qualification conversions are performed to bring them
5043 // to their composite pointer type. The result is of the composite
5045 // -- The second and third operands have pointer to member type, or one has
5046 // pointer to member type and the other is a null pointer constant;
5047 // pointer to member conversions and qualification conversions are
5048 // performed to bring them to a common type, whose cv-qualification
5049 // shall match the cv-qualification of either the second or the third
5050 // operand. The result is of the common type.
5051 bool NonStandardCompositeType = false;
5052 QualType Composite = FindCompositePointerType(QuestionLoc, LHS, RHS,
5053 isSFINAEContext() ? nullptr
5054 : &NonStandardCompositeType);
5055 if (!Composite.isNull()) {
5056 if (NonStandardCompositeType)
5058 diag::ext_typecheck_cond_incompatible_operands_nonstandard)
5059 << LTy << RTy << Composite
5060 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
5065 // Similarly, attempt to find composite type of two objective-c pointers.
5066 Composite = FindCompositeObjCPointerType(LHS, RHS, QuestionLoc);
5067 if (!Composite.isNull())
5070 // Check if we are using a null with a non-pointer type.
5071 if (DiagnoseConditionalForNull(LHS.get(), RHS.get(), QuestionLoc))
5074 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
5075 << LHS.get()->getType() << RHS.get()->getType()
5076 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
5080 /// \brief Find a merged pointer type and convert the two expressions to it.
5082 /// This finds the composite pointer type (or member pointer type) for @p E1
5083 /// and @p E2 according to C++11 5.9p2. It converts both expressions to this
5084 /// type and returns it.
5085 /// It does not emit diagnostics.
5087 /// \param Loc The location of the operator requiring these two expressions to
5088 /// be converted to the composite pointer type.
5090 /// If \p NonStandardCompositeType is non-NULL, then we are permitted to find
5091 /// a non-standard (but still sane) composite type to which both expressions
5092 /// can be converted. When such a type is chosen, \c *NonStandardCompositeType
5093 /// will be set true.
5094 QualType Sema::FindCompositePointerType(SourceLocation Loc,
5095 Expr *&E1, Expr *&E2,
5096 bool *NonStandardCompositeType) {
5097 if (NonStandardCompositeType)
5098 *NonStandardCompositeType = false;
5100 assert(getLangOpts().CPlusPlus && "This function assumes C++");
5101 QualType T1 = E1->getType(), T2 = E2->getType();
5104 // Pointer conversions and qualification conversions are performed on
5105 // pointer operands to bring them to their composite pointer type. If
5106 // one operand is a null pointer constant, the composite pointer type is
5107 // std::nullptr_t if the other operand is also a null pointer constant or,
5108 // if the other operand is a pointer, the type of the other operand.
5109 if (!T1->isAnyPointerType() && !T1->isMemberPointerType() &&
5110 !T2->isAnyPointerType() && !T2->isMemberPointerType()) {
5111 if (T1->isNullPtrType() &&
5112 E2->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
5113 E2 = ImpCastExprToType(E2, T1, CK_NullToPointer).get();
5116 if (T2->isNullPtrType() &&
5117 E1->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
5118 E1 = ImpCastExprToType(E1, T2, CK_NullToPointer).get();
5124 if (E1->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
5125 if (T2->isMemberPointerType())
5126 E1 = ImpCastExprToType(E1, T2, CK_NullToMemberPointer).get();
5128 E1 = ImpCastExprToType(E1, T2, CK_NullToPointer).get();
5131 if (E2->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
5132 if (T1->isMemberPointerType())
5133 E2 = ImpCastExprToType(E2, T1, CK_NullToMemberPointer).get();
5135 E2 = ImpCastExprToType(E2, T1, CK_NullToPointer).get();
5139 // Now both have to be pointers or member pointers.
5140 if ((!T1->isPointerType() && !T1->isMemberPointerType()) ||
5141 (!T2->isPointerType() && !T2->isMemberPointerType()))
5144 // Otherwise, of one of the operands has type "pointer to cv1 void," then
5145 // the other has type "pointer to cv2 T" and the composite pointer type is
5146 // "pointer to cv12 void," where cv12 is the union of cv1 and cv2.
5147 // Otherwise, the composite pointer type is a pointer type similar to the
5148 // type of one of the operands, with a cv-qualification signature that is
5149 // the union of the cv-qualification signatures of the operand types.
5150 // In practice, the first part here is redundant; it's subsumed by the second.
5151 // What we do here is, we build the two possible composite types, and try the
5152 // conversions in both directions. If only one works, or if the two composite
5153 // types are the same, we have succeeded.
5154 // FIXME: extended qualifiers?
5155 typedef SmallVector<unsigned, 4> QualifierVector;
5156 QualifierVector QualifierUnion;
5157 typedef SmallVector<std::pair<const Type *, const Type *>, 4>
5158 ContainingClassVector;
5159 ContainingClassVector MemberOfClass;
5160 QualType Composite1 = Context.getCanonicalType(T1),
5161 Composite2 = Context.getCanonicalType(T2);
5162 unsigned NeedConstBefore = 0;
5164 const PointerType *Ptr1, *Ptr2;
5165 if ((Ptr1 = Composite1->getAs<PointerType>()) &&
5166 (Ptr2 = Composite2->getAs<PointerType>())) {
5167 Composite1 = Ptr1->getPointeeType();
5168 Composite2 = Ptr2->getPointeeType();
5170 // If we're allowed to create a non-standard composite type, keep track
5171 // of where we need to fill in additional 'const' qualifiers.
5172 if (NonStandardCompositeType &&
5173 Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers())
5174 NeedConstBefore = QualifierUnion.size();
5176 QualifierUnion.push_back(
5177 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers());
5178 MemberOfClass.push_back(std::make_pair(nullptr, nullptr));
5182 const MemberPointerType *MemPtr1, *MemPtr2;
5183 if ((MemPtr1 = Composite1->getAs<MemberPointerType>()) &&
5184 (MemPtr2 = Composite2->getAs<MemberPointerType>())) {
5185 Composite1 = MemPtr1->getPointeeType();
5186 Composite2 = MemPtr2->getPointeeType();
5188 // If we're allowed to create a non-standard composite type, keep track
5189 // of where we need to fill in additional 'const' qualifiers.
5190 if (NonStandardCompositeType &&
5191 Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers())
5192 NeedConstBefore = QualifierUnion.size();
5194 QualifierUnion.push_back(
5195 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers());
5196 MemberOfClass.push_back(std::make_pair(MemPtr1->getClass(),
5197 MemPtr2->getClass()));
5201 // FIXME: block pointer types?
5203 // Cannot unwrap any more types.
5207 if (NeedConstBefore && NonStandardCompositeType) {
5208 // Extension: Add 'const' to qualifiers that come before the first qualifier
5209 // mismatch, so that our (non-standard!) composite type meets the
5210 // requirements of C++ [conv.qual]p4 bullet 3.
5211 for (unsigned I = 0; I != NeedConstBefore; ++I) {
5212 if ((QualifierUnion[I] & Qualifiers::Const) == 0) {
5213 QualifierUnion[I] = QualifierUnion[I] | Qualifiers::Const;
5214 *NonStandardCompositeType = true;
5219 // Rewrap the composites as pointers or member pointers with the union CVRs.
5220 ContainingClassVector::reverse_iterator MOC
5221 = MemberOfClass.rbegin();
5222 for (QualifierVector::reverse_iterator
5223 I = QualifierUnion.rbegin(),
5224 E = QualifierUnion.rend();
5225 I != E; (void)++I, ++MOC) {
5226 Qualifiers Quals = Qualifiers::fromCVRMask(*I);
5227 if (MOC->first && MOC->second) {
5228 // Rebuild member pointer type
5229 Composite1 = Context.getMemberPointerType(
5230 Context.getQualifiedType(Composite1, Quals),
5232 Composite2 = Context.getMemberPointerType(
5233 Context.getQualifiedType(Composite2, Quals),
5236 // Rebuild pointer type
5238 = Context.getPointerType(Context.getQualifiedType(Composite1, Quals));
5240 = Context.getPointerType(Context.getQualifiedType(Composite2, Quals));
5244 // Try to convert to the first composite pointer type.
5245 InitializedEntity Entity1
5246 = InitializedEntity::InitializeTemporary(Composite1);
5247 InitializationKind Kind
5248 = InitializationKind::CreateCopy(Loc, SourceLocation());
5249 InitializationSequence E1ToC1(*this, Entity1, Kind, E1);
5250 InitializationSequence E2ToC1(*this, Entity1, Kind, E2);
5252 if (E1ToC1 && E2ToC1) {
5253 // Conversion to Composite1 is viable.
5254 if (!Context.hasSameType(Composite1, Composite2)) {
5255 // Composite2 is a different type from Composite1. Check whether
5256 // Composite2 is also viable.
5257 InitializedEntity Entity2
5258 = InitializedEntity::InitializeTemporary(Composite2);
5259 InitializationSequence E1ToC2(*this, Entity2, Kind, E1);
5260 InitializationSequence E2ToC2(*this, Entity2, Kind, E2);
5261 if (E1ToC2 && E2ToC2) {
5262 // Both Composite1 and Composite2 are viable and are different;
5263 // this is an ambiguity.
5268 // Convert E1 to Composite1
5270 = E1ToC1.Perform(*this, Entity1, Kind, E1);
5271 if (E1Result.isInvalid())
5273 E1 = E1Result.getAs<Expr>();
5275 // Convert E2 to Composite1
5277 = E2ToC1.Perform(*this, Entity1, Kind, E2);
5278 if (E2Result.isInvalid())
5280 E2 = E2Result.getAs<Expr>();
5285 // Check whether Composite2 is viable.
5286 InitializedEntity Entity2
5287 = InitializedEntity::InitializeTemporary(Composite2);
5288 InitializationSequence E1ToC2(*this, Entity2, Kind, E1);
5289 InitializationSequence E2ToC2(*this, Entity2, Kind, E2);
5290 if (!E1ToC2 || !E2ToC2)
5293 // Convert E1 to Composite2
5295 = E1ToC2.Perform(*this, Entity2, Kind, E1);
5296 if (E1Result.isInvalid())
5298 E1 = E1Result.getAs<Expr>();
5300 // Convert E2 to Composite2
5302 = E2ToC2.Perform(*this, Entity2, Kind, E2);
5303 if (E2Result.isInvalid())
5305 E2 = E2Result.getAs<Expr>();
5310 ExprResult Sema::MaybeBindToTemporary(Expr *E) {
5314 assert(!isa<CXXBindTemporaryExpr>(E) && "Double-bound temporary?");
5316 // If the result is a glvalue, we shouldn't bind it.
5320 // In ARC, calls that return a retainable type can return retained,
5321 // in which case we have to insert a consuming cast.
5322 if (getLangOpts().ObjCAutoRefCount &&
5323 E->getType()->isObjCRetainableType()) {
5325 bool ReturnsRetained;
5327 // For actual calls, we compute this by examining the type of the
5329 if (CallExpr *Call = dyn_cast<CallExpr>(E)) {
5330 Expr *Callee = Call->getCallee()->IgnoreParens();
5331 QualType T = Callee->getType();
5333 if (T == Context.BoundMemberTy) {
5334 // Handle pointer-to-members.
5335 if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(Callee))
5336 T = BinOp->getRHS()->getType();
5337 else if (MemberExpr *Mem = dyn_cast<MemberExpr>(Callee))
5338 T = Mem->getMemberDecl()->getType();
5341 if (const PointerType *Ptr = T->getAs<PointerType>())
5342 T = Ptr->getPointeeType();
5343 else if (const BlockPointerType *Ptr = T->getAs<BlockPointerType>())
5344 T = Ptr->getPointeeType();
5345 else if (const MemberPointerType *MemPtr = T->getAs<MemberPointerType>())
5346 T = MemPtr->getPointeeType();
5348 const FunctionType *FTy = T->getAs<FunctionType>();
5349 assert(FTy && "call to value not of function type?");
5350 ReturnsRetained = FTy->getExtInfo().getProducesResult();
5352 // ActOnStmtExpr arranges things so that StmtExprs of retainable
5353 // type always produce a +1 object.
5354 } else if (isa<StmtExpr>(E)) {
5355 ReturnsRetained = true;
5357 // We hit this case with the lambda conversion-to-block optimization;
5358 // we don't want any extra casts here.
5359 } else if (isa<CastExpr>(E) &&
5360 isa<BlockExpr>(cast<CastExpr>(E)->getSubExpr())) {
5363 // For message sends and property references, we try to find an
5364 // actual method. FIXME: we should infer retention by selector in
5365 // cases where we don't have an actual method.
5367 ObjCMethodDecl *D = nullptr;
5368 if (ObjCMessageExpr *Send = dyn_cast<ObjCMessageExpr>(E)) {
5369 D = Send->getMethodDecl();
5370 } else if (ObjCBoxedExpr *BoxedExpr = dyn_cast<ObjCBoxedExpr>(E)) {
5371 D = BoxedExpr->getBoxingMethod();
5372 } else if (ObjCArrayLiteral *ArrayLit = dyn_cast<ObjCArrayLiteral>(E)) {
5373 D = ArrayLit->getArrayWithObjectsMethod();
5374 } else if (ObjCDictionaryLiteral *DictLit
5375 = dyn_cast<ObjCDictionaryLiteral>(E)) {
5376 D = DictLit->getDictWithObjectsMethod();
5379 ReturnsRetained = (D && D->hasAttr<NSReturnsRetainedAttr>());
5381 // Don't do reclaims on performSelector calls; despite their
5382 // return type, the invoked method doesn't necessarily actually
5383 // return an object.
5384 if (!ReturnsRetained &&
5385 D && D->getMethodFamily() == OMF_performSelector)
5389 // Don't reclaim an object of Class type.
5390 if (!ReturnsRetained && E->getType()->isObjCARCImplicitlyUnretainedType())
5393 ExprNeedsCleanups = true;
5395 CastKind ck = (ReturnsRetained ? CK_ARCConsumeObject
5396 : CK_ARCReclaimReturnedObject);
5397 return ImplicitCastExpr::Create(Context, E->getType(), ck, E, nullptr,
5401 if (!getLangOpts().CPlusPlus)
5404 // Search for the base element type (cf. ASTContext::getBaseElementType) with
5405 // a fast path for the common case that the type is directly a RecordType.
5406 const Type *T = Context.getCanonicalType(E->getType().getTypePtr());
5407 const RecordType *RT = nullptr;
5409 switch (T->getTypeClass()) {
5411 RT = cast<RecordType>(T);
5413 case Type::ConstantArray:
5414 case Type::IncompleteArray:
5415 case Type::VariableArray:
5416 case Type::DependentSizedArray:
5417 T = cast<ArrayType>(T)->getElementType().getTypePtr();
5424 // That should be enough to guarantee that this type is complete, if we're
5425 // not processing a decltype expression.
5426 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
5427 if (RD->isInvalidDecl() || RD->isDependentContext())
5430 bool IsDecltype = ExprEvalContexts.back().IsDecltype;
5431 CXXDestructorDecl *Destructor = IsDecltype ? nullptr : LookupDestructor(RD);
5434 MarkFunctionReferenced(E->getExprLoc(), Destructor);
5435 CheckDestructorAccess(E->getExprLoc(), Destructor,
5436 PDiag(diag::err_access_dtor_temp)
5438 if (DiagnoseUseOfDecl(Destructor, E->getExprLoc()))
5441 // If destructor is trivial, we can avoid the extra copy.
5442 if (Destructor->isTrivial())
5445 // We need a cleanup, but we don't need to remember the temporary.
5446 ExprNeedsCleanups = true;
5449 CXXTemporary *Temp = CXXTemporary::Create(Context, Destructor);
5450 CXXBindTemporaryExpr *Bind = CXXBindTemporaryExpr::Create(Context, Temp, E);
5453 ExprEvalContexts.back().DelayedDecltypeBinds.push_back(Bind);
5459 Sema::MaybeCreateExprWithCleanups(ExprResult SubExpr) {
5460 if (SubExpr.isInvalid())
5463 return MaybeCreateExprWithCleanups(SubExpr.get());
5466 Expr *Sema::MaybeCreateExprWithCleanups(Expr *SubExpr) {
5467 assert(SubExpr && "subexpression can't be null!");
5469 CleanupVarDeclMarking();
5471 unsigned FirstCleanup = ExprEvalContexts.back().NumCleanupObjects;
5472 assert(ExprCleanupObjects.size() >= FirstCleanup);
5473 assert(ExprNeedsCleanups || ExprCleanupObjects.size() == FirstCleanup);
5474 if (!ExprNeedsCleanups)
5477 auto Cleanups = llvm::makeArrayRef(ExprCleanupObjects.begin() + FirstCleanup,
5478 ExprCleanupObjects.size() - FirstCleanup);
5480 Expr *E = ExprWithCleanups::Create(Context, SubExpr, Cleanups);
5481 DiscardCleanupsInEvaluationContext();
5486 Stmt *Sema::MaybeCreateStmtWithCleanups(Stmt *SubStmt) {
5487 assert(SubStmt && "sub-statement can't be null!");
5489 CleanupVarDeclMarking();
5491 if (!ExprNeedsCleanups)
5494 // FIXME: In order to attach the temporaries, wrap the statement into
5495 // a StmtExpr; currently this is only used for asm statements.
5496 // This is hacky, either create a new CXXStmtWithTemporaries statement or
5497 // a new AsmStmtWithTemporaries.
5498 CompoundStmt *CompStmt = new (Context) CompoundStmt(Context, SubStmt,
5501 Expr *E = new (Context) StmtExpr(CompStmt, Context.VoidTy, SourceLocation(),
5503 return MaybeCreateExprWithCleanups(E);
5506 /// Process the expression contained within a decltype. For such expressions,
5507 /// certain semantic checks on temporaries are delayed until this point, and
5508 /// are omitted for the 'topmost' call in the decltype expression. If the
5509 /// topmost call bound a temporary, strip that temporary off the expression.
5510 ExprResult Sema::ActOnDecltypeExpression(Expr *E) {
5511 assert(ExprEvalContexts.back().IsDecltype && "not in a decltype expression");
5513 // C++11 [expr.call]p11:
5514 // If a function call is a prvalue of object type,
5515 // -- if the function call is either
5516 // -- the operand of a decltype-specifier, or
5517 // -- the right operand of a comma operator that is the operand of a
5518 // decltype-specifier,
5519 // a temporary object is not introduced for the prvalue.
5521 // Recursively rebuild ParenExprs and comma expressions to strip out the
5522 // outermost CXXBindTemporaryExpr, if any.
5523 if (ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
5524 ExprResult SubExpr = ActOnDecltypeExpression(PE->getSubExpr());
5525 if (SubExpr.isInvalid())
5527 if (SubExpr.get() == PE->getSubExpr())
5529 return ActOnParenExpr(PE->getLParen(), PE->getRParen(), SubExpr.get());
5531 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
5532 if (BO->getOpcode() == BO_Comma) {
5533 ExprResult RHS = ActOnDecltypeExpression(BO->getRHS());
5534 if (RHS.isInvalid())
5536 if (RHS.get() == BO->getRHS())
5538 return new (Context) BinaryOperator(
5539 BO->getLHS(), RHS.get(), BO_Comma, BO->getType(), BO->getValueKind(),
5540 BO->getObjectKind(), BO->getOperatorLoc(), BO->isFPContractable());
5544 CXXBindTemporaryExpr *TopBind = dyn_cast<CXXBindTemporaryExpr>(E);
5545 CallExpr *TopCall = TopBind ? dyn_cast<CallExpr>(TopBind->getSubExpr())
5552 // Disable the special decltype handling now.
5553 ExprEvalContexts.back().IsDecltype = false;
5555 // In MS mode, don't perform any extra checking of call return types within a
5556 // decltype expression.
5557 if (getLangOpts().MSVCCompat)
5560 // Perform the semantic checks we delayed until this point.
5561 for (unsigned I = 0, N = ExprEvalContexts.back().DelayedDecltypeCalls.size();
5563 CallExpr *Call = ExprEvalContexts.back().DelayedDecltypeCalls[I];
5564 if (Call == TopCall)
5567 if (CheckCallReturnType(Call->getCallReturnType(Context),
5568 Call->getLocStart(),
5569 Call, Call->getDirectCallee()))
5573 // Now all relevant types are complete, check the destructors are accessible
5574 // and non-deleted, and annotate them on the temporaries.
5575 for (unsigned I = 0, N = ExprEvalContexts.back().DelayedDecltypeBinds.size();
5577 CXXBindTemporaryExpr *Bind =
5578 ExprEvalContexts.back().DelayedDecltypeBinds[I];
5579 if (Bind == TopBind)
5582 CXXTemporary *Temp = Bind->getTemporary();
5585 Bind->getType()->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
5586 CXXDestructorDecl *Destructor = LookupDestructor(RD);
5587 Temp->setDestructor(Destructor);
5589 MarkFunctionReferenced(Bind->getExprLoc(), Destructor);
5590 CheckDestructorAccess(Bind->getExprLoc(), Destructor,
5591 PDiag(diag::err_access_dtor_temp)
5592 << Bind->getType());
5593 if (DiagnoseUseOfDecl(Destructor, Bind->getExprLoc()))
5596 // We need a cleanup, but we don't need to remember the temporary.
5597 ExprNeedsCleanups = true;
5600 // Possibly strip off the top CXXBindTemporaryExpr.
5604 /// Note a set of 'operator->' functions that were used for a member access.
5605 static void noteOperatorArrows(Sema &S,
5606 ArrayRef<FunctionDecl *> OperatorArrows) {
5607 unsigned SkipStart = OperatorArrows.size(), SkipCount = 0;
5608 // FIXME: Make this configurable?
5610 if (OperatorArrows.size() > Limit) {
5611 // Produce Limit-1 normal notes and one 'skipping' note.
5612 SkipStart = (Limit - 1) / 2 + (Limit - 1) % 2;
5613 SkipCount = OperatorArrows.size() - (Limit - 1);
5616 for (unsigned I = 0; I < OperatorArrows.size(); /**/) {
5617 if (I == SkipStart) {
5618 S.Diag(OperatorArrows[I]->getLocation(),
5619 diag::note_operator_arrows_suppressed)
5623 S.Diag(OperatorArrows[I]->getLocation(), diag::note_operator_arrow_here)
5624 << OperatorArrows[I]->getCallResultType();
5630 ExprResult Sema::ActOnStartCXXMemberReference(Scope *S, Expr *Base,
5631 SourceLocation OpLoc,
5632 tok::TokenKind OpKind,
5633 ParsedType &ObjectType,
5634 bool &MayBePseudoDestructor) {
5635 // Since this might be a postfix expression, get rid of ParenListExprs.
5636 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Base);
5637 if (Result.isInvalid()) return ExprError();
5638 Base = Result.get();
5640 Result = CheckPlaceholderExpr(Base);
5641 if (Result.isInvalid()) return ExprError();
5642 Base = Result.get();
5644 QualType BaseType = Base->getType();
5645 MayBePseudoDestructor = false;
5646 if (BaseType->isDependentType()) {
5647 // If we have a pointer to a dependent type and are using the -> operator,
5648 // the object type is the type that the pointer points to. We might still
5649 // have enough information about that type to do something useful.
5650 if (OpKind == tok::arrow)
5651 if (const PointerType *Ptr = BaseType->getAs<PointerType>())
5652 BaseType = Ptr->getPointeeType();
5654 ObjectType = ParsedType::make(BaseType);
5655 MayBePseudoDestructor = true;
5659 // C++ [over.match.oper]p8:
5660 // [...] When operator->returns, the operator-> is applied to the value
5661 // returned, with the original second operand.
5662 if (OpKind == tok::arrow) {
5663 QualType StartingType = BaseType;
5664 bool NoArrowOperatorFound = false;
5665 bool FirstIteration = true;
5666 FunctionDecl *CurFD = dyn_cast<FunctionDecl>(CurContext);
5667 // The set of types we've considered so far.
5668 llvm::SmallPtrSet<CanQualType,8> CTypes;
5669 SmallVector<FunctionDecl*, 8> OperatorArrows;
5670 CTypes.insert(Context.getCanonicalType(BaseType));
5672 while (BaseType->isRecordType()) {
5673 if (OperatorArrows.size() >= getLangOpts().ArrowDepth) {
5674 Diag(OpLoc, diag::err_operator_arrow_depth_exceeded)
5675 << StartingType << getLangOpts().ArrowDepth << Base->getSourceRange();
5676 noteOperatorArrows(*this, OperatorArrows);
5677 Diag(OpLoc, diag::note_operator_arrow_depth)
5678 << getLangOpts().ArrowDepth;
5682 Result = BuildOverloadedArrowExpr(
5684 // When in a template specialization and on the first loop iteration,
5685 // potentially give the default diagnostic (with the fixit in a
5686 // separate note) instead of having the error reported back to here
5687 // and giving a diagnostic with a fixit attached to the error itself.
5688 (FirstIteration && CurFD && CurFD->isFunctionTemplateSpecialization())
5690 : &NoArrowOperatorFound);
5691 if (Result.isInvalid()) {
5692 if (NoArrowOperatorFound) {
5693 if (FirstIteration) {
5694 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
5695 << BaseType << 1 << Base->getSourceRange()
5696 << FixItHint::CreateReplacement(OpLoc, ".");
5697 OpKind = tok::period;
5700 Diag(OpLoc, diag::err_typecheck_member_reference_arrow)
5701 << BaseType << Base->getSourceRange();
5702 CallExpr *CE = dyn_cast<CallExpr>(Base);
5703 if (Decl *CD = (CE ? CE->getCalleeDecl() : nullptr)) {
5704 Diag(CD->getLocStart(),
5705 diag::note_member_reference_arrow_from_operator_arrow);
5710 Base = Result.get();
5711 if (CXXOperatorCallExpr *OpCall = dyn_cast<CXXOperatorCallExpr>(Base))
5712 OperatorArrows.push_back(OpCall->getDirectCallee());
5713 BaseType = Base->getType();
5714 CanQualType CBaseType = Context.getCanonicalType(BaseType);
5715 if (!CTypes.insert(CBaseType).second) {
5716 Diag(OpLoc, diag::err_operator_arrow_circular) << StartingType;
5717 noteOperatorArrows(*this, OperatorArrows);
5720 FirstIteration = false;
5723 if (OpKind == tok::arrow &&
5724 (BaseType->isPointerType() || BaseType->isObjCObjectPointerType()))
5725 BaseType = BaseType->getPointeeType();
5728 // Objective-C properties allow "." access on Objective-C pointer types,
5729 // so adjust the base type to the object type itself.
5730 if (BaseType->isObjCObjectPointerType())
5731 BaseType = BaseType->getPointeeType();
5733 // C++ [basic.lookup.classref]p2:
5734 // [...] If the type of the object expression is of pointer to scalar
5735 // type, the unqualified-id is looked up in the context of the complete
5736 // postfix-expression.
5738 // This also indicates that we could be parsing a pseudo-destructor-name.
5739 // Note that Objective-C class and object types can be pseudo-destructor
5740 // expressions or normal member (ivar or property) access expressions, and
5741 // it's legal for the type to be incomplete if this is a pseudo-destructor
5742 // call. We'll do more incomplete-type checks later in the lookup process,
5743 // so just skip this check for ObjC types.
5744 if (BaseType->isObjCObjectOrInterfaceType()) {
5745 ObjectType = ParsedType::make(BaseType);
5746 MayBePseudoDestructor = true;
5748 } else if (!BaseType->isRecordType()) {
5749 ObjectType = ParsedType();
5750 MayBePseudoDestructor = true;
5754 // The object type must be complete (or dependent), or
5755 // C++11 [expr.prim.general]p3:
5756 // Unlike the object expression in other contexts, *this is not required to
5757 // be of complete type for purposes of class member access (5.2.5) outside
5758 // the member function body.
5759 if (!BaseType->isDependentType() &&
5760 !isThisOutsideMemberFunctionBody(BaseType) &&
5761 RequireCompleteType(OpLoc, BaseType, diag::err_incomplete_member_access))
5764 // C++ [basic.lookup.classref]p2:
5765 // If the id-expression in a class member access (5.2.5) is an
5766 // unqualified-id, and the type of the object expression is of a class
5767 // type C (or of pointer to a class type C), the unqualified-id is looked
5768 // up in the scope of class C. [...]
5769 ObjectType = ParsedType::make(BaseType);
5773 static bool CheckArrow(Sema& S, QualType& ObjectType, Expr *&Base,
5774 tok::TokenKind& OpKind, SourceLocation OpLoc) {
5775 if (Base->hasPlaceholderType()) {
5776 ExprResult result = S.CheckPlaceholderExpr(Base);
5777 if (result.isInvalid()) return true;
5778 Base = result.get();
5780 ObjectType = Base->getType();
5782 // C++ [expr.pseudo]p2:
5783 // The left-hand side of the dot operator shall be of scalar type. The
5784 // left-hand side of the arrow operator shall be of pointer to scalar type.
5785 // This scalar type is the object type.
5786 // Note that this is rather different from the normal handling for the
5788 if (OpKind == tok::arrow) {
5789 if (const PointerType *Ptr = ObjectType->getAs<PointerType>()) {
5790 ObjectType = Ptr->getPointeeType();
5791 } else if (!Base->isTypeDependent()) {
5792 // The user wrote "p->" when she probably meant "p."; fix it.
5793 S.Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
5794 << ObjectType << true
5795 << FixItHint::CreateReplacement(OpLoc, ".");
5796 if (S.isSFINAEContext())
5799 OpKind = tok::period;
5806 ExprResult Sema::BuildPseudoDestructorExpr(Expr *Base,
5807 SourceLocation OpLoc,
5808 tok::TokenKind OpKind,
5809 const CXXScopeSpec &SS,
5810 TypeSourceInfo *ScopeTypeInfo,
5811 SourceLocation CCLoc,
5812 SourceLocation TildeLoc,
5813 PseudoDestructorTypeStorage Destructed) {
5814 TypeSourceInfo *DestructedTypeInfo = Destructed.getTypeSourceInfo();
5816 QualType ObjectType;
5817 if (CheckArrow(*this, ObjectType, Base, OpKind, OpLoc))
5820 if (!ObjectType->isDependentType() && !ObjectType->isScalarType() &&
5821 !ObjectType->isVectorType()) {
5822 if (getLangOpts().MSVCCompat && ObjectType->isVoidType())
5823 Diag(OpLoc, diag::ext_pseudo_dtor_on_void) << Base->getSourceRange();
5825 Diag(OpLoc, diag::err_pseudo_dtor_base_not_scalar)
5826 << ObjectType << Base->getSourceRange();
5831 // C++ [expr.pseudo]p2:
5832 // [...] The cv-unqualified versions of the object type and of the type
5833 // designated by the pseudo-destructor-name shall be the same type.
5834 if (DestructedTypeInfo) {
5835 QualType DestructedType = DestructedTypeInfo->getType();
5836 SourceLocation DestructedTypeStart
5837 = DestructedTypeInfo->getTypeLoc().getLocalSourceRange().getBegin();
5838 if (!DestructedType->isDependentType() && !ObjectType->isDependentType()) {
5839 if (!Context.hasSameUnqualifiedType(DestructedType, ObjectType)) {
5840 Diag(DestructedTypeStart, diag::err_pseudo_dtor_type_mismatch)
5841 << ObjectType << DestructedType << Base->getSourceRange()
5842 << DestructedTypeInfo->getTypeLoc().getLocalSourceRange();
5844 // Recover by setting the destructed type to the object type.
5845 DestructedType = ObjectType;
5846 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(ObjectType,
5847 DestructedTypeStart);
5848 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo);
5849 } else if (DestructedType.getObjCLifetime() !=
5850 ObjectType.getObjCLifetime()) {
5852 if (DestructedType.getObjCLifetime() == Qualifiers::OCL_None) {
5853 // Okay: just pretend that the user provided the correctly-qualified
5856 Diag(DestructedTypeStart, diag::err_arc_pseudo_dtor_inconstant_quals)
5857 << ObjectType << DestructedType << Base->getSourceRange()
5858 << DestructedTypeInfo->getTypeLoc().getLocalSourceRange();
5861 // Recover by setting the destructed type to the object type.
5862 DestructedType = ObjectType;
5863 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(ObjectType,
5864 DestructedTypeStart);
5865 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo);
5870 // C++ [expr.pseudo]p2:
5871 // [...] Furthermore, the two type-names in a pseudo-destructor-name of the
5874 // ::[opt] nested-name-specifier[opt] type-name :: ~ type-name
5876 // shall designate the same scalar type.
5877 if (ScopeTypeInfo) {
5878 QualType ScopeType = ScopeTypeInfo->getType();
5879 if (!ScopeType->isDependentType() && !ObjectType->isDependentType() &&
5880 !Context.hasSameUnqualifiedType(ScopeType, ObjectType)) {
5882 Diag(ScopeTypeInfo->getTypeLoc().getLocalSourceRange().getBegin(),
5883 diag::err_pseudo_dtor_type_mismatch)
5884 << ObjectType << ScopeType << Base->getSourceRange()
5885 << ScopeTypeInfo->getTypeLoc().getLocalSourceRange();
5887 ScopeType = QualType();
5888 ScopeTypeInfo = nullptr;
5893 = new (Context) CXXPseudoDestructorExpr(Context, Base,
5894 OpKind == tok::arrow, OpLoc,
5895 SS.getWithLocInContext(Context),
5904 ExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, Expr *Base,
5905 SourceLocation OpLoc,
5906 tok::TokenKind OpKind,
5908 UnqualifiedId &FirstTypeName,
5909 SourceLocation CCLoc,
5910 SourceLocation TildeLoc,
5911 UnqualifiedId &SecondTypeName) {
5912 assert((FirstTypeName.getKind() == UnqualifiedId::IK_TemplateId ||
5913 FirstTypeName.getKind() == UnqualifiedId::IK_Identifier) &&
5914 "Invalid first type name in pseudo-destructor");
5915 assert((SecondTypeName.getKind() == UnqualifiedId::IK_TemplateId ||
5916 SecondTypeName.getKind() == UnqualifiedId::IK_Identifier) &&
5917 "Invalid second type name in pseudo-destructor");
5919 QualType ObjectType;
5920 if (CheckArrow(*this, ObjectType, Base, OpKind, OpLoc))
5923 // Compute the object type that we should use for name lookup purposes. Only
5924 // record types and dependent types matter.
5925 ParsedType ObjectTypePtrForLookup;
5927 if (ObjectType->isRecordType())
5928 ObjectTypePtrForLookup = ParsedType::make(ObjectType);
5929 else if (ObjectType->isDependentType())
5930 ObjectTypePtrForLookup = ParsedType::make(Context.DependentTy);
5933 // Convert the name of the type being destructed (following the ~) into a
5934 // type (with source-location information).
5935 QualType DestructedType;
5936 TypeSourceInfo *DestructedTypeInfo = nullptr;
5937 PseudoDestructorTypeStorage Destructed;
5938 if (SecondTypeName.getKind() == UnqualifiedId::IK_Identifier) {
5939 ParsedType T = getTypeName(*SecondTypeName.Identifier,
5940 SecondTypeName.StartLocation,
5941 S, &SS, true, false, ObjectTypePtrForLookup);
5943 ((SS.isSet() && !computeDeclContext(SS, false)) ||
5944 (!SS.isSet() && ObjectType->isDependentType()))) {
5945 // The name of the type being destroyed is a dependent name, and we
5946 // couldn't find anything useful in scope. Just store the identifier and
5947 // it's location, and we'll perform (qualified) name lookup again at
5948 // template instantiation time.
5949 Destructed = PseudoDestructorTypeStorage(SecondTypeName.Identifier,
5950 SecondTypeName.StartLocation);
5952 Diag(SecondTypeName.StartLocation,
5953 diag::err_pseudo_dtor_destructor_non_type)
5954 << SecondTypeName.Identifier << ObjectType;
5955 if (isSFINAEContext())
5958 // Recover by assuming we had the right type all along.
5959 DestructedType = ObjectType;
5961 DestructedType = GetTypeFromParser(T, &DestructedTypeInfo);
5963 // Resolve the template-id to a type.
5964 TemplateIdAnnotation *TemplateId = SecondTypeName.TemplateId;
5965 ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
5966 TemplateId->NumArgs);
5967 TypeResult T = ActOnTemplateIdType(TemplateId->SS,
5968 TemplateId->TemplateKWLoc,
5969 TemplateId->Template,
5970 TemplateId->TemplateNameLoc,
5971 TemplateId->LAngleLoc,
5973 TemplateId->RAngleLoc);
5974 if (T.isInvalid() || !T.get()) {
5975 // Recover by assuming we had the right type all along.
5976 DestructedType = ObjectType;
5978 DestructedType = GetTypeFromParser(T.get(), &DestructedTypeInfo);
5981 // If we've performed some kind of recovery, (re-)build the type source
5983 if (!DestructedType.isNull()) {
5984 if (!DestructedTypeInfo)
5985 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(DestructedType,
5986 SecondTypeName.StartLocation);
5987 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo);
5990 // Convert the name of the scope type (the type prior to '::') into a type.
5991 TypeSourceInfo *ScopeTypeInfo = nullptr;
5993 if (FirstTypeName.getKind() == UnqualifiedId::IK_TemplateId ||
5994 FirstTypeName.Identifier) {
5995 if (FirstTypeName.getKind() == UnqualifiedId::IK_Identifier) {
5996 ParsedType T = getTypeName(*FirstTypeName.Identifier,
5997 FirstTypeName.StartLocation,
5998 S, &SS, true, false, ObjectTypePtrForLookup);
6000 Diag(FirstTypeName.StartLocation,
6001 diag::err_pseudo_dtor_destructor_non_type)
6002 << FirstTypeName.Identifier << ObjectType;
6004 if (isSFINAEContext())
6007 // Just drop this type. It's unnecessary anyway.
6008 ScopeType = QualType();
6010 ScopeType = GetTypeFromParser(T, &ScopeTypeInfo);
6012 // Resolve the template-id to a type.
6013 TemplateIdAnnotation *TemplateId = FirstTypeName.TemplateId;
6014 ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
6015 TemplateId->NumArgs);
6016 TypeResult T = ActOnTemplateIdType(TemplateId->SS,
6017 TemplateId->TemplateKWLoc,
6018 TemplateId->Template,
6019 TemplateId->TemplateNameLoc,
6020 TemplateId->LAngleLoc,
6022 TemplateId->RAngleLoc);
6023 if (T.isInvalid() || !T.get()) {
6024 // Recover by dropping this type.
6025 ScopeType = QualType();
6027 ScopeType = GetTypeFromParser(T.get(), &ScopeTypeInfo);
6031 if (!ScopeType.isNull() && !ScopeTypeInfo)
6032 ScopeTypeInfo = Context.getTrivialTypeSourceInfo(ScopeType,
6033 FirstTypeName.StartLocation);
6036 return BuildPseudoDestructorExpr(Base, OpLoc, OpKind, SS,
6037 ScopeTypeInfo, CCLoc, TildeLoc,
6041 ExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, Expr *Base,
6042 SourceLocation OpLoc,
6043 tok::TokenKind OpKind,
6044 SourceLocation TildeLoc,
6045 const DeclSpec& DS) {
6046 QualType ObjectType;
6047 if (CheckArrow(*this, ObjectType, Base, OpKind, OpLoc))
6050 QualType T = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc(),
6054 DecltypeTypeLoc DecltypeTL = TLB.push<DecltypeTypeLoc>(T);
6055 DecltypeTL.setNameLoc(DS.getTypeSpecTypeLoc());
6056 TypeSourceInfo *DestructedTypeInfo = TLB.getTypeSourceInfo(Context, T);
6057 PseudoDestructorTypeStorage Destructed(DestructedTypeInfo);
6059 return BuildPseudoDestructorExpr(Base, OpLoc, OpKind, CXXScopeSpec(),
6060 nullptr, SourceLocation(), TildeLoc,
6064 ExprResult Sema::BuildCXXMemberCallExpr(Expr *E, NamedDecl *FoundDecl,
6065 CXXConversionDecl *Method,
6066 bool HadMultipleCandidates) {
6067 if (Method->getParent()->isLambda() &&
6068 Method->getConversionType()->isBlockPointerType()) {
6069 // This is a lambda coversion to block pointer; check if the argument
6072 CastExpr *CE = dyn_cast<CastExpr>(SubE);
6073 if (CE && CE->getCastKind() == CK_NoOp)
6074 SubE = CE->getSubExpr();
6075 SubE = SubE->IgnoreParens();
6076 if (CXXBindTemporaryExpr *BE = dyn_cast<CXXBindTemporaryExpr>(SubE))
6077 SubE = BE->getSubExpr();
6078 if (isa<LambdaExpr>(SubE)) {
6079 // For the conversion to block pointer on a lambda expression, we
6080 // construct a special BlockLiteral instead; this doesn't really make
6081 // a difference in ARC, but outside of ARC the resulting block literal
6082 // follows the normal lifetime rules for block literals instead of being
6084 DiagnosticErrorTrap Trap(Diags);
6085 ExprResult Exp = BuildBlockForLambdaConversion(E->getExprLoc(),
6088 if (Exp.isInvalid())
6089 Diag(E->getExprLoc(), diag::note_lambda_to_block_conv);
6094 ExprResult Exp = PerformObjectArgumentInitialization(E, /*Qualifier=*/nullptr,
6096 if (Exp.isInvalid())
6099 MemberExpr *ME = new (Context) MemberExpr(
6100 Exp.get(), /*IsArrow=*/false, SourceLocation(), Method, SourceLocation(),
6101 Context.BoundMemberTy, VK_RValue, OK_Ordinary);
6102 if (HadMultipleCandidates)
6103 ME->setHadMultipleCandidates(true);
6104 MarkMemberReferenced(ME);
6106 QualType ResultType = Method->getReturnType();
6107 ExprValueKind VK = Expr::getValueKindForType(ResultType);
6108 ResultType = ResultType.getNonLValueExprType(Context);
6110 CXXMemberCallExpr *CE =
6111 new (Context) CXXMemberCallExpr(Context, ME, None, ResultType, VK,
6112 Exp.get()->getLocEnd());
6116 ExprResult Sema::BuildCXXNoexceptExpr(SourceLocation KeyLoc, Expr *Operand,
6117 SourceLocation RParen) {
6118 // If the operand is an unresolved lookup expression, the expression is ill-
6119 // formed per [over.over]p1, because overloaded function names cannot be used
6120 // without arguments except in explicit contexts.
6121 ExprResult R = CheckPlaceholderExpr(Operand);
6125 // The operand may have been modified when checking the placeholder type.
6128 if (ActiveTemplateInstantiations.empty() &&
6129 Operand->HasSideEffects(Context, false)) {
6130 // The expression operand for noexcept is in an unevaluated expression
6131 // context, so side effects could result in unintended consequences.
6132 Diag(Operand->getExprLoc(), diag::warn_side_effects_unevaluated_context);
6135 CanThrowResult CanThrow = canThrow(Operand);
6136 return new (Context)
6137 CXXNoexceptExpr(Context.BoolTy, Operand, CanThrow, KeyLoc, RParen);
6140 ExprResult Sema::ActOnNoexceptExpr(SourceLocation KeyLoc, SourceLocation,
6141 Expr *Operand, SourceLocation RParen) {
6142 return BuildCXXNoexceptExpr(KeyLoc, Operand, RParen);
6145 static bool IsSpecialDiscardedValue(Expr *E) {
6146 // In C++11, discarded-value expressions of a certain form are special,
6147 // according to [expr]p10:
6148 // The lvalue-to-rvalue conversion (4.1) is applied only if the
6149 // expression is an lvalue of volatile-qualified type and it has
6150 // one of the following forms:
6151 E = E->IgnoreParens();
6153 // - id-expression (5.1.1),
6154 if (isa<DeclRefExpr>(E))
6157 // - subscripting (5.2.1),
6158 if (isa<ArraySubscriptExpr>(E))
6161 // - class member access (5.2.5),
6162 if (isa<MemberExpr>(E))
6165 // - indirection (5.3.1),
6166 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E))
6167 if (UO->getOpcode() == UO_Deref)
6170 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
6171 // - pointer-to-member operation (5.5),
6172 if (BO->isPtrMemOp())
6175 // - comma expression (5.18) where the right operand is one of the above.
6176 if (BO->getOpcode() == BO_Comma)
6177 return IsSpecialDiscardedValue(BO->getRHS());
6180 // - conditional expression (5.16) where both the second and the third
6181 // operands are one of the above, or
6182 if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E))
6183 return IsSpecialDiscardedValue(CO->getTrueExpr()) &&
6184 IsSpecialDiscardedValue(CO->getFalseExpr());
6185 // The related edge case of "*x ?: *x".
6186 if (BinaryConditionalOperator *BCO =
6187 dyn_cast<BinaryConditionalOperator>(E)) {
6188 if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(BCO->getTrueExpr()))
6189 return IsSpecialDiscardedValue(OVE->getSourceExpr()) &&
6190 IsSpecialDiscardedValue(BCO->getFalseExpr());
6193 // Objective-C++ extensions to the rule.
6194 if (isa<PseudoObjectExpr>(E) || isa<ObjCIvarRefExpr>(E))
6200 /// Perform the conversions required for an expression used in a
6201 /// context that ignores the result.
6202 ExprResult Sema::IgnoredValueConversions(Expr *E) {
6203 if (E->hasPlaceholderType()) {
6204 ExprResult result = CheckPlaceholderExpr(E);
6205 if (result.isInvalid()) return E;
6210 // [Except in specific positions,] an lvalue that does not have
6211 // array type is converted to the value stored in the
6212 // designated object (and is no longer an lvalue).
6213 if (E->isRValue()) {
6214 // In C, function designators (i.e. expressions of function type)
6215 // are r-values, but we still want to do function-to-pointer decay
6216 // on them. This is both technically correct and convenient for
6218 if (!getLangOpts().CPlusPlus && E->getType()->isFunctionType())
6219 return DefaultFunctionArrayConversion(E);
6224 if (getLangOpts().CPlusPlus) {
6225 // The C++11 standard defines the notion of a discarded-value expression;
6226 // normally, we don't need to do anything to handle it, but if it is a
6227 // volatile lvalue with a special form, we perform an lvalue-to-rvalue
6229 if (getLangOpts().CPlusPlus11 && E->isGLValue() &&
6230 E->getType().isVolatileQualified() &&
6231 IsSpecialDiscardedValue(E)) {
6232 ExprResult Res = DefaultLvalueConversion(E);
6233 if (Res.isInvalid())
6240 // GCC seems to also exclude expressions of incomplete enum type.
6241 if (const EnumType *T = E->getType()->getAs<EnumType>()) {
6242 if (!T->getDecl()->isComplete()) {
6243 // FIXME: stupid workaround for a codegen bug!
6244 E = ImpCastExprToType(E, Context.VoidTy, CK_ToVoid).get();
6249 ExprResult Res = DefaultFunctionArrayLvalueConversion(E);
6250 if (Res.isInvalid())
6254 if (!E->getType()->isVoidType())
6255 RequireCompleteType(E->getExprLoc(), E->getType(),
6256 diag::err_incomplete_type);
6260 // If we can unambiguously determine whether Var can never be used
6261 // in a constant expression, return true.
6262 // - if the variable and its initializer are non-dependent, then
6263 // we can unambiguously check if the variable is a constant expression.
6264 // - if the initializer is not value dependent - we can determine whether
6265 // it can be used to initialize a constant expression. If Init can not
6266 // be used to initialize a constant expression we conclude that Var can
6267 // never be a constant expression.
6268 // - FXIME: if the initializer is dependent, we can still do some analysis and
6269 // identify certain cases unambiguously as non-const by using a Visitor:
6270 // - such as those that involve odr-use of a ParmVarDecl, involve a new
6271 // delete, lambda-expr, dynamic-cast, reinterpret-cast etc...
6272 static inline bool VariableCanNeverBeAConstantExpression(VarDecl *Var,
6273 ASTContext &Context) {
6274 if (isa<ParmVarDecl>(Var)) return true;
6275 const VarDecl *DefVD = nullptr;
6277 // If there is no initializer - this can not be a constant expression.
6278 if (!Var->getAnyInitializer(DefVD)) return true;
6280 if (DefVD->isWeak()) return false;
6281 EvaluatedStmt *Eval = DefVD->ensureEvaluatedStmt();
6283 Expr *Init = cast<Expr>(Eval->Value);
6285 if (Var->getType()->isDependentType() || Init->isValueDependent()) {
6286 // FIXME: Teach the constant evaluator to deal with the non-dependent parts
6287 // of value-dependent expressions, and use it here to determine whether the
6288 // initializer is a potential constant expression.
6292 return !IsVariableAConstantExpression(Var, Context);
6295 /// \brief Check if the current lambda has any potential captures
6296 /// that must be captured by any of its enclosing lambdas that are ready to
6297 /// capture. If there is a lambda that can capture a nested
6298 /// potential-capture, go ahead and do so. Also, check to see if any
6299 /// variables are uncaptureable or do not involve an odr-use so do not
6300 /// need to be captured.
6302 static void CheckIfAnyEnclosingLambdasMustCaptureAnyPotentialCaptures(
6303 Expr *const FE, LambdaScopeInfo *const CurrentLSI, Sema &S) {
6305 assert(!S.isUnevaluatedContext());
6306 assert(S.CurContext->isDependentContext());
6307 assert(CurrentLSI->CallOperator == S.CurContext &&
6308 "The current call operator must be synchronized with Sema's CurContext");
6310 const bool IsFullExprInstantiationDependent = FE->isInstantiationDependent();
6312 ArrayRef<const FunctionScopeInfo *> FunctionScopesArrayRef(
6313 S.FunctionScopes.data(), S.FunctionScopes.size());
6315 // All the potentially captureable variables in the current nested
6316 // lambda (within a generic outer lambda), must be captured by an
6317 // outer lambda that is enclosed within a non-dependent context.
6318 const unsigned NumPotentialCaptures =
6319 CurrentLSI->getNumPotentialVariableCaptures();
6320 for (unsigned I = 0; I != NumPotentialCaptures; ++I) {
6321 Expr *VarExpr = nullptr;
6322 VarDecl *Var = nullptr;
6323 CurrentLSI->getPotentialVariableCapture(I, Var, VarExpr);
6324 // If the variable is clearly identified as non-odr-used and the full
6325 // expression is not instantiation dependent, only then do we not
6326 // need to check enclosing lambda's for speculative captures.
6328 // Even though 'x' is not odr-used, it should be captured.
6330 // const int x = 10;
6331 // auto L = [=](auto a) {
6335 if (CurrentLSI->isVariableExprMarkedAsNonODRUsed(VarExpr) &&
6336 !IsFullExprInstantiationDependent)
6339 // If we have a capture-capable lambda for the variable, go ahead and
6340 // capture the variable in that lambda (and all its enclosing lambdas).
6341 if (const Optional<unsigned> Index =
6342 getStackIndexOfNearestEnclosingCaptureCapableLambda(
6343 FunctionScopesArrayRef, Var, S)) {
6344 const unsigned FunctionScopeIndexOfCapturableLambda = Index.getValue();
6345 MarkVarDeclODRUsed(Var, VarExpr->getExprLoc(), S,
6346 &FunctionScopeIndexOfCapturableLambda);
6348 const bool IsVarNeverAConstantExpression =
6349 VariableCanNeverBeAConstantExpression(Var, S.Context);
6350 if (!IsFullExprInstantiationDependent || IsVarNeverAConstantExpression) {
6351 // This full expression is not instantiation dependent or the variable
6352 // can not be used in a constant expression - which means
6353 // this variable must be odr-used here, so diagnose a
6354 // capture violation early, if the variable is un-captureable.
6355 // This is purely for diagnosing errors early. Otherwise, this
6356 // error would get diagnosed when the lambda becomes capture ready.
6357 QualType CaptureType, DeclRefType;
6358 SourceLocation ExprLoc = VarExpr->getExprLoc();
6359 if (S.tryCaptureVariable(Var, ExprLoc, S.TryCapture_Implicit,
6360 /*EllipsisLoc*/ SourceLocation(),
6361 /*BuildAndDiagnose*/false, CaptureType,
6362 DeclRefType, nullptr)) {
6363 // We will never be able to capture this variable, and we need
6364 // to be able to in any and all instantiations, so diagnose it.
6365 S.tryCaptureVariable(Var, ExprLoc, S.TryCapture_Implicit,
6366 /*EllipsisLoc*/ SourceLocation(),
6367 /*BuildAndDiagnose*/true, CaptureType,
6368 DeclRefType, nullptr);
6373 // Check if 'this' needs to be captured.
6374 if (CurrentLSI->hasPotentialThisCapture()) {
6375 // If we have a capture-capable lambda for 'this', go ahead and capture
6376 // 'this' in that lambda (and all its enclosing lambdas).
6377 if (const Optional<unsigned> Index =
6378 getStackIndexOfNearestEnclosingCaptureCapableLambda(
6379 FunctionScopesArrayRef, /*0 is 'this'*/ nullptr, S)) {
6380 const unsigned FunctionScopeIndexOfCapturableLambda = Index.getValue();
6381 S.CheckCXXThisCapture(CurrentLSI->PotentialThisCaptureLocation,
6382 /*Explicit*/ false, /*BuildAndDiagnose*/ true,
6383 &FunctionScopeIndexOfCapturableLambda);
6387 // Reset all the potential captures at the end of each full-expression.
6388 CurrentLSI->clearPotentialCaptures();
6391 static ExprResult attemptRecovery(Sema &SemaRef,
6392 const TypoCorrectionConsumer &Consumer,
6393 TypoCorrection TC) {
6394 LookupResult R(SemaRef, Consumer.getLookupResult().getLookupNameInfo(),
6395 Consumer.getLookupResult().getLookupKind());
6396 const CXXScopeSpec *SS = Consumer.getSS();
6399 // Use an approprate CXXScopeSpec for building the expr.
6400 if (auto *NNS = TC.getCorrectionSpecifier())
6401 NewSS.MakeTrivial(SemaRef.Context, NNS, TC.getCorrectionRange());
6402 else if (SS && !TC.WillReplaceSpecifier())
6405 if (auto *ND = TC.getFoundDecl()) {
6406 R.setLookupName(ND->getDeclName());
6408 if (ND->isCXXClassMember()) {
6409 // Figure out the correct naming class to add to the LookupResult.
6410 CXXRecordDecl *Record = nullptr;
6411 if (auto *NNS = TC.getCorrectionSpecifier())
6412 Record = NNS->getAsType()->getAsCXXRecordDecl();
6415 dyn_cast<CXXRecordDecl>(ND->getDeclContext()->getRedeclContext());
6417 R.setNamingClass(Record);
6419 // Detect and handle the case where the decl might be an implicit
6421 bool MightBeImplicitMember;
6422 if (!Consumer.isAddressOfOperand())
6423 MightBeImplicitMember = true;
6424 else if (!NewSS.isEmpty())
6425 MightBeImplicitMember = false;
6426 else if (R.isOverloadedResult())
6427 MightBeImplicitMember = false;
6428 else if (R.isUnresolvableResult())
6429 MightBeImplicitMember = true;
6431 MightBeImplicitMember = isa<FieldDecl>(ND) ||
6432 isa<IndirectFieldDecl>(ND) ||
6433 isa<MSPropertyDecl>(ND);
6435 if (MightBeImplicitMember)
6436 return SemaRef.BuildPossibleImplicitMemberExpr(
6437 NewSS, /*TemplateKWLoc*/ SourceLocation(), R,
6438 /*TemplateArgs*/ nullptr, /*S*/ nullptr);
6439 } else if (auto *Ivar = dyn_cast<ObjCIvarDecl>(ND)) {
6440 return SemaRef.LookupInObjCMethod(R, Consumer.getScope(),
6441 Ivar->getIdentifier());
6445 return SemaRef.BuildDeclarationNameExpr(NewSS, R, /*NeedsADL*/ false,
6446 /*AcceptInvalidDecl*/ true);
6450 class FindTypoExprs : public RecursiveASTVisitor<FindTypoExprs> {
6451 llvm::SmallSetVector<TypoExpr *, 2> &TypoExprs;
6454 explicit FindTypoExprs(llvm::SmallSetVector<TypoExpr *, 2> &TypoExprs)
6455 : TypoExprs(TypoExprs) {}
6456 bool VisitTypoExpr(TypoExpr *TE) {
6457 TypoExprs.insert(TE);
6462 class TransformTypos : public TreeTransform<TransformTypos> {
6463 typedef TreeTransform<TransformTypos> BaseTransform;
6465 VarDecl *InitDecl; // A decl to avoid as a correction because it is in the
6466 // process of being initialized.
6467 llvm::function_ref<ExprResult(Expr *)> ExprFilter;
6468 llvm::SmallSetVector<TypoExpr *, 2> TypoExprs, AmbiguousTypoExprs;
6469 llvm::SmallDenseMap<TypoExpr *, ExprResult, 2> TransformCache;
6470 llvm::SmallDenseMap<OverloadExpr *, Expr *, 4> OverloadResolution;
6472 /// \brief Emit diagnostics for all of the TypoExprs encountered.
6473 /// If the TypoExprs were successfully corrected, then the diagnostics should
6474 /// suggest the corrections. Otherwise the diagnostics will not suggest
6475 /// anything (having been passed an empty TypoCorrection).
6476 void EmitAllDiagnostics() {
6477 for (auto E : TypoExprs) {
6478 TypoExpr *TE = cast<TypoExpr>(E);
6479 auto &State = SemaRef.getTypoExprState(TE);
6480 if (State.DiagHandler) {
6481 TypoCorrection TC = State.Consumer->getCurrentCorrection();
6482 ExprResult Replacement = TransformCache[TE];
6484 // Extract the NamedDecl from the transformed TypoExpr and add it to the
6485 // TypoCorrection, replacing the existing decls. This ensures the right
6486 // NamedDecl is used in diagnostics e.g. in the case where overload
6487 // resolution was used to select one from several possible decls that
6488 // had been stored in the TypoCorrection.
6489 if (auto *ND = getDeclFromExpr(
6490 Replacement.isInvalid() ? nullptr : Replacement.get()))
6491 TC.setCorrectionDecl(ND);
6493 State.DiagHandler(TC);
6495 SemaRef.clearDelayedTypo(TE);
6499 /// \brief If corrections for the first TypoExpr have been exhausted for a
6500 /// given combination of the other TypoExprs, retry those corrections against
6501 /// the next combination of substitutions for the other TypoExprs by advancing
6502 /// to the next potential correction of the second TypoExpr. For the second
6503 /// and subsequent TypoExprs, if its stream of corrections has been exhausted,
6504 /// the stream is reset and the next TypoExpr's stream is advanced by one (a
6505 /// TypoExpr's correction stream is advanced by removing the TypoExpr from the
6506 /// TransformCache). Returns true if there is still any untried combinations
6508 bool CheckAndAdvanceTypoExprCorrectionStreams() {
6509 for (auto TE : TypoExprs) {
6510 auto &State = SemaRef.getTypoExprState(TE);
6511 TransformCache.erase(TE);
6512 if (!State.Consumer->finished())
6514 State.Consumer->resetCorrectionStream();
6519 NamedDecl *getDeclFromExpr(Expr *E) {
6520 if (auto *OE = dyn_cast_or_null<OverloadExpr>(E))
6521 E = OverloadResolution[OE];
6525 if (auto *DRE = dyn_cast<DeclRefExpr>(E))
6526 return DRE->getFoundDecl();
6527 if (auto *ME = dyn_cast<MemberExpr>(E))
6528 return ME->getFoundDecl();
6529 // FIXME: Add any other expr types that could be be seen by the delayed typo
6530 // correction TreeTransform for which the corresponding TypoCorrection could
6531 // contain multiple decls.
6535 ExprResult TryTransform(Expr *E) {
6536 Sema::SFINAETrap Trap(SemaRef);
6537 ExprResult Res = TransformExpr(E);
6538 if (Trap.hasErrorOccurred() || Res.isInvalid())
6541 return ExprFilter(Res.get());
6545 TransformTypos(Sema &SemaRef, VarDecl *InitDecl, llvm::function_ref<ExprResult(Expr *)> Filter)
6546 : BaseTransform(SemaRef), InitDecl(InitDecl), ExprFilter(Filter) {}
6548 ExprResult RebuildCallExpr(Expr *Callee, SourceLocation LParenLoc,
6550 SourceLocation RParenLoc,
6551 Expr *ExecConfig = nullptr) {
6552 auto Result = BaseTransform::RebuildCallExpr(Callee, LParenLoc, Args,
6553 RParenLoc, ExecConfig);
6554 if (auto *OE = dyn_cast<OverloadExpr>(Callee)) {
6555 if (Result.isUsable()) {
6556 Expr *ResultCall = Result.get();
6557 if (auto *BE = dyn_cast<CXXBindTemporaryExpr>(ResultCall))
6558 ResultCall = BE->getSubExpr();
6559 if (auto *CE = dyn_cast<CallExpr>(ResultCall))
6560 OverloadResolution[OE] = CE->getCallee();
6566 ExprResult TransformLambdaExpr(LambdaExpr *E) { return Owned(E); }
6568 ExprResult TransformBlockExpr(BlockExpr *E) { return Owned(E); }
6570 ExprResult Transform(Expr *E) {
6573 Res = TryTransform(E);
6575 // Exit if either the transform was valid or if there were no TypoExprs
6576 // to transform that still have any untried correction candidates..
6577 if (!Res.isInvalid() ||
6578 !CheckAndAdvanceTypoExprCorrectionStreams())
6582 // Ensure none of the TypoExprs have multiple typo correction candidates
6583 // with the same edit length that pass all the checks and filters.
6584 // TODO: Properly handle various permutations of possible corrections when
6585 // there is more than one potentially ambiguous typo correction.
6586 // Also, disable typo correction while attempting the transform when
6587 // handling potentially ambiguous typo corrections as any new TypoExprs will
6588 // have been introduced by the application of one of the correction
6589 // candidates and add little to no value if corrected.
6590 SemaRef.DisableTypoCorrection = true;
6591 while (!AmbiguousTypoExprs.empty()) {
6592 auto TE = AmbiguousTypoExprs.back();
6593 auto Cached = TransformCache[TE];
6594 auto &State = SemaRef.getTypoExprState(TE);
6595 State.Consumer->saveCurrentPosition();
6596 TransformCache.erase(TE);
6597 if (!TryTransform(E).isInvalid()) {
6598 State.Consumer->resetCorrectionStream();
6599 TransformCache.erase(TE);
6603 AmbiguousTypoExprs.remove(TE);
6604 State.Consumer->restoreSavedPosition();
6605 TransformCache[TE] = Cached;
6607 SemaRef.DisableTypoCorrection = false;
6609 // Ensure that all of the TypoExprs within the current Expr have been found.
6610 if (!Res.isUsable())
6611 FindTypoExprs(TypoExprs).TraverseStmt(E);
6613 EmitAllDiagnostics();
6618 ExprResult TransformTypoExpr(TypoExpr *E) {
6619 // If the TypoExpr hasn't been seen before, record it. Otherwise, return the
6620 // cached transformation result if there is one and the TypoExpr isn't the
6621 // first one that was encountered.
6622 auto &CacheEntry = TransformCache[E];
6623 if (!TypoExprs.insert(E) && !CacheEntry.isUnset()) {
6627 auto &State = SemaRef.getTypoExprState(E);
6628 assert(State.Consumer && "Cannot transform a cleared TypoExpr");
6630 // For the first TypoExpr and an uncached TypoExpr, find the next likely
6631 // typo correction and return it.
6632 while (TypoCorrection TC = State.Consumer->getNextCorrection()) {
6633 if (InitDecl && TC.getFoundDecl() == InitDecl)
6635 ExprResult NE = State.RecoveryHandler ?
6636 State.RecoveryHandler(SemaRef, E, TC) :
6637 attemptRecovery(SemaRef, *State.Consumer, TC);
6638 if (!NE.isInvalid()) {
6639 // Check whether there may be a second viable correction with the same
6640 // edit distance; if so, remember this TypoExpr may have an ambiguous
6641 // correction so it can be more thoroughly vetted later.
6642 TypoCorrection Next;
6643 if ((Next = State.Consumer->peekNextCorrection()) &&
6644 Next.getEditDistance(false) == TC.getEditDistance(false)) {
6645 AmbiguousTypoExprs.insert(E);
6647 AmbiguousTypoExprs.remove(E);
6649 assert(!NE.isUnset() &&
6650 "Typo was transformed into a valid-but-null ExprResult");
6651 return CacheEntry = NE;
6654 return CacheEntry = ExprError();
6660 Sema::CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl,
6661 llvm::function_ref<ExprResult(Expr *)> Filter) {
6662 // If the current evaluation context indicates there are uncorrected typos
6663 // and the current expression isn't guaranteed to not have typos, try to
6664 // resolve any TypoExpr nodes that might be in the expression.
6665 if (E && !ExprEvalContexts.empty() && ExprEvalContexts.back().NumTypos &&
6666 (E->isTypeDependent() || E->isValueDependent() ||
6667 E->isInstantiationDependent())) {
6668 auto TyposInContext = ExprEvalContexts.back().NumTypos;
6669 assert(TyposInContext < ~0U && "Recursive call of CorrectDelayedTyposInExpr");
6670 ExprEvalContexts.back().NumTypos = ~0U;
6671 auto TyposResolved = DelayedTypos.size();
6672 auto Result = TransformTypos(*this, InitDecl, Filter).Transform(E);
6673 ExprEvalContexts.back().NumTypos = TyposInContext;
6674 TyposResolved -= DelayedTypos.size();
6675 if (Result.isInvalid() || Result.get() != E) {
6676 ExprEvalContexts.back().NumTypos -= TyposResolved;
6679 assert(TyposResolved == 0 && "Corrected typo but got same Expr back?");
6684 ExprResult Sema::ActOnFinishFullExpr(Expr *FE, SourceLocation CC,
6685 bool DiscardedValue,
6687 bool IsLambdaInitCaptureInitializer) {
6688 ExprResult FullExpr = FE;
6690 if (!FullExpr.get())
6693 // If we are an init-expression in a lambdas init-capture, we should not
6694 // diagnose an unexpanded pack now (will be diagnosed once lambda-expr
6695 // containing full-expression is done).
6696 // template<class ... Ts> void test(Ts ... t) {
6697 // test([&a(t)]() { <-- (t) is an init-expr that shouldn't be diagnosed now.
6701 // FIXME: This is a hack. It would be better if we pushed the lambda scope
6702 // when we parse the lambda introducer, and teach capturing (but not
6703 // unexpanded pack detection) to walk over LambdaScopeInfos which don't have a
6704 // corresponding class yet (that is, have LambdaScopeInfo either represent a
6705 // lambda where we've entered the introducer but not the body, or represent a
6706 // lambda where we've entered the body, depending on where the
6707 // parser/instantiation has got to).
6708 if (!IsLambdaInitCaptureInitializer &&
6709 DiagnoseUnexpandedParameterPack(FullExpr.get()))
6712 // Top-level expressions default to 'id' when we're in a debugger.
6713 if (DiscardedValue && getLangOpts().DebuggerCastResultToId &&
6714 FullExpr.get()->getType() == Context.UnknownAnyTy) {
6715 FullExpr = forceUnknownAnyToType(FullExpr.get(), Context.getObjCIdType());
6716 if (FullExpr.isInvalid())
6720 if (DiscardedValue) {
6721 FullExpr = CheckPlaceholderExpr(FullExpr.get());
6722 if (FullExpr.isInvalid())
6725 FullExpr = IgnoredValueConversions(FullExpr.get());
6726 if (FullExpr.isInvalid())
6730 FullExpr = CorrectDelayedTyposInExpr(FullExpr.get());
6731 if (FullExpr.isInvalid())
6734 CheckCompletedExpr(FullExpr.get(), CC, IsConstexpr);
6736 // At the end of this full expression (which could be a deeply nested
6737 // lambda), if there is a potential capture within the nested lambda,
6738 // have the outer capture-able lambda try and capture it.
6739 // Consider the following code:
6740 // void f(int, int);
6741 // void f(const int&, double);
6743 // const int x = 10, y = 20;
6744 // auto L = [=](auto a) {
6745 // auto M = [=](auto b) {
6746 // f(x, b); <-- requires x to be captured by L and M
6747 // f(y, a); <-- requires y to be captured by L, but not all Ms
6752 // FIXME: Also consider what happens for something like this that involves
6753 // the gnu-extension statement-expressions or even lambda-init-captures:
6756 // auto L = [&](auto a) {
6757 // +n + ({ 0; a; });
6761 // Here, we see +n, and then the full-expression 0; ends, so we don't
6762 // capture n (and instead remove it from our list of potential captures),
6763 // and then the full-expression +n + ({ 0; }); ends, but it's too late
6764 // for us to see that we need to capture n after all.
6766 LambdaScopeInfo *const CurrentLSI = getCurLambda();
6767 // FIXME: PR 17877 showed that getCurLambda() can return a valid pointer
6768 // even if CurContext is not a lambda call operator. Refer to that Bug Report
6769 // for an example of the code that might cause this asynchrony.
6770 // By ensuring we are in the context of a lambda's call operator
6771 // we can fix the bug (we only need to check whether we need to capture
6772 // if we are within a lambda's body); but per the comments in that
6773 // PR, a proper fix would entail :
6774 // "Alternative suggestion:
6775 // - Add to Sema an integer holding the smallest (outermost) scope
6776 // index that we are *lexically* within, and save/restore/set to
6777 // FunctionScopes.size() in InstantiatingTemplate's
6778 // constructor/destructor.
6779 // - Teach the handful of places that iterate over FunctionScopes to
6780 // stop at the outermost enclosing lexical scope."
6781 const bool IsInLambdaDeclContext = isLambdaCallOperator(CurContext);
6782 if (IsInLambdaDeclContext && CurrentLSI &&
6783 CurrentLSI->hasPotentialCaptures() && !FullExpr.isInvalid())
6784 CheckIfAnyEnclosingLambdasMustCaptureAnyPotentialCaptures(FE, CurrentLSI,
6786 return MaybeCreateExprWithCleanups(FullExpr);
6789 StmtResult Sema::ActOnFinishFullStmt(Stmt *FullStmt) {
6790 if (!FullStmt) return StmtError();
6792 return MaybeCreateStmtWithCleanups(FullStmt);
6795 Sema::IfExistsResult
6796 Sema::CheckMicrosoftIfExistsSymbol(Scope *S,
6798 const DeclarationNameInfo &TargetNameInfo) {
6799 DeclarationName TargetName = TargetNameInfo.getName();
6801 return IER_DoesNotExist;
6803 // If the name itself is dependent, then the result is dependent.
6804 if (TargetName.isDependentName())
6805 return IER_Dependent;
6807 // Do the redeclaration lookup in the current scope.
6808 LookupResult R(*this, TargetNameInfo, Sema::LookupAnyName,
6809 Sema::NotForRedeclaration);
6810 LookupParsedName(R, S, &SS);
6811 R.suppressDiagnostics();
6813 switch (R.getResultKind()) {
6814 case LookupResult::Found:
6815 case LookupResult::FoundOverloaded:
6816 case LookupResult::FoundUnresolvedValue:
6817 case LookupResult::Ambiguous:
6820 case LookupResult::NotFound:
6821 return IER_DoesNotExist;
6823 case LookupResult::NotFoundInCurrentInstantiation:
6824 return IER_Dependent;
6827 llvm_unreachable("Invalid LookupResult Kind!");
6830 Sema::IfExistsResult
6831 Sema::CheckMicrosoftIfExistsSymbol(Scope *S, SourceLocation KeywordLoc,
6832 bool IsIfExists, CXXScopeSpec &SS,
6833 UnqualifiedId &Name) {
6834 DeclarationNameInfo TargetNameInfo = GetNameFromUnqualifiedId(Name);
6836 // Check for unexpanded parameter packs.
6837 SmallVector<UnexpandedParameterPack, 4> Unexpanded;
6838 collectUnexpandedParameterPacks(SS, Unexpanded);
6839 collectUnexpandedParameterPacks(TargetNameInfo, Unexpanded);
6840 if (!Unexpanded.empty()) {
6841 DiagnoseUnexpandedParameterPacks(KeywordLoc,
6842 IsIfExists? UPPC_IfExists
6848 return CheckMicrosoftIfExistsSymbol(S, SS, TargetNameInfo);