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 //===----------------------------------------------------------------------===//
10 // This file implements semantic analysis for C++ expressions.
12 //===----------------------------------------------------------------------===//
14 #include "clang/Sema/SemaInternal.h"
15 #include "clang/Sema/DeclSpec.h"
16 #include "clang/Sema/Initialization.h"
17 #include "clang/Sema/Lookup.h"
18 #include "clang/Sema/ParsedTemplate.h"
19 #include "clang/Sema/ScopeInfo.h"
20 #include "clang/Sema/Scope.h"
21 #include "clang/Sema/TemplateDeduction.h"
22 #include "clang/AST/ASTContext.h"
23 #include "clang/AST/CXXInheritance.h"
24 #include "clang/AST/DeclObjC.h"
25 #include "clang/AST/ExprCXX.h"
26 #include "clang/AST/ExprObjC.h"
27 #include "clang/AST/TypeLoc.h"
28 #include "clang/Basic/PartialDiagnostic.h"
29 #include "clang/Basic/TargetInfo.h"
30 #include "clang/Lex/Preprocessor.h"
31 #include "llvm/ADT/STLExtras.h"
32 #include "llvm/Support/ErrorHandling.h"
33 using namespace clang
;
36 ParsedType
Sema::getDestructorName(SourceLocation TildeLoc
,
38 SourceLocation NameLoc
,
39 Scope
*S
, CXXScopeSpec
&SS
,
40 ParsedType ObjectTypePtr
,
41 bool EnteringContext
) {
42 // Determine where to perform name lookup.
44 // FIXME: This area of the standard is very messy, and the current
45 // wording is rather unclear about which scopes we search for the
46 // destructor name; see core issues 399 and 555. Issue 399 in
47 // particular shows where the current description of destructor name
48 // lookup is completely out of line with existing practice, e.g.,
49 // this appears to be ill-formed:
52 // template <typename T> struct S {
57 // void f(N::S<int>* s) {
58 // s->N::S<int>::~S();
61 // See also PR6358 and PR6359.
62 // For this reason, we're currently only doing the C++03 version of this
63 // code; the C++0x version has to wait until we get a proper spec.
65 DeclContext
*LookupCtx
= 0;
66 bool isDependent
= false;
67 bool LookInScope
= false;
69 // If we have an object type, it's because we are in a
70 // pseudo-destructor-expression or a member access expression, and
71 // we know what type we're looking for.
73 SearchType
= GetTypeFromParser(ObjectTypePtr
);
76 NestedNameSpecifier
*NNS
= (NestedNameSpecifier
*)SS
.getScopeRep();
78 bool AlreadySearched
= false;
79 bool LookAtPrefix
= true;
80 // C++ [basic.lookup.qual]p6:
81 // If a pseudo-destructor-name (5.2.4) contains a nested-name-specifier,
82 // the type-names are looked up as types in the scope designated by the
83 // nested-name-specifier. In a qualified-id of the form:
85 // ::[opt] nested-name-specifier ~ class-name
87 // where the nested-name-specifier designates a namespace scope, and in
88 // a qualified-id of the form:
90 // ::opt nested-name-specifier class-name :: ~ class-name
92 // the class-names are looked up as types in the scope designated by
93 // the nested-name-specifier.
95 // Here, we check the first case (completely) and determine whether the
96 // code below is permitted to look at the prefix of the
97 // nested-name-specifier.
98 DeclContext
*DC
= computeDeclContext(SS
, EnteringContext
);
99 if (DC
&& DC
->isFileContext()) {
100 AlreadySearched
= true;
103 } else if (DC
&& isa
<CXXRecordDecl
>(DC
))
104 LookAtPrefix
= false;
106 // The second case from the C++03 rules quoted further above.
107 NestedNameSpecifier
*Prefix
= 0;
108 if (AlreadySearched
) {
109 // Nothing left to do.
110 } else if (LookAtPrefix
&& (Prefix
= NNS
->getPrefix())) {
111 CXXScopeSpec PrefixSS
;
112 PrefixSS
.Adopt(NestedNameSpecifierLoc(Prefix
, SS
.location_data()));
113 LookupCtx
= computeDeclContext(PrefixSS
, EnteringContext
);
114 isDependent
= isDependentScopeSpecifier(PrefixSS
);
115 } else if (ObjectTypePtr
) {
116 LookupCtx
= computeDeclContext(SearchType
);
117 isDependent
= SearchType
->isDependentType();
119 LookupCtx
= computeDeclContext(SS
, EnteringContext
);
120 isDependent
= LookupCtx
&& LookupCtx
->isDependentContext();
124 } else if (ObjectTypePtr
) {
125 // C++ [basic.lookup.classref]p3:
126 // If the unqualified-id is ~type-name, the type-name is looked up
127 // in the context of the entire postfix-expression. If the type T
128 // of the object expression is of a class type C, the type-name is
129 // also looked up in the scope of class C. At least one of the
130 // lookups shall find a name that refers to (possibly
132 LookupCtx
= computeDeclContext(SearchType
);
133 isDependent
= SearchType
->isDependentType();
134 assert((isDependent
|| !SearchType
->isIncompleteType()) &&
135 "Caller should have completed object type");
139 // Perform lookup into the current scope (only).
143 TypeDecl
*NonMatchingTypeDecl
= 0;
144 LookupResult
Found(*this, &II
, NameLoc
, LookupOrdinaryName
);
145 for (unsigned Step
= 0; Step
!= 2; ++Step
) {
146 // Look for the name first in the computed lookup context (if we
147 // have one) and, if that fails to find a match, in the scope (if
148 // we're allowed to look there).
150 if (Step
== 0 && LookupCtx
)
151 LookupQualifiedName(Found
, LookupCtx
);
152 else if (Step
== 1 && LookInScope
&& S
)
153 LookupName(Found
, S
);
157 // FIXME: Should we be suppressing ambiguities here?
158 if (Found
.isAmbiguous())
161 if (TypeDecl
*Type
= Found
.getAsSingle
<TypeDecl
>()) {
162 QualType T
= Context
.getTypeDeclType(Type
);
164 if (SearchType
.isNull() || SearchType
->isDependentType() ||
165 Context
.hasSameUnqualifiedType(T
, SearchType
)) {
166 // We found our type!
168 return ParsedType::make(T
);
171 if (!SearchType
.isNull())
172 NonMatchingTypeDecl
= Type
;
175 // If the name that we found is a class template name, and it is
176 // the same name as the template name in the last part of the
177 // nested-name-specifier (if present) or the object type, then
178 // this is the destructor for that class.
179 // FIXME: This is a workaround until we get real drafting for core
180 // issue 399, for which there isn't even an obvious direction.
181 if (ClassTemplateDecl
*Template
= Found
.getAsSingle
<ClassTemplateDecl
>()) {
182 QualType MemberOfType
;
184 if (DeclContext
*Ctx
= computeDeclContext(SS
, EnteringContext
)) {
185 // Figure out the type of the context, if it has one.
186 if (CXXRecordDecl
*Record
= dyn_cast
<CXXRecordDecl
>(Ctx
))
187 MemberOfType
= Context
.getTypeDeclType(Record
);
190 if (MemberOfType
.isNull())
191 MemberOfType
= SearchType
;
193 if (MemberOfType
.isNull())
196 // We're referring into a class template specialization. If the
197 // class template we found is the same as the template being
198 // specialized, we found what we are looking for.
199 if (const RecordType
*Record
= MemberOfType
->getAs
<RecordType
>()) {
200 if (ClassTemplateSpecializationDecl
*Spec
201 = dyn_cast
<ClassTemplateSpecializationDecl
>(Record
->getDecl())) {
202 if (Spec
->getSpecializedTemplate()->getCanonicalDecl() ==
203 Template
->getCanonicalDecl())
204 return ParsedType::make(MemberOfType
);
210 // We're referring to an unresolved class template
211 // specialization. Determine whether we class template we found
212 // is the same as the template being specialized or, if we don't
213 // know which template is being specialized, that it at least
214 // has the same name.
215 if (const TemplateSpecializationType
*SpecType
216 = MemberOfType
->getAs
<TemplateSpecializationType
>()) {
217 TemplateName SpecName
= SpecType
->getTemplateName();
219 // The class template we found is the same template being
221 if (TemplateDecl
*SpecTemplate
= SpecName
.getAsTemplateDecl()) {
222 if (SpecTemplate
->getCanonicalDecl() == Template
->getCanonicalDecl())
223 return ParsedType::make(MemberOfType
);
228 // The class template we found has the same name as the
229 // (dependent) template name being specialized.
230 if (DependentTemplateName
*DepTemplate
231 = SpecName
.getAsDependentTemplateName()) {
232 if (DepTemplate
->isIdentifier() &&
233 DepTemplate
->getIdentifier() == Template
->getIdentifier())
234 return ParsedType::make(MemberOfType
);
243 // We didn't find our type, but that's okay: it's dependent
246 // FIXME: What if we have no nested-name-specifier?
247 QualType T
= CheckTypenameType(ETK_None
, SourceLocation(),
248 SS
.getWithLocInContext(Context
),
250 return ParsedType::make(T
);
253 if (NonMatchingTypeDecl
) {
254 QualType T
= Context
.getTypeDeclType(NonMatchingTypeDecl
);
255 Diag(NameLoc
, diag::err_destructor_expr_type_mismatch
)
257 Diag(NonMatchingTypeDecl
->getLocation(), diag::note_destructor_type_here
)
259 } else if (ObjectTypePtr
)
260 Diag(NameLoc
, diag::err_ident_in_dtor_not_a_type
)
263 Diag(NameLoc
, diag::err_destructor_class_name
);
268 /// \brief Build a C++ typeid expression with a type operand.
269 ExprResult
Sema::BuildCXXTypeId(QualType TypeInfoType
,
270 SourceLocation TypeidLoc
,
271 TypeSourceInfo
*Operand
,
272 SourceLocation RParenLoc
) {
273 // C++ [expr.typeid]p4:
274 // The top-level cv-qualifiers of the lvalue expression or the type-id
275 // that is the operand of typeid are always ignored.
276 // If the type of the type-id is a class type or a reference to a class
277 // type, the class shall be completely-defined.
280 = Context
.getUnqualifiedArrayType(Operand
->getType().getNonReferenceType(),
282 if (T
->getAs
<RecordType
>() &&
283 RequireCompleteType(TypeidLoc
, T
, diag::err_incomplete_typeid
))
286 return Owned(new (Context
) CXXTypeidExpr(TypeInfoType
.withConst(),
288 SourceRange(TypeidLoc
, RParenLoc
)));
291 /// \brief Build a C++ typeid expression with an expression operand.
292 ExprResult
Sema::BuildCXXTypeId(QualType TypeInfoType
,
293 SourceLocation TypeidLoc
,
295 SourceLocation RParenLoc
) {
296 bool isUnevaluatedOperand
= true;
297 if (E
&& !E
->isTypeDependent()) {
298 QualType T
= E
->getType();
299 if (const RecordType
*RecordT
= T
->getAs
<RecordType
>()) {
300 CXXRecordDecl
*RecordD
= cast
<CXXRecordDecl
>(RecordT
->getDecl());
301 // C++ [expr.typeid]p3:
302 // [...] If the type of the expression is a class type, the class
303 // shall be completely-defined.
304 if (RequireCompleteType(TypeidLoc
, T
, diag::err_incomplete_typeid
))
307 // C++ [expr.typeid]p3:
308 // When typeid is applied to an expression other than an glvalue of a
309 // polymorphic class type [...] [the] expression is an unevaluated
311 if (RecordD
->isPolymorphic() && E
->Classify(Context
).isGLValue()) {
312 isUnevaluatedOperand
= false;
314 // We require a vtable to query the type at run time.
315 MarkVTableUsed(TypeidLoc
, RecordD
);
319 // C++ [expr.typeid]p4:
320 // [...] If the type of the type-id is a reference to a possibly
321 // cv-qualified type, the result of the typeid expression refers to a
322 // std::type_info object representing the cv-unqualified referenced
325 QualType UnqualT
= Context
.getUnqualifiedArrayType(T
, Quals
);
326 if (!Context
.hasSameType(T
, UnqualT
)) {
328 E
= ImpCastExprToType(E
, UnqualT
, CK_NoOp
, CastCategory(E
)).take();
332 // If this is an unevaluated operand, clear out the set of
333 // declaration references we have been computing and eliminate any
334 // temporaries introduced in its computation.
335 if (isUnevaluatedOperand
)
336 ExprEvalContexts
.back().Context
= Unevaluated
;
338 return Owned(new (Context
) CXXTypeidExpr(TypeInfoType
.withConst(),
340 SourceRange(TypeidLoc
, RParenLoc
)));
343 /// ActOnCXXTypeidOfType - Parse typeid( type-id ) or typeid (expression);
345 Sema::ActOnCXXTypeid(SourceLocation OpLoc
, SourceLocation LParenLoc
,
346 bool isType
, void *TyOrExpr
, SourceLocation RParenLoc
) {
347 // Find the std::type_info type.
348 if (!getStdNamespace())
349 return ExprError(Diag(OpLoc
, diag::err_need_header_before_typeid
));
351 if (!CXXTypeInfoDecl
) {
352 IdentifierInfo
*TypeInfoII
= &PP
.getIdentifierTable().get("type_info");
353 LookupResult
R(*this, TypeInfoII
, SourceLocation(), LookupTagName
);
354 LookupQualifiedName(R
, getStdNamespace());
355 CXXTypeInfoDecl
= R
.getAsSingle
<RecordDecl
>();
356 if (!CXXTypeInfoDecl
)
357 return ExprError(Diag(OpLoc
, diag::err_need_header_before_typeid
));
360 QualType TypeInfoType
= Context
.getTypeDeclType(CXXTypeInfoDecl
);
363 // The operand is a type; handle it as such.
364 TypeSourceInfo
*TInfo
= 0;
365 QualType T
= GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrExpr
),
371 TInfo
= Context
.getTrivialTypeSourceInfo(T
, OpLoc
);
373 return BuildCXXTypeId(TypeInfoType
, OpLoc
, TInfo
, RParenLoc
);
376 // The operand is an expression.
377 return BuildCXXTypeId(TypeInfoType
, OpLoc
, (Expr
*)TyOrExpr
, RParenLoc
);
380 /// Retrieve the UuidAttr associated with QT.
381 static UuidAttr
*GetUuidAttrOfType(QualType QT
) {
382 // Optionally remove one level of pointer, reference or array indirection.
383 const Type
*Ty
= QT
.getTypePtr();;
384 if (QT
->isPointerType() || QT
->isReferenceType())
385 Ty
= QT
->getPointeeType().getTypePtr();
386 else if (QT
->isArrayType())
387 Ty
= cast
<ArrayType
>(QT
)->getElementType().getTypePtr();
389 // Loop all record redeclaration looking for an uuid attribute.
390 CXXRecordDecl
*RD
= Ty
->getAsCXXRecordDecl();
391 for (CXXRecordDecl::redecl_iterator I
= RD
->redecls_begin(),
392 E
= RD
->redecls_end(); I
!= E
; ++I
) {
393 if (UuidAttr
*Uuid
= I
->getAttr
<UuidAttr
>())
400 /// \brief Build a Microsoft __uuidof expression with a type operand.
401 ExprResult
Sema::BuildCXXUuidof(QualType TypeInfoType
,
402 SourceLocation TypeidLoc
,
403 TypeSourceInfo
*Operand
,
404 SourceLocation RParenLoc
) {
405 if (!Operand
->getType()->isDependentType()) {
406 if (!GetUuidAttrOfType(Operand
->getType()))
407 return ExprError(Diag(TypeidLoc
, diag::err_uuidof_without_guid
));
410 // FIXME: add __uuidof semantic analysis for type operand.
411 return Owned(new (Context
) CXXUuidofExpr(TypeInfoType
.withConst(),
413 SourceRange(TypeidLoc
, RParenLoc
)));
416 /// \brief Build a Microsoft __uuidof expression with an expression operand.
417 ExprResult
Sema::BuildCXXUuidof(QualType TypeInfoType
,
418 SourceLocation TypeidLoc
,
420 SourceLocation RParenLoc
) {
421 if (!E
->getType()->isDependentType()) {
422 if (!GetUuidAttrOfType(E
->getType()) &&
423 !E
->isNullPointerConstant(Context
, Expr::NPC_ValueDependentIsNull
))
424 return ExprError(Diag(TypeidLoc
, diag::err_uuidof_without_guid
));
426 // FIXME: add __uuidof semantic analysis for type operand.
427 return Owned(new (Context
) CXXUuidofExpr(TypeInfoType
.withConst(),
429 SourceRange(TypeidLoc
, RParenLoc
)));
432 /// ActOnCXXUuidof - Parse __uuidof( type-id ) or __uuidof (expression);
434 Sema::ActOnCXXUuidof(SourceLocation OpLoc
, SourceLocation LParenLoc
,
435 bool isType
, void *TyOrExpr
, SourceLocation RParenLoc
) {
436 // If MSVCGuidDecl has not been cached, do the lookup.
438 IdentifierInfo
*GuidII
= &PP
.getIdentifierTable().get("_GUID");
439 LookupResult
R(*this, GuidII
, SourceLocation(), LookupTagName
);
440 LookupQualifiedName(R
, Context
.getTranslationUnitDecl());
441 MSVCGuidDecl
= R
.getAsSingle
<RecordDecl
>();
443 return ExprError(Diag(OpLoc
, diag::err_need_header_before_ms_uuidof
));
446 QualType GuidType
= Context
.getTypeDeclType(MSVCGuidDecl
);
449 // The operand is a type; handle it as such.
450 TypeSourceInfo
*TInfo
= 0;
451 QualType T
= GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrExpr
),
457 TInfo
= Context
.getTrivialTypeSourceInfo(T
, OpLoc
);
459 return BuildCXXUuidof(GuidType
, OpLoc
, TInfo
, RParenLoc
);
462 // The operand is an expression.
463 return BuildCXXUuidof(GuidType
, OpLoc
, (Expr
*)TyOrExpr
, RParenLoc
);
466 /// ActOnCXXBoolLiteral - Parse {true,false} literals.
468 Sema::ActOnCXXBoolLiteral(SourceLocation OpLoc
, tok::TokenKind Kind
) {
469 assert((Kind
== tok::kw_true
|| Kind
== tok::kw_false
) &&
470 "Unknown C++ Boolean value!");
471 return Owned(new (Context
) CXXBoolLiteralExpr(Kind
== tok::kw_true
,
472 Context
.BoolTy
, OpLoc
));
475 /// ActOnCXXNullPtrLiteral - Parse 'nullptr'.
477 Sema::ActOnCXXNullPtrLiteral(SourceLocation Loc
) {
478 return Owned(new (Context
) CXXNullPtrLiteralExpr(Context
.NullPtrTy
, Loc
));
481 /// ActOnCXXThrow - Parse throw expressions.
483 Sema::ActOnCXXThrow(SourceLocation OpLoc
, Expr
*Ex
) {
484 // Don't report an error if 'throw' is used in system headers.
485 if (!getLangOptions().CXXExceptions
&&
486 !getSourceManager().isInSystemHeader(OpLoc
))
487 Diag(OpLoc
, diag::err_exceptions_disabled
) << "throw";
489 if (Ex
&& !Ex
->isTypeDependent()) {
490 ExprResult ExRes
= CheckCXXThrowOperand(OpLoc
, Ex
);
491 if (ExRes
.isInvalid())
495 return Owned(new (Context
) CXXThrowExpr(Ex
, Context
.VoidTy
, OpLoc
));
498 /// CheckCXXThrowOperand - Validate the operand of a throw.
499 ExprResult
Sema::CheckCXXThrowOperand(SourceLocation ThrowLoc
, Expr
*E
) {
500 // C++ [except.throw]p3:
501 // A throw-expression initializes a temporary object, called the exception
502 // object, the type of which is determined by removing any top-level
503 // cv-qualifiers from the static type of the operand of throw and adjusting
504 // the type from "array of T" or "function returning T" to "pointer to T"
505 // or "pointer to function returning T", [...]
506 if (E
->getType().hasQualifiers())
507 E
= ImpCastExprToType(E
, E
->getType().getUnqualifiedType(), CK_NoOp
,
508 CastCategory(E
)).take();
510 ExprResult Res
= DefaultFunctionArrayConversion(E
);
515 // If the type of the exception would be an incomplete type or a pointer
516 // to an incomplete type other than (cv) void the program is ill-formed.
517 QualType Ty
= E
->getType();
518 bool isPointer
= false;
519 if (const PointerType
* Ptr
= Ty
->getAs
<PointerType
>()) {
520 Ty
= Ptr
->getPointeeType();
523 if (!isPointer
|| !Ty
->isVoidType()) {
524 if (RequireCompleteType(ThrowLoc
, Ty
,
525 PDiag(isPointer
? diag::err_throw_incomplete_ptr
526 : diag::err_throw_incomplete
)
527 << E
->getSourceRange()))
530 if (RequireNonAbstractType(ThrowLoc
, E
->getType(),
531 PDiag(diag::err_throw_abstract_type
)
532 << E
->getSourceRange()))
536 // Initialize the exception result. This implicitly weeds out
537 // abstract types or types with inaccessible copy constructors.
538 const VarDecl
*NRVOVariable
= getCopyElisionCandidate(QualType(), E
, false);
540 // FIXME: Determine whether we can elide this copy per C++0x [class.copy]p32.
541 InitializedEntity Entity
=
542 InitializedEntity::InitializeException(ThrowLoc
, E
->getType(),
544 Res
= PerformMoveOrCopyInitialization(Entity
, NRVOVariable
,
550 // If the exception has class type, we need additional handling.
551 const RecordType
*RecordTy
= Ty
->getAs
<RecordType
>();
554 CXXRecordDecl
*RD
= cast
<CXXRecordDecl
>(RecordTy
->getDecl());
556 // If we are throwing a polymorphic class type or pointer thereof,
557 // exception handling will make use of the vtable.
558 MarkVTableUsed(ThrowLoc
, RD
);
560 // If a pointer is thrown, the referenced object will not be destroyed.
564 // If the class has a non-trivial destructor, we must be able to call it.
565 if (RD
->hasTrivialDestructor())
568 CXXDestructorDecl
*Destructor
569 = const_cast<CXXDestructorDecl
*>(LookupDestructor(RD
));
573 MarkDeclarationReferenced(E
->getExprLoc(), Destructor
);
574 CheckDestructorAccess(E
->getExprLoc(), Destructor
,
575 PDiag(diag::err_access_dtor_exception
) << Ty
);
579 QualType
Sema::getAndCaptureCurrentThisType() {
580 // Ignore block scopes: we can capture through them.
581 // Ignore nested enum scopes: we'll diagnose non-constant expressions
582 // where they're invalid, and other uses are legitimate.
583 // Don't ignore nested class scopes: you can't use 'this' in a local class.
584 DeclContext
*DC
= CurContext
;
585 unsigned NumBlocks
= 0;
587 if (isa
<BlockDecl
>(DC
)) {
588 DC
= cast
<BlockDecl
>(DC
)->getDeclContext();
590 } else if (isa
<EnumDecl
>(DC
))
591 DC
= cast
<EnumDecl
>(DC
)->getDeclContext();
596 if (CXXMethodDecl
*method
= dyn_cast
<CXXMethodDecl
>(DC
)) {
597 if (method
&& method
->isInstance())
598 ThisTy
= method
->getThisType(Context
);
599 } else if (CXXRecordDecl
*RD
= dyn_cast
<CXXRecordDecl
>(DC
)) {
600 // C++0x [expr.prim]p4:
601 // Otherwise, if a member-declarator declares a non-static data member
602 // of a class X, the expression this is a prvalue of type "pointer to X"
603 // within the optional brace-or-equal-initializer.
604 Scope
*S
= getScopeForContext(DC
);
605 if (!S
|| S
->getFlags() & Scope::ThisScope
)
606 ThisTy
= Context
.getPointerType(Context
.getRecordType(RD
));
609 // Mark that we're closing on 'this' in all the block scopes we ignored.
610 if (!ThisTy
.isNull())
611 for (unsigned idx
= FunctionScopes
.size() - 1;
612 NumBlocks
; --idx
, --NumBlocks
)
613 cast
<BlockScopeInfo
>(FunctionScopes
[idx
])->CapturesCXXThis
= true;
618 ExprResult
Sema::ActOnCXXThis(SourceLocation Loc
) {
619 /// C++ 9.3.2: In the body of a non-static member function, the keyword this
620 /// is a non-lvalue expression whose value is the address of the object for
621 /// which the function is called.
623 QualType ThisTy
= getAndCaptureCurrentThisType();
624 if (ThisTy
.isNull()) return Diag(Loc
, diag::err_invalid_this_use
);
626 return Owned(new (Context
) CXXThisExpr(Loc
, ThisTy
, /*isImplicit=*/false));
630 Sema::ActOnCXXTypeConstructExpr(ParsedType TypeRep
,
631 SourceLocation LParenLoc
,
633 SourceLocation RParenLoc
) {
637 TypeSourceInfo
*TInfo
;
638 QualType Ty
= GetTypeFromParser(TypeRep
, &TInfo
);
640 TInfo
= Context
.getTrivialTypeSourceInfo(Ty
, SourceLocation());
642 return BuildCXXTypeConstructExpr(TInfo
, LParenLoc
, exprs
, RParenLoc
);
645 /// ActOnCXXTypeConstructExpr - Parse construction of a specified type.
646 /// Can be interpreted either as function-style casting ("int(x)")
647 /// or class type construction ("ClassType(x,y,z)")
648 /// or creation of a value-initialized type ("int()").
650 Sema::BuildCXXTypeConstructExpr(TypeSourceInfo
*TInfo
,
651 SourceLocation LParenLoc
,
653 SourceLocation RParenLoc
) {
654 QualType Ty
= TInfo
->getType();
655 unsigned NumExprs
= exprs
.size();
656 Expr
**Exprs
= (Expr
**)exprs
.get();
657 SourceLocation TyBeginLoc
= TInfo
->getTypeLoc().getBeginLoc();
658 SourceRange FullRange
= SourceRange(TyBeginLoc
, RParenLoc
);
660 if (Ty
->isDependentType() ||
661 CallExpr::hasAnyTypeDependentArguments(Exprs
, NumExprs
)) {
664 return Owned(CXXUnresolvedConstructExpr::Create(Context
, TInfo
,
670 if (Ty
->isArrayType())
671 return ExprError(Diag(TyBeginLoc
,
672 diag::err_value_init_for_array_type
) << FullRange
);
673 if (!Ty
->isVoidType() &&
674 RequireCompleteType(TyBeginLoc
, Ty
,
675 PDiag(diag::err_invalid_incomplete_type_use
)
679 if (RequireNonAbstractType(TyBeginLoc
, Ty
,
680 diag::err_allocation_of_abstract_type
))
684 // C++ [expr.type.conv]p1:
685 // If the expression list is a single expression, the type conversion
686 // expression is equivalent (in definedness, and if defined in meaning) to the
687 // corresponding cast expression.
690 CastKind Kind
= CK_Invalid
;
691 ExprValueKind VK
= VK_RValue
;
692 CXXCastPath BasePath
;
693 ExprResult CastExpr
=
694 CheckCastTypes(TInfo
->getTypeLoc().getBeginLoc(),
695 TInfo
->getTypeLoc().getSourceRange(), Ty
, Exprs
[0],
697 /*FunctionalStyle=*/true);
698 if (CastExpr
.isInvalid())
700 Exprs
[0] = CastExpr
.take();
704 return Owned(CXXFunctionalCastExpr::Create(Context
,
705 Ty
.getNonLValueExprType(Context
),
706 VK
, TInfo
, TyBeginLoc
, Kind
,
711 InitializedEntity Entity
= InitializedEntity::InitializeTemporary(TInfo
);
712 InitializationKind Kind
713 = NumExprs
? InitializationKind::CreateDirect(TyBeginLoc
,
714 LParenLoc
, RParenLoc
)
715 : InitializationKind::CreateValue(TyBeginLoc
,
716 LParenLoc
, RParenLoc
);
717 InitializationSequence
InitSeq(*this, Entity
, Kind
, Exprs
, NumExprs
);
718 ExprResult Result
= InitSeq
.Perform(*this, Entity
, Kind
, move(exprs
));
720 // FIXME: Improve AST representation?
724 /// doesUsualArrayDeleteWantSize - Answers whether the usual
725 /// operator delete[] for the given type has a size_t parameter.
726 static bool doesUsualArrayDeleteWantSize(Sema
&S
, SourceLocation loc
,
727 QualType allocType
) {
728 const RecordType
*record
=
729 allocType
->getBaseElementTypeUnsafe()->getAs
<RecordType
>();
730 if (!record
) return false;
732 // Try to find an operator delete[] in class scope.
734 DeclarationName deleteName
=
735 S
.Context
.DeclarationNames
.getCXXOperatorName(OO_Array_Delete
);
736 LookupResult
ops(S
, deleteName
, loc
, Sema::LookupOrdinaryName
);
737 S
.LookupQualifiedName(ops
, record
->getDecl());
739 // We're just doing this for information.
740 ops
.suppressDiagnostics();
742 // Very likely: there's no operator delete[].
743 if (ops
.empty()) return false;
745 // If it's ambiguous, it should be illegal to call operator delete[]
746 // on this thing, so it doesn't matter if we allocate extra space or not.
747 if (ops
.isAmbiguous()) return false;
749 LookupResult::Filter filter
= ops
.makeFilter();
750 while (filter
.hasNext()) {
751 NamedDecl
*del
= filter
.next()->getUnderlyingDecl();
753 // C++0x [basic.stc.dynamic.deallocation]p2:
754 // A template instance is never a usual deallocation function,
755 // regardless of its signature.
756 if (isa
<FunctionTemplateDecl
>(del
)) {
761 // C++0x [basic.stc.dynamic.deallocation]p2:
762 // If class T does not declare [an operator delete[] with one
763 // parameter] but does declare a member deallocation function
764 // named operator delete[] with exactly two parameters, the
765 // second of which has type std::size_t, then this function
766 // is a usual deallocation function.
767 if (!cast
<CXXMethodDecl
>(del
)->isUsualDeallocationFunction()) {
774 if (!ops
.isSingleResult()) return false;
776 const FunctionDecl
*del
= cast
<FunctionDecl
>(ops
.getFoundDecl());
777 return (del
->getNumParams() == 2);
780 /// ActOnCXXNew - Parsed a C++ 'new' expression (C++ 5.3.4), as in e.g.:
781 /// @code new (memory) int[size][4] @endcode
783 /// @code ::new Foo(23, "hello") @endcode
784 /// For the interpretation of this heap of arguments, consult the base version.
786 Sema::ActOnCXXNew(SourceLocation StartLoc
, bool UseGlobal
,
787 SourceLocation PlacementLParen
, MultiExprArg PlacementArgs
,
788 SourceLocation PlacementRParen
, SourceRange TypeIdParens
,
789 Declarator
&D
, SourceLocation ConstructorLParen
,
790 MultiExprArg ConstructorArgs
,
791 SourceLocation ConstructorRParen
) {
792 bool TypeContainsAuto
= D
.getDeclSpec().getTypeSpecType() == DeclSpec::TST_auto
;
795 // If the specified type is an array, unwrap it and save the expression.
796 if (D
.getNumTypeObjects() > 0 &&
797 D
.getTypeObject(0).Kind
== DeclaratorChunk::Array
) {
798 DeclaratorChunk
&Chunk
= D
.getTypeObject(0);
799 if (TypeContainsAuto
)
800 return ExprError(Diag(Chunk
.Loc
, diag::err_new_array_of_auto
)
801 << D
.getSourceRange());
802 if (Chunk
.Arr
.hasStatic
)
803 return ExprError(Diag(Chunk
.Loc
, diag::err_static_illegal_in_new
)
804 << D
.getSourceRange());
805 if (!Chunk
.Arr
.NumElts
)
806 return ExprError(Diag(Chunk
.Loc
, diag::err_array_new_needs_size
)
807 << D
.getSourceRange());
809 ArraySize
= static_cast<Expr
*>(Chunk
.Arr
.NumElts
);
810 D
.DropFirstTypeObject();
813 // Every dimension shall be of constant size.
815 for (unsigned I
= 0, N
= D
.getNumTypeObjects(); I
< N
; ++I
) {
816 if (D
.getTypeObject(I
).Kind
!= DeclaratorChunk::Array
)
819 DeclaratorChunk::ArrayTypeInfo
&Array
= D
.getTypeObject(I
).Arr
;
820 if (Expr
*NumElts
= (Expr
*)Array
.NumElts
) {
821 if (!NumElts
->isTypeDependent() && !NumElts
->isValueDependent() &&
822 !NumElts
->isIntegerConstantExpr(Context
)) {
823 Diag(D
.getTypeObject(I
).Loc
, diag::err_new_array_nonconst
)
824 << NumElts
->getSourceRange();
831 TypeSourceInfo
*TInfo
= GetTypeForDeclarator(D
, /*Scope=*/0, /*OwnedDecl=*/0,
833 QualType AllocType
= TInfo
->getType();
834 if (D
.isInvalidType())
837 return BuildCXXNew(StartLoc
, UseGlobal
,
846 move(ConstructorArgs
),
852 Sema::BuildCXXNew(SourceLocation StartLoc
, bool UseGlobal
,
853 SourceLocation PlacementLParen
,
854 MultiExprArg PlacementArgs
,
855 SourceLocation PlacementRParen
,
856 SourceRange TypeIdParens
,
858 TypeSourceInfo
*AllocTypeInfo
,
860 SourceLocation ConstructorLParen
,
861 MultiExprArg ConstructorArgs
,
862 SourceLocation ConstructorRParen
,
863 bool TypeMayContainAuto
) {
864 SourceRange TypeRange
= AllocTypeInfo
->getTypeLoc().getSourceRange();
866 // C++0x [decl.spec.auto]p6. Deduce the type which 'auto' stands in for.
867 if (TypeMayContainAuto
&& AllocType
->getContainedAutoType()) {
868 if (ConstructorArgs
.size() == 0)
869 return ExprError(Diag(StartLoc
, diag::err_auto_new_requires_ctor_arg
)
870 << AllocType
<< TypeRange
);
871 if (ConstructorArgs
.size() != 1) {
872 Expr
*FirstBad
= ConstructorArgs
.get()[1];
873 return ExprError(Diag(FirstBad
->getSourceRange().getBegin(),
874 diag::err_auto_new_ctor_multiple_expressions
)
875 << AllocType
<< TypeRange
);
877 TypeSourceInfo
*DeducedType
= 0;
878 if (!DeduceAutoType(AllocTypeInfo
, ConstructorArgs
.get()[0], DeducedType
))
879 return ExprError(Diag(StartLoc
, diag::err_auto_new_deduction_failure
)
881 << ConstructorArgs
.get()[0]->getType()
883 << ConstructorArgs
.get()[0]->getSourceRange());
887 AllocTypeInfo
= DeducedType
;
888 AllocType
= AllocTypeInfo
->getType();
891 // Per C++0x [expr.new]p5, the type being constructed may be a
892 // typedef of an array type.
894 if (const ConstantArrayType
*Array
895 = Context
.getAsConstantArrayType(AllocType
)) {
896 ArraySize
= IntegerLiteral::Create(Context
, Array
->getSize(),
897 Context
.getSizeType(),
899 AllocType
= Array
->getElementType();
903 if (CheckAllocatedType(AllocType
, TypeRange
.getBegin(), TypeRange
))
906 // In ARC, infer 'retaining' for the allocated
907 if (getLangOptions().ObjCAutoRefCount
&&
908 AllocType
.getObjCLifetime() == Qualifiers::OCL_None
&&
909 AllocType
->isObjCLifetimeType()) {
910 AllocType
= Context
.getLifetimeQualifiedType(AllocType
,
911 AllocType
->getObjCARCImplicitLifetime());
914 QualType ResultType
= Context
.getPointerType(AllocType
);
916 // C++ 5.3.4p6: "The expression in a direct-new-declarator shall have integral
917 // or enumeration type with a non-negative value."
918 if (ArraySize
&& !ArraySize
->isTypeDependent()) {
920 QualType SizeType
= ArraySize
->getType();
922 ExprResult ConvertedSize
923 = ConvertToIntegralOrEnumerationType(StartLoc
, ArraySize
,
924 PDiag(diag::err_array_size_not_integral
),
925 PDiag(diag::err_array_size_incomplete_type
)
926 << ArraySize
->getSourceRange(),
927 PDiag(diag::err_array_size_explicit_conversion
),
928 PDiag(diag::note_array_size_conversion
),
929 PDiag(diag::err_array_size_ambiguous_conversion
),
930 PDiag(diag::note_array_size_conversion
),
931 PDiag(getLangOptions().CPlusPlus0x
? 0
932 : diag::ext_array_size_conversion
));
933 if (ConvertedSize
.isInvalid())
936 ArraySize
= ConvertedSize
.take();
937 SizeType
= ArraySize
->getType();
938 if (!SizeType
->isIntegralOrUnscopedEnumerationType())
941 // Let's see if this is a constant < 0. If so, we reject it out of hand.
942 // We don't care about special rules, so we tell the machinery it's not
943 // evaluated - it gives us a result in more cases.
944 if (!ArraySize
->isValueDependent()) {
946 if (ArraySize
->isIntegerConstantExpr(Value
, Context
, 0, false)) {
947 if (Value
< llvm::APSInt(
948 llvm::APInt::getNullValue(Value
.getBitWidth()),
950 return ExprError(Diag(ArraySize
->getSourceRange().getBegin(),
951 diag::err_typecheck_negative_array_size
)
952 << ArraySize
->getSourceRange());
954 if (!AllocType
->isDependentType()) {
955 unsigned ActiveSizeBits
956 = ConstantArrayType::getNumAddressingBits(Context
, AllocType
, Value
);
957 if (ActiveSizeBits
> ConstantArrayType::getMaxSizeBits(Context
)) {
958 Diag(ArraySize
->getSourceRange().getBegin(),
959 diag::err_array_too_large
)
960 << Value
.toString(10)
961 << ArraySize
->getSourceRange();
965 } else if (TypeIdParens
.isValid()) {
966 // Can't have dynamic array size when the type-id is in parentheses.
967 Diag(ArraySize
->getLocStart(), diag::ext_new_paren_array_nonconst
)
968 << ArraySize
->getSourceRange()
969 << FixItHint::CreateRemoval(TypeIdParens
.getBegin())
970 << FixItHint::CreateRemoval(TypeIdParens
.getEnd());
972 TypeIdParens
= SourceRange();
976 // ARC: warn about ABI issues.
977 if (getLangOptions().ObjCAutoRefCount
) {
978 QualType BaseAllocType
= Context
.getBaseElementType(AllocType
);
979 if (BaseAllocType
.hasStrongOrWeakObjCLifetime())
980 Diag(StartLoc
, diag::warn_err_new_delete_object_array
)
981 << 0 << BaseAllocType
;
984 // Note that we do *not* convert the argument in any way. It can
985 // be signed, larger than size_t, whatever.
988 FunctionDecl
*OperatorNew
= 0;
989 FunctionDecl
*OperatorDelete
= 0;
990 Expr
**PlaceArgs
= (Expr
**)PlacementArgs
.get();
991 unsigned NumPlaceArgs
= PlacementArgs
.size();
993 if (!AllocType
->isDependentType() &&
994 !Expr::hasAnyTypeDependentArguments(PlaceArgs
, NumPlaceArgs
) &&
995 FindAllocationFunctions(StartLoc
,
996 SourceRange(PlacementLParen
, PlacementRParen
),
997 UseGlobal
, AllocType
, ArraySize
, PlaceArgs
,
998 NumPlaceArgs
, OperatorNew
, OperatorDelete
))
1001 // If this is an array allocation, compute whether the usual array
1002 // deallocation function for the type has a size_t parameter.
1003 bool UsualArrayDeleteWantsSize
= false;
1004 if (ArraySize
&& !AllocType
->isDependentType())
1005 UsualArrayDeleteWantsSize
1006 = doesUsualArrayDeleteWantSize(*this, StartLoc
, AllocType
);
1008 llvm::SmallVector
<Expr
*, 8> AllPlaceArgs
;
1010 // Add default arguments, if any.
1011 const FunctionProtoType
*Proto
=
1012 OperatorNew
->getType()->getAs
<FunctionProtoType
>();
1013 VariadicCallType CallType
=
1014 Proto
->isVariadic() ? VariadicFunction
: VariadicDoesNotApply
;
1016 if (GatherArgumentsForCall(PlacementLParen
, OperatorNew
,
1017 Proto
, 1, PlaceArgs
, NumPlaceArgs
,
1018 AllPlaceArgs
, CallType
))
1021 NumPlaceArgs
= AllPlaceArgs
.size();
1022 if (NumPlaceArgs
> 0)
1023 PlaceArgs
= &AllPlaceArgs
[0];
1026 bool Init
= ConstructorLParen
.isValid();
1027 // --- Choosing a constructor ---
1028 CXXConstructorDecl
*Constructor
= 0;
1029 Expr
**ConsArgs
= (Expr
**)ConstructorArgs
.get();
1030 unsigned NumConsArgs
= ConstructorArgs
.size();
1031 ASTOwningVector
<Expr
*> ConvertedConstructorArgs(*this);
1033 // Array 'new' can't have any initializers.
1034 if (NumConsArgs
&& (ResultType
->isArrayType() || ArraySize
)) {
1035 SourceRange
InitRange(ConsArgs
[0]->getLocStart(),
1036 ConsArgs
[NumConsArgs
- 1]->getLocEnd());
1038 Diag(StartLoc
, diag::err_new_array_init_args
) << InitRange
;
1042 if (!AllocType
->isDependentType() &&
1043 !Expr::hasAnyTypeDependentArguments(ConsArgs
, NumConsArgs
)) {
1044 // C++0x [expr.new]p15:
1045 // A new-expression that creates an object of type T initializes that
1046 // object as follows:
1047 InitializationKind Kind
1048 // - If the new-initializer is omitted, the object is default-
1049 // initialized (8.5); if no initialization is performed,
1050 // the object has indeterminate value
1051 = !Init
? InitializationKind::CreateDefault(TypeRange
.getBegin())
1052 // - Otherwise, the new-initializer is interpreted according to the
1053 // initialization rules of 8.5 for direct-initialization.
1054 : InitializationKind::CreateDirect(TypeRange
.getBegin(),
1058 InitializedEntity Entity
1059 = InitializedEntity::InitializeNew(StartLoc
, AllocType
);
1060 InitializationSequence
InitSeq(*this, Entity
, Kind
, ConsArgs
, NumConsArgs
);
1061 ExprResult FullInit
= InitSeq
.Perform(*this, Entity
, Kind
,
1062 move(ConstructorArgs
));
1063 if (FullInit
.isInvalid())
1066 // FullInit is our initializer; walk through it to determine if it's a
1067 // constructor call, which CXXNewExpr handles directly.
1068 if (Expr
*FullInitExpr
= (Expr
*)FullInit
.get()) {
1069 if (CXXBindTemporaryExpr
*Binder
1070 = dyn_cast
<CXXBindTemporaryExpr
>(FullInitExpr
))
1071 FullInitExpr
= Binder
->getSubExpr();
1072 if (CXXConstructExpr
*Construct
1073 = dyn_cast
<CXXConstructExpr
>(FullInitExpr
)) {
1074 Constructor
= Construct
->getConstructor();
1075 for (CXXConstructExpr::arg_iterator A
= Construct
->arg_begin(),
1076 AEnd
= Construct
->arg_end();
1078 ConvertedConstructorArgs
.push_back(*A
);
1080 // Take the converted initializer.
1081 ConvertedConstructorArgs
.push_back(FullInit
.release());
1084 // No initialization required.
1087 // Take the converted arguments and use them for the new expression.
1088 NumConsArgs
= ConvertedConstructorArgs
.size();
1089 ConsArgs
= (Expr
**)ConvertedConstructorArgs
.take();
1092 // Mark the new and delete operators as referenced.
1094 MarkDeclarationReferenced(StartLoc
, OperatorNew
);
1096 MarkDeclarationReferenced(StartLoc
, OperatorDelete
);
1098 // FIXME: Also check that the destructor is accessible. (C++ 5.3.4p16)
1100 PlacementArgs
.release();
1101 ConstructorArgs
.release();
1103 return Owned(new (Context
) CXXNewExpr(Context
, UseGlobal
, OperatorNew
,
1104 PlaceArgs
, NumPlaceArgs
, TypeIdParens
,
1105 ArraySize
, Constructor
, Init
,
1106 ConsArgs
, NumConsArgs
, OperatorDelete
,
1107 UsualArrayDeleteWantsSize
,
1108 ResultType
, AllocTypeInfo
,
1110 Init
? ConstructorRParen
:
1112 ConstructorLParen
, ConstructorRParen
));
1115 /// CheckAllocatedType - Checks that a type is suitable as the allocated type
1116 /// in a new-expression.
1117 /// dimension off and stores the size expression in ArraySize.
1118 bool Sema::CheckAllocatedType(QualType AllocType
, SourceLocation Loc
,
1120 // C++ 5.3.4p1: "[The] type shall be a complete object type, but not an
1121 // abstract class type or array thereof.
1122 if (AllocType
->isFunctionType())
1123 return Diag(Loc
, diag::err_bad_new_type
)
1124 << AllocType
<< 0 << R
;
1125 else if (AllocType
->isReferenceType())
1126 return Diag(Loc
, diag::err_bad_new_type
)
1127 << AllocType
<< 1 << R
;
1128 else if (!AllocType
->isDependentType() &&
1129 RequireCompleteType(Loc
, AllocType
,
1130 PDiag(diag::err_new_incomplete_type
)
1133 else if (RequireNonAbstractType(Loc
, AllocType
,
1134 diag::err_allocation_of_abstract_type
))
1136 else if (AllocType
->isVariablyModifiedType())
1137 return Diag(Loc
, diag::err_variably_modified_new_type
)
1139 else if (unsigned AddressSpace
= AllocType
.getAddressSpace())
1140 return Diag(Loc
, diag::err_address_space_qualified_new
)
1141 << AllocType
.getUnqualifiedType() << AddressSpace
;
1142 else if (getLangOptions().ObjCAutoRefCount
) {
1143 if (const ArrayType
*AT
= Context
.getAsArrayType(AllocType
)) {
1144 QualType BaseAllocType
= Context
.getBaseElementType(AT
);
1145 if (BaseAllocType
.getObjCLifetime() == Qualifiers::OCL_None
&&
1146 BaseAllocType
->isObjCLifetimeType())
1147 return Diag(Loc
, diag::err_arc_new_array_without_ownership
)
1155 /// \brief Determine whether the given function is a non-placement
1156 /// deallocation function.
1157 static bool isNonPlacementDeallocationFunction(FunctionDecl
*FD
) {
1158 if (FD
->isInvalidDecl())
1161 if (CXXMethodDecl
*Method
= dyn_cast
<CXXMethodDecl
>(FD
))
1162 return Method
->isUsualDeallocationFunction();
1164 return ((FD
->getOverloadedOperator() == OO_Delete
||
1165 FD
->getOverloadedOperator() == OO_Array_Delete
) &&
1166 FD
->getNumParams() == 1);
1169 /// FindAllocationFunctions - Finds the overloads of operator new and delete
1170 /// that are appropriate for the allocation.
1171 bool Sema::FindAllocationFunctions(SourceLocation StartLoc
, SourceRange Range
,
1172 bool UseGlobal
, QualType AllocType
,
1173 bool IsArray
, Expr
**PlaceArgs
,
1174 unsigned NumPlaceArgs
,
1175 FunctionDecl
*&OperatorNew
,
1176 FunctionDecl
*&OperatorDelete
) {
1177 // --- Choosing an allocation function ---
1178 // C++ 5.3.4p8 - 14 & 18
1179 // 1) If UseGlobal is true, only look in the global scope. Else, also look
1180 // in the scope of the allocated class.
1181 // 2) If an array size is given, look for operator new[], else look for
1183 // 3) The first argument is always size_t. Append the arguments from the
1186 llvm::SmallVector
<Expr
*, 8> AllocArgs(1 + NumPlaceArgs
);
1187 // We don't care about the actual value of this argument.
1188 // FIXME: Should the Sema create the expression and embed it in the syntax
1189 // tree? Or should the consumer just recalculate the value?
1190 IntegerLiteral
Size(Context
, llvm::APInt::getNullValue(
1191 Context
.Target
.getPointerWidth(0)),
1192 Context
.getSizeType(),
1194 AllocArgs
[0] = &Size
;
1195 std::copy(PlaceArgs
, PlaceArgs
+ NumPlaceArgs
, AllocArgs
.begin() + 1);
1197 // C++ [expr.new]p8:
1198 // If the allocated type is a non-array type, the allocation
1199 // function's name is operator new and the deallocation function's
1200 // name is operator delete. If the allocated type is an array
1201 // type, the allocation function's name is operator new[] and the
1202 // deallocation function's name is operator delete[].
1203 DeclarationName NewName
= Context
.DeclarationNames
.getCXXOperatorName(
1204 IsArray
? OO_Array_New
: OO_New
);
1205 DeclarationName DeleteName
= Context
.DeclarationNames
.getCXXOperatorName(
1206 IsArray
? OO_Array_Delete
: OO_Delete
);
1208 QualType AllocElemType
= Context
.getBaseElementType(AllocType
);
1210 if (AllocElemType
->isRecordType() && !UseGlobal
) {
1211 CXXRecordDecl
*Record
1212 = cast
<CXXRecordDecl
>(AllocElemType
->getAs
<RecordType
>()->getDecl());
1213 if (FindAllocationOverload(StartLoc
, Range
, NewName
, &AllocArgs
[0],
1214 AllocArgs
.size(), Record
, /*AllowMissing=*/true,
1219 // Didn't find a member overload. Look for a global one.
1220 DeclareGlobalNewDelete();
1221 DeclContext
*TUDecl
= Context
.getTranslationUnitDecl();
1222 if (FindAllocationOverload(StartLoc
, Range
, NewName
, &AllocArgs
[0],
1223 AllocArgs
.size(), TUDecl
, /*AllowMissing=*/false,
1228 // We don't need an operator delete if we're running under
1230 if (!getLangOptions().Exceptions
) {
1235 // FindAllocationOverload can change the passed in arguments, so we need to
1237 if (NumPlaceArgs
> 0)
1238 std::copy(&AllocArgs
[1], AllocArgs
.end(), PlaceArgs
);
1240 // C++ [expr.new]p19:
1242 // If the new-expression begins with a unary :: operator, the
1243 // deallocation function's name is looked up in the global
1244 // scope. Otherwise, if the allocated type is a class type T or an
1245 // array thereof, the deallocation function's name is looked up in
1246 // the scope of T. If this lookup fails to find the name, or if
1247 // the allocated type is not a class type or array thereof, the
1248 // deallocation function's name is looked up in the global scope.
1249 LookupResult
FoundDelete(*this, DeleteName
, StartLoc
, LookupOrdinaryName
);
1250 if (AllocElemType
->isRecordType() && !UseGlobal
) {
1252 = cast
<CXXRecordDecl
>(AllocElemType
->getAs
<RecordType
>()->getDecl());
1253 LookupQualifiedName(FoundDelete
, RD
);
1255 if (FoundDelete
.isAmbiguous())
1256 return true; // FIXME: clean up expressions?
1258 if (FoundDelete
.empty()) {
1259 DeclareGlobalNewDelete();
1260 LookupQualifiedName(FoundDelete
, Context
.getTranslationUnitDecl());
1263 FoundDelete
.suppressDiagnostics();
1265 llvm::SmallVector
<std::pair
<DeclAccessPair
,FunctionDecl
*>, 2> Matches
;
1267 // Whether we're looking for a placement operator delete is dictated
1268 // by whether we selected a placement operator new, not by whether
1269 // we had explicit placement arguments. This matters for things like
1270 // struct A { void *operator new(size_t, int = 0); ... };
1272 bool isPlacementNew
= (NumPlaceArgs
> 0 || OperatorNew
->param_size() != 1);
1274 if (isPlacementNew
) {
1275 // C++ [expr.new]p20:
1276 // A declaration of a placement deallocation function matches the
1277 // declaration of a placement allocation function if it has the
1278 // same number of parameters and, after parameter transformations
1279 // (8.3.5), all parameter types except the first are
1282 // To perform this comparison, we compute the function type that
1283 // the deallocation function should have, and use that type both
1284 // for template argument deduction and for comparison purposes.
1286 // FIXME: this comparison should ignore CC and the like.
1287 QualType ExpectedFunctionType
;
1289 const FunctionProtoType
*Proto
1290 = OperatorNew
->getType()->getAs
<FunctionProtoType
>();
1292 llvm::SmallVector
<QualType
, 4> ArgTypes
;
1293 ArgTypes
.push_back(Context
.VoidPtrTy
);
1294 for (unsigned I
= 1, N
= Proto
->getNumArgs(); I
< N
; ++I
)
1295 ArgTypes
.push_back(Proto
->getArgType(I
));
1297 FunctionProtoType::ExtProtoInfo EPI
;
1298 EPI
.Variadic
= Proto
->isVariadic();
1300 ExpectedFunctionType
1301 = Context
.getFunctionType(Context
.VoidTy
, ArgTypes
.data(),
1302 ArgTypes
.size(), EPI
);
1305 for (LookupResult::iterator D
= FoundDelete
.begin(),
1306 DEnd
= FoundDelete
.end();
1308 FunctionDecl
*Fn
= 0;
1309 if (FunctionTemplateDecl
*FnTmpl
1310 = dyn_cast
<FunctionTemplateDecl
>((*D
)->getUnderlyingDecl())) {
1311 // Perform template argument deduction to try to match the
1312 // expected function type.
1313 TemplateDeductionInfo
Info(Context
, StartLoc
);
1314 if (DeduceTemplateArguments(FnTmpl
, 0, ExpectedFunctionType
, Fn
, Info
))
1317 Fn
= cast
<FunctionDecl
>((*D
)->getUnderlyingDecl());
1319 if (Context
.hasSameType(Fn
->getType(), ExpectedFunctionType
))
1320 Matches
.push_back(std::make_pair(D
.getPair(), Fn
));
1323 // C++ [expr.new]p20:
1324 // [...] Any non-placement deallocation function matches a
1325 // non-placement allocation function. [...]
1326 for (LookupResult::iterator D
= FoundDelete
.begin(),
1327 DEnd
= FoundDelete
.end();
1329 if (FunctionDecl
*Fn
= dyn_cast
<FunctionDecl
>((*D
)->getUnderlyingDecl()))
1330 if (isNonPlacementDeallocationFunction(Fn
))
1331 Matches
.push_back(std::make_pair(D
.getPair(), Fn
));
1335 // C++ [expr.new]p20:
1336 // [...] If the lookup finds a single matching deallocation
1337 // function, that function will be called; otherwise, no
1338 // deallocation function will be called.
1339 if (Matches
.size() == 1) {
1340 OperatorDelete
= Matches
[0].second
;
1342 // C++0x [expr.new]p20:
1343 // If the lookup finds the two-parameter form of a usual
1344 // deallocation function (3.7.4.2) and that function, considered
1345 // as a placement deallocation function, would have been
1346 // selected as a match for the allocation function, the program
1348 if (NumPlaceArgs
&& getLangOptions().CPlusPlus0x
&&
1349 isNonPlacementDeallocationFunction(OperatorDelete
)) {
1350 Diag(StartLoc
, diag::err_placement_new_non_placement_delete
)
1351 << SourceRange(PlaceArgs
[0]->getLocStart(),
1352 PlaceArgs
[NumPlaceArgs
- 1]->getLocEnd());
1353 Diag(OperatorDelete
->getLocation(), diag::note_previous_decl
)
1356 CheckAllocationAccess(StartLoc
, Range
, FoundDelete
.getNamingClass(),
1364 /// FindAllocationOverload - Find an fitting overload for the allocation
1365 /// function in the specified scope.
1366 bool Sema::FindAllocationOverload(SourceLocation StartLoc
, SourceRange Range
,
1367 DeclarationName Name
, Expr
** Args
,
1368 unsigned NumArgs
, DeclContext
*Ctx
,
1369 bool AllowMissing
, FunctionDecl
*&Operator
,
1371 LookupResult
R(*this, Name
, StartLoc
, LookupOrdinaryName
);
1372 LookupQualifiedName(R
, Ctx
);
1374 if (AllowMissing
|| !Diagnose
)
1376 return Diag(StartLoc
, diag::err_ovl_no_viable_function_in_call
)
1380 if (R
.isAmbiguous())
1383 R
.suppressDiagnostics();
1385 OverloadCandidateSet
Candidates(StartLoc
);
1386 for (LookupResult::iterator Alloc
= R
.begin(), AllocEnd
= R
.end();
1387 Alloc
!= AllocEnd
; ++Alloc
) {
1388 // Even member operator new/delete are implicitly treated as
1389 // static, so don't use AddMemberCandidate.
1390 NamedDecl
*D
= (*Alloc
)->getUnderlyingDecl();
1392 if (FunctionTemplateDecl
*FnTemplate
= dyn_cast
<FunctionTemplateDecl
>(D
)) {
1393 AddTemplateOverloadCandidate(FnTemplate
, Alloc
.getPair(),
1394 /*ExplicitTemplateArgs=*/0, Args
, NumArgs
,
1396 /*SuppressUserConversions=*/false);
1400 FunctionDecl
*Fn
= cast
<FunctionDecl
>(D
);
1401 AddOverloadCandidate(Fn
, Alloc
.getPair(), Args
, NumArgs
, Candidates
,
1402 /*SuppressUserConversions=*/false);
1405 // Do the resolution.
1406 OverloadCandidateSet::iterator Best
;
1407 switch (Candidates
.BestViableFunction(*this, StartLoc
, Best
)) {
1410 FunctionDecl
*FnDecl
= Best
->Function
;
1411 MarkDeclarationReferenced(StartLoc
, FnDecl
);
1412 // The first argument is size_t, and the first parameter must be size_t,
1413 // too. This is checked on declaration and can be assumed. (It can't be
1414 // asserted on, though, since invalid decls are left in there.)
1415 // Watch out for variadic allocator function.
1416 unsigned NumArgsInFnDecl
= FnDecl
->getNumParams();
1417 for (unsigned i
= 0; (i
< NumArgs
&& i
< NumArgsInFnDecl
); ++i
) {
1418 InitializedEntity Entity
= InitializedEntity::InitializeParameter(Context
,
1419 FnDecl
->getParamDecl(i
));
1421 if (!Diagnose
&& !CanPerformCopyInitialization(Entity
, Owned(Args
[i
])))
1425 = PerformCopyInitialization(Entity
, SourceLocation(), Owned(Args
[i
]));
1426 if (Result
.isInvalid())
1429 Args
[i
] = Result
.takeAs
<Expr
>();
1432 CheckAllocationAccess(StartLoc
, Range
, R
.getNamingClass(), Best
->FoundDecl
,
1437 case OR_No_Viable_Function
:
1439 Diag(StartLoc
, diag::err_ovl_no_viable_function_in_call
)
1441 Candidates
.NoteCandidates(*this, OCD_AllCandidates
, Args
, NumArgs
);
1447 Diag(StartLoc
, diag::err_ovl_ambiguous_call
)
1449 Candidates
.NoteCandidates(*this, OCD_ViableCandidates
, Args
, NumArgs
);
1455 Diag(StartLoc
, diag::err_ovl_deleted_call
)
1456 << Best
->Function
->isDeleted()
1458 << getDeletedOrUnavailableSuffix(Best
->Function
)
1460 Candidates
.NoteCandidates(*this, OCD_AllCandidates
, Args
, NumArgs
);
1465 assert(false && "Unreachable, bad result from BestViableFunction");
1470 /// DeclareGlobalNewDelete - Declare the global forms of operator new and
1471 /// delete. These are:
1474 /// void* operator new(std::size_t) throw(std::bad_alloc);
1475 /// void* operator new[](std::size_t) throw(std::bad_alloc);
1476 /// void operator delete(void *) throw();
1477 /// void operator delete[](void *) throw();
1479 /// void* operator new(std::size_t);
1480 /// void* operator new[](std::size_t);
1481 /// void operator delete(void *);
1482 /// void operator delete[](void *);
1484 /// C++0x operator delete is implicitly noexcept.
1485 /// Note that the placement and nothrow forms of new are *not* implicitly
1486 /// declared. Their use requires including \<new\>.
1487 void Sema::DeclareGlobalNewDelete() {
1488 if (GlobalNewDeleteDeclared
)
1491 // C++ [basic.std.dynamic]p2:
1492 // [...] The following allocation and deallocation functions (18.4) are
1493 // implicitly declared in global scope in each translation unit of a
1497 // void* operator new(std::size_t) throw(std::bad_alloc);
1498 // void* operator new[](std::size_t) throw(std::bad_alloc);
1499 // void operator delete(void*) throw();
1500 // void operator delete[](void*) throw();
1502 // void* operator new(std::size_t);
1503 // void* operator new[](std::size_t);
1504 // void operator delete(void*);
1505 // void operator delete[](void*);
1507 // These implicit declarations introduce only the function names operator
1508 // new, operator new[], operator delete, operator delete[].
1510 // Here, we need to refer to std::bad_alloc, so we will implicitly declare
1511 // "std" or "bad_alloc" as necessary to form the exception specification.
1512 // However, we do not make these implicit declarations visible to name
1514 // Note that the C++0x versions of operator delete are deallocation functions,
1515 // and thus are implicitly noexcept.
1516 if (!StdBadAlloc
&& !getLangOptions().CPlusPlus0x
) {
1517 // The "std::bad_alloc" class has not yet been declared, so build it
1519 StdBadAlloc
= CXXRecordDecl::Create(Context
, TTK_Class
,
1520 getOrCreateStdNamespace(),
1521 SourceLocation(), SourceLocation(),
1522 &PP
.getIdentifierTable().get("bad_alloc"),
1524 getStdBadAlloc()->setImplicit(true);
1527 GlobalNewDeleteDeclared
= true;
1529 QualType VoidPtr
= Context
.getPointerType(Context
.VoidTy
);
1530 QualType SizeT
= Context
.getSizeType();
1531 bool AssumeSaneOperatorNew
= getLangOptions().AssumeSaneOperatorNew
;
1533 DeclareGlobalAllocationFunction(
1534 Context
.DeclarationNames
.getCXXOperatorName(OO_New
),
1535 VoidPtr
, SizeT
, AssumeSaneOperatorNew
);
1536 DeclareGlobalAllocationFunction(
1537 Context
.DeclarationNames
.getCXXOperatorName(OO_Array_New
),
1538 VoidPtr
, SizeT
, AssumeSaneOperatorNew
);
1539 DeclareGlobalAllocationFunction(
1540 Context
.DeclarationNames
.getCXXOperatorName(OO_Delete
),
1541 Context
.VoidTy
, VoidPtr
);
1542 DeclareGlobalAllocationFunction(
1543 Context
.DeclarationNames
.getCXXOperatorName(OO_Array_Delete
),
1544 Context
.VoidTy
, VoidPtr
);
1547 /// DeclareGlobalAllocationFunction - Declares a single implicit global
1548 /// allocation function if it doesn't already exist.
1549 void Sema::DeclareGlobalAllocationFunction(DeclarationName Name
,
1550 QualType Return
, QualType Argument
,
1551 bool AddMallocAttr
) {
1552 DeclContext
*GlobalCtx
= Context
.getTranslationUnitDecl();
1554 // Check if this function is already declared.
1556 DeclContext::lookup_iterator Alloc
, AllocEnd
;
1557 for (llvm::tie(Alloc
, AllocEnd
) = GlobalCtx
->lookup(Name
);
1558 Alloc
!= AllocEnd
; ++Alloc
) {
1559 // Only look at non-template functions, as it is the predefined,
1560 // non-templated allocation function we are trying to declare here.
1561 if (FunctionDecl
*Func
= dyn_cast
<FunctionDecl
>(*Alloc
)) {
1562 QualType InitialParamType
=
1563 Context
.getCanonicalType(
1564 Func
->getParamDecl(0)->getType().getUnqualifiedType());
1565 // FIXME: Do we need to check for default arguments here?
1566 if (Func
->getNumParams() == 1 && InitialParamType
== Argument
) {
1567 if(AddMallocAttr
&& !Func
->hasAttr
<MallocAttr
>())
1568 Func
->addAttr(::new (Context
) MallocAttr(SourceLocation(), Context
));
1575 QualType BadAllocType
;
1576 bool HasBadAllocExceptionSpec
1577 = (Name
.getCXXOverloadedOperator() == OO_New
||
1578 Name
.getCXXOverloadedOperator() == OO_Array_New
);
1579 if (HasBadAllocExceptionSpec
&& !getLangOptions().CPlusPlus0x
) {
1580 assert(StdBadAlloc
&& "Must have std::bad_alloc declared");
1581 BadAllocType
= Context
.getTypeDeclType(getStdBadAlloc());
1584 FunctionProtoType::ExtProtoInfo EPI
;
1585 if (HasBadAllocExceptionSpec
) {
1586 if (!getLangOptions().CPlusPlus0x
) {
1587 EPI
.ExceptionSpecType
= EST_Dynamic
;
1588 EPI
.NumExceptions
= 1;
1589 EPI
.Exceptions
= &BadAllocType
;
1592 EPI
.ExceptionSpecType
= getLangOptions().CPlusPlus0x
?
1593 EST_BasicNoexcept
: EST_DynamicNone
;
1596 QualType FnType
= Context
.getFunctionType(Return
, &Argument
, 1, EPI
);
1597 FunctionDecl
*Alloc
=
1598 FunctionDecl::Create(Context
, GlobalCtx
, SourceLocation(),
1599 SourceLocation(), Name
,
1600 FnType
, /*TInfo=*/0, SC_None
,
1601 SC_None
, false, true);
1602 Alloc
->setImplicit();
1605 Alloc
->addAttr(::new (Context
) MallocAttr(SourceLocation(), Context
));
1607 ParmVarDecl
*Param
= ParmVarDecl::Create(Context
, Alloc
, SourceLocation(),
1608 SourceLocation(), 0,
1609 Argument
, /*TInfo=*/0,
1610 SC_None
, SC_None
, 0);
1611 Alloc
->setParams(&Param
, 1);
1613 // FIXME: Also add this declaration to the IdentifierResolver, but
1614 // make sure it is at the end of the chain to coincide with the
1616 Context
.getTranslationUnitDecl()->addDecl(Alloc
);
1619 bool Sema::FindDeallocationFunction(SourceLocation StartLoc
, CXXRecordDecl
*RD
,
1620 DeclarationName Name
,
1621 FunctionDecl
* &Operator
, bool Diagnose
) {
1622 LookupResult
Found(*this, Name
, StartLoc
, LookupOrdinaryName
);
1623 // Try to find operator delete/operator delete[] in class scope.
1624 LookupQualifiedName(Found
, RD
);
1626 if (Found
.isAmbiguous())
1629 Found
.suppressDiagnostics();
1631 llvm::SmallVector
<DeclAccessPair
,4> Matches
;
1632 for (LookupResult::iterator F
= Found
.begin(), FEnd
= Found
.end();
1634 NamedDecl
*ND
= (*F
)->getUnderlyingDecl();
1636 // Ignore template operator delete members from the check for a usual
1637 // deallocation function.
1638 if (isa
<FunctionTemplateDecl
>(ND
))
1641 if (cast
<CXXMethodDecl
>(ND
)->isUsualDeallocationFunction())
1642 Matches
.push_back(F
.getPair());
1645 // There's exactly one suitable operator; pick it.
1646 if (Matches
.size() == 1) {
1647 Operator
= cast
<CXXMethodDecl
>(Matches
[0]->getUnderlyingDecl());
1649 if (Operator
->isDeleted()) {
1651 Diag(StartLoc
, diag::err_deleted_function_use
);
1652 Diag(Operator
->getLocation(), diag::note_unavailable_here
) << true;
1657 CheckAllocationAccess(StartLoc
, SourceRange(), Found
.getNamingClass(),
1658 Matches
[0], Diagnose
);
1661 // We found multiple suitable operators; complain about the ambiguity.
1662 } else if (!Matches
.empty()) {
1664 Diag(StartLoc
, diag::err_ambiguous_suitable_delete_member_function_found
)
1667 for (llvm::SmallVectorImpl
<DeclAccessPair
>::iterator
1668 F
= Matches
.begin(), FEnd
= Matches
.end(); F
!= FEnd
; ++F
)
1669 Diag((*F
)->getUnderlyingDecl()->getLocation(),
1670 diag::note_member_declared_here
) << Name
;
1675 // We did find operator delete/operator delete[] declarations, but
1676 // none of them were suitable.
1677 if (!Found
.empty()) {
1679 Diag(StartLoc
, diag::err_no_suitable_delete_member_function_found
)
1682 for (LookupResult::iterator F
= Found
.begin(), FEnd
= Found
.end();
1684 Diag((*F
)->getUnderlyingDecl()->getLocation(),
1685 diag::note_member_declared_here
) << Name
;
1690 // Look for a global declaration.
1691 DeclareGlobalNewDelete();
1692 DeclContext
*TUDecl
= Context
.getTranslationUnitDecl();
1694 CXXNullPtrLiteralExpr
Null(Context
.VoidPtrTy
, SourceLocation());
1695 Expr
* DeallocArgs
[1];
1696 DeallocArgs
[0] = &Null
;
1697 if (FindAllocationOverload(StartLoc
, SourceRange(), Name
,
1698 DeallocArgs
, 1, TUDecl
, !Diagnose
,
1699 Operator
, Diagnose
))
1702 assert(Operator
&& "Did not find a deallocation function!");
1706 /// ActOnCXXDelete - Parsed a C++ 'delete' expression (C++ 5.3.5), as in:
1707 /// @code ::delete ptr; @endcode
1709 /// @code delete [] ptr; @endcode
1711 Sema::ActOnCXXDelete(SourceLocation StartLoc
, bool UseGlobal
,
1712 bool ArrayForm
, Expr
*ExE
) {
1713 // C++ [expr.delete]p1:
1714 // The operand shall have a pointer type, or a class type having a single
1715 // conversion function to a pointer type. The result has type void.
1717 // DR599 amends "pointer type" to "pointer to object type" in both cases.
1719 ExprResult Ex
= Owned(ExE
);
1720 FunctionDecl
*OperatorDelete
= 0;
1721 bool ArrayFormAsWritten
= ArrayForm
;
1722 bool UsualArrayDeleteWantsSize
= false;
1724 if (!Ex
.get()->isTypeDependent()) {
1725 QualType Type
= Ex
.get()->getType();
1727 if (const RecordType
*Record
= Type
->getAs
<RecordType
>()) {
1728 if (RequireCompleteType(StartLoc
, Type
,
1729 PDiag(diag::err_delete_incomplete_class_type
)))
1732 llvm::SmallVector
<CXXConversionDecl
*, 4> ObjectPtrConversions
;
1734 CXXRecordDecl
*RD
= cast
<CXXRecordDecl
>(Record
->getDecl());
1735 const UnresolvedSetImpl
*Conversions
= RD
->getVisibleConversionFunctions();
1736 for (UnresolvedSetImpl::iterator I
= Conversions
->begin(),
1737 E
= Conversions
->end(); I
!= E
; ++I
) {
1738 NamedDecl
*D
= I
.getDecl();
1739 if (isa
<UsingShadowDecl
>(D
))
1740 D
= cast
<UsingShadowDecl
>(D
)->getTargetDecl();
1742 // Skip over templated conversion functions; they aren't considered.
1743 if (isa
<FunctionTemplateDecl
>(D
))
1746 CXXConversionDecl
*Conv
= cast
<CXXConversionDecl
>(D
);
1748 QualType ConvType
= Conv
->getConversionType().getNonReferenceType();
1749 if (const PointerType
*ConvPtrType
= ConvType
->getAs
<PointerType
>())
1750 if (ConvPtrType
->getPointeeType()->isIncompleteOrObjectType())
1751 ObjectPtrConversions
.push_back(Conv
);
1753 if (ObjectPtrConversions
.size() == 1) {
1754 // We have a single conversion to a pointer-to-object type. Perform
1756 // TODO: don't redo the conversion calculation.
1758 PerformImplicitConversion(Ex
.get(),
1759 ObjectPtrConversions
.front()->getConversionType(),
1761 if (Res
.isUsable()) {
1763 Type
= Ex
.get()->getType();
1766 else if (ObjectPtrConversions
.size() > 1) {
1767 Diag(StartLoc
, diag::err_ambiguous_delete_operand
)
1768 << Type
<< Ex
.get()->getSourceRange();
1769 for (unsigned i
= 0; i
< ObjectPtrConversions
.size(); i
++)
1770 NoteOverloadCandidate(ObjectPtrConversions
[i
]);
1775 if (!Type
->isPointerType())
1776 return ExprError(Diag(StartLoc
, diag::err_delete_operand
)
1777 << Type
<< Ex
.get()->getSourceRange());
1779 QualType Pointee
= Type
->getAs
<PointerType
>()->getPointeeType();
1780 if (Pointee
->isVoidType() && !isSFINAEContext()) {
1781 // The C++ standard bans deleting a pointer to a non-object type, which
1782 // effectively bans deletion of "void*". However, most compilers support
1783 // this, so we treat it as a warning unless we're in a SFINAE context.
1784 Diag(StartLoc
, diag::ext_delete_void_ptr_operand
)
1785 << Type
<< Ex
.get()->getSourceRange();
1786 } else if (Pointee
->isFunctionType() || Pointee
->isVoidType())
1787 return ExprError(Diag(StartLoc
, diag::err_delete_operand
)
1788 << Type
<< Ex
.get()->getSourceRange());
1789 else if (!Pointee
->isDependentType() &&
1790 RequireCompleteType(StartLoc
, Pointee
,
1791 PDiag(diag::warn_delete_incomplete
)
1792 << Ex
.get()->getSourceRange()))
1794 else if (unsigned AddressSpace
= Pointee
.getAddressSpace())
1795 return Diag(Ex
.get()->getLocStart(),
1796 diag::err_address_space_qualified_delete
)
1797 << Pointee
.getUnqualifiedType() << AddressSpace
;
1798 // C++ [expr.delete]p2:
1799 // [Note: a pointer to a const type can be the operand of a
1800 // delete-expression; it is not necessary to cast away the constness
1801 // (5.2.11) of the pointer expression before it is used as the operand
1802 // of the delete-expression. ]
1803 if (!Context
.hasSameType(Ex
.get()->getType(), Context
.VoidPtrTy
))
1804 Ex
= Owned(ImplicitCastExpr::Create(Context
, Context
.VoidPtrTy
, CK_NoOp
,
1805 Ex
.take(), 0, VK_RValue
));
1807 if (Pointee
->isArrayType() && !ArrayForm
) {
1808 Diag(StartLoc
, diag::warn_delete_array_type
)
1809 << Type
<< Ex
.get()->getSourceRange()
1810 << FixItHint::CreateInsertion(PP
.getLocForEndOfToken(StartLoc
), "[]");
1814 DeclarationName DeleteName
= Context
.DeclarationNames
.getCXXOperatorName(
1815 ArrayForm
? OO_Array_Delete
: OO_Delete
);
1817 QualType PointeeElem
= Context
.getBaseElementType(Pointee
);
1818 if (const RecordType
*RT
= PointeeElem
->getAs
<RecordType
>()) {
1819 CXXRecordDecl
*RD
= cast
<CXXRecordDecl
>(RT
->getDecl());
1822 FindDeallocationFunction(StartLoc
, RD
, DeleteName
, OperatorDelete
))
1825 // If we're allocating an array of records, check whether the
1826 // usual operator delete[] has a size_t parameter.
1828 // If the user specifically asked to use the global allocator,
1829 // we'll need to do the lookup into the class.
1831 UsualArrayDeleteWantsSize
=
1832 doesUsualArrayDeleteWantSize(*this, StartLoc
, PointeeElem
);
1834 // Otherwise, the usual operator delete[] should be the
1835 // function we just found.
1836 else if (isa
<CXXMethodDecl
>(OperatorDelete
))
1837 UsualArrayDeleteWantsSize
= (OperatorDelete
->getNumParams() == 2);
1840 if (!RD
->hasTrivialDestructor())
1841 if (CXXDestructorDecl
*Dtor
= LookupDestructor(RD
)) {
1842 MarkDeclarationReferenced(StartLoc
,
1843 const_cast<CXXDestructorDecl
*>(Dtor
));
1844 DiagnoseUseOfDecl(Dtor
, StartLoc
);
1847 // C++ [expr.delete]p3:
1848 // In the first alternative (delete object), if the static type of the
1849 // object to be deleted is different from its dynamic type, the static
1850 // type shall be a base class of the dynamic type of the object to be
1851 // deleted and the static type shall have a virtual destructor or the
1852 // behavior is undefined.
1854 // Note: a final class cannot be derived from, no issue there
1855 if (!ArrayForm
&& RD
->isPolymorphic() && !RD
->hasAttr
<FinalAttr
>()) {
1856 CXXDestructorDecl
*dtor
= RD
->getDestructor();
1857 if (!dtor
|| !dtor
->isVirtual())
1858 Diag(StartLoc
, diag::warn_delete_non_virtual_dtor
) << PointeeElem
;
1861 } else if (getLangOptions().ObjCAutoRefCount
&&
1862 PointeeElem
->isObjCLifetimeType() &&
1863 (PointeeElem
.getObjCLifetime() == Qualifiers::OCL_Strong
||
1864 PointeeElem
.getObjCLifetime() == Qualifiers::OCL_Weak
) &&
1866 Diag(StartLoc
, diag::warn_err_new_delete_object_array
)
1867 << 1 << PointeeElem
;
1870 if (!OperatorDelete
) {
1871 // Look for a global declaration.
1872 DeclareGlobalNewDelete();
1873 DeclContext
*TUDecl
= Context
.getTranslationUnitDecl();
1874 Expr
*Arg
= Ex
.get();
1875 if (FindAllocationOverload(StartLoc
, SourceRange(), DeleteName
,
1876 &Arg
, 1, TUDecl
, /*AllowMissing=*/false,
1881 MarkDeclarationReferenced(StartLoc
, OperatorDelete
);
1883 // Check access and ambiguity of operator delete and destructor.
1884 if (const RecordType
*RT
= PointeeElem
->getAs
<RecordType
>()) {
1885 CXXRecordDecl
*RD
= cast
<CXXRecordDecl
>(RT
->getDecl());
1886 if (CXXDestructorDecl
*Dtor
= LookupDestructor(RD
)) {
1887 CheckDestructorAccess(Ex
.get()->getExprLoc(), Dtor
,
1888 PDiag(diag::err_access_dtor
) << PointeeElem
);
1894 return Owned(new (Context
) CXXDeleteExpr(Context
.VoidTy
, UseGlobal
, ArrayForm
,
1896 UsualArrayDeleteWantsSize
,
1897 OperatorDelete
, Ex
.take(), StartLoc
));
1900 /// \brief Check the use of the given variable as a C++ condition in an if,
1901 /// while, do-while, or switch statement.
1902 ExprResult
Sema::CheckConditionVariable(VarDecl
*ConditionVar
,
1903 SourceLocation StmtLoc
,
1904 bool ConvertToBoolean
) {
1905 QualType T
= ConditionVar
->getType();
1907 // C++ [stmt.select]p2:
1908 // The declarator shall not specify a function or an array.
1909 if (T
->isFunctionType())
1910 return ExprError(Diag(ConditionVar
->getLocation(),
1911 diag::err_invalid_use_of_function_type
)
1912 << ConditionVar
->getSourceRange());
1913 else if (T
->isArrayType())
1914 return ExprError(Diag(ConditionVar
->getLocation(),
1915 diag::err_invalid_use_of_array_type
)
1916 << ConditionVar
->getSourceRange());
1918 ExprResult Condition
=
1919 Owned(DeclRefExpr::Create(Context
, NestedNameSpecifierLoc(),
1921 ConditionVar
->getLocation(),
1922 ConditionVar
->getType().getNonReferenceType(),
1924 if (ConvertToBoolean
) {
1925 Condition
= CheckBooleanCondition(Condition
.take(), StmtLoc
);
1926 if (Condition
.isInvalid())
1930 return move(Condition
);
1933 /// CheckCXXBooleanCondition - Returns true if a conversion to bool is invalid.
1934 ExprResult
Sema::CheckCXXBooleanCondition(Expr
*CondExpr
) {
1936 // The value of a condition that is an initialized declaration in a statement
1937 // other than a switch statement is the value of the declared variable
1938 // implicitly converted to type bool. If that conversion is ill-formed, the
1939 // program is ill-formed.
1940 // The value of a condition that is an expression is the value of the
1941 // expression, implicitly converted to bool.
1943 return PerformContextuallyConvertToBool(CondExpr
);
1946 /// Helper function to determine whether this is the (deprecated) C++
1947 /// conversion from a string literal to a pointer to non-const char or
1948 /// non-const wchar_t (for narrow and wide string literals,
1951 Sema::IsStringLiteralToNonConstPointerConversion(Expr
*From
, QualType ToType
) {
1952 // Look inside the implicit cast, if it exists.
1953 if (ImplicitCastExpr
*Cast
= dyn_cast
<ImplicitCastExpr
>(From
))
1954 From
= Cast
->getSubExpr();
1956 // A string literal (2.13.4) that is not a wide string literal can
1957 // be converted to an rvalue of type "pointer to char"; a wide
1958 // string literal can be converted to an rvalue of type "pointer
1959 // to wchar_t" (C++ 4.2p2).
1960 if (StringLiteral
*StrLit
= dyn_cast
<StringLiteral
>(From
->IgnoreParens()))
1961 if (const PointerType
*ToPtrType
= ToType
->getAs
<PointerType
>())
1962 if (const BuiltinType
*ToPointeeType
1963 = ToPtrType
->getPointeeType()->getAs
<BuiltinType
>()) {
1964 // This conversion is considered only when there is an
1965 // explicit appropriate pointer target type (C++ 4.2p2).
1966 if (!ToPtrType
->getPointeeType().hasQualifiers() &&
1967 ((StrLit
->isWide() && ToPointeeType
->isWideCharType()) ||
1968 (!StrLit
->isWide() &&
1969 (ToPointeeType
->getKind() == BuiltinType::Char_U
||
1970 ToPointeeType
->getKind() == BuiltinType::Char_S
))))
1977 static ExprResult
BuildCXXCastArgument(Sema
&S
,
1978 SourceLocation CastLoc
,
1981 CXXMethodDecl
*Method
,
1982 NamedDecl
*FoundDecl
,
1985 default: assert(0 && "Unhandled cast kind!");
1986 case CK_ConstructorConversion
: {
1987 ASTOwningVector
<Expr
*> ConstructorArgs(S
);
1989 if (S
.CompleteConstructorCall(cast
<CXXConstructorDecl
>(Method
),
1990 MultiExprArg(&From
, 1),
1991 CastLoc
, ConstructorArgs
))
1995 S
.BuildCXXConstructExpr(CastLoc
, Ty
, cast
<CXXConstructorDecl
>(Method
),
1996 move_arg(ConstructorArgs
),
1997 /*ZeroInit*/ false, CXXConstructExpr::CK_Complete
,
1999 if (Result
.isInvalid())
2002 return S
.MaybeBindToTemporary(Result
.takeAs
<Expr
>());
2005 case CK_UserDefinedConversion
: {
2006 assert(!From
->getType()->isPointerType() && "Arg can't have pointer type!");
2008 // Create an implicit call expr that calls it.
2009 ExprResult Result
= S
.BuildCXXMemberCallExpr(From
, FoundDecl
, Method
);
2010 if (Result
.isInvalid())
2013 return S
.MaybeBindToTemporary(Result
.get());
2018 /// PerformImplicitConversion - Perform an implicit conversion of the
2019 /// expression From to the type ToType using the pre-computed implicit
2020 /// conversion sequence ICS. Returns the converted
2021 /// expression. Action is the kind of conversion we're performing,
2022 /// used in the error message.
2024 Sema::PerformImplicitConversion(Expr
*From
, QualType ToType
,
2025 const ImplicitConversionSequence
&ICS
,
2026 AssignmentAction Action
,
2027 CheckedConversionKind CCK
) {
2028 switch (ICS
.getKind()) {
2029 case ImplicitConversionSequence::StandardConversion
: {
2030 ExprResult Res
= PerformImplicitConversion(From
, ToType
, ICS
.Standard
,
2032 if (Res
.isInvalid())
2038 case ImplicitConversionSequence::UserDefinedConversion
: {
2040 FunctionDecl
*FD
= ICS
.UserDefined
.ConversionFunction
;
2042 QualType BeforeToType
;
2043 if (const CXXConversionDecl
*Conv
= dyn_cast
<CXXConversionDecl
>(FD
)) {
2044 CastKind
= CK_UserDefinedConversion
;
2046 // If the user-defined conversion is specified by a conversion function,
2047 // the initial standard conversion sequence converts the source type to
2048 // the implicit object parameter of the conversion function.
2049 BeforeToType
= Context
.getTagDeclType(Conv
->getParent());
2051 const CXXConstructorDecl
*Ctor
= cast
<CXXConstructorDecl
>(FD
);
2052 CastKind
= CK_ConstructorConversion
;
2053 // Do no conversion if dealing with ... for the first conversion.
2054 if (!ICS
.UserDefined
.EllipsisConversion
) {
2055 // If the user-defined conversion is specified by a constructor, the
2056 // initial standard conversion sequence converts the source type to the
2057 // type required by the argument of the constructor
2058 BeforeToType
= Ctor
->getParamDecl(0)->getType().getNonReferenceType();
2061 // Watch out for elipsis conversion.
2062 if (!ICS
.UserDefined
.EllipsisConversion
) {
2064 PerformImplicitConversion(From
, BeforeToType
,
2065 ICS
.UserDefined
.Before
, AA_Converting
,
2067 if (Res
.isInvalid())
2073 = BuildCXXCastArgument(*this,
2074 From
->getLocStart(),
2075 ToType
.getNonReferenceType(),
2076 CastKind
, cast
<CXXMethodDecl
>(FD
),
2077 ICS
.UserDefined
.FoundConversionFunction
,
2080 if (CastArg
.isInvalid())
2083 From
= CastArg
.take();
2085 return PerformImplicitConversion(From
, ToType
, ICS
.UserDefined
.After
,
2086 AA_Converting
, CCK
);
2089 case ImplicitConversionSequence::AmbiguousConversion
:
2090 ICS
.DiagnoseAmbiguousConversion(*this, From
->getExprLoc(),
2091 PDiag(diag::err_typecheck_ambiguous_condition
)
2092 << From
->getSourceRange());
2095 case ImplicitConversionSequence::EllipsisConversion
:
2096 assert(false && "Cannot perform an ellipsis conversion");
2099 case ImplicitConversionSequence::BadConversion
:
2103 // Everything went well.
2107 /// PerformImplicitConversion - Perform an implicit conversion of the
2108 /// expression From to the type ToType by following the standard
2109 /// conversion sequence SCS. Returns the converted
2110 /// expression. Flavor is the context in which we're performing this
2111 /// conversion, for use in error messages.
2113 Sema::PerformImplicitConversion(Expr
*From
, QualType ToType
,
2114 const StandardConversionSequence
& SCS
,
2115 AssignmentAction Action
,
2116 CheckedConversionKind CCK
) {
2117 bool CStyle
= (CCK
== CCK_CStyleCast
|| CCK
== CCK_FunctionalCast
);
2119 // Overall FIXME: we are recomputing too many types here and doing far too
2120 // much extra work. What this means is that we need to keep track of more
2121 // information that is computed when we try the implicit conversion initially,
2122 // so that we don't need to recompute anything here.
2123 QualType FromType
= From
->getType();
2125 if (SCS
.CopyConstructor
) {
2126 // FIXME: When can ToType be a reference type?
2127 assert(!ToType
->isReferenceType());
2128 if (SCS
.Second
== ICK_Derived_To_Base
) {
2129 ASTOwningVector
<Expr
*> ConstructorArgs(*this);
2130 if (CompleteConstructorCall(cast
<CXXConstructorDecl
>(SCS
.CopyConstructor
),
2131 MultiExprArg(*this, &From
, 1),
2132 /*FIXME:ConstructLoc*/SourceLocation(),
2135 return BuildCXXConstructExpr(/*FIXME:ConstructLoc*/SourceLocation(),
2136 ToType
, SCS
.CopyConstructor
,
2137 move_arg(ConstructorArgs
),
2139 CXXConstructExpr::CK_Complete
,
2142 return BuildCXXConstructExpr(/*FIXME:ConstructLoc*/SourceLocation(),
2143 ToType
, SCS
.CopyConstructor
,
2144 MultiExprArg(*this, &From
, 1),
2146 CXXConstructExpr::CK_Complete
,
2150 // Resolve overloaded function references.
2151 if (Context
.hasSameType(FromType
, Context
.OverloadTy
)) {
2152 DeclAccessPair Found
;
2153 FunctionDecl
*Fn
= ResolveAddressOfOverloadedFunction(From
, ToType
,
2158 if (DiagnoseUseOfDecl(Fn
, From
->getSourceRange().getBegin()))
2161 From
= FixOverloadedFunctionReference(From
, Found
, Fn
);
2162 FromType
= From
->getType();
2165 // Perform the first implicit conversion.
2166 switch (SCS
.First
) {
2171 case ICK_Lvalue_To_Rvalue
:
2172 // Should this get its own ICK?
2173 if (From
->getObjectKind() == OK_ObjCProperty
) {
2174 ExprResult FromRes
= ConvertPropertyForRValue(From
);
2175 if (FromRes
.isInvalid())
2177 From
= FromRes
.take();
2178 if (!From
->isGLValue()) break;
2181 // Check for trivial buffer overflows.
2182 CheckArrayAccess(From
);
2184 FromType
= FromType
.getUnqualifiedType();
2185 From
= ImplicitCastExpr::Create(Context
, FromType
, CK_LValueToRValue
,
2186 From
, 0, VK_RValue
);
2189 case ICK_Array_To_Pointer
:
2190 FromType
= Context
.getArrayDecayedType(FromType
);
2191 From
= ImpCastExprToType(From
, FromType
, CK_ArrayToPointerDecay
,
2192 VK_RValue
, /*BasePath=*/0, CCK
).take();
2195 case ICK_Function_To_Pointer
:
2196 FromType
= Context
.getPointerType(FromType
);
2197 From
= ImpCastExprToType(From
, FromType
, CK_FunctionToPointerDecay
,
2198 VK_RValue
, /*BasePath=*/0, CCK
).take();
2202 assert(false && "Improper first standard conversion");
2206 // Perform the second implicit conversion
2207 switch (SCS
.Second
) {
2209 // If both sides are functions (or pointers/references to them), there could
2210 // be incompatible exception declarations.
2211 if (CheckExceptionSpecCompatibility(From
, ToType
))
2213 // Nothing else to do.
2216 case ICK_NoReturn_Adjustment
:
2217 // If both sides are functions (or pointers/references to them), there could
2218 // be incompatible exception declarations.
2219 if (CheckExceptionSpecCompatibility(From
, ToType
))
2222 From
= ImpCastExprToType(From
, ToType
, CK_NoOp
,
2223 VK_RValue
, /*BasePath=*/0, CCK
).take();
2226 case ICK_Integral_Promotion
:
2227 case ICK_Integral_Conversion
:
2228 From
= ImpCastExprToType(From
, ToType
, CK_IntegralCast
,
2229 VK_RValue
, /*BasePath=*/0, CCK
).take();
2232 case ICK_Floating_Promotion
:
2233 case ICK_Floating_Conversion
:
2234 From
= ImpCastExprToType(From
, ToType
, CK_FloatingCast
,
2235 VK_RValue
, /*BasePath=*/0, CCK
).take();
2238 case ICK_Complex_Promotion
:
2239 case ICK_Complex_Conversion
: {
2240 QualType FromEl
= From
->getType()->getAs
<ComplexType
>()->getElementType();
2241 QualType ToEl
= ToType
->getAs
<ComplexType
>()->getElementType();
2243 if (FromEl
->isRealFloatingType()) {
2244 if (ToEl
->isRealFloatingType())
2245 CK
= CK_FloatingComplexCast
;
2247 CK
= CK_FloatingComplexToIntegralComplex
;
2248 } else if (ToEl
->isRealFloatingType()) {
2249 CK
= CK_IntegralComplexToFloatingComplex
;
2251 CK
= CK_IntegralComplexCast
;
2253 From
= ImpCastExprToType(From
, ToType
, CK
,
2254 VK_RValue
, /*BasePath=*/0, CCK
).take();
2258 case ICK_Floating_Integral
:
2259 if (ToType
->isRealFloatingType())
2260 From
= ImpCastExprToType(From
, ToType
, CK_IntegralToFloating
,
2261 VK_RValue
, /*BasePath=*/0, CCK
).take();
2263 From
= ImpCastExprToType(From
, ToType
, CK_FloatingToIntegral
,
2264 VK_RValue
, /*BasePath=*/0, CCK
).take();
2267 case ICK_Compatible_Conversion
:
2268 From
= ImpCastExprToType(From
, ToType
, CK_NoOp
,
2269 VK_RValue
, /*BasePath=*/0, CCK
).take();
2272 case ICK_Writeback_Conversion
:
2273 case ICK_Pointer_Conversion
: {
2274 if (SCS
.IncompatibleObjC
&& Action
!= AA_Casting
) {
2275 // Diagnose incompatible Objective-C conversions
2276 if (Action
== AA_Initializing
|| Action
== AA_Assigning
)
2277 Diag(From
->getSourceRange().getBegin(),
2278 diag::ext_typecheck_convert_incompatible_pointer
)
2279 << ToType
<< From
->getType() << Action
2280 << From
->getSourceRange();
2282 Diag(From
->getSourceRange().getBegin(),
2283 diag::ext_typecheck_convert_incompatible_pointer
)
2284 << From
->getType() << ToType
<< Action
2285 << From
->getSourceRange();
2287 if (From
->getType()->isObjCObjectPointerType() &&
2288 ToType
->isObjCObjectPointerType())
2289 EmitRelatedResultTypeNote(From
);
2292 CastKind Kind
= CK_Invalid
;
2293 CXXCastPath BasePath
;
2294 if (CheckPointerConversion(From
, ToType
, Kind
, BasePath
, CStyle
))
2296 From
= ImpCastExprToType(From
, ToType
, Kind
, VK_RValue
, &BasePath
, CCK
)
2301 case ICK_Pointer_Member
: {
2302 CastKind Kind
= CK_Invalid
;
2303 CXXCastPath BasePath
;
2304 if (CheckMemberPointerConversion(From
, ToType
, Kind
, BasePath
, CStyle
))
2306 if (CheckExceptionSpecCompatibility(From
, ToType
))
2308 From
= ImpCastExprToType(From
, ToType
, Kind
, VK_RValue
, &BasePath
, CCK
)
2313 case ICK_Boolean_Conversion
:
2314 From
= ImpCastExprToType(From
, Context
.BoolTy
,
2315 ScalarTypeToBooleanCastKind(FromType
),
2316 VK_RValue
, /*BasePath=*/0, CCK
).take();
2319 case ICK_Derived_To_Base
: {
2320 CXXCastPath BasePath
;
2321 if (CheckDerivedToBaseConversion(From
->getType(),
2322 ToType
.getNonReferenceType(),
2323 From
->getLocStart(),
2324 From
->getSourceRange(),
2329 From
= ImpCastExprToType(From
, ToType
.getNonReferenceType(),
2330 CK_DerivedToBase
, CastCategory(From
),
2331 &BasePath
, CCK
).take();
2335 case ICK_Vector_Conversion
:
2336 From
= ImpCastExprToType(From
, ToType
, CK_BitCast
,
2337 VK_RValue
, /*BasePath=*/0, CCK
).take();
2340 case ICK_Vector_Splat
:
2341 From
= ImpCastExprToType(From
, ToType
, CK_VectorSplat
,
2342 VK_RValue
, /*BasePath=*/0, CCK
).take();
2345 case ICK_Complex_Real
:
2346 // Case 1. x -> _Complex y
2347 if (const ComplexType
*ToComplex
= ToType
->getAs
<ComplexType
>()) {
2348 QualType ElType
= ToComplex
->getElementType();
2349 bool isFloatingComplex
= ElType
->isRealFloatingType();
2352 if (Context
.hasSameUnqualifiedType(ElType
, From
->getType())) {
2354 } else if (From
->getType()->isRealFloatingType()) {
2355 From
= ImpCastExprToType(From
, ElType
,
2356 isFloatingComplex
? CK_FloatingCast
: CK_FloatingToIntegral
).take();
2358 assert(From
->getType()->isIntegerType());
2359 From
= ImpCastExprToType(From
, ElType
,
2360 isFloatingComplex
? CK_IntegralToFloating
: CK_IntegralCast
).take();
2363 From
= ImpCastExprToType(From
, ToType
,
2364 isFloatingComplex
? CK_FloatingRealToComplex
2365 : CK_IntegralRealToComplex
).take();
2367 // Case 2. _Complex x -> y
2369 const ComplexType
*FromComplex
= From
->getType()->getAs
<ComplexType
>();
2370 assert(FromComplex
);
2372 QualType ElType
= FromComplex
->getElementType();
2373 bool isFloatingComplex
= ElType
->isRealFloatingType();
2376 From
= ImpCastExprToType(From
, ElType
,
2377 isFloatingComplex
? CK_FloatingComplexToReal
2378 : CK_IntegralComplexToReal
,
2379 VK_RValue
, /*BasePath=*/0, CCK
).take();
2382 if (Context
.hasSameUnqualifiedType(ElType
, ToType
)) {
2384 } else if (ToType
->isRealFloatingType()) {
2385 From
= ImpCastExprToType(From
, ToType
,
2386 isFloatingComplex
? CK_FloatingCast
: CK_IntegralToFloating
,
2387 VK_RValue
, /*BasePath=*/0, CCK
).take();
2389 assert(ToType
->isIntegerType());
2390 From
= ImpCastExprToType(From
, ToType
,
2391 isFloatingComplex
? CK_FloatingToIntegral
: CK_IntegralCast
,
2392 VK_RValue
, /*BasePath=*/0, CCK
).take();
2397 case ICK_Block_Pointer_Conversion
: {
2398 From
= ImpCastExprToType(From
, ToType
.getUnqualifiedType(), CK_BitCast
,
2399 VK_RValue
, /*BasePath=*/0, CCK
).take();
2403 case ICK_TransparentUnionConversion
: {
2404 ExprResult FromRes
= Owned(From
);
2405 Sema::AssignConvertType ConvTy
=
2406 CheckTransparentUnionArgumentConstraints(ToType
, FromRes
);
2407 if (FromRes
.isInvalid())
2409 From
= FromRes
.take();
2410 assert ((ConvTy
== Sema::Compatible
) &&
2411 "Improper transparent union conversion");
2416 case ICK_Lvalue_To_Rvalue
:
2417 case ICK_Array_To_Pointer
:
2418 case ICK_Function_To_Pointer
:
2419 case ICK_Qualification
:
2420 case ICK_Num_Conversion_Kinds
:
2421 assert(false && "Improper second standard conversion");
2425 switch (SCS
.Third
) {
2430 case ICK_Qualification
: {
2431 // The qualification keeps the category of the inner expression, unless the
2432 // target type isn't a reference.
2433 ExprValueKind VK
= ToType
->isReferenceType() ?
2434 CastCategory(From
) : VK_RValue
;
2435 From
= ImpCastExprToType(From
, ToType
.getNonLValueExprType(Context
),
2436 CK_NoOp
, VK
, /*BasePath=*/0, CCK
).take();
2438 if (SCS
.DeprecatedStringLiteralToCharPtr
&&
2439 !getLangOptions().WritableStrings
)
2440 Diag(From
->getLocStart(), diag::warn_deprecated_string_literal_conversion
)
2441 << ToType
.getNonReferenceType();
2447 assert(false && "Improper third standard conversion");
2454 ExprResult
Sema::ActOnUnaryTypeTrait(UnaryTypeTrait UTT
,
2455 SourceLocation KWLoc
,
2457 SourceLocation RParen
) {
2458 TypeSourceInfo
*TSInfo
;
2459 QualType T
= GetTypeFromParser(Ty
, &TSInfo
);
2462 TSInfo
= Context
.getTrivialTypeSourceInfo(T
);
2463 return BuildUnaryTypeTrait(UTT
, KWLoc
, TSInfo
, RParen
);
2466 /// \brief Check the completeness of a type in a unary type trait.
2468 /// If the particular type trait requires a complete type, tries to complete
2469 /// it. If completing the type fails, a diagnostic is emitted and false
2470 /// returned. If completing the type succeeds or no completion was required,
2472 static bool CheckUnaryTypeTraitTypeCompleteness(Sema
&S
,
2476 // C++0x [meta.unary.prop]p3:
2477 // For all of the class templates X declared in this Clause, instantiating
2478 // that template with a template argument that is a class template
2479 // specialization may result in the implicit instantiation of the template
2480 // argument if and only if the semantics of X require that the argument
2481 // must be a complete type.
2482 // We apply this rule to all the type trait expressions used to implement
2483 // these class templates. We also try to follow any GCC documented behavior
2484 // in these expressions to ensure portability of standard libraries.
2486 // is_complete_type somewhat obviously cannot require a complete type.
2487 case UTT_IsCompleteType
:
2490 // These traits are modeled on the type predicates in C++0x
2491 // [meta.unary.cat] and [meta.unary.comp]. They are not specified as
2492 // requiring a complete type, as whether or not they return true cannot be
2493 // impacted by the completeness of the type.
2495 case UTT_IsIntegral
:
2496 case UTT_IsFloatingPoint
:
2499 case UTT_IsLvalueReference
:
2500 case UTT_IsRvalueReference
:
2501 case UTT_IsMemberFunctionPointer
:
2502 case UTT_IsMemberObjectPointer
:
2506 case UTT_IsFunction
:
2507 case UTT_IsReference
:
2508 case UTT_IsArithmetic
:
2509 case UTT_IsFundamental
:
2512 case UTT_IsCompound
:
2513 case UTT_IsMemberPointer
:
2516 // These traits are modeled on type predicates in C++0x [meta.unary.prop]
2517 // which requires some of its traits to have the complete type. However,
2518 // the completeness of the type cannot impact these traits' semantics, and
2519 // so they don't require it. This matches the comments on these traits in
2522 case UTT_IsVolatile
:
2524 case UTT_IsUnsigned
:
2527 // C++0x [meta.unary.prop] Table 49 requires the following traits to be
2528 // applied to a complete type.
2530 case UTT_IsTriviallyCopyable
:
2531 case UTT_IsStandardLayout
:
2535 case UTT_IsPolymorphic
:
2536 case UTT_IsAbstract
:
2539 // These trait expressions are designed to help implement predicates in
2540 // [meta.unary.prop] despite not being named the same. They are specified
2541 // by both GCC and the Embarcadero C++ compiler, and require the complete
2542 // type due to the overarching C++0x type predicates being implemented
2543 // requiring the complete type.
2544 case UTT_HasNothrowAssign
:
2545 case UTT_HasNothrowConstructor
:
2546 case UTT_HasNothrowCopy
:
2547 case UTT_HasTrivialAssign
:
2548 case UTT_HasTrivialDefaultConstructor
:
2549 case UTT_HasTrivialCopy
:
2550 case UTT_HasTrivialDestructor
:
2551 case UTT_HasVirtualDestructor
:
2552 // Arrays of unknown bound are expressly allowed.
2553 QualType ElTy
= ArgTy
;
2554 if (ArgTy
->isIncompleteArrayType())
2555 ElTy
= S
.Context
.getAsArrayType(ArgTy
)->getElementType();
2557 // The void type is expressly allowed.
2558 if (ElTy
->isVoidType())
2561 return !S
.RequireCompleteType(
2562 Loc
, ElTy
, diag::err_incomplete_type_used_in_type_trait_expr
);
2564 llvm_unreachable("Type trait not handled by switch");
2567 static bool EvaluateUnaryTypeTrait(Sema
&Self
, UnaryTypeTrait UTT
,
2568 SourceLocation KeyLoc
, QualType T
) {
2569 assert(!T
->isDependentType() && "Cannot evaluate traits of dependent type");
2571 ASTContext
&C
= Self
.Context
;
2573 // Type trait expressions corresponding to the primary type category
2574 // predicates in C++0x [meta.unary.cat].
2576 return T
->isVoidType();
2577 case UTT_IsIntegral
:
2578 return T
->isIntegralType(C
);
2579 case UTT_IsFloatingPoint
:
2580 return T
->isFloatingType();
2582 return T
->isArrayType();
2584 return T
->isPointerType();
2585 case UTT_IsLvalueReference
:
2586 return T
->isLValueReferenceType();
2587 case UTT_IsRvalueReference
:
2588 return T
->isRValueReferenceType();
2589 case UTT_IsMemberFunctionPointer
:
2590 return T
->isMemberFunctionPointerType();
2591 case UTT_IsMemberObjectPointer
:
2592 return T
->isMemberDataPointerType();
2594 return T
->isEnumeralType();
2596 return T
->isUnionType();
2598 return T
->isClassType() || T
->isStructureType();
2599 case UTT_IsFunction
:
2600 return T
->isFunctionType();
2602 // Type trait expressions which correspond to the convenient composition
2603 // predicates in C++0x [meta.unary.comp].
2604 case UTT_IsReference
:
2605 return T
->isReferenceType();
2606 case UTT_IsArithmetic
:
2607 return T
->isArithmeticType() && !T
->isEnumeralType();
2608 case UTT_IsFundamental
:
2609 return T
->isFundamentalType();
2611 return T
->isObjectType();
2613 // Note: semantic analysis depends on Objective-C lifetime types to be
2614 // considered scalar types. However, such types do not actually behave
2615 // like scalar types at run time (since they may require retain/release
2616 // operations), so we report them as non-scalar.
2617 if (T
->isObjCLifetimeType()) {
2618 switch (T
.getObjCLifetime()) {
2619 case Qualifiers::OCL_None
:
2620 case Qualifiers::OCL_ExplicitNone
:
2623 case Qualifiers::OCL_Strong
:
2624 case Qualifiers::OCL_Weak
:
2625 case Qualifiers::OCL_Autoreleasing
:
2630 return T
->isScalarType();
2631 case UTT_IsCompound
:
2632 return T
->isCompoundType();
2633 case UTT_IsMemberPointer
:
2634 return T
->isMemberPointerType();
2636 // Type trait expressions which correspond to the type property predicates
2637 // in C++0x [meta.unary.prop].
2639 return T
.isConstQualified();
2640 case UTT_IsVolatile
:
2641 return T
.isVolatileQualified();
2643 return T
.isTrivialType(Self
.Context
);
2644 case UTT_IsTriviallyCopyable
:
2645 return T
.isTriviallyCopyableType(Self
.Context
);
2646 case UTT_IsStandardLayout
:
2647 return T
->isStandardLayoutType();
2649 return T
.isPODType(Self
.Context
);
2651 return T
->isLiteralType();
2653 if (const CXXRecordDecl
*RD
= T
->getAsCXXRecordDecl())
2654 return !RD
->isUnion() && RD
->isEmpty();
2656 case UTT_IsPolymorphic
:
2657 if (const CXXRecordDecl
*RD
= T
->getAsCXXRecordDecl())
2658 return RD
->isPolymorphic();
2660 case UTT_IsAbstract
:
2661 if (const CXXRecordDecl
*RD
= T
->getAsCXXRecordDecl())
2662 return RD
->isAbstract();
2665 return T
->isSignedIntegerType();
2666 case UTT_IsUnsigned
:
2667 return T
->isUnsignedIntegerType();
2669 // Type trait expressions which query classes regarding their construction,
2670 // destruction, and copying. Rather than being based directly on the
2671 // related type predicates in the standard, they are specified by both
2672 // GCC[1] and the Embarcadero C++ compiler[2], and Clang implements those
2675 // 1: http://gcc.gnu/.org/onlinedocs/gcc/Type-Traits.html
2676 // 2: http://docwiki.embarcadero.com/RADStudio/XE/en/Type_Trait_Functions_(C%2B%2B0x)_Index
2677 case UTT_HasTrivialDefaultConstructor
:
2678 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
2679 // If __is_pod (type) is true then the trait is true, else if type is
2680 // a cv class or union type (or array thereof) with a trivial default
2681 // constructor ([class.ctor]) then the trait is true, else it is false.
2682 if (T
.isPODType(Self
.Context
))
2684 if (const RecordType
*RT
=
2685 C
.getBaseElementType(T
)->getAs
<RecordType
>())
2686 return cast
<CXXRecordDecl
>(RT
->getDecl())->hasTrivialDefaultConstructor();
2688 case UTT_HasTrivialCopy
:
2689 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
2690 // If __is_pod (type) is true or type is a reference type then
2691 // the trait is true, else if type is a cv class or union type
2692 // with a trivial copy constructor ([class.copy]) then the trait
2693 // is true, else it is false.
2694 if (T
.isPODType(Self
.Context
) || T
->isReferenceType())
2696 if (const RecordType
*RT
= T
->getAs
<RecordType
>())
2697 return cast
<CXXRecordDecl
>(RT
->getDecl())->hasTrivialCopyConstructor();
2699 case UTT_HasTrivialAssign
:
2700 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
2701 // If type is const qualified or is a reference type then the
2702 // trait is false. Otherwise if __is_pod (type) is true then the
2703 // trait is true, else if type is a cv class or union type with
2704 // a trivial copy assignment ([class.copy]) then the trait is
2705 // true, else it is false.
2706 // Note: the const and reference restrictions are interesting,
2707 // given that const and reference members don't prevent a class
2708 // from having a trivial copy assignment operator (but do cause
2709 // errors if the copy assignment operator is actually used, q.v.
2710 // [class.copy]p12).
2712 if (C
.getBaseElementType(T
).isConstQualified())
2714 if (T
.isPODType(Self
.Context
))
2716 if (const RecordType
*RT
= T
->getAs
<RecordType
>())
2717 return cast
<CXXRecordDecl
>(RT
->getDecl())->hasTrivialCopyAssignment();
2719 case UTT_HasTrivialDestructor
:
2720 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
2721 // If __is_pod (type) is true or type is a reference type
2722 // then the trait is true, else if type is a cv class or union
2723 // type (or array thereof) with a trivial destructor
2724 // ([class.dtor]) then the trait is true, else it is
2726 if (T
.isPODType(Self
.Context
) || T
->isReferenceType())
2729 // Objective-C++ ARC: autorelease types don't require destruction.
2730 if (T
->isObjCLifetimeType() &&
2731 T
.getObjCLifetime() == Qualifiers::OCL_Autoreleasing
)
2734 if (const RecordType
*RT
=
2735 C
.getBaseElementType(T
)->getAs
<RecordType
>())
2736 return cast
<CXXRecordDecl
>(RT
->getDecl())->hasTrivialDestructor();
2738 // TODO: Propagate nothrowness for implicitly declared special members.
2739 case UTT_HasNothrowAssign
:
2740 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
2741 // If type is const qualified or is a reference type then the
2742 // trait is false. Otherwise if __has_trivial_assign (type)
2743 // is true then the trait is true, else if type is a cv class
2744 // or union type with copy assignment operators that are known
2745 // not to throw an exception then the trait is true, else it is
2747 if (C
.getBaseElementType(T
).isConstQualified())
2749 if (T
->isReferenceType())
2751 if (T
.isPODType(Self
.Context
) || T
->isObjCLifetimeType())
2753 if (const RecordType
*RT
= T
->getAs
<RecordType
>()) {
2754 CXXRecordDecl
* RD
= cast
<CXXRecordDecl
>(RT
->getDecl());
2755 if (RD
->hasTrivialCopyAssignment())
2758 bool FoundAssign
= false;
2759 DeclarationName Name
= C
.DeclarationNames
.getCXXOperatorName(OO_Equal
);
2760 LookupResult
Res(Self
, DeclarationNameInfo(Name
, KeyLoc
),
2761 Sema::LookupOrdinaryName
);
2762 if (Self
.LookupQualifiedName(Res
, RD
)) {
2763 for (LookupResult::iterator Op
= Res
.begin(), OpEnd
= Res
.end();
2764 Op
!= OpEnd
; ++Op
) {
2765 CXXMethodDecl
*Operator
= cast
<CXXMethodDecl
>(*Op
);
2766 if (Operator
->isCopyAssignmentOperator()) {
2768 const FunctionProtoType
*CPT
2769 = Operator
->getType()->getAs
<FunctionProtoType
>();
2770 if (CPT
->getExceptionSpecType() == EST_Delayed
)
2772 if (!CPT
->isNothrow(Self
.Context
))
2781 case UTT_HasNothrowCopy
:
2782 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
2783 // If __has_trivial_copy (type) is true then the trait is true, else
2784 // if type is a cv class or union type with copy constructors that are
2785 // known not to throw an exception then the trait is true, else it is
2787 if (T
.isPODType(C
) || T
->isReferenceType() || T
->isObjCLifetimeType())
2789 if (const RecordType
*RT
= T
->getAs
<RecordType
>()) {
2790 CXXRecordDecl
*RD
= cast
<CXXRecordDecl
>(RT
->getDecl());
2791 if (RD
->hasTrivialCopyConstructor())
2794 bool FoundConstructor
= false;
2796 DeclContext::lookup_const_iterator Con
, ConEnd
;
2797 for (llvm::tie(Con
, ConEnd
) = Self
.LookupConstructors(RD
);
2798 Con
!= ConEnd
; ++Con
) {
2799 // A template constructor is never a copy constructor.
2800 // FIXME: However, it may actually be selected at the actual overload
2801 // resolution point.
2802 if (isa
<FunctionTemplateDecl
>(*Con
))
2804 CXXConstructorDecl
*Constructor
= cast
<CXXConstructorDecl
>(*Con
);
2805 if (Constructor
->isCopyConstructor(FoundTQs
)) {
2806 FoundConstructor
= true;
2807 const FunctionProtoType
*CPT
2808 = Constructor
->getType()->getAs
<FunctionProtoType
>();
2809 if (CPT
->getExceptionSpecType() == EST_Delayed
)
2811 // FIXME: check whether evaluating default arguments can throw.
2812 // For now, we'll be conservative and assume that they can throw.
2813 if (!CPT
->isNothrow(Self
.Context
) || CPT
->getNumArgs() > 1)
2818 return FoundConstructor
;
2821 case UTT_HasNothrowConstructor
:
2822 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
2823 // If __has_trivial_constructor (type) is true then the trait is
2824 // true, else if type is a cv class or union type (or array
2825 // thereof) with a default constructor that is known not to
2826 // throw an exception then the trait is true, else it is false.
2827 if (T
.isPODType(C
) || T
->isObjCLifetimeType())
2829 if (const RecordType
*RT
= C
.getBaseElementType(T
)->getAs
<RecordType
>()) {
2830 CXXRecordDecl
*RD
= cast
<CXXRecordDecl
>(RT
->getDecl());
2831 if (RD
->hasTrivialDefaultConstructor())
2834 DeclContext::lookup_const_iterator Con
, ConEnd
;
2835 for (llvm::tie(Con
, ConEnd
) = Self
.LookupConstructors(RD
);
2836 Con
!= ConEnd
; ++Con
) {
2837 // FIXME: In C++0x, a constructor template can be a default constructor.
2838 if (isa
<FunctionTemplateDecl
>(*Con
))
2840 CXXConstructorDecl
*Constructor
= cast
<CXXConstructorDecl
>(*Con
);
2841 if (Constructor
->isDefaultConstructor()) {
2842 const FunctionProtoType
*CPT
2843 = Constructor
->getType()->getAs
<FunctionProtoType
>();
2844 if (CPT
->getExceptionSpecType() == EST_Delayed
)
2846 // TODO: check whether evaluating default arguments can throw.
2847 // For now, we'll be conservative and assume that they can throw.
2848 return CPT
->isNothrow(Self
.Context
) && CPT
->getNumArgs() == 0;
2853 case UTT_HasVirtualDestructor
:
2854 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
2855 // If type is a class type with a virtual destructor ([class.dtor])
2856 // then the trait is true, else it is false.
2857 if (const RecordType
*Record
= T
->getAs
<RecordType
>()) {
2858 CXXRecordDecl
*RD
= cast
<CXXRecordDecl
>(Record
->getDecl());
2859 if (CXXDestructorDecl
*Destructor
= Self
.LookupDestructor(RD
))
2860 return Destructor
->isVirtual();
2864 // These type trait expressions are modeled on the specifications for the
2865 // Embarcadero C++0x type trait functions:
2866 // http://docwiki.embarcadero.com/RADStudio/XE/en/Type_Trait_Functions_(C%2B%2B0x)_Index
2867 case UTT_IsCompleteType
:
2868 // http://docwiki.embarcadero.com/RADStudio/XE/en/Is_complete_type_(typename_T_):
2869 // Returns True if and only if T is a complete type at the point of the
2871 return !T
->isIncompleteType();
2873 llvm_unreachable("Type trait not covered by switch");
2876 ExprResult
Sema::BuildUnaryTypeTrait(UnaryTypeTrait UTT
,
2877 SourceLocation KWLoc
,
2878 TypeSourceInfo
*TSInfo
,
2879 SourceLocation RParen
) {
2880 QualType T
= TSInfo
->getType();
2881 if (!CheckUnaryTypeTraitTypeCompleteness(*this, UTT
, KWLoc
, T
))
2885 if (!T
->isDependentType())
2886 Value
= EvaluateUnaryTypeTrait(*this, UTT
, KWLoc
, T
);
2888 return Owned(new (Context
) UnaryTypeTraitExpr(KWLoc
, UTT
, TSInfo
, Value
,
2889 RParen
, Context
.BoolTy
));
2892 ExprResult
Sema::ActOnBinaryTypeTrait(BinaryTypeTrait BTT
,
2893 SourceLocation KWLoc
,
2896 SourceLocation RParen
) {
2897 TypeSourceInfo
*LhsTSInfo
;
2898 QualType LhsT
= GetTypeFromParser(LhsTy
, &LhsTSInfo
);
2900 LhsTSInfo
= Context
.getTrivialTypeSourceInfo(LhsT
);
2902 TypeSourceInfo
*RhsTSInfo
;
2903 QualType RhsT
= GetTypeFromParser(RhsTy
, &RhsTSInfo
);
2905 RhsTSInfo
= Context
.getTrivialTypeSourceInfo(RhsT
);
2907 return BuildBinaryTypeTrait(BTT
, KWLoc
, LhsTSInfo
, RhsTSInfo
, RParen
);
2910 static bool EvaluateBinaryTypeTrait(Sema
&Self
, BinaryTypeTrait BTT
,
2911 QualType LhsT
, QualType RhsT
,
2912 SourceLocation KeyLoc
) {
2913 assert(!LhsT
->isDependentType() && !RhsT
->isDependentType() &&
2914 "Cannot evaluate traits of dependent types");
2917 case BTT_IsBaseOf
: {
2918 // C++0x [meta.rel]p2
2919 // Base is a base class of Derived without regard to cv-qualifiers or
2920 // Base and Derived are not unions and name the same class type without
2921 // regard to cv-qualifiers.
2923 const RecordType
*lhsRecord
= LhsT
->getAs
<RecordType
>();
2924 if (!lhsRecord
) return false;
2926 const RecordType
*rhsRecord
= RhsT
->getAs
<RecordType
>();
2927 if (!rhsRecord
) return false;
2929 assert(Self
.Context
.hasSameUnqualifiedType(LhsT
, RhsT
)
2930 == (lhsRecord
== rhsRecord
));
2932 if (lhsRecord
== rhsRecord
)
2933 return !lhsRecord
->getDecl()->isUnion();
2935 // C++0x [meta.rel]p2:
2936 // If Base and Derived are class types and are different types
2937 // (ignoring possible cv-qualifiers) then Derived shall be a
2939 if (Self
.RequireCompleteType(KeyLoc
, RhsT
,
2940 diag::err_incomplete_type_used_in_type_trait_expr
))
2943 return cast
<CXXRecordDecl
>(rhsRecord
->getDecl())
2944 ->isDerivedFrom(cast
<CXXRecordDecl
>(lhsRecord
->getDecl()));
2947 return Self
.Context
.hasSameType(LhsT
, RhsT
);
2948 case BTT_TypeCompatible
:
2949 return Self
.Context
.typesAreCompatible(LhsT
.getUnqualifiedType(),
2950 RhsT
.getUnqualifiedType());
2951 case BTT_IsConvertible
:
2952 case BTT_IsConvertibleTo
: {
2953 // C++0x [meta.rel]p4:
2954 // Given the following function prototype:
2956 // template <class T>
2957 // typename add_rvalue_reference<T>::type create();
2959 // the predicate condition for a template specialization
2960 // is_convertible<From, To> shall be satisfied if and only if
2961 // the return expression in the following code would be
2962 // well-formed, including any implicit conversions to the return
2963 // type of the function:
2966 // return create<From>();
2969 // Access checking is performed as if in a context unrelated to To and
2970 // From. Only the validity of the immediate context of the expression
2971 // of the return-statement (including conversions to the return type)
2974 // We model the initialization as a copy-initialization of a temporary
2975 // of the appropriate type, which for this expression is identical to the
2976 // return statement (since NRVO doesn't apply).
2977 if (LhsT
->isObjectType() || LhsT
->isFunctionType())
2978 LhsT
= Self
.Context
.getRValueReferenceType(LhsT
);
2980 InitializedEntity
To(InitializedEntity::InitializeTemporary(RhsT
));
2981 OpaqueValueExpr
From(KeyLoc
, LhsT
.getNonLValueExprType(Self
.Context
),
2982 Expr::getValueKindForType(LhsT
));
2983 Expr
*FromPtr
= &From
;
2984 InitializationKind
Kind(InitializationKind::CreateCopy(KeyLoc
,
2987 // Perform the initialization within a SFINAE trap at translation unit
2989 Sema::SFINAETrap
SFINAE(Self
, /*AccessCheckingSFINAE=*/true);
2990 Sema::ContextRAII
TUContext(Self
, Self
.Context
.getTranslationUnitDecl());
2991 InitializationSequence
Init(Self
, To
, Kind
, &FromPtr
, 1);
2995 ExprResult Result
= Init
.Perform(Self
, To
, Kind
, MultiExprArg(&FromPtr
, 1));
2996 return !Result
.isInvalid() && !SFINAE
.hasErrorOccurred();
2999 llvm_unreachable("Unknown type trait or not implemented");
3002 ExprResult
Sema::BuildBinaryTypeTrait(BinaryTypeTrait BTT
,
3003 SourceLocation KWLoc
,
3004 TypeSourceInfo
*LhsTSInfo
,
3005 TypeSourceInfo
*RhsTSInfo
,
3006 SourceLocation RParen
) {
3007 QualType LhsT
= LhsTSInfo
->getType();
3008 QualType RhsT
= RhsTSInfo
->getType();
3010 if (BTT
== BTT_TypeCompatible
) {
3011 if (getLangOptions().CPlusPlus
) {
3012 Diag(KWLoc
, diag::err_types_compatible_p_in_cplusplus
)
3013 << SourceRange(KWLoc
, RParen
);
3019 if (!LhsT
->isDependentType() && !RhsT
->isDependentType())
3020 Value
= EvaluateBinaryTypeTrait(*this, BTT
, LhsT
, RhsT
, KWLoc
);
3022 // Select trait result type.
3023 QualType ResultType
;
3025 case BTT_IsBaseOf
: ResultType
= Context
.BoolTy
; break;
3026 case BTT_IsConvertible
: ResultType
= Context
.BoolTy
; break;
3027 case BTT_IsSame
: ResultType
= Context
.BoolTy
; break;
3028 case BTT_TypeCompatible
: ResultType
= Context
.IntTy
; break;
3029 case BTT_IsConvertibleTo
: ResultType
= Context
.BoolTy
; break;
3032 return Owned(new (Context
) BinaryTypeTraitExpr(KWLoc
, BTT
, LhsTSInfo
,
3033 RhsTSInfo
, Value
, RParen
,
3037 ExprResult
Sema::ActOnArrayTypeTrait(ArrayTypeTrait ATT
,
3038 SourceLocation KWLoc
,
3041 SourceLocation RParen
) {
3042 TypeSourceInfo
*TSInfo
;
3043 QualType T
= GetTypeFromParser(Ty
, &TSInfo
);
3045 TSInfo
= Context
.getTrivialTypeSourceInfo(T
);
3047 return BuildArrayTypeTrait(ATT
, KWLoc
, TSInfo
, DimExpr
, RParen
);
3050 static uint64_t EvaluateArrayTypeTrait(Sema
&Self
, ArrayTypeTrait ATT
,
3051 QualType T
, Expr
*DimExpr
,
3052 SourceLocation KeyLoc
) {
3053 assert(!T
->isDependentType() && "Cannot evaluate traits of dependent type");
3057 if (T
->isArrayType()) {
3059 while (const ArrayType
*AT
= Self
.Context
.getAsArrayType(T
)) {
3061 T
= AT
->getElementType();
3067 case ATT_ArrayExtent
: {
3070 if (DimExpr
->isIntegerConstantExpr(Value
, Self
.Context
, 0, false)) {
3071 if (Value
< llvm::APSInt(Value
.getBitWidth(), Value
.isUnsigned())) {
3072 Self
.Diag(KeyLoc
, diag::err_dimension_expr_not_constant_integer
) <<
3073 DimExpr
->getSourceRange();
3076 Dim
= Value
.getLimitedValue();
3078 Self
.Diag(KeyLoc
, diag::err_dimension_expr_not_constant_integer
) <<
3079 DimExpr
->getSourceRange();
3083 if (T
->isArrayType()) {
3085 bool Matched
= false;
3086 while (const ArrayType
*AT
= Self
.Context
.getAsArrayType(T
)) {
3092 T
= AT
->getElementType();
3095 if (Matched
&& T
->isArrayType()) {
3096 if (const ConstantArrayType
*CAT
= Self
.Context
.getAsConstantArrayType(T
))
3097 return CAT
->getSize().getLimitedValue();
3103 llvm_unreachable("Unknown type trait or not implemented");
3106 ExprResult
Sema::BuildArrayTypeTrait(ArrayTypeTrait ATT
,
3107 SourceLocation KWLoc
,
3108 TypeSourceInfo
*TSInfo
,
3110 SourceLocation RParen
) {
3111 QualType T
= TSInfo
->getType();
3113 // FIXME: This should likely be tracked as an APInt to remove any host
3114 // assumptions about the width of size_t on the target.
3116 if (!T
->isDependentType())
3117 Value
= EvaluateArrayTypeTrait(*this, ATT
, T
, DimExpr
, KWLoc
);
3119 // While the specification for these traits from the Embarcadero C++
3120 // compiler's documentation says the return type is 'unsigned int', Clang
3121 // returns 'size_t'. On Windows, the primary platform for the Embarcadero
3122 // compiler, there is no difference. On several other platforms this is an
3123 // important distinction.
3124 return Owned(new (Context
) ArrayTypeTraitExpr(KWLoc
, ATT
, TSInfo
, Value
,
3126 Context
.getSizeType()));
3129 ExprResult
Sema::ActOnExpressionTrait(ExpressionTrait ET
,
3130 SourceLocation KWLoc
,
3132 SourceLocation RParen
) {
3133 // If error parsing the expression, ignore.
3137 ExprResult Result
= BuildExpressionTrait(ET
, KWLoc
, Queried
, RParen
);
3139 return move(Result
);
3142 static bool EvaluateExpressionTrait(ExpressionTrait ET
, Expr
*E
) {
3144 case ET_IsLValueExpr
: return E
->isLValue();
3145 case ET_IsRValueExpr
: return E
->isRValue();
3147 llvm_unreachable("Expression trait not covered by switch");
3150 ExprResult
Sema::BuildExpressionTrait(ExpressionTrait ET
,
3151 SourceLocation KWLoc
,
3153 SourceLocation RParen
) {
3154 if (Queried
->isTypeDependent()) {
3155 // Delay type-checking for type-dependent expressions.
3156 } else if (Queried
->getType()->isPlaceholderType()) {
3157 ExprResult PE
= CheckPlaceholderExpr(Queried
);
3158 if (PE
.isInvalid()) return ExprError();
3159 return BuildExpressionTrait(ET
, KWLoc
, PE
.take(), RParen
);
3162 bool Value
= EvaluateExpressionTrait(ET
, Queried
);
3164 return Owned(new (Context
) ExpressionTraitExpr(KWLoc
, ET
, Queried
, Value
,
3165 RParen
, Context
.BoolTy
));
3168 QualType
Sema::CheckPointerToMemberOperands(ExprResult
&lex
, ExprResult
&rex
,
3172 const char *OpSpelling
= isIndirect
? "->*" : ".*";
3174 // The binary operator .* [p3: ->*] binds its second operand, which shall
3175 // be of type "pointer to member of T" (where T is a completely-defined
3176 // class type) [...]
3177 QualType RType
= rex
.get()->getType();
3178 const MemberPointerType
*MemPtr
= RType
->getAs
<MemberPointerType
>();
3180 Diag(Loc
, diag::err_bad_memptr_rhs
)
3181 << OpSpelling
<< RType
<< rex
.get()->getSourceRange();
3185 QualType
Class(MemPtr
->getClass(), 0);
3187 // Note: C++ [expr.mptr.oper]p2-3 says that the class type into which the
3188 // member pointer points must be completely-defined. However, there is no
3189 // reason for this semantic distinction, and the rule is not enforced by
3190 // other compilers. Therefore, we do not check this property, as it is
3191 // likely to be considered a defect.
3194 // [...] to its first operand, which shall be of class T or of a class of
3195 // which T is an unambiguous and accessible base class. [p3: a pointer to
3197 QualType LType
= lex
.get()->getType();
3199 if (const PointerType
*Ptr
= LType
->getAs
<PointerType
>())
3200 LType
= Ptr
->getPointeeType();
3202 Diag(Loc
, diag::err_bad_memptr_lhs
)
3203 << OpSpelling
<< 1 << LType
3204 << FixItHint::CreateReplacement(SourceRange(Loc
), ".*");
3209 if (!Context
.hasSameUnqualifiedType(Class
, LType
)) {
3210 // If we want to check the hierarchy, we need a complete type.
3211 if (RequireCompleteType(Loc
, LType
, PDiag(diag::err_bad_memptr_lhs
)
3212 << OpSpelling
<< (int)isIndirect
)) {
3215 CXXBasePaths
Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
3216 /*DetectVirtual=*/false);
3217 // FIXME: Would it be useful to print full ambiguity paths, or is that
3219 if (!IsDerivedFrom(LType
, Class
, Paths
) ||
3220 Paths
.isAmbiguous(Context
.getCanonicalType(Class
))) {
3221 Diag(Loc
, diag::err_bad_memptr_lhs
) << OpSpelling
3222 << (int)isIndirect
<< lex
.get()->getType();
3225 // Cast LHS to type of use.
3226 QualType UseType
= isIndirect
? Context
.getPointerType(Class
) : Class
;
3228 isIndirect
? VK_RValue
: CastCategory(lex
.get());
3230 CXXCastPath BasePath
;
3231 BuildBasePathArray(Paths
, BasePath
);
3232 lex
= ImpCastExprToType(lex
.take(), UseType
, CK_DerivedToBase
, VK
, &BasePath
);
3235 if (isa
<CXXScalarValueInitExpr
>(rex
.get()->IgnoreParens())) {
3236 // Diagnose use of pointer-to-member type which when used as
3237 // the functional cast in a pointer-to-member expression.
3238 Diag(Loc
, diag::err_pointer_to_member_type
) << isIndirect
;
3243 // The result is an object or a function of the type specified by the
3245 // The cv qualifiers are the union of those in the pointer and the left side,
3246 // in accordance with 5.5p5 and 5.2.5.
3247 QualType Result
= MemPtr
->getPointeeType();
3248 Result
= Context
.getCVRQualifiedType(Result
, LType
.getCVRQualifiers());
3250 // C++0x [expr.mptr.oper]p6:
3251 // In a .* expression whose object expression is an rvalue, the program is
3252 // ill-formed if the second operand is a pointer to member function with
3253 // ref-qualifier &. In a ->* expression or in a .* expression whose object
3254 // expression is an lvalue, the program is ill-formed if the second operand
3255 // is a pointer to member function with ref-qualifier &&.
3256 if (const FunctionProtoType
*Proto
= Result
->getAs
<FunctionProtoType
>()) {
3257 switch (Proto
->getRefQualifier()) {
3263 if (!isIndirect
&& !lex
.get()->Classify(Context
).isLValue())
3264 Diag(Loc
, diag::err_pointer_to_member_oper_value_classify
)
3265 << RType
<< 1 << lex
.get()->getSourceRange();
3269 if (isIndirect
|| !lex
.get()->Classify(Context
).isRValue())
3270 Diag(Loc
, diag::err_pointer_to_member_oper_value_classify
)
3271 << RType
<< 0 << lex
.get()->getSourceRange();
3276 // C++ [expr.mptr.oper]p6:
3277 // The result of a .* expression whose second operand is a pointer
3278 // to a data member is of the same value category as its
3279 // first operand. The result of a .* expression whose second
3280 // operand is a pointer to a member function is a prvalue. The
3281 // result of an ->* expression is an lvalue if its second operand
3282 // is a pointer to data member and a prvalue otherwise.
3283 if (Result
->isFunctionType()) {
3285 return Context
.BoundMemberTy
;
3286 } else if (isIndirect
) {
3289 VK
= lex
.get()->getValueKind();
3295 /// \brief Try to convert a type to another according to C++0x 5.16p3.
3297 /// This is part of the parameter validation for the ? operator. If either
3298 /// value operand is a class type, the two operands are attempted to be
3299 /// converted to each other. This function does the conversion in one direction.
3300 /// It returns true if the program is ill-formed and has already been diagnosed
3302 static bool TryClassUnification(Sema
&Self
, Expr
*From
, Expr
*To
,
3303 SourceLocation QuestionLoc
,
3304 bool &HaveConversion
,
3306 HaveConversion
= false;
3307 ToType
= To
->getType();
3309 InitializationKind Kind
= InitializationKind::CreateCopy(To
->getLocStart(),
3312 // The process for determining whether an operand expression E1 of type T1
3313 // can be converted to match an operand expression E2 of type T2 is defined
3315 // -- If E2 is an lvalue:
3316 bool ToIsLvalue
= To
->isLValue();
3318 // E1 can be converted to match E2 if E1 can be implicitly converted to
3319 // type "lvalue reference to T2", subject to the constraint that in the
3320 // conversion the reference must bind directly to E1.
3321 QualType T
= Self
.Context
.getLValueReferenceType(ToType
);
3322 InitializedEntity Entity
= InitializedEntity::InitializeTemporary(T
);
3324 InitializationSequence
InitSeq(Self
, Entity
, Kind
, &From
, 1);
3325 if (InitSeq
.isDirectReferenceBinding()) {
3327 HaveConversion
= true;
3331 if (InitSeq
.isAmbiguous())
3332 return InitSeq
.Diagnose(Self
, Entity
, Kind
, &From
, 1);
3335 // -- If E2 is an rvalue, or if the conversion above cannot be done:
3336 // -- if E1 and E2 have class type, and the underlying class types are
3337 // the same or one is a base class of the other:
3338 QualType FTy
= From
->getType();
3339 QualType TTy
= To
->getType();
3340 const RecordType
*FRec
= FTy
->getAs
<RecordType
>();
3341 const RecordType
*TRec
= TTy
->getAs
<RecordType
>();
3342 bool FDerivedFromT
= FRec
&& TRec
&& FRec
!= TRec
&&
3343 Self
.IsDerivedFrom(FTy
, TTy
);
3345 (FRec
== TRec
|| FDerivedFromT
|| Self
.IsDerivedFrom(TTy
, FTy
))) {
3346 // E1 can be converted to match E2 if the class of T2 is the
3347 // same type as, or a base class of, the class of T1, and
3349 if (FRec
== TRec
|| FDerivedFromT
) {
3350 if (TTy
.isAtLeastAsQualifiedAs(FTy
)) {
3351 InitializedEntity Entity
= InitializedEntity::InitializeTemporary(TTy
);
3352 InitializationSequence
InitSeq(Self
, Entity
, Kind
, &From
, 1);
3354 HaveConversion
= true;
3358 if (InitSeq
.isAmbiguous())
3359 return InitSeq
.Diagnose(Self
, Entity
, Kind
, &From
, 1);
3366 // -- Otherwise: E1 can be converted to match E2 if E1 can be
3367 // implicitly converted to the type that expression E2 would have
3368 // if E2 were converted to an rvalue (or the type it has, if E2 is
3371 // This actually refers very narrowly to the lvalue-to-rvalue conversion, not
3372 // to the array-to-pointer or function-to-pointer conversions.
3373 if (!TTy
->getAs
<TagType
>())
3374 TTy
= TTy
.getUnqualifiedType();
3376 InitializedEntity Entity
= InitializedEntity::InitializeTemporary(TTy
);
3377 InitializationSequence
InitSeq(Self
, Entity
, Kind
, &From
, 1);
3378 HaveConversion
= !InitSeq
.Failed();
3380 if (InitSeq
.isAmbiguous())
3381 return InitSeq
.Diagnose(Self
, Entity
, Kind
, &From
, 1);
3386 /// \brief Try to find a common type for two according to C++0x 5.16p5.
3388 /// This is part of the parameter validation for the ? operator. If either
3389 /// value operand is a class type, overload resolution is used to find a
3390 /// conversion to a common type.
3391 static bool FindConditionalOverload(Sema
&Self
, ExprResult
&LHS
, ExprResult
&RHS
,
3392 SourceLocation QuestionLoc
) {
3393 Expr
*Args
[2] = { LHS
.get(), RHS
.get() };
3394 OverloadCandidateSet
CandidateSet(QuestionLoc
);
3395 Self
.AddBuiltinOperatorCandidates(OO_Conditional
, QuestionLoc
, Args
, 2,
3398 OverloadCandidateSet::iterator Best
;
3399 switch (CandidateSet
.BestViableFunction(Self
, QuestionLoc
, Best
)) {
3401 // We found a match. Perform the conversions on the arguments and move on.
3403 Self
.PerformImplicitConversion(LHS
.get(), Best
->BuiltinTypes
.ParamTypes
[0],
3404 Best
->Conversions
[0], Sema::AA_Converting
);
3405 if (LHSRes
.isInvalid())
3410 Self
.PerformImplicitConversion(RHS
.get(), Best
->BuiltinTypes
.ParamTypes
[1],
3411 Best
->Conversions
[1], Sema::AA_Converting
);
3412 if (RHSRes
.isInvalid())
3416 Self
.MarkDeclarationReferenced(QuestionLoc
, Best
->Function
);
3420 case OR_No_Viable_Function
:
3422 // Emit a better diagnostic if one of the expressions is a null pointer
3423 // constant and the other is a pointer type. In this case, the user most
3424 // likely forgot to take the address of the other expression.
3425 if (Self
.DiagnoseConditionalForNull(LHS
.get(), RHS
.get(), QuestionLoc
))
3428 Self
.Diag(QuestionLoc
, diag::err_typecheck_cond_incompatible_operands
)
3429 << LHS
.get()->getType() << RHS
.get()->getType()
3430 << LHS
.get()->getSourceRange() << RHS
.get()->getSourceRange();
3434 Self
.Diag(QuestionLoc
, diag::err_conditional_ambiguous_ovl
)
3435 << LHS
.get()->getType() << RHS
.get()->getType()
3436 << LHS
.get()->getSourceRange() << RHS
.get()->getSourceRange();
3437 // FIXME: Print the possible common types by printing the return types of
3438 // the viable candidates.
3442 assert(false && "Conditional operator has only built-in overloads");
3448 /// \brief Perform an "extended" implicit conversion as returned by
3449 /// TryClassUnification.
3450 static bool ConvertForConditional(Sema
&Self
, ExprResult
&E
, QualType T
) {
3451 InitializedEntity Entity
= InitializedEntity::InitializeTemporary(T
);
3452 InitializationKind Kind
= InitializationKind::CreateCopy(E
.get()->getLocStart(),
3454 Expr
*Arg
= E
.take();
3455 InitializationSequence
InitSeq(Self
, Entity
, Kind
, &Arg
, 1);
3456 ExprResult Result
= InitSeq
.Perform(Self
, Entity
, Kind
, MultiExprArg(&Arg
, 1));
3457 if (Result
.isInvalid())
3464 /// \brief Check the operands of ?: under C++ semantics.
3466 /// See C++ [expr.cond]. Note that LHS is never null, even for the GNU x ?: y
3467 /// extension. In this case, LHS == Cond. (But they're not aliases.)
3468 QualType
Sema::CXXCheckConditionalOperands(ExprResult
&Cond
, ExprResult
&LHS
, ExprResult
&RHS
,
3469 ExprValueKind
&VK
, ExprObjectKind
&OK
,
3470 SourceLocation QuestionLoc
) {
3471 // FIXME: Handle C99's complex types, vector types, block pointers and Obj-C++
3472 // interface pointers.
3475 // The first expression is contextually converted to bool.
3476 if (!Cond
.get()->isTypeDependent()) {
3477 ExprResult CondRes
= CheckCXXBooleanCondition(Cond
.take());
3478 if (CondRes
.isInvalid())
3480 Cond
= move(CondRes
);
3487 // Either of the arguments dependent?
3488 if (LHS
.get()->isTypeDependent() || RHS
.get()->isTypeDependent())
3489 return Context
.DependentTy
;
3492 // If either the second or the third operand has type (cv) void, ...
3493 QualType LTy
= LHS
.get()->getType();
3494 QualType RTy
= RHS
.get()->getType();
3495 bool LVoid
= LTy
->isVoidType();
3496 bool RVoid
= RTy
->isVoidType();
3497 if (LVoid
|| RVoid
) {
3498 // ... then the [l2r] conversions are performed on the second and third
3500 LHS
= DefaultFunctionArrayLvalueConversion(LHS
.take());
3501 RHS
= DefaultFunctionArrayLvalueConversion(RHS
.take());
3502 if (LHS
.isInvalid() || RHS
.isInvalid())
3504 LTy
= LHS
.get()->getType();
3505 RTy
= RHS
.get()->getType();
3507 // ... and one of the following shall hold:
3508 // -- The second or the third operand (but not both) is a throw-
3509 // expression; the result is of the type of the other and is an rvalue.
3510 bool LThrow
= isa
<CXXThrowExpr
>(LHS
.get());
3511 bool RThrow
= isa
<CXXThrowExpr
>(RHS
.get());
3512 if (LThrow
&& !RThrow
)
3514 if (RThrow
&& !LThrow
)
3517 // -- Both the second and third operands have type void; the result is of
3518 // type void and is an rvalue.
3520 return Context
.VoidTy
;
3522 // Neither holds, error.
3523 Diag(QuestionLoc
, diag::err_conditional_void_nonvoid
)
3524 << (LVoid
? RTy
: LTy
) << (LVoid
? 0 : 1)
3525 << LHS
.get()->getSourceRange() << RHS
.get()->getSourceRange();
3532 // Otherwise, if the second and third operand have different types, and
3533 // either has (cv) class type, and attempt is made to convert each of those
3534 // operands to the other.
3535 if (!Context
.hasSameType(LTy
, RTy
) &&
3536 (LTy
->isRecordType() || RTy
->isRecordType())) {
3537 ImplicitConversionSequence ICSLeftToRight
, ICSRightToLeft
;
3538 // These return true if a single direction is already ambiguous.
3539 QualType L2RType
, R2LType
;
3540 bool HaveL2R
, HaveR2L
;
3541 if (TryClassUnification(*this, LHS
.get(), RHS
.get(), QuestionLoc
, HaveL2R
, L2RType
))
3543 if (TryClassUnification(*this, RHS
.get(), LHS
.get(), QuestionLoc
, HaveR2L
, R2LType
))
3546 // If both can be converted, [...] the program is ill-formed.
3547 if (HaveL2R
&& HaveR2L
) {
3548 Diag(QuestionLoc
, diag::err_conditional_ambiguous
)
3549 << LTy
<< RTy
<< LHS
.get()->getSourceRange() << RHS
.get()->getSourceRange();
3553 // If exactly one conversion is possible, that conversion is applied to
3554 // the chosen operand and the converted operands are used in place of the
3555 // original operands for the remainder of this section.
3557 if (ConvertForConditional(*this, LHS
, L2RType
) || LHS
.isInvalid())
3559 LTy
= LHS
.get()->getType();
3560 } else if (HaveR2L
) {
3561 if (ConvertForConditional(*this, RHS
, R2LType
) || RHS
.isInvalid())
3563 RTy
= RHS
.get()->getType();
3568 // If the second and third operands are glvalues of the same value
3569 // category and have the same type, the result is of that type and
3570 // value category and it is a bit-field if the second or the third
3571 // operand is a bit-field, or if both are bit-fields.
3572 // We only extend this to bitfields, not to the crazy other kinds of
3574 bool Same
= Context
.hasSameType(LTy
, RTy
);
3576 LHS
.get()->isGLValue() &&
3577 LHS
.get()->getValueKind() == RHS
.get()->getValueKind() &&
3578 LHS
.get()->isOrdinaryOrBitFieldObject() &&
3579 RHS
.get()->isOrdinaryOrBitFieldObject()) {
3580 VK
= LHS
.get()->getValueKind();
3581 if (LHS
.get()->getObjectKind() == OK_BitField
||
3582 RHS
.get()->getObjectKind() == OK_BitField
)
3588 // Otherwise, the result is an rvalue. If the second and third operands
3589 // do not have the same type, and either has (cv) class type, ...
3590 if (!Same
&& (LTy
->isRecordType() || RTy
->isRecordType())) {
3591 // ... overload resolution is used to determine the conversions (if any)
3592 // to be applied to the operands. If the overload resolution fails, the
3593 // program is ill-formed.
3594 if (FindConditionalOverload(*this, LHS
, RHS
, QuestionLoc
))
3599 // LValue-to-rvalue, array-to-pointer, and function-to-pointer standard
3600 // conversions are performed on the second and third operands.
3601 LHS
= DefaultFunctionArrayLvalueConversion(LHS
.take());
3602 RHS
= DefaultFunctionArrayLvalueConversion(RHS
.take());
3603 if (LHS
.isInvalid() || RHS
.isInvalid())
3605 LTy
= LHS
.get()->getType();
3606 RTy
= RHS
.get()->getType();
3608 // After those conversions, one of the following shall hold:
3609 // -- The second and third operands have the same type; the result
3610 // is of that type. If the operands have class type, the result
3611 // is a prvalue temporary of the result type, which is
3612 // copy-initialized from either the second operand or the third
3613 // operand depending on the value of the first operand.
3614 if (Context
.getCanonicalType(LTy
) == Context
.getCanonicalType(RTy
)) {
3615 if (LTy
->isRecordType()) {
3616 // The operands have class type. Make a temporary copy.
3617 InitializedEntity Entity
= InitializedEntity::InitializeTemporary(LTy
);
3618 ExprResult LHSCopy
= PerformCopyInitialization(Entity
,
3621 if (LHSCopy
.isInvalid())
3624 ExprResult RHSCopy
= PerformCopyInitialization(Entity
,
3627 if (RHSCopy
.isInvalid())
3637 // Extension: conditional operator involving vector types.
3638 if (LTy
->isVectorType() || RTy
->isVectorType())
3639 return CheckVectorOperands(LHS
, RHS
, QuestionLoc
, /*isCompAssign*/false);
3641 // -- The second and third operands have arithmetic or enumeration type;
3642 // the usual arithmetic conversions are performed to bring them to a
3643 // common type, and the result is of that type.
3644 if (LTy
->isArithmeticType() && RTy
->isArithmeticType()) {
3645 UsualArithmeticConversions(LHS
, RHS
);
3646 if (LHS
.isInvalid() || RHS
.isInvalid())
3648 return LHS
.get()->getType();
3651 // -- The second and third operands have pointer type, or one has pointer
3652 // type and the other is a null pointer constant; pointer conversions
3653 // and qualification conversions are performed to bring them to their
3654 // composite pointer type. The result is of the composite pointer type.
3655 // -- The second and third operands have pointer to member type, or one has
3656 // pointer to member type and the other is a null pointer constant;
3657 // pointer to member conversions and qualification conversions are
3658 // performed to bring them to a common type, whose cv-qualification
3659 // shall match the cv-qualification of either the second or the third
3660 // operand. The result is of the common type.
3661 bool NonStandardCompositeType
= false;
3662 QualType Composite
= FindCompositePointerType(QuestionLoc
, LHS
, RHS
,
3663 isSFINAEContext()? 0 : &NonStandardCompositeType
);
3664 if (!Composite
.isNull()) {
3665 if (NonStandardCompositeType
)
3667 diag::ext_typecheck_cond_incompatible_operands_nonstandard
)
3668 << LTy
<< RTy
<< Composite
3669 << LHS
.get()->getSourceRange() << RHS
.get()->getSourceRange();
3674 // Similarly, attempt to find composite type of two objective-c pointers.
3675 Composite
= FindCompositeObjCPointerType(LHS
, RHS
, QuestionLoc
);
3676 if (!Composite
.isNull())
3679 // Check if we are using a null with a non-pointer type.
3680 if (DiagnoseConditionalForNull(LHS
.get(), RHS
.get(), QuestionLoc
))
3683 Diag(QuestionLoc
, diag::err_typecheck_cond_incompatible_operands
)
3684 << LHS
.get()->getType() << RHS
.get()->getType()
3685 << LHS
.get()->getSourceRange() << RHS
.get()->getSourceRange();
3689 /// \brief Find a merged pointer type and convert the two expressions to it.
3691 /// This finds the composite pointer type (or member pointer type) for @p E1
3692 /// and @p E2 according to C++0x 5.9p2. It converts both expressions to this
3693 /// type and returns it.
3694 /// It does not emit diagnostics.
3696 /// \param Loc The location of the operator requiring these two expressions to
3697 /// be converted to the composite pointer type.
3699 /// If \p NonStandardCompositeType is non-NULL, then we are permitted to find
3700 /// a non-standard (but still sane) composite type to which both expressions
3701 /// can be converted. When such a type is chosen, \c *NonStandardCompositeType
3702 /// will be set true.
3703 QualType
Sema::FindCompositePointerType(SourceLocation Loc
,
3704 Expr
*&E1
, Expr
*&E2
,
3705 bool *NonStandardCompositeType
) {
3706 if (NonStandardCompositeType
)
3707 *NonStandardCompositeType
= false;
3709 assert(getLangOptions().CPlusPlus
&& "This function assumes C++");
3710 QualType T1
= E1
->getType(), T2
= E2
->getType();
3712 if (!T1
->isAnyPointerType() && !T1
->isMemberPointerType() &&
3713 !T2
->isAnyPointerType() && !T2
->isMemberPointerType())
3717 // Pointer conversions and qualification conversions are performed on
3718 // pointer operands to bring them to their composite pointer type. If
3719 // one operand is a null pointer constant, the composite pointer type is
3720 // the type of the other operand.
3721 if (E1
->isNullPointerConstant(Context
, Expr::NPC_ValueDependentIsNull
)) {
3722 if (T2
->isMemberPointerType())
3723 E1
= ImpCastExprToType(E1
, T2
, CK_NullToMemberPointer
).take();
3725 E1
= ImpCastExprToType(E1
, T2
, CK_NullToPointer
).take();
3728 if (E2
->isNullPointerConstant(Context
, Expr::NPC_ValueDependentIsNull
)) {
3729 if (T1
->isMemberPointerType())
3730 E2
= ImpCastExprToType(E2
, T1
, CK_NullToMemberPointer
).take();
3732 E2
= ImpCastExprToType(E2
, T1
, CK_NullToPointer
).take();
3736 // Now both have to be pointers or member pointers.
3737 if ((!T1
->isPointerType() && !T1
->isMemberPointerType()) ||
3738 (!T2
->isPointerType() && !T2
->isMemberPointerType()))
3741 // Otherwise, of one of the operands has type "pointer to cv1 void," then
3742 // the other has type "pointer to cv2 T" and the composite pointer type is
3743 // "pointer to cv12 void," where cv12 is the union of cv1 and cv2.
3744 // Otherwise, the composite pointer type is a pointer type similar to the
3745 // type of one of the operands, with a cv-qualification signature that is
3746 // the union of the cv-qualification signatures of the operand types.
3747 // In practice, the first part here is redundant; it's subsumed by the second.
3748 // What we do here is, we build the two possible composite types, and try the
3749 // conversions in both directions. If only one works, or if the two composite
3750 // types are the same, we have succeeded.
3751 // FIXME: extended qualifiers?
3752 typedef llvm::SmallVector
<unsigned, 4> QualifierVector
;
3753 QualifierVector QualifierUnion
;
3754 typedef llvm::SmallVector
<std::pair
<const Type
*, const Type
*>, 4>
3755 ContainingClassVector
;
3756 ContainingClassVector MemberOfClass
;
3757 QualType Composite1
= Context
.getCanonicalType(T1
),
3758 Composite2
= Context
.getCanonicalType(T2
);
3759 unsigned NeedConstBefore
= 0;
3761 const PointerType
*Ptr1
, *Ptr2
;
3762 if ((Ptr1
= Composite1
->getAs
<PointerType
>()) &&
3763 (Ptr2
= Composite2
->getAs
<PointerType
>())) {
3764 Composite1
= Ptr1
->getPointeeType();
3765 Composite2
= Ptr2
->getPointeeType();
3767 // If we're allowed to create a non-standard composite type, keep track
3768 // of where we need to fill in additional 'const' qualifiers.
3769 if (NonStandardCompositeType
&&
3770 Composite1
.getCVRQualifiers() != Composite2
.getCVRQualifiers())
3771 NeedConstBefore
= QualifierUnion
.size();
3773 QualifierUnion
.push_back(
3774 Composite1
.getCVRQualifiers() | Composite2
.getCVRQualifiers());
3775 MemberOfClass
.push_back(std::make_pair((const Type
*)0, (const Type
*)0));
3779 const MemberPointerType
*MemPtr1
, *MemPtr2
;
3780 if ((MemPtr1
= Composite1
->getAs
<MemberPointerType
>()) &&
3781 (MemPtr2
= Composite2
->getAs
<MemberPointerType
>())) {
3782 Composite1
= MemPtr1
->getPointeeType();
3783 Composite2
= MemPtr2
->getPointeeType();
3785 // If we're allowed to create a non-standard composite type, keep track
3786 // of where we need to fill in additional 'const' qualifiers.
3787 if (NonStandardCompositeType
&&
3788 Composite1
.getCVRQualifiers() != Composite2
.getCVRQualifiers())
3789 NeedConstBefore
= QualifierUnion
.size();
3791 QualifierUnion
.push_back(
3792 Composite1
.getCVRQualifiers() | Composite2
.getCVRQualifiers());
3793 MemberOfClass
.push_back(std::make_pair(MemPtr1
->getClass(),
3794 MemPtr2
->getClass()));
3798 // FIXME: block pointer types?
3800 // Cannot unwrap any more types.
3804 if (NeedConstBefore
&& NonStandardCompositeType
) {
3805 // Extension: Add 'const' to qualifiers that come before the first qualifier
3806 // mismatch, so that our (non-standard!) composite type meets the
3807 // requirements of C++ [conv.qual]p4 bullet 3.
3808 for (unsigned I
= 0; I
!= NeedConstBefore
; ++I
) {
3809 if ((QualifierUnion
[I
] & Qualifiers::Const
) == 0) {
3810 QualifierUnion
[I
] = QualifierUnion
[I
] | Qualifiers::Const
;
3811 *NonStandardCompositeType
= true;
3816 // Rewrap the composites as pointers or member pointers with the union CVRs.
3817 ContainingClassVector::reverse_iterator MOC
3818 = MemberOfClass
.rbegin();
3819 for (QualifierVector::reverse_iterator
3820 I
= QualifierUnion
.rbegin(),
3821 E
= QualifierUnion
.rend();
3822 I
!= E
; (void)++I
, ++MOC
) {
3823 Qualifiers Quals
= Qualifiers::fromCVRMask(*I
);
3824 if (MOC
->first
&& MOC
->second
) {
3825 // Rebuild member pointer type
3826 Composite1
= Context
.getMemberPointerType(
3827 Context
.getQualifiedType(Composite1
, Quals
),
3829 Composite2
= Context
.getMemberPointerType(
3830 Context
.getQualifiedType(Composite2
, Quals
),
3833 // Rebuild pointer type
3835 = Context
.getPointerType(Context
.getQualifiedType(Composite1
, Quals
));
3837 = Context
.getPointerType(Context
.getQualifiedType(Composite2
, Quals
));
3841 // Try to convert to the first composite pointer type.
3842 InitializedEntity Entity1
3843 = InitializedEntity::InitializeTemporary(Composite1
);
3844 InitializationKind Kind
3845 = InitializationKind::CreateCopy(Loc
, SourceLocation());
3846 InitializationSequence
E1ToC1(*this, Entity1
, Kind
, &E1
, 1);
3847 InitializationSequence
E2ToC1(*this, Entity1
, Kind
, &E2
, 1);
3849 if (E1ToC1
&& E2ToC1
) {
3850 // Conversion to Composite1 is viable.
3851 if (!Context
.hasSameType(Composite1
, Composite2
)) {
3852 // Composite2 is a different type from Composite1. Check whether
3853 // Composite2 is also viable.
3854 InitializedEntity Entity2
3855 = InitializedEntity::InitializeTemporary(Composite2
);
3856 InitializationSequence
E1ToC2(*this, Entity2
, Kind
, &E1
, 1);
3857 InitializationSequence
E2ToC2(*this, Entity2
, Kind
, &E2
, 1);
3858 if (E1ToC2
&& E2ToC2
) {
3859 // Both Composite1 and Composite2 are viable and are different;
3860 // this is an ambiguity.
3865 // Convert E1 to Composite1
3867 = E1ToC1
.Perform(*this, Entity1
, Kind
, MultiExprArg(*this,&E1
,1));
3868 if (E1Result
.isInvalid())
3870 E1
= E1Result
.takeAs
<Expr
>();
3872 // Convert E2 to Composite1
3874 = E2ToC1
.Perform(*this, Entity1
, Kind
, MultiExprArg(*this,&E2
,1));
3875 if (E2Result
.isInvalid())
3877 E2
= E2Result
.takeAs
<Expr
>();
3882 // Check whether Composite2 is viable.
3883 InitializedEntity Entity2
3884 = InitializedEntity::InitializeTemporary(Composite2
);
3885 InitializationSequence
E1ToC2(*this, Entity2
, Kind
, &E1
, 1);
3886 InitializationSequence
E2ToC2(*this, Entity2
, Kind
, &E2
, 1);
3887 if (!E1ToC2
|| !E2ToC2
)
3890 // Convert E1 to Composite2
3892 = E1ToC2
.Perform(*this, Entity2
, Kind
, MultiExprArg(*this, &E1
, 1));
3893 if (E1Result
.isInvalid())
3895 E1
= E1Result
.takeAs
<Expr
>();
3897 // Convert E2 to Composite2
3899 = E2ToC2
.Perform(*this, Entity2
, Kind
, MultiExprArg(*this, &E2
, 1));
3900 if (E2Result
.isInvalid())
3902 E2
= E2Result
.takeAs
<Expr
>();
3907 ExprResult
Sema::MaybeBindToTemporary(Expr
*E
) {
3911 assert(!isa
<CXXBindTemporaryExpr
>(E
) && "Double-bound temporary?");
3913 // If the result is a glvalue, we shouldn't bind it.
3917 // In ARC, calls that return a retainable type can return retained,
3918 // in which case we have to insert a consuming cast.
3919 if (getLangOptions().ObjCAutoRefCount
&&
3920 E
->getType()->isObjCRetainableType()) {
3922 bool ReturnsRetained
;
3924 // For actual calls, we compute this by examining the type of the
3926 if (CallExpr
*Call
= dyn_cast
<CallExpr
>(E
)) {
3927 Expr
*Callee
= Call
->getCallee()->IgnoreParens();
3928 QualType T
= Callee
->getType();
3930 if (T
== Context
.BoundMemberTy
) {
3931 // Handle pointer-to-members.
3932 if (BinaryOperator
*BinOp
= dyn_cast
<BinaryOperator
>(Callee
))
3933 T
= BinOp
->getRHS()->getType();
3934 else if (MemberExpr
*Mem
= dyn_cast
<MemberExpr
>(Callee
))
3935 T
= Mem
->getMemberDecl()->getType();
3938 if (const PointerType
*Ptr
= T
->getAs
<PointerType
>())
3939 T
= Ptr
->getPointeeType();
3940 else if (const BlockPointerType
*Ptr
= T
->getAs
<BlockPointerType
>())
3941 T
= Ptr
->getPointeeType();
3942 else if (const MemberPointerType
*MemPtr
= T
->getAs
<MemberPointerType
>())
3943 T
= MemPtr
->getPointeeType();
3945 const FunctionType
*FTy
= T
->getAs
<FunctionType
>();
3946 assert(FTy
&& "call to value not of function type?");
3947 ReturnsRetained
= FTy
->getExtInfo().getProducesResult();
3949 // ActOnStmtExpr arranges things so that StmtExprs of retainable
3950 // type always produce a +1 object.
3951 } else if (isa
<StmtExpr
>(E
)) {
3952 ReturnsRetained
= true;
3954 // For message sends and property references, we try to find an
3955 // actual method. FIXME: we should infer retention by selector in
3956 // cases where we don't have an actual method.
3959 if (ObjCMessageExpr
*Send
= dyn_cast
<ObjCMessageExpr
>(E
)) {
3960 D
= Send
->getMethodDecl();
3962 CastExpr
*CE
= cast
<CastExpr
>(E
);
3963 // FIXME. What other cast kinds to check for?
3964 if (CE
->getCastKind() == CK_ObjCProduceObject
||
3965 CE
->getCastKind() == CK_LValueToRValue
)
3966 return MaybeBindToTemporary(CE
->getSubExpr());
3967 assert(CE
->getCastKind() == CK_GetObjCProperty
);
3968 const ObjCPropertyRefExpr
*PRE
= CE
->getSubExpr()->getObjCProperty();
3969 D
= (PRE
->isImplicitProperty() ? PRE
->getImplicitPropertyGetter() : 0);
3972 ReturnsRetained
= (D
&& D
->hasAttr
<NSReturnsRetainedAttr
>());
3975 if (ReturnsRetained
) {
3976 ExprNeedsCleanups
= true;
3977 E
= ImplicitCastExpr::Create(Context
, E
->getType(),
3978 CK_ObjCConsumeObject
, E
, 0,
3984 if (!getLangOptions().CPlusPlus
)
3987 const RecordType
*RT
= E
->getType()->getAs
<RecordType
>();
3991 // That should be enough to guarantee that this type is complete.
3992 // If it has a trivial destructor, we can avoid the extra copy.
3993 CXXRecordDecl
*RD
= cast
<CXXRecordDecl
>(RT
->getDecl());
3994 if (RD
->isInvalidDecl() || RD
->hasTrivialDestructor())
3997 CXXDestructorDecl
*Destructor
= LookupDestructor(RD
);
3999 CXXTemporary
*Temp
= CXXTemporary::Create(Context
, Destructor
);
4001 MarkDeclarationReferenced(E
->getExprLoc(), Destructor
);
4002 CheckDestructorAccess(E
->getExprLoc(), Destructor
,
4003 PDiag(diag::err_access_dtor_temp
)
4006 ExprTemporaries
.push_back(Temp
);
4007 ExprNeedsCleanups
= true;
4009 return Owned(CXXBindTemporaryExpr::Create(Context
, Temp
, E
));
4012 Expr
*Sema::MaybeCreateExprWithCleanups(Expr
*SubExpr
) {
4013 assert(SubExpr
&& "sub expression can't be null!");
4015 unsigned FirstTemporary
= ExprEvalContexts
.back().NumTemporaries
;
4016 assert(ExprTemporaries
.size() >= FirstTemporary
);
4017 assert(ExprNeedsCleanups
|| ExprTemporaries
.size() == FirstTemporary
);
4018 if (!ExprNeedsCleanups
)
4021 Expr
*E
= ExprWithCleanups::Create(Context
, SubExpr
,
4022 ExprTemporaries
.begin() + FirstTemporary
,
4023 ExprTemporaries
.size() - FirstTemporary
);
4024 ExprTemporaries
.erase(ExprTemporaries
.begin() + FirstTemporary
,
4025 ExprTemporaries
.end());
4026 ExprNeedsCleanups
= false;
4032 Sema::MaybeCreateExprWithCleanups(ExprResult SubExpr
) {
4033 if (SubExpr
.isInvalid())
4036 return Owned(MaybeCreateExprWithCleanups(SubExpr
.take()));
4039 Stmt
*Sema::MaybeCreateStmtWithCleanups(Stmt
*SubStmt
) {
4040 assert(SubStmt
&& "sub statement can't be null!");
4042 if (!ExprNeedsCleanups
)
4045 // FIXME: In order to attach the temporaries, wrap the statement into
4046 // a StmtExpr; currently this is only used for asm statements.
4047 // This is hacky, either create a new CXXStmtWithTemporaries statement or
4048 // a new AsmStmtWithTemporaries.
4049 CompoundStmt
*CompStmt
= new (Context
) CompoundStmt(Context
, &SubStmt
, 1,
4052 Expr
*E
= new (Context
) StmtExpr(CompStmt
, Context
.VoidTy
, SourceLocation(),
4054 return MaybeCreateExprWithCleanups(E
);
4058 Sema::ActOnStartCXXMemberReference(Scope
*S
, Expr
*Base
, SourceLocation OpLoc
,
4059 tok::TokenKind OpKind
, ParsedType
&ObjectType
,
4060 bool &MayBePseudoDestructor
) {
4061 // Since this might be a postfix expression, get rid of ParenListExprs.
4062 ExprResult Result
= MaybeConvertParenListExprToParenExpr(S
, Base
);
4063 if (Result
.isInvalid()) return ExprError();
4064 Base
= Result
.get();
4066 QualType BaseType
= Base
->getType();
4067 MayBePseudoDestructor
= false;
4068 if (BaseType
->isDependentType()) {
4069 // If we have a pointer to a dependent type and are using the -> operator,
4070 // the object type is the type that the pointer points to. We might still
4071 // have enough information about that type to do something useful.
4072 if (OpKind
== tok::arrow
)
4073 if (const PointerType
*Ptr
= BaseType
->getAs
<PointerType
>())
4074 BaseType
= Ptr
->getPointeeType();
4076 ObjectType
= ParsedType::make(BaseType
);
4077 MayBePseudoDestructor
= true;
4081 // C++ [over.match.oper]p8:
4082 // [...] When operator->returns, the operator-> is applied to the value
4083 // returned, with the original second operand.
4084 if (OpKind
== tok::arrow
) {
4085 // The set of types we've considered so far.
4086 llvm::SmallPtrSet
<CanQualType
,8> CTypes
;
4087 llvm::SmallVector
<SourceLocation
, 8> Locations
;
4088 CTypes
.insert(Context
.getCanonicalType(BaseType
));
4090 while (BaseType
->isRecordType()) {
4091 Result
= BuildOverloadedArrowExpr(S
, Base
, OpLoc
);
4092 if (Result
.isInvalid())
4094 Base
= Result
.get();
4095 if (CXXOperatorCallExpr
*OpCall
= dyn_cast
<CXXOperatorCallExpr
>(Base
))
4096 Locations
.push_back(OpCall
->getDirectCallee()->getLocation());
4097 BaseType
= Base
->getType();
4098 CanQualType CBaseType
= Context
.getCanonicalType(BaseType
);
4099 if (!CTypes
.insert(CBaseType
)) {
4100 Diag(OpLoc
, diag::err_operator_arrow_circular
);
4101 for (unsigned i
= 0; i
< Locations
.size(); i
++)
4102 Diag(Locations
[i
], diag::note_declared_at
);
4107 if (BaseType
->isPointerType())
4108 BaseType
= BaseType
->getPointeeType();
4111 // We could end up with various non-record types here, such as extended
4112 // vector types or Objective-C interfaces. Just return early and let
4113 // ActOnMemberReferenceExpr do the work.
4114 if (!BaseType
->isRecordType()) {
4115 // C++ [basic.lookup.classref]p2:
4116 // [...] If the type of the object expression is of pointer to scalar
4117 // type, the unqualified-id is looked up in the context of the complete
4118 // postfix-expression.
4120 // This also indicates that we should be parsing a
4121 // pseudo-destructor-name.
4122 ObjectType
= ParsedType();
4123 MayBePseudoDestructor
= true;
4127 // The object type must be complete (or dependent).
4128 if (!BaseType
->isDependentType() &&
4129 RequireCompleteType(OpLoc
, BaseType
,
4130 PDiag(diag::err_incomplete_member_access
)))
4133 // C++ [basic.lookup.classref]p2:
4134 // If the id-expression in a class member access (5.2.5) is an
4135 // unqualified-id, and the type of the object expression is of a class
4136 // type C (or of pointer to a class type C), the unqualified-id is looked
4137 // up in the scope of class C. [...]
4138 ObjectType
= ParsedType::make(BaseType
);
4142 ExprResult
Sema::DiagnoseDtorReference(SourceLocation NameLoc
,
4144 SourceLocation ExpectedLParenLoc
= PP
.getLocForEndOfToken(NameLoc
);
4145 Diag(MemExpr
->getLocStart(), diag::err_dtor_expr_without_call
)
4146 << isa
<CXXPseudoDestructorExpr
>(MemExpr
)
4147 << FixItHint::CreateInsertion(ExpectedLParenLoc
, "()");
4149 return ActOnCallExpr(/*Scope*/ 0,
4151 /*LPLoc*/ ExpectedLParenLoc
,
4153 /*RPLoc*/ ExpectedLParenLoc
);
4156 ExprResult
Sema::BuildPseudoDestructorExpr(Expr
*Base
,
4157 SourceLocation OpLoc
,
4158 tok::TokenKind OpKind
,
4159 const CXXScopeSpec
&SS
,
4160 TypeSourceInfo
*ScopeTypeInfo
,
4161 SourceLocation CCLoc
,
4162 SourceLocation TildeLoc
,
4163 PseudoDestructorTypeStorage Destructed
,
4164 bool HasTrailingLParen
) {
4165 TypeSourceInfo
*DestructedTypeInfo
= Destructed
.getTypeSourceInfo();
4167 // C++ [expr.pseudo]p2:
4168 // The left-hand side of the dot operator shall be of scalar type. The
4169 // left-hand side of the arrow operator shall be of pointer to scalar type.
4170 // This scalar type is the object type.
4171 QualType ObjectType
= Base
->getType();
4172 if (OpKind
== tok::arrow
) {
4173 if (const PointerType
*Ptr
= ObjectType
->getAs
<PointerType
>()) {
4174 ObjectType
= Ptr
->getPointeeType();
4175 } else if (!Base
->isTypeDependent()) {
4176 // The user wrote "p->" when she probably meant "p."; fix it.
4177 Diag(OpLoc
, diag::err_typecheck_member_reference_suggestion
)
4178 << ObjectType
<< true
4179 << FixItHint::CreateReplacement(OpLoc
, ".");
4180 if (isSFINAEContext())
4183 OpKind
= tok::period
;
4187 if (!ObjectType
->isDependentType() && !ObjectType
->isScalarType()) {
4188 Diag(OpLoc
, diag::err_pseudo_dtor_base_not_scalar
)
4189 << ObjectType
<< Base
->getSourceRange();
4193 // C++ [expr.pseudo]p2:
4194 // [...] The cv-unqualified versions of the object type and of the type
4195 // designated by the pseudo-destructor-name shall be the same type.
4196 if (DestructedTypeInfo
) {
4197 QualType DestructedType
= DestructedTypeInfo
->getType();
4198 SourceLocation DestructedTypeStart
4199 = DestructedTypeInfo
->getTypeLoc().getLocalSourceRange().getBegin();
4200 if (!DestructedType
->isDependentType() && !ObjectType
->isDependentType()) {
4201 if (!Context
.hasSameUnqualifiedType(DestructedType
, ObjectType
)) {
4202 Diag(DestructedTypeStart
, diag::err_pseudo_dtor_type_mismatch
)
4203 << ObjectType
<< DestructedType
<< Base
->getSourceRange()
4204 << DestructedTypeInfo
->getTypeLoc().getLocalSourceRange();
4206 // Recover by setting the destructed type to the object type.
4207 DestructedType
= ObjectType
;
4208 DestructedTypeInfo
= Context
.getTrivialTypeSourceInfo(ObjectType
,
4209 DestructedTypeStart
);
4210 Destructed
= PseudoDestructorTypeStorage(DestructedTypeInfo
);
4211 } else if (DestructedType
.getObjCLifetime() !=
4212 ObjectType
.getObjCLifetime()) {
4214 if (DestructedType
.getObjCLifetime() == Qualifiers::OCL_None
) {
4215 // Okay: just pretend that the user provided the correctly-qualified
4218 Diag(DestructedTypeStart
, diag::err_arc_pseudo_dtor_inconstant_quals
)
4219 << ObjectType
<< DestructedType
<< Base
->getSourceRange()
4220 << DestructedTypeInfo
->getTypeLoc().getLocalSourceRange();
4223 // Recover by setting the destructed type to the object type.
4224 DestructedType
= ObjectType
;
4225 DestructedTypeInfo
= Context
.getTrivialTypeSourceInfo(ObjectType
,
4226 DestructedTypeStart
);
4227 Destructed
= PseudoDestructorTypeStorage(DestructedTypeInfo
);
4232 // C++ [expr.pseudo]p2:
4233 // [...] Furthermore, the two type-names in a pseudo-destructor-name of the
4236 // ::[opt] nested-name-specifier[opt] type-name :: ~ type-name
4238 // shall designate the same scalar type.
4239 if (ScopeTypeInfo
) {
4240 QualType ScopeType
= ScopeTypeInfo
->getType();
4241 if (!ScopeType
->isDependentType() && !ObjectType
->isDependentType() &&
4242 !Context
.hasSameUnqualifiedType(ScopeType
, ObjectType
)) {
4244 Diag(ScopeTypeInfo
->getTypeLoc().getLocalSourceRange().getBegin(),
4245 diag::err_pseudo_dtor_type_mismatch
)
4246 << ObjectType
<< ScopeType
<< Base
->getSourceRange()
4247 << ScopeTypeInfo
->getTypeLoc().getLocalSourceRange();
4249 ScopeType
= QualType();
4255 = new (Context
) CXXPseudoDestructorExpr(Context
, Base
,
4256 OpKind
== tok::arrow
, OpLoc
,
4257 SS
.getWithLocInContext(Context
),
4263 if (HasTrailingLParen
)
4264 return Owned(Result
);
4266 return DiagnoseDtorReference(Destructed
.getLocation(), Result
);
4269 ExprResult
Sema::ActOnPseudoDestructorExpr(Scope
*S
, Expr
*Base
,
4270 SourceLocation OpLoc
,
4271 tok::TokenKind OpKind
,
4273 UnqualifiedId
&FirstTypeName
,
4274 SourceLocation CCLoc
,
4275 SourceLocation TildeLoc
,
4276 UnqualifiedId
&SecondTypeName
,
4277 bool HasTrailingLParen
) {
4278 assert((FirstTypeName
.getKind() == UnqualifiedId::IK_TemplateId
||
4279 FirstTypeName
.getKind() == UnqualifiedId::IK_Identifier
) &&
4280 "Invalid first type name in pseudo-destructor");
4281 assert((SecondTypeName
.getKind() == UnqualifiedId::IK_TemplateId
||
4282 SecondTypeName
.getKind() == UnqualifiedId::IK_Identifier
) &&
4283 "Invalid second type name in pseudo-destructor");
4285 // C++ [expr.pseudo]p2:
4286 // The left-hand side of the dot operator shall be of scalar type. The
4287 // left-hand side of the arrow operator shall be of pointer to scalar type.
4288 // This scalar type is the object type.
4289 QualType ObjectType
= Base
->getType();
4290 if (OpKind
== tok::arrow
) {
4291 if (const PointerType
*Ptr
= ObjectType
->getAs
<PointerType
>()) {
4292 ObjectType
= Ptr
->getPointeeType();
4293 } else if (!ObjectType
->isDependentType()) {
4294 // The user wrote "p->" when she probably meant "p."; fix it.
4295 Diag(OpLoc
, diag::err_typecheck_member_reference_suggestion
)
4296 << ObjectType
<< true
4297 << FixItHint::CreateReplacement(OpLoc
, ".");
4298 if (isSFINAEContext())
4301 OpKind
= tok::period
;
4305 // Compute the object type that we should use for name lookup purposes. Only
4306 // record types and dependent types matter.
4307 ParsedType ObjectTypePtrForLookup
;
4309 if (ObjectType
->isRecordType())
4310 ObjectTypePtrForLookup
= ParsedType::make(ObjectType
);
4311 else if (ObjectType
->isDependentType())
4312 ObjectTypePtrForLookup
= ParsedType::make(Context
.DependentTy
);
4315 // Convert the name of the type being destructed (following the ~) into a
4316 // type (with source-location information).
4317 QualType DestructedType
;
4318 TypeSourceInfo
*DestructedTypeInfo
= 0;
4319 PseudoDestructorTypeStorage Destructed
;
4320 if (SecondTypeName
.getKind() == UnqualifiedId::IK_Identifier
) {
4321 ParsedType T
= getTypeName(*SecondTypeName
.Identifier
,
4322 SecondTypeName
.StartLocation
,
4323 S
, &SS
, true, false, ObjectTypePtrForLookup
);
4325 ((SS
.isSet() && !computeDeclContext(SS
, false)) ||
4326 (!SS
.isSet() && ObjectType
->isDependentType()))) {
4327 // The name of the type being destroyed is a dependent name, and we
4328 // couldn't find anything useful in scope. Just store the identifier and
4329 // it's location, and we'll perform (qualified) name lookup again at
4330 // template instantiation time.
4331 Destructed
= PseudoDestructorTypeStorage(SecondTypeName
.Identifier
,
4332 SecondTypeName
.StartLocation
);
4334 Diag(SecondTypeName
.StartLocation
,
4335 diag::err_pseudo_dtor_destructor_non_type
)
4336 << SecondTypeName
.Identifier
<< ObjectType
;
4337 if (isSFINAEContext())
4340 // Recover by assuming we had the right type all along.
4341 DestructedType
= ObjectType
;
4343 DestructedType
= GetTypeFromParser(T
, &DestructedTypeInfo
);
4345 // Resolve the template-id to a type.
4346 TemplateIdAnnotation
*TemplateId
= SecondTypeName
.TemplateId
;
4347 ASTTemplateArgsPtr
TemplateArgsPtr(*this,
4348 TemplateId
->getTemplateArgs(),
4349 TemplateId
->NumArgs
);
4350 TypeResult T
= ActOnTemplateIdType(TemplateId
->SS
,
4351 TemplateId
->Template
,
4352 TemplateId
->TemplateNameLoc
,
4353 TemplateId
->LAngleLoc
,
4355 TemplateId
->RAngleLoc
);
4356 if (T
.isInvalid() || !T
.get()) {
4357 // Recover by assuming we had the right type all along.
4358 DestructedType
= ObjectType
;
4360 DestructedType
= GetTypeFromParser(T
.get(), &DestructedTypeInfo
);
4363 // If we've performed some kind of recovery, (re-)build the type source
4365 if (!DestructedType
.isNull()) {
4366 if (!DestructedTypeInfo
)
4367 DestructedTypeInfo
= Context
.getTrivialTypeSourceInfo(DestructedType
,
4368 SecondTypeName
.StartLocation
);
4369 Destructed
= PseudoDestructorTypeStorage(DestructedTypeInfo
);
4372 // Convert the name of the scope type (the type prior to '::') into a type.
4373 TypeSourceInfo
*ScopeTypeInfo
= 0;
4375 if (FirstTypeName
.getKind() == UnqualifiedId::IK_TemplateId
||
4376 FirstTypeName
.Identifier
) {
4377 if (FirstTypeName
.getKind() == UnqualifiedId::IK_Identifier
) {
4378 ParsedType T
= getTypeName(*FirstTypeName
.Identifier
,
4379 FirstTypeName
.StartLocation
,
4380 S
, &SS
, true, false, ObjectTypePtrForLookup
);
4382 Diag(FirstTypeName
.StartLocation
,
4383 diag::err_pseudo_dtor_destructor_non_type
)
4384 << FirstTypeName
.Identifier
<< ObjectType
;
4386 if (isSFINAEContext())
4389 // Just drop this type. It's unnecessary anyway.
4390 ScopeType
= QualType();
4392 ScopeType
= GetTypeFromParser(T
, &ScopeTypeInfo
);
4394 // Resolve the template-id to a type.
4395 TemplateIdAnnotation
*TemplateId
= FirstTypeName
.TemplateId
;
4396 ASTTemplateArgsPtr
TemplateArgsPtr(*this,
4397 TemplateId
->getTemplateArgs(),
4398 TemplateId
->NumArgs
);
4399 TypeResult T
= ActOnTemplateIdType(TemplateId
->SS
,
4400 TemplateId
->Template
,
4401 TemplateId
->TemplateNameLoc
,
4402 TemplateId
->LAngleLoc
,
4404 TemplateId
->RAngleLoc
);
4405 if (T
.isInvalid() || !T
.get()) {
4406 // Recover by dropping this type.
4407 ScopeType
= QualType();
4409 ScopeType
= GetTypeFromParser(T
.get(), &ScopeTypeInfo
);
4413 if (!ScopeType
.isNull() && !ScopeTypeInfo
)
4414 ScopeTypeInfo
= Context
.getTrivialTypeSourceInfo(ScopeType
,
4415 FirstTypeName
.StartLocation
);
4418 return BuildPseudoDestructorExpr(Base
, OpLoc
, OpKind
, SS
,
4419 ScopeTypeInfo
, CCLoc
, TildeLoc
,
4420 Destructed
, HasTrailingLParen
);
4423 ExprResult
Sema::BuildCXXMemberCallExpr(Expr
*E
, NamedDecl
*FoundDecl
,
4424 CXXMethodDecl
*Method
) {
4425 ExprResult Exp
= PerformObjectArgumentInitialization(E
, /*Qualifier=*/0,
4427 if (Exp
.isInvalid())
4431 new (Context
) MemberExpr(Exp
.take(), /*IsArrow=*/false, Method
,
4432 SourceLocation(), Method
->getType(),
4433 VK_RValue
, OK_Ordinary
);
4434 QualType ResultType
= Method
->getResultType();
4435 ExprValueKind VK
= Expr::getValueKindForType(ResultType
);
4436 ResultType
= ResultType
.getNonLValueExprType(Context
);
4438 MarkDeclarationReferenced(Exp
.get()->getLocStart(), Method
);
4439 CXXMemberCallExpr
*CE
=
4440 new (Context
) CXXMemberCallExpr(Context
, ME
, 0, 0, ResultType
, VK
,
4441 Exp
.get()->getLocEnd());
4445 ExprResult
Sema::BuildCXXNoexceptExpr(SourceLocation KeyLoc
, Expr
*Operand
,
4446 SourceLocation RParen
) {
4447 return Owned(new (Context
) CXXNoexceptExpr(Context
.BoolTy
, Operand
,
4448 Operand
->CanThrow(Context
),
4452 ExprResult
Sema::ActOnNoexceptExpr(SourceLocation KeyLoc
, SourceLocation
,
4453 Expr
*Operand
, SourceLocation RParen
) {
4454 return BuildCXXNoexceptExpr(KeyLoc
, Operand
, RParen
);
4457 /// Perform the conversions required for an expression used in a
4458 /// context that ignores the result.
4459 ExprResult
Sema::IgnoredValueConversions(Expr
*E
) {
4461 // [Except in specific positions,] an lvalue that does not have
4462 // array type is converted to the value stored in the
4463 // designated object (and is no longer an lvalue).
4464 if (E
->isRValue()) return Owned(E
);
4466 // We always want to do this on ObjC property references.
4467 if (E
->getObjectKind() == OK_ObjCProperty
) {
4468 ExprResult Res
= ConvertPropertyForRValue(E
);
4469 if (Res
.isInvalid()) return Owned(E
);
4471 if (E
->isRValue()) return Owned(E
);
4474 // Otherwise, this rule does not apply in C++, at least not for the moment.
4475 if (getLangOptions().CPlusPlus
) return Owned(E
);
4477 // GCC seems to also exclude expressions of incomplete enum type.
4478 if (const EnumType
*T
= E
->getType()->getAs
<EnumType
>()) {
4479 if (!T
->getDecl()->isComplete()) {
4480 // FIXME: stupid workaround for a codegen bug!
4481 E
= ImpCastExprToType(E
, Context
.VoidTy
, CK_ToVoid
).take();
4486 ExprResult Res
= DefaultFunctionArrayLvalueConversion(E
);
4487 if (Res
.isInvalid())
4491 if (!E
->getType()->isVoidType())
4492 RequireCompleteType(E
->getExprLoc(), E
->getType(),
4493 diag::err_incomplete_type
);
4497 ExprResult
Sema::ActOnFinishFullExpr(Expr
*FE
) {
4498 ExprResult FullExpr
= Owned(FE
);
4500 if (!FullExpr
.get())
4503 if (DiagnoseUnexpandedParameterPack(FullExpr
.get()))
4506 FullExpr
= CheckPlaceholderExpr(FullExpr
.take());
4507 if (FullExpr
.isInvalid())
4510 FullExpr
= IgnoredValueConversions(FullExpr
.take());
4511 if (FullExpr
.isInvalid())
4514 CheckImplicitConversions(FullExpr
.get());
4515 return MaybeCreateExprWithCleanups(FullExpr
);
4518 StmtResult
Sema::ActOnFinishFullStmt(Stmt
*FullStmt
) {
4519 if (!FullStmt
) return StmtError();
4521 return MaybeCreateStmtWithCleanups(FullStmt
);
4524 bool Sema::CheckMicrosoftIfExistsSymbol(CXXScopeSpec
&SS
,
4525 UnqualifiedId
&Name
) {
4526 DeclarationNameInfo TargetNameInfo
= GetNameFromUnqualifiedId(Name
);
4527 DeclarationName TargetName
= TargetNameInfo
.getName();
4531 // Do the redeclaration lookup in the current scope.
4532 LookupResult
R(*this, TargetNameInfo
, Sema::LookupAnyName
,
4533 Sema::NotForRedeclaration
);
4534 R
.suppressDiagnostics();
4535 LookupParsedName(R
, getCurScope(), &SS
);